Loading...
Note: File does not exist in v6.8.
1/**
2@file Qos.C
3This file contains the routines related to Quality of Service.
4*/
5#include "headers.h"
6
7static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter, PVOID pvEthPayload, struct bcm_eth_packet_info *pstEthCsPktInfo);
8static bool EThCSClassifyPkt(struct bcm_mini_adapter *Adapter, struct sk_buff* skb, struct bcm_eth_packet_info *pstEthCsPktInfo, struct bcm_classifier_rule *pstClassifierRule, B_UINT8 EthCSCupport);
9
10static USHORT IpVersion4(struct bcm_mini_adapter *Adapter, struct iphdr *iphd,
11 struct bcm_classifier_rule *pstClassifierRule);
12
13static VOID PruneQueue(struct bcm_mini_adapter *Adapter, INT iIndex);
14
15
16/*******************************************************************
17* Function - MatchSrcIpAddress()
18*
19* Description - Checks whether the Source IP address from the packet
20* matches with that of Queue.
21*
22* Parameters - pstClassifierRule: Pointer to the packet info structure.
23* - ulSrcIP : Source IP address from the packet.
24*
25* Returns - TRUE(If address matches) else FAIL .
26*********************************************************************/
27static bool MatchSrcIpAddress(struct bcm_classifier_rule *pstClassifierRule, ULONG ulSrcIP)
28{
29 UCHAR ucLoopIndex = 0;
30
31 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
32
33 ulSrcIP = ntohl(ulSrcIP);
34 if (0 == pstClassifierRule->ucIPSourceAddressLength)
35 return TRUE;
36 for (ucLoopIndex = 0; ucLoopIndex < (pstClassifierRule->ucIPSourceAddressLength); ucLoopIndex++)
37 {
38 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Ip Address Mask:0x%x PacketIp:0x%x and Classification:0x%x", (UINT)pstClassifierRule->stSrcIpAddress.ulIpv4Mask[ucLoopIndex], (UINT)ulSrcIP, (UINT)pstClassifierRule->stSrcIpAddress.ulIpv6Addr[ucLoopIndex]);
39 if ((pstClassifierRule->stSrcIpAddress.ulIpv4Mask[ucLoopIndex] & ulSrcIP) ==
40 (pstClassifierRule->stSrcIpAddress.ulIpv4Addr[ucLoopIndex] & pstClassifierRule->stSrcIpAddress.ulIpv4Mask[ucLoopIndex]))
41 {
42 return TRUE;
43 }
44 }
45 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Ip Address Not Matched");
46 return false;
47}
48
49
50/*******************************************************************
51* Function - MatchDestIpAddress()
52*
53* Description - Checks whether the Destination IP address from the packet
54* matches with that of Queue.
55*
56* Parameters - pstClassifierRule: Pointer to the packet info structure.
57* - ulDestIP : Destination IP address from the packet.
58*
59* Returns - TRUE(If address matches) else FAIL .
60*********************************************************************/
61static bool MatchDestIpAddress(struct bcm_classifier_rule *pstClassifierRule, ULONG ulDestIP)
62{
63 UCHAR ucLoopIndex = 0;
64 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
65
66 ulDestIP = ntohl(ulDestIP);
67 if (0 == pstClassifierRule->ucIPDestinationAddressLength)
68 return TRUE;
69 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Ip Address 0x%x 0x%x 0x%x ", (UINT)ulDestIP, (UINT)pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex], (UINT)pstClassifierRule->stDestIpAddress.ulIpv4Addr[ucLoopIndex]);
70
71 for (ucLoopIndex = 0; ucLoopIndex < (pstClassifierRule->ucIPDestinationAddressLength); ucLoopIndex++)
72 {
73 if ((pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex] & ulDestIP) ==
74 (pstClassifierRule->stDestIpAddress.ulIpv4Addr[ucLoopIndex] & pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex]))
75 {
76 return TRUE;
77 }
78 }
79 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Ip Address Not Matched");
80 return false;
81}
82
83
84/************************************************************************
85* Function - MatchTos()
86*
87* Description - Checks the TOS from the packet matches with that of queue.
88*
89* Parameters - pstClassifierRule : Pointer to the packet info structure.
90* - ucTypeOfService: TOS from the packet.
91*
92* Returns - TRUE(If address matches) else FAIL.
93**************************************************************************/
94static bool MatchTos(struct bcm_classifier_rule *pstClassifierRule, UCHAR ucTypeOfService)
95{
96
97 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
98 if (3 != pstClassifierRule->ucIPTypeOfServiceLength)
99 return TRUE;
100
101 if (((pstClassifierRule->ucTosMask & ucTypeOfService) <= pstClassifierRule->ucTosHigh) && ((pstClassifierRule->ucTosMask & ucTypeOfService) >= pstClassifierRule->ucTosLow))
102 {
103 return TRUE;
104 }
105 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Type Of Service Not Matched");
106 return false;
107}
108
109
110/***************************************************************************
111* Function - MatchProtocol()
112*
113* Description - Checks the protocol from the packet matches with that of queue.
114*
115* Parameters - pstClassifierRule: Pointer to the packet info structure.
116* - ucProtocol : Protocol from the packet.
117*
118* Returns - TRUE(If address matches) else FAIL.
119****************************************************************************/
120bool MatchProtocol(struct bcm_classifier_rule *pstClassifierRule, UCHAR ucProtocol)
121{
122 UCHAR ucLoopIndex = 0;
123 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
124 if (0 == pstClassifierRule->ucProtocolLength)
125 return TRUE;
126 for (ucLoopIndex = 0; ucLoopIndex < pstClassifierRule->ucProtocolLength; ucLoopIndex++)
127 {
128 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol:0x%X Classification Protocol:0x%X", ucProtocol, pstClassifierRule->ucProtocol[ucLoopIndex]);
129 if (pstClassifierRule->ucProtocol[ucLoopIndex] == ucProtocol)
130 {
131 return TRUE;
132 }
133 }
134 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol Not Matched");
135 return false;
136}
137
138
139/***********************************************************************
140* Function - MatchSrcPort()
141*
142* Description - Checks, Source port from the packet matches with that of queue.
143*
144* Parameters - pstClassifierRule: Pointer to the packet info structure.
145* - ushSrcPort : Source port from the packet.
146*
147* Returns - TRUE(If address matches) else FAIL.
148***************************************************************************/
149bool MatchSrcPort(struct bcm_classifier_rule *pstClassifierRule, USHORT ushSrcPort)
150{
151 UCHAR ucLoopIndex = 0;
152
153 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
154
155
156 if (0 == pstClassifierRule->ucSrcPortRangeLength)
157 return TRUE;
158 for (ucLoopIndex = 0; ucLoopIndex < pstClassifierRule->ucSrcPortRangeLength; ucLoopIndex++)
159 {
160 if (ushSrcPort <= pstClassifierRule->usSrcPortRangeHi[ucLoopIndex] &&
161 ushSrcPort >= pstClassifierRule->usSrcPortRangeLo[ucLoopIndex])
162 {
163 return TRUE;
164 }
165 }
166 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Port: %x Not Matched ", ushSrcPort);
167 return false;
168}
169
170
171/***********************************************************************
172* Function - MatchDestPort()
173*
174* Description - Checks, Destination port from packet matches with that of queue.
175*
176* Parameters - pstClassifierRule: Pointer to the packet info structure.
177* - ushDestPort : Destination port from the packet.
178*
179* Returns - TRUE(If address matches) else FAIL.
180***************************************************************************/
181bool MatchDestPort(struct bcm_classifier_rule *pstClassifierRule, USHORT ushDestPort)
182{
183 UCHAR ucLoopIndex = 0;
184 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
185
186 if (0 == pstClassifierRule->ucDestPortRangeLength)
187 return TRUE;
188
189 for (ucLoopIndex = 0; ucLoopIndex < pstClassifierRule->ucDestPortRangeLength; ucLoopIndex++)
190 {
191 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Matching Port:0x%X 0x%X 0x%X", ushDestPort, pstClassifierRule->usDestPortRangeLo[ucLoopIndex], pstClassifierRule->usDestPortRangeHi[ucLoopIndex]);
192
193 if (ushDestPort <= pstClassifierRule->usDestPortRangeHi[ucLoopIndex] &&
194 ushDestPort >= pstClassifierRule->usDestPortRangeLo[ucLoopIndex])
195 {
196 return TRUE;
197 }
198 }
199 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Dest Port: %x Not Matched", ushDestPort);
200 return false;
201}
202/**
203@ingroup tx_functions
204Compares IPV4 Ip address and port number
205@return Queue Index.
206*/
207static USHORT IpVersion4(struct bcm_mini_adapter *Adapter,
208 struct iphdr *iphd,
209 struct bcm_classifier_rule *pstClassifierRule)
210{
211 struct bcm_transport_header *xprt_hdr = NULL;
212 bool bClassificationSucceed = false;
213
214 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "========>");
215
216 xprt_hdr = (struct bcm_transport_header *)((PUCHAR)iphd + sizeof(struct iphdr));
217
218 do {
219 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Trying to see Direction = %d %d",
220 pstClassifierRule->ucDirection,
221 pstClassifierRule->usVCID_Value);
222
223 //Checking classifier validity
224 if (!pstClassifierRule->bUsed || pstClassifierRule->ucDirection == DOWNLINK_DIR)
225 break;
226
227 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "is IPv6 check!");
228 if (pstClassifierRule->bIpv6Protocol)
229 break;
230
231 //**************Checking IP header parameter**************************//
232 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Trying to match Source IP Address");
233 if (!MatchSrcIpAddress(pstClassifierRule, iphd->saddr))
234 break;
235 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Source IP Address Matched");
236
237 if (!MatchDestIpAddress(pstClassifierRule, iphd->daddr))
238 break;
239 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination IP Address Matched");
240
241 if (!MatchTos(pstClassifierRule, iphd->tos)) {
242 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "TOS Match failed\n");
243 break;
244 }
245 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "TOS Matched");
246
247 if (!MatchProtocol(pstClassifierRule, iphd->protocol))
248 break;
249 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol Matched");
250
251 //if protocol is not TCP or UDP then no need of comparing source port and destination port
252 if (iphd->protocol != TCP && iphd->protocol != UDP) {
253 bClassificationSucceed = TRUE;
254 break;
255 }
256 //******************Checking Transport Layer Header field if present *****************//
257 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Source Port %04x",
258 (iphd->protocol == UDP) ? xprt_hdr->uhdr.source : xprt_hdr->thdr.source);
259
260 if (!MatchSrcPort(pstClassifierRule,
261 ntohs((iphd->protocol == UDP) ?
262 xprt_hdr->uhdr.source : xprt_hdr->thdr.source)))
263 break;
264 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Port Matched");
265
266 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Port %04x",
267 (iphd->protocol == UDP) ? xprt_hdr->uhdr.dest :
268 xprt_hdr->thdr.dest);
269 if (!MatchDestPort(pstClassifierRule,
270 ntohs((iphd->protocol == UDP) ?
271 xprt_hdr->uhdr.dest : xprt_hdr->thdr.dest)))
272 break;
273 bClassificationSucceed = TRUE;
274 } while (0);
275
276 if (TRUE == bClassificationSucceed)
277 {
278 INT iMatchedSFQueueIndex = 0;
279 iMatchedSFQueueIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
280 if (iMatchedSFQueueIndex >= NO_OF_QUEUES)
281 {
282 bClassificationSucceed = false;
283 }
284 else
285 {
286 if (false == Adapter->PackInfo[iMatchedSFQueueIndex].bActive)
287 {
288 bClassificationSucceed = false;
289 }
290 }
291 }
292
293 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "IpVersion4 <==========");
294
295 return bClassificationSucceed;
296}
297
298VOID PruneQueueAllSF(struct bcm_mini_adapter *Adapter)
299{
300 UINT iIndex = 0;
301
302 for (iIndex = 0; iIndex < HiPriority; iIndex++)
303 {
304 if (!Adapter->PackInfo[iIndex].bValid)
305 continue;
306
307 PruneQueue(Adapter, iIndex);
308 }
309}
310
311
312/**
313@ingroup tx_functions
314This function checks if the max queue size for a queue
315is less than number of bytes in the queue. If so -
316drops packets from the Head till the number of bytes is
317less than or equal to max queue size for the queue.
318*/
319static VOID PruneQueue(struct bcm_mini_adapter *Adapter, INT iIndex)
320{
321 struct sk_buff* PacketToDrop = NULL;
322 struct net_device_stats *netstats;
323
324 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "=====> Index %d", iIndex);
325
326 if (iIndex == HiPriority)
327 return;
328
329 if (!Adapter || (iIndex < 0) || (iIndex > HiPriority))
330 return;
331
332 /* To Store the netdevice statistic */
333 netstats = &Adapter->dev->stats;
334
335 spin_lock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
336
337 while (1)
338// while((UINT)Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost >
339// SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
340 {
341 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "uiCurrentBytesOnHost:%x uiMaxBucketSize :%x",
342 Adapter->PackInfo[iIndex].uiCurrentBytesOnHost,
343 Adapter->PackInfo[iIndex].uiMaxBucketSize);
344
345 PacketToDrop = Adapter->PackInfo[iIndex].FirstTxQueue;
346
347 if (PacketToDrop == NULL)
348 break;
349 if ((Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost < SF_MAX_ALLOWED_PACKETS_TO_BACKUP) &&
350 ((1000*(jiffies - *((B_UINT32 *)(PacketToDrop->cb)+SKB_CB_LATENCY_OFFSET))/HZ) <= Adapter->PackInfo[iIndex].uiMaxLatency))
351 break;
352
353 if (PacketToDrop)
354 {
355 if (netif_msg_tx_err(Adapter))
356 pr_info(PFX "%s: tx queue %d overlimit\n",
357 Adapter->dev->name, iIndex);
358
359 netstats->tx_dropped++;
360
361 DEQUEUEPACKET(Adapter->PackInfo[iIndex].FirstTxQueue,
362 Adapter->PackInfo[iIndex].LastTxQueue);
363 /// update current bytes and packets count
364 Adapter->PackInfo[iIndex].uiCurrentBytesOnHost -=
365 PacketToDrop->len;
366 Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost--;
367 /// update dropped bytes and packets counts
368 Adapter->PackInfo[iIndex].uiDroppedCountBytes += PacketToDrop->len;
369 Adapter->PackInfo[iIndex].uiDroppedCountPackets++;
370 dev_kfree_skb(PacketToDrop);
371
372 }
373
374 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "Dropped Bytes:%x Dropped Packets:%x",
375 Adapter->PackInfo[iIndex].uiDroppedCountBytes,
376 Adapter->PackInfo[iIndex].uiDroppedCountPackets);
377
378 atomic_dec(&Adapter->TotalPacketCount);
379 }
380
381 spin_unlock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
382
383 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "TotalPacketCount:%x",
384 atomic_read(&Adapter->TotalPacketCount));
385 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "<=====");
386}
387
388VOID flush_all_queues(struct bcm_mini_adapter *Adapter)
389{
390 INT iQIndex;
391 UINT uiTotalPacketLength;
392 struct sk_buff* PacketToDrop = NULL;
393
394 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "=====>");
395
396// down(&Adapter->data_packet_queue_lock);
397 for (iQIndex = LowPriority; iQIndex < HiPriority; iQIndex++)
398 {
399 struct net_device_stats *netstats = &Adapter->dev->stats;
400
401 spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
402 while (Adapter->PackInfo[iQIndex].FirstTxQueue)
403 {
404 PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
405 if (PacketToDrop)
406 {
407 uiTotalPacketLength = PacketToDrop->len;
408 netstats->tx_dropped++;
409 }
410 else
411 uiTotalPacketLength = 0;
412
413 DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue,
414 Adapter->PackInfo[iQIndex].LastTxQueue);
415
416 /* Free the skb */
417 dev_kfree_skb(PacketToDrop);
418
419 /// update current bytes and packets count
420 Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= uiTotalPacketLength;
421 Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
422
423 /// update dropped bytes and packets counts
424 Adapter->PackInfo[iQIndex].uiDroppedCountBytes += uiTotalPacketLength;
425 Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
426
427 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Dropped Bytes:%x Dropped Packets:%x",
428 Adapter->PackInfo[iQIndex].uiDroppedCountBytes,
429 Adapter->PackInfo[iQIndex].uiDroppedCountPackets);
430 atomic_dec(&Adapter->TotalPacketCount);
431 }
432 spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
433 }
434// up(&Adapter->data_packet_queue_lock);
435 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "<=====");
436}
437
438USHORT ClassifyPacket(struct bcm_mini_adapter *Adapter, struct sk_buff* skb)
439{
440 INT uiLoopIndex = 0;
441 struct bcm_classifier_rule *pstClassifierRule = NULL;
442 struct bcm_eth_packet_info stEthCsPktInfo;
443 PVOID pvEThPayload = NULL;
444 struct iphdr *pIpHeader = NULL;
445 INT uiSfIndex = 0;
446 USHORT usIndex = Adapter->usBestEffortQueueIndex;
447 bool bFragmentedPkt = false, bClassificationSucceed = false;
448 USHORT usCurrFragment = 0;
449
450 struct bcm_tcp_header *pTcpHeader;
451 UCHAR IpHeaderLength;
452 UCHAR TcpHeaderLength;
453
454 pvEThPayload = skb->data;
455 *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET) = 0;
456 EThCSGetPktInfo(Adapter, pvEThPayload, &stEthCsPktInfo);
457
458 switch (stEthCsPktInfo.eNwpktEthFrameType)
459 {
460 case eEth802LLCFrame:
461 {
462 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802LLCFrame\n");
463 pIpHeader = pvEThPayload + sizeof(struct bcm_eth_llc_frame);
464 break;
465 }
466
467 case eEth802LLCSNAPFrame:
468 {
469 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802LLC SNAP Frame\n");
470 pIpHeader = pvEThPayload + sizeof(struct bcm_eth_llc_snap_frame);
471 break;
472 }
473 case eEth802QVLANFrame:
474 {
475 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802.1Q VLANFrame\n");
476 pIpHeader = pvEThPayload + sizeof(struct bcm_eth_q_frame);
477 break;
478 }
479 case eEthOtherFrame:
480 {
481 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : ETH Other Frame\n");
482 pIpHeader = pvEThPayload + sizeof(struct bcm_ethernet2_frame);
483 break;
484 }
485 default:
486 {
487 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : Unrecognized ETH Frame\n");
488 pIpHeader = pvEThPayload + sizeof(struct bcm_ethernet2_frame);
489 break;
490 }
491 }
492
493 if (stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
494 {
495 usCurrFragment = (ntohs(pIpHeader->frag_off) & IP_OFFSET);
496 if ((ntohs(pIpHeader->frag_off) & IP_MF) || usCurrFragment)
497 bFragmentedPkt = TRUE;
498
499 if (bFragmentedPkt)
500 {
501 //Fragmented Packet. Get Frag Classifier Entry.
502 pstClassifierRule = GetFragIPClsEntry(Adapter, pIpHeader->id, pIpHeader->saddr);
503 if (pstClassifierRule)
504 {
505 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "It is next Fragmented pkt");
506 bClassificationSucceed = TRUE;
507 }
508 if (!(ntohs(pIpHeader->frag_off) & IP_MF))
509 {
510 //Fragmented Last packet . Remove Frag Classifier Entry
511 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "This is the last fragmented Pkt");
512 DelFragIPClsEntry(Adapter, pIpHeader->id, pIpHeader->saddr);
513 }
514 }
515 }
516
517 for (uiLoopIndex = MAX_CLASSIFIERS - 1; uiLoopIndex >= 0; uiLoopIndex--)
518 {
519 if (bClassificationSucceed)
520 break;
521 //Iterate through all classifiers which are already in order of priority
522 //to classify the packet until match found
523 do
524 {
525 if (false == Adapter->astClassifierTable[uiLoopIndex].bUsed)
526 {
527 bClassificationSucceed = false;
528 break;
529 }
530 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Adapter->PackInfo[%d].bvalid=True\n", uiLoopIndex);
531
532 if (0 == Adapter->astClassifierTable[uiLoopIndex].ucDirection)
533 {
534 bClassificationSucceed = false;//cannot be processed for classification.
535 break; // it is a down link connection
536 }
537
538 pstClassifierRule = &Adapter->astClassifierTable[uiLoopIndex];
539
540 uiSfIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
541 if (uiSfIndex >= NO_OF_QUEUES) {
542 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Queue Not Valid. SearchSfid for this classifier Failed\n");
543 break;
544 }
545
546 if (Adapter->PackInfo[uiSfIndex].bEthCSSupport)
547 {
548
549 if (eEthUnsupportedFrame == stEthCsPktInfo.eNwpktEthFrameType)
550 {
551 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, " ClassifyPacket : Packet Not a Valid Supported Ethernet Frame\n");
552 bClassificationSucceed = false;
553 break;
554 }
555
556
557
558 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Performing ETH CS Classification on Classifier Rule ID : %x Service Flow ID : %lx\n", pstClassifierRule->uiClassifierRuleIndex, Adapter->PackInfo[uiSfIndex].ulSFID);
559 bClassificationSucceed = EThCSClassifyPkt(Adapter, skb, &stEthCsPktInfo, pstClassifierRule, Adapter->PackInfo[uiSfIndex].bEthCSSupport);
560
561 if (!bClassificationSucceed)
562 {
563 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : Ethernet CS Classification Failed\n");
564 break;
565 }
566 }
567
568 else // No ETH Supported on this SF
569 {
570 if (eEthOtherFrame != stEthCsPktInfo.eNwpktEthFrameType)
571 {
572 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, " ClassifyPacket : Packet Not a 802.3 Ethernet Frame... hence not allowed over non-ETH CS SF\n");
573 bClassificationSucceed = false;
574 break;
575 }
576 }
577
578 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Proceeding to IP CS Clasification");
579
580 if (Adapter->PackInfo[uiSfIndex].bIPCSSupport)
581 {
582
583 if (stEthCsPktInfo.eNwpktIPFrameType == eNonIPPacket)
584 {
585 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, " ClassifyPacket : Packet is Not an IP Packet\n");
586 bClassificationSucceed = false;
587 break;
588 }
589 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Dump IP Header :\n");
590 DumpFullPacket((PUCHAR)pIpHeader, 20);
591
592 if (stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
593 bClassificationSucceed = IpVersion4(Adapter, pIpHeader, pstClassifierRule);
594 else if (stEthCsPktInfo.eNwpktIPFrameType == eIPv6Packet)
595 bClassificationSucceed = IpVersion6(Adapter, pIpHeader, pstClassifierRule);
596 }
597
598 } while (0);
599 }
600
601 if (bClassificationSucceed == TRUE)
602 {
603 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "CF id : %d, SF ID is =%lu", pstClassifierRule->uiClassifierRuleIndex, pstClassifierRule->ulSFID);
604
605 //Store The matched Classifier in SKB
606 *((UINT32*)(skb->cb)+SKB_CB_CLASSIFICATION_OFFSET) = pstClassifierRule->uiClassifierRuleIndex;
607 if ((TCP == pIpHeader->protocol) && !bFragmentedPkt && (ETH_AND_IP_HEADER_LEN + TCP_HEADER_LEN <= skb->len))
608 {
609 IpHeaderLength = pIpHeader->ihl;
610 pTcpHeader = (struct bcm_tcp_header *)(((PUCHAR)pIpHeader)+(IpHeaderLength*4));
611 TcpHeaderLength = GET_TCP_HEADER_LEN(pTcpHeader->HeaderLength);
612
613 if ((pTcpHeader->ucFlags & TCP_ACK) &&
614 (ntohs(pIpHeader->tot_len) == (IpHeaderLength*4)+(TcpHeaderLength*4)))
615 {
616 *((UINT32*) (skb->cb) + SKB_CB_TCPACK_OFFSET) = TCP_ACK;
617 }
618 }
619
620 usIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
621 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "index is =%d", usIndex);
622
623 //If this is the first fragment of a Fragmented pkt, add this CF. Only This CF should be used for all other fragment of this Pkt.
624 if (bFragmentedPkt && (usCurrFragment == 0))
625 {
626 //First Fragment of Fragmented Packet. Create Frag CLS Entry
627 struct bcm_fragmented_packet_info stFragPktInfo;
628 stFragPktInfo.bUsed = TRUE;
629 stFragPktInfo.ulSrcIpAddress = pIpHeader->saddr;
630 stFragPktInfo.usIpIdentification = pIpHeader->id;
631 stFragPktInfo.pstMatchedClassifierEntry = pstClassifierRule;
632 stFragPktInfo.bOutOfOrderFragment = false;
633 AddFragIPClsEntry(Adapter, &stFragPktInfo);
634 }
635
636
637 }
638
639 if (bClassificationSucceed)
640 return usIndex;
641 else
642 return INVALID_QUEUE_INDEX;
643}
644
645static bool EthCSMatchSrcMACAddress(struct bcm_classifier_rule *pstClassifierRule, PUCHAR Mac)
646{
647 UINT i = 0;
648 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
649 if (pstClassifierRule->ucEthCSSrcMACLen == 0)
650 return TRUE;
651 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s\n", __FUNCTION__);
652 for (i = 0; i < MAC_ADDRESS_SIZE; i++)
653 {
654 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "SRC MAC[%x] = %x ClassifierRuleSrcMAC = %x Mask : %x\n", i, Mac[i], pstClassifierRule->au8EThCSSrcMAC[i], pstClassifierRule->au8EThCSSrcMACMask[i]);
655 if ((pstClassifierRule->au8EThCSSrcMAC[i] & pstClassifierRule->au8EThCSSrcMACMask[i]) !=
656 (Mac[i] & pstClassifierRule->au8EThCSSrcMACMask[i]))
657 return false;
658 }
659 return TRUE;
660}
661
662static bool EthCSMatchDestMACAddress(struct bcm_classifier_rule *pstClassifierRule, PUCHAR Mac)
663{
664 UINT i = 0;
665 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
666 if (pstClassifierRule->ucEthCSDestMACLen == 0)
667 return TRUE;
668 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s\n", __FUNCTION__);
669 for (i = 0; i < MAC_ADDRESS_SIZE; i++)
670 {
671 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "SRC MAC[%x] = %x ClassifierRuleSrcMAC = %x Mask : %x\n", i, Mac[i], pstClassifierRule->au8EThCSDestMAC[i], pstClassifierRule->au8EThCSDestMACMask[i]);
672 if ((pstClassifierRule->au8EThCSDestMAC[i] & pstClassifierRule->au8EThCSDestMACMask[i]) !=
673 (Mac[i] & pstClassifierRule->au8EThCSDestMACMask[i]))
674 return false;
675 }
676 return TRUE;
677}
678
679static bool EthCSMatchEThTypeSAP(struct bcm_classifier_rule *pstClassifierRule, struct sk_buff* skb, struct bcm_eth_packet_info *pstEthCsPktInfo)
680{
681 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
682 if ((pstClassifierRule->ucEtherTypeLen == 0) ||
683 (pstClassifierRule->au8EthCSEtherType[0] == 0))
684 return TRUE;
685
686 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s SrcEtherType:%x CLS EtherType[0]:%x\n", __FUNCTION__, pstEthCsPktInfo->usEtherType, pstClassifierRule->au8EthCSEtherType[0]);
687 if (pstClassifierRule->au8EthCSEtherType[0] == 1)
688 {
689 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s CLS EtherType[1]:%x EtherType[2]:%x\n", __FUNCTION__, pstClassifierRule->au8EthCSEtherType[1], pstClassifierRule->au8EthCSEtherType[2]);
690
691 if (memcmp(&pstEthCsPktInfo->usEtherType, &pstClassifierRule->au8EthCSEtherType[1], 2) == 0)
692 return TRUE;
693 else
694 return false;
695 }
696
697 if (pstClassifierRule->au8EthCSEtherType[0] == 2)
698 {
699 if (eEth802LLCFrame != pstEthCsPktInfo->eNwpktEthFrameType)
700 return false;
701
702 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s EthCS DSAP:%x EtherType[2]:%x\n", __FUNCTION__, pstEthCsPktInfo->ucDSAP, pstClassifierRule->au8EthCSEtherType[2]);
703 if (pstEthCsPktInfo->ucDSAP == pstClassifierRule->au8EthCSEtherType[2])
704 return TRUE;
705 else
706 return false;
707
708 }
709
710 return false;
711
712}
713
714static bool EthCSMatchVLANRules(struct bcm_classifier_rule *pstClassifierRule, struct sk_buff* skb, struct bcm_eth_packet_info *pstEthCsPktInfo)
715{
716 bool bClassificationSucceed = false;
717 USHORT usVLANID;
718 B_UINT8 uPriority = 0;
719 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
720
721 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s CLS UserPrio:%x CLS VLANID:%x\n", __FUNCTION__, ntohs(*((USHORT *)pstClassifierRule->usUserPriority)), pstClassifierRule->usVLANID);
722
723 /* In case FW didn't receive the TLV, the priority field should be ignored */
724 if (pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_USER_PRIORITY_VALID))
725 {
726 if (pstEthCsPktInfo->eNwpktEthFrameType != eEth802QVLANFrame)
727 return false;
728
729 uPriority = (ntohs(*(USHORT *)(skb->data + sizeof(struct bcm_eth_header))) & 0xF000) >> 13;
730
731 if ((uPriority >= pstClassifierRule->usUserPriority[0]) && (uPriority <= pstClassifierRule->usUserPriority[1]))
732 bClassificationSucceed = TRUE;
733
734 if (!bClassificationSucceed)
735 return false;
736 }
737
738 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 D User Priority Rule Matched\n");
739
740 bClassificationSucceed = false;
741
742 if (pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_VLANID_VALID))
743 {
744 if (pstEthCsPktInfo->eNwpktEthFrameType != eEth802QVLANFrame)
745 return false;
746
747 usVLANID = ntohs(*(USHORT *)(skb->data + sizeof(struct bcm_eth_header))) & 0xFFF;
748
749 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s Pkt VLANID %x Priority: %d\n", __FUNCTION__, usVLANID, uPriority);
750
751 if (usVLANID == ((pstClassifierRule->usVLANID & 0xFFF0) >> 4))
752 bClassificationSucceed = TRUE;
753
754 if (!bClassificationSucceed)
755 return false;
756 }
757
758 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 Q VLAN ID Rule Matched\n");
759
760 return TRUE;
761}
762
763
764static bool EThCSClassifyPkt(struct bcm_mini_adapter *Adapter, struct sk_buff* skb,
765 struct bcm_eth_packet_info *pstEthCsPktInfo,
766 struct bcm_classifier_rule *pstClassifierRule,
767 B_UINT8 EthCSCupport)
768{
769 bool bClassificationSucceed = false;
770 bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule, ((struct bcm_eth_header *)(skb->data))->au8SourceAddress);
771 if (!bClassificationSucceed)
772 return false;
773 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS SrcMAC Matched\n");
774
775 bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule, ((struct bcm_eth_header *)(skb->data))->au8DestinationAddress);
776 if (!bClassificationSucceed)
777 return false;
778 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS DestMAC Matched\n");
779
780 //classify on ETHType/802.2SAP TLV
781 bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule, skb, pstEthCsPktInfo);
782 if (!bClassificationSucceed)
783 return false;
784
785 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS EthType/802.2SAP Matched\n");
786
787 //classify on 802.1VLAN Header Parameters
788
789 bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule, skb, pstEthCsPktInfo);
790 if (!bClassificationSucceed)
791 return false;
792 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 VLAN Rules Matched\n");
793
794 return bClassificationSucceed;
795}
796
797static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter, PVOID pvEthPayload,
798 struct bcm_eth_packet_info *pstEthCsPktInfo)
799{
800 USHORT u16Etype = ntohs(((struct bcm_eth_header *)pvEthPayload)->u16Etype);
801
802 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : Eth Hdr Type : %X\n", u16Etype);
803 if (u16Etype > 0x5dc)
804 {
805 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : ETH2 Frame\n");
806 //ETH2 Frame
807 if (u16Etype == ETHERNET_FRAMETYPE_802QVLAN)
808 {
809 //802.1Q VLAN Header
810 pstEthCsPktInfo->eNwpktEthFrameType = eEth802QVLANFrame;
811 u16Etype = ((struct bcm_eth_q_frame *)pvEthPayload)->EthType;
812 //((ETH_CS_802_Q_FRAME*)pvEthPayload)->UserPriority
813 }
814 else
815 {
816 pstEthCsPktInfo->eNwpktEthFrameType = eEthOtherFrame;
817 u16Etype = ntohs(u16Etype);
818 }
819
820 }
821 else
822 {
823 //802.2 LLC
824 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "802.2 LLC Frame\n");
825 pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCFrame;
826 pstEthCsPktInfo->ucDSAP = ((struct bcm_eth_llc_frame *)pvEthPayload)->DSAP;
827 if (pstEthCsPktInfo->ucDSAP == 0xAA && ((struct bcm_eth_llc_frame *)pvEthPayload)->SSAP == 0xAA)
828 {
829 //SNAP Frame
830 pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCSNAPFrame;
831 u16Etype = ((struct bcm_eth_llc_snap_frame *)pvEthPayload)->usEtherType;
832 }
833 }
834 if (u16Etype == ETHERNET_FRAMETYPE_IPV4)
835 pstEthCsPktInfo->eNwpktIPFrameType = eIPv4Packet;
836 else if (u16Etype == ETHERNET_FRAMETYPE_IPV6)
837 pstEthCsPktInfo->eNwpktIPFrameType = eIPv6Packet;
838 else
839 pstEthCsPktInfo->eNwpktIPFrameType = eNonIPPacket;
840
841 pstEthCsPktInfo->usEtherType = ((struct bcm_eth_header *)pvEthPayload)->u16Etype;
842 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->eNwpktIPFrameType : %x\n", pstEthCsPktInfo->eNwpktIPFrameType);
843 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->eNwpktEthFrameType : %x\n", pstEthCsPktInfo->eNwpktEthFrameType);
844 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->usEtherType : %x\n", pstEthCsPktInfo->usEtherType);
845}
846
847
848