↑ Collapse Diff ↑
1
 
#define BUILD_NUMBER "build-920308"
2
 
#define BUILD_NUMBER_NUMERIC 920308
3
 
#define BUILD_NUMBER_NUMERIC_STRING "920308"
4
 
#define PRODUCT_BUILD_NUMBER "product-build-53817"
5
 
#define PRODUCT_BUILD_NUMBER_NUMERIC 53817
6
 
#define PRODUCT_BUILD_NUMBER_NUMERIC_STRING "53817"
1
 
#define BUILD_NUMBER "build-1312038"
2
 
#define BUILD_NUMBER_NUMERIC 1312038
3
 
#define BUILD_NUMBER_NUMERIC_STRING "1312038"
4
 
#define PRODUCT_BUILD_NUMBER "product-build-63466"
5
 
#define PRODUCT_BUILD_NUMBER_NUMERIC 63466
6
 
#define PRODUCT_BUILD_NUMBER_NUMERIC_STRING "63466"
...
 
@@ -11924,8 +11924,8 @@ static void bnx2x_get_drvinfo(struct net_device *dev,
11924 11924
 
	struct bnx2x *bp = netdev_priv(dev);
11925 11925
 
	u8 phy_fw_ver[PHY_FW_VER_LEN];
11926 11926
 

	
11927
 
	strcpy(info->driver, DRV_MODULE_NAME);
11928
 
	strcpy(info->version, DRV_MODULE_VERSION);
11927
 
	strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
11928
 
	strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
11929 11929
 

	
11930 11930
 
	phy_fw_ver[0] = '\0';
11931 11931
 
	if (bp->port.pmf) {
...
 
@@ -11936,14 +11936,14 @@ static void bnx2x_get_drvinfo(struct net_device *dev,
11936 11936
 
		bnx2x_release_phy_lock(bp);
11937 11937
 
	}
11938 11938
 

	
11939
 
	strncpy(info->fw_version, bp->fw_ver, 32);
11939
 
	strlcpy(info->fw_version, bp->fw_ver, sizeof(info->fw_version));
11940 11940
 
	snprintf(info->fw_version + strlen(bp->fw_ver), 32 - strlen(bp->fw_ver),
11941 11941
 
		 "bc %d.%d.%d%s%s",
11942 11942
 
		 (bp->common.bc_ver & 0xff0000) >> 16,
11943 11943
 
		 (bp->common.bc_ver & 0xff00) >> 8,
11944 11944
 
		 (bp->common.bc_ver & 0xff),
11945 11945
 
		 ((phy_fw_ver[0] != '\0') ? " phy " : ""), phy_fw_ver);
11946
 
	strcpy(info->bus_info, pci_name(bp->pdev));
11946
 
	strlcpy(info->bus_info, pci_name(bp->pdev), sizeof(info->bus_info));
11947 11947
 
	info->n_stats = BNX2X_NUM_STATS;
11948 11948
 
	info->testinfo_len = BNX2X_NUM_TESTS;
11949 11949
 
	info->eedump_len = bp->common.flash_size;
...
 
@@ -3733,14 +3733,14 @@ static irqreturn_t e1000_intr(int irq, void *data)
3733 3733
 
	}
3734 3734
 

	
3735 3735
 
#ifdef CONFIG_E1000_NAPI
3736
 
	/* XXX only using ring 0 for napi */
3737 3736
 
#if !defined(__VMKLNX__)
3737
 
	/* XXX only using ring 0 for napi */
3738 3738
 
	if (likely(netif_rx_schedule_prep(netdev, &adapter->rx_ring[0].napi))) {
3739 3739
 
#else /* defined(__VMKLNX__) */
3740
 
	/* disable interrupts, without the synchronize_irq bit */
3741
 
	E1000_WRITE_REG(hw, E1000_IMC, ~0);
3742
 
	E1000_WRITE_FLUSH(&adapter->hw);
3740 3743
 
	if (likely(netif_rx_schedule_prep(netdev, &adapter->napi))) {
3741
 
		/* disable interrupts, without the synchronize_irq bit */
3742
 
		E1000_WRITE_REG(hw, E1000_IMC, ~0);
3743
 
		E1000_WRITE_FLUSH(&adapter->hw);
3744 3744
 
#endif /* !defined(__VMKLNX__) */
3745 3745
 
		adapter->total_tx_bytes = 0;
3746 3746
 
		adapter->total_tx_packets = 0;
...
 
@@ -29,7 +29,7 @@
29 29
 
/*
30 30
 
 * Source file for NIC routines to access the Phantom hardware
31 31
 
 *
32
 
 * $Id: //depot/vmkdrivers/esx50u2/src_9/drivers/net/nx_nic/unm_nic_hw.c#1 $
32
 
 * $Id: //depot/vmkdrivers/esx50u3/src_9/drivers/net/nx_nic/unm_nic_hw.c#1 $
33 33
 
 *
34 34
 
 */
35 35
 
#include <linux/delay.h>
...
 
@@ -478,14 +478,15 @@ hpsa_get_target_sas_identifier(struct scsi_target *starget, u64 *sas_id)
478 478
 
static int hpsa_proc_get_info(char *buffer, char **start, off_t offset,
479 479
 
			       int length, int *eof, void *data)
480 480
 
{
481
 
	off_t pos = 0;
482 481
 
	off_t len = 0;
483 482
 
	int size, i, ctlr;
484 483
 
	int logicals = 0;
485 484
 
	struct ctlr_info *h = (struct ctlr_info *) data;
486 485
 
	struct hpsa_scsi_dev_t *drv;
487 486
 
	unsigned long flags;
488
 

	
487
 
#define HPSA_MAXPROCINFO_LINE 256
488
 
	char line[HPSA_MAXPROCINFO_LINE];
489
 
	static int loop_resume = 0;
489 490
 
	ctlr = h->ctlr;
490 491
 

	
491 492
 
	/* prevent displaying bogus info during configuration
...
 
@@ -499,69 +500,82 @@ static int hpsa_proc_get_info(char *buffer, char **start, off_t offset,
499 500
 
	h->busy_initializing = 1;
500 501
 
	spin_unlock_irqrestore(&h->lock, flags);
501 502
 

	
502
 
	/* count the logical disk devices */
503
 
	for (i = 0; i < h->ndevices; i++) {
504
 
		drv = h->dev[i];
505
 
		if (drv == NULL )
506
 
			continue; 
507
 
		if (drv->devtype == TYPE_DISK)
508
 
			logicals++;
503
 
	if(!offset)
504
 
	{
505
 
		/* count the logical disk devices */
506
 
		for (i = 0; i < h->ndevices; i++) {
507
 
			drv = h->dev[i];
508
 
			if (drv == NULL )
509
 
				continue;
510
 
			if (drv->devtype == TYPE_DISK)
511
 
				logicals++;
512
 
		}
513
 

	
514
 
		size = sprintf(buffer, "%s: HP %s Controller\n"
515
 
			"Board ID: 0x%08lx\n"
516
 
			"Firmware Version: %c%c%c%c\n"
517
 
			"Driver Version: %s\n"
518
 
			"Driver Build: %s\n"
519
 
			"IRQ: %d\n"
520
 
			"Logical drives: %d\n"
521
 
			"Current Q depth: %d\n"
522
 
			"Current # commands on controller: %d\n"
523
 
			"Max Q depth since init: %d\n"
524
 
			"Max # commands on controller since init: %d\n"
525
 
			"Max SG entries since init: %d\n"
526
 
			"Max Commands supported: %d\n"
527
 
			"SCSI host number: %d\n\n",
528
 
			h->devname, h->product_name,
529
 
			(unsigned long)h->board_id,
530
 
			h->firm_ver[0], h->firm_ver[1],
531
 
			h->firm_ver[2], h->firm_ver[3],
532
 
			DRIVER_NAME, DRIVER_BUILD,
533
 
			(unsigned int)h->intr[SIMPLE_MODE_INT],
534
 
			logicals, h->Qdepth, h->commands_outstanding,
535
 
			h->maxQsinceinit, h->max_outstanding, h->maxSG,
536
 
			h->nr_cmds, h->scsi_host->host_no);
537
 
		len += size;
509 538
 
	}
510
 
	
511
 
	size = sprintf(buffer, "%s: HP %s Controller\n"
512
 
		"Board ID: 0x%08lx\n"
513
 
		"Firmware Version: %c%c%c%c\n"
514
 
		"Driver Version: %s\n"
515
 
		"Driver Build: %s\n"
516
 
		"IRQ: %d\n"
517
 
		"Logical drives: %d\n"
518
 
		"Current Q depth: %d\n"
519
 
		"Current # commands on controller: %d\n"
520
 
		"Max Q depth since init: %d\n"
521
 
		"Max # commands on controller since init: %d\n"
522
 
		"Max SG entries since init: %d\n"
523
 
		"Max Commands supported: %d\n"
524
 
		"SCSI host number: %d\n\n",
525
 
		h->devname, h->product_name,
526
 
		(unsigned long)h->board_id,
527
 
		h->firm_ver[0], h->firm_ver[1], 
528
 
		h->firm_ver[2], h->firm_ver[3], 
529
 
		DRIVER_NAME, DRIVER_BUILD,
530
 
		(unsigned int)h->intr[SIMPLE_MODE_INT],
531
 
		logicals, h->Qdepth, h->commands_outstanding,
532
 
		h->maxQsinceinit, h->max_outstanding, h->maxSG, 
533
 
		h->nr_cmds, h->scsi_host->host_no);
534
 
	pos += size;
535
 
	len += size;
536
 
	for (i = 0; i < h->ndevices; i++) {
539
 

	
540
 
	for (i = loop_resume; i < h->ndevices; i++) {
537 541
 
		drv = h->dev[i];
538
 
		if (drv == NULL ) 
542
 
		if (drv == NULL )
539 543
 
			continue;
540 544
 
		/* Only show disk and enclosure information */
541
 
		if (drv->devtype != TYPE_DISK && 
545
 
		if (drv->devtype != TYPE_DISK &&
542 546
 
			drv->devtype != TYPE_ENCLOSURE)
543 547
 
			continue;
544 548
 

	
545 549
 
		if (drv->raid_level > 5)
546 550
 
			drv->raid_level = RAID_UNKNOWN;
547 551
 

	
548
 
		size = sprintf(buffer + len, "hpsa%d/"
552
 
		size = snprintf(line, HPSA_MAXPROCINFO_LINE, "hpsa%d/"
549 553
 
			"C%d:B%d:T%d:L%d"
550
 
                	"\t%s\t%.16s\t%.4s\tRAID %s\n",
554
 
			"\t%s\t%.16s\t%.4s\tRAID %s\n",
551 555
 
                        ctlr, h->scsi_host->host_no,
552 556
 
			drv->bus, drv->target, drv->lun,
553 557
 
			scsi_device_type(drv->devtype),
554 558
 
			drv->model, drv->revision,
555 559
 
			raid_label[drv->raid_level]);
556
 
		pos += size;
560
 
		/* avoid buffer overflow */
561
 
		if ((len + size) > length) {
562
 
			loop_resume = i;
563
 
			break;
564
 
		}
565
 
		sprintf(buffer + len, "%s", line);
557 566
 
		len += size;
558 567
 
	}
559 568
 

	
560
 
	*eof = 1;
561
 
	*start = buffer + offset;
562
 
	len -= offset;
563
 
	if (len > length)
564
 
		len = length;
569
 
	if (len == 0 ||
570
 
		i == h->ndevices) {
571
 
		*eof = 1;
572
 
		loop_resume = 0;
573
 
	}
574
 
	else {
575
 
		*eof = 0;
576
 
	}
577
 

	
578
 
	*start = buffer;
565 579
 
	h->busy_initializing = 0;
566 580
 
	return len;
567 581
 
}
...
 
@@ -149,6 +149,16 @@ void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor)
149 149
 
}
150 150
 
EXPORT_SYMBOL_GPL(usb_anchor_urb);
151 151
 

	
152
 
/* Callers must hold anchor->lock */
153
 
static void __usb_unanchor_urb(struct urb *urb, struct usb_anchor *anchor)
154
 
{
155
 
        urb->anchor = NULL;
156
 
        list_del(&urb->anchor_list);
157
 
        usb_put_urb(urb);
158
 
        if (list_empty(&anchor->urb_list))
159
 
                wake_up(&anchor->wait);
160
 
}
161
 

	
152 162
 
/**
153 163
 
 * usb_unanchor_urb - unanchors an URB
154 164
 
 * @urb: pointer to the urb to anchor
...
 
@@ -168,17 +178,13 @@ void usb_unanchor_urb(struct urb *urb)
168 178
 
		return;
169 179
 

	
170 180
 
	spin_lock_irqsave(&anchor->lock, flags);
171
 
	if (unlikely(anchor != urb->anchor)) {
172
 
		/* we've lost the race to another thread */
173
 
		spin_unlock_irqrestore(&anchor->lock, flags);
174
 
		return;
175
 
	}
176
 
	urb->anchor = NULL;
177
 
	list_del(&urb->anchor_list);
181
 
        /* At this point, we could be competing with another thread which
182
 
         * has the same intention. To protect the urb from being unanchored
183
 
         * twice, only the winner of the race gets the job.
184
 
         */
185
 
        if (likely(anchor == urb->anchor))
186
 
                __usb_unanchor_urb(urb, anchor);
178 187
 
	spin_unlock_irqrestore(&anchor->lock, flags);
179
 
	usb_put_urb(urb);
180
 
	if (list_empty(&anchor->urb_list))
181
 
		wake_up(&anchor->wait);
182 188
 
}
183 189
 
EXPORT_SYMBOL_GPL(usb_unanchor_urb);
184 190
 

	
...
 
@@ -828,20 +834,11 @@ EXPORT_SYMBOL_GPL(usb_unpoison_anchored_urbs);
828 834
 
void usb_unlink_anchored_urbs(struct usb_anchor *anchor)
829 835
 
{
830 836
 
	struct urb *victim;
831
 
	unsigned long flags;
832 837
 

	
833
 
	spin_lock_irqsave(&anchor->lock, flags);
834
 
	while (!list_empty(&anchor->urb_list)) {
835
 
		victim = list_entry(anchor->urb_list.prev, struct urb,
836
 
				    anchor_list);
837
 
		usb_get_urb(victim);
838
 
		spin_unlock_irqrestore(&anchor->lock, flags);
839
 
		/* this will unanchor the URB */
838
 
        while ((victim = usb_get_from_anchor(anchor)) != NULL) {
840 839
 
		usb_unlink_urb(victim);
841 840
 
		usb_put_urb(victim);
842
 
		spin_lock_irqsave(&anchor->lock, flags);
843 841
 
	}
844
 
	spin_unlock_irqrestore(&anchor->lock, flags);
845 842
 
}
846 843
 
EXPORT_SYMBOL_GPL(usb_unlink_anchored_urbs);
847 844
 

	
...
 
@@ -878,13 +875,13 @@ struct urb *usb_get_from_anchor(struct usb_anchor *anchor)
878 875
 
		victim = list_entry(anchor->urb_list.next, struct urb,
879 876
 
				    anchor_list);
880 877
 
		usb_get_urb(victim);
881
 
		spin_unlock_irqrestore(&anchor->lock, flags);
882
 
		usb_unanchor_urb(victim);
878
 
		__usb_unanchor_urb(victim, anchor);
883 879
 
	} else {
884
 
		spin_unlock_irqrestore(&anchor->lock, flags);
885 880
 
		victim = NULL;
886 881
 
	}
887 882
 

	
883
 
	spin_unlock_irqrestore(&anchor->lock, flags);
884
 

	
888 885
 
	return victim;
889 886
 
}
890 887
 

	
...
 
@@ -905,12 +902,7 @@ void usb_scuttle_anchored_urbs(struct usb_anchor *anchor)
905 902
 
	while (!list_empty(&anchor->urb_list)) {
906 903
 
		victim = list_entry(anchor->urb_list.prev, struct urb,
907 904
 
				    anchor_list);
908
 
		usb_get_urb(victim);
909
 
		spin_unlock_irqrestore(&anchor->lock, flags);
910
 
		/* this may free the URB */
911
 
		usb_unanchor_urb(victim);
912
 
		usb_put_urb(victim);
913
 
		spin_lock_irqsave(&anchor->lock, flags);
905
 
		__usb_unanchor_urb(victim, anchor);
914 906
 
	}
915 907
 
	spin_unlock_irqrestore(&anchor->lock, flags);
916 908
 
}
...
 
@@ -299,6 +299,40 @@ typedef enum {
299 299
 
   NETPOLL_BACKUP = 1,
300 300
 
} vmklnx_poll_type;
301 301
 

	
302
 
/*
303
 
 * since all pointers are 4 bytes or even 8 bytes aligned,
304
 
 * let's simply embed the poll_type in the lower bits of vmk_NetPoll->priv
305
 
 * final pointer value = (original priv pointer | poll_type)
306
 
 */
307
 
#define POLLPRIV_TYPE_BITS	1
308
 
#define POLLPRIV_TYPE_MASK	((1 << POLLPRIV_TYPE_BITS) - 1)
309
 

	
310
 
static inline void *pollpriv_embed(void *priv, vmklnx_poll_type poll_type)
311
 
{
312
 
        VMK_ASSERT(priv);
313
 
        VMK_ASSERT((((unsigned long) priv) & POLLPRIV_TYPE_MASK) == 0);
314
 
        VMK_ASSERT(poll_type <= POLLPRIV_TYPE_MASK);
315
 
        return (void *)(((unsigned long )priv) | poll_type);
316
 
}
317
 

	
318
 
static inline vmklnx_poll_type pollpriv_type(void *priv)
319
 
{
320
 
        VMK_ASSERT(priv);
321
 
        return (vmklnx_poll_type)(((unsigned long)priv) & POLLPRIV_TYPE_MASK);
322
 
}
323
 

	
324
 
static inline struct napi_struct *pollpriv_napi(void *priv)
325
 
{
326
 
        VMK_ASSERT(pollpriv_type(priv) == NETPOLL_DEFAULT);
327
 
        return (struct napi_struct *) (((unsigned long)priv) & (~POLLPRIV_TYPE_MASK));
328
 
}
329
 

	
330
 
static inline struct net_device *pollpriv_net_device(void *priv)
331
 
{
332
 
        VMK_ASSERT(pollpriv_type(priv) == NETPOLL_BACKUP);
333
 
        return (struct net_device *)  (((unsigned long)priv) & (~POLLPRIV_TYPE_MASK));
334
 
}
335
 

	
302 336
 
struct napi_struct {
303 337
 
        unsigned long           state;
304 338
 
        int                     weight;
...
 
@@ -427,7 +427,7 @@ int
427 427
 
netif_receive_skb(struct sk_buff *skb)
428 428
 
{
429 429
 
   struct net_device *dev = skb->dev;
430
 
   vmk_NetPoll pollPriv;
430
 
   vmk_NetPoll netPoll;
431 431
 
   vmk_Worldlet wdt;
432 432
 
   struct napi_struct *napi = NULL;
433 433
 
   vmk_PktHandle *pkt;
...
 
@@ -440,7 +440,7 @@ netif_receive_skb(struct sk_buff *skb)
440 440
 
    * skb->napi->rxPktList.
441 441
 
    */
442 442
 
   if (skb->napi == NULL) {
443
 
      if (unlikely(vmk_WorldletGetCurrent(&wdt, (void **)&pollPriv) != VMK_OK)) {
443
 
      if (unlikely(vmk_WorldletGetCurrent(&wdt, (void **)&netPoll) != VMK_OK)) {
444 444
 
         VMK_ASSERT(VMK_FALSE);
445 445
 
         dev_kfree_skb_any(skb);
446 446
 
         dev->linnet_rx_dropped++;
...
 
@@ -449,14 +449,26 @@ netif_receive_skb(struct sk_buff *skb)
449 449
 
      } else {
450 450
 
         /*
451 451
 
          * When the system is in the panic/debug status, the current worldlet is the
452
 
          * debug worldlet rather than the napi_poll worldlet. In this case, put the
452
 
          * debug worldlet rather than the NetPollWorldlet. In this case, put the
453 453
 
          * arrived packets into debugPktList. This list will be processed by
454 454
 
          * FlushRxBuffers, because netdump/netdebug will bypass the vswitch to read
455 455
 
          * the packets.
456 456
 
         */
457
 
         if  (vmk_NetPollGetCurrent(&pollPriv) == VMK_OK) { 
458
 
            napi = (struct napi_struct *)vmk_NetPollGetPrivate(pollPriv);
457
 
         if  (vmk_NetPollGetCurrent(&netPoll) == VMK_OK) {
458
 
            void *priv = vmk_NetPollGetPrivate(netPoll);
459
 
            if (pollpriv_type(priv) == NETPOLL_DEFAULT) {
460
 
               napi = pollpriv_napi(priv);
461
 
            } else {
462
 
               spin_lock(&dev->napi_lock);
463
 
               list_for_each_entry(napi, &dev->napi_list, dev_list) {
464
 
                  if (napi->dev_poll && test_bit(NAPI_STATE_SCHED, &napi->state)) {
465
 
                     break;
466
 
                  }
467
 
               }
468
 
               spin_unlock(&dev->napi_lock);
469
 
            }
459 470
 
         }
471
 

	
460 472
 
         if (!napi || vmk_SystemCheckState(VMK_SYSTEM_STATE_PANIC)) {
461 473
 
            pkt = skb->pkt;
462 474
 
            status = map_skb_to_pkt(skb);
...
 
@@ -475,7 +487,7 @@ netif_receive_skb(struct sk_buff *skb)
475 487
 
            }
476 488
 
            goto done;
477 489
 
         } else {
478
 
            VMK_ASSERT(pollPriv != NULL);
490
 
            VMK_ASSERT(netPoll != NULL);
479 491
 
            skb->napi = napi;
480 492
 
         }
481 493
 
      }
...
 
@@ -519,10 +531,10 @@ EXPORT_SYMBOL(netif_receive_skb);
519 531
 
 */
520 532
 

	
521 533
 
static vmk_Bool
522
 
napi_poll(void *ptr) 
534
 
napi_poll(void *ptr)
523 535
 
{
524 536
 
   VMK_ReturnStatus status = VMK_OK;
525
 
   struct napi_struct *napi = (struct napi_struct *)ptr;
537
 
   struct napi_struct *napi = pollpriv_napi(ptr);
526 538
 

	
527 539
 
   /*
528 540
 
    * napi_schedule_prep()/napi_schedule() depend on accurately seeing whether
...
 
@@ -574,9 +586,9 @@ napi_poll(void *ptr)
574 586
 
 */
575 587
 

	
576 588
 
static vmk_Bool
577
 
netdev_poll(void *private)
589
 
netdev_poll(void *ptr)
578 590
 
{
579
 
   struct net_device *dev = private;
591
 
   struct net_device *dev = pollpriv_net_device(ptr);
580 592
 
   vmk_Bool needWork;
581 593
 
   struct napi_struct *napi;
582 594
 
   VMK_ReturnStatus status = VMK_OK;
...
 
@@ -646,7 +658,7 @@ napi_poll_init(struct napi_struct *napi)
646 658
 
   napi->vector = 0;
647 659
 

	
648 660
 
   pollInit.poll = napi_poll;
649
 
   pollInit.priv = napi;
661
 
   pollInit.priv = pollpriv_embed(napi, NETPOLL_DEFAULT);
650 662
 

	
651 663
 
   if (napi->dev->features & NETIF_F_CNA) {
652 664
 
      pollInit.deliveryCallback = LinuxCNA_Poll;
...
 
@@ -730,9 +742,9 @@ netdev_poll_init(struct net_device *dev)
730 742
 

	
731 743
 
   dev->napi_wdt_priv.dev = dev;
732 744
 
   dev->napi_wdt_priv.napi = NULL;
733
 
 
745
 

734 746
 
   pollInit.poll = netdev_poll;
735
 
   pollInit.priv = dev;
747
 
   pollInit.priv = pollpriv_embed(dev, NETPOLL_BACKUP);
736 748
 

	
737 749
 
   if (dev->features & NETIF_F_CNA) {
738 750
 
      pollInit.deliveryCallback = LinuxCNADev_Poll;
...
 
@@ -1155,6 +1167,15 @@ skb_gen_pkt_frags(struct sk_buff *skb)
1155 1167
 
   }
1156 1168
 

	
1157 1169
 
   /*
1170
 
   * PR 922606:
1171
 
   *   Set skb frag ownership to vmkernel, such that vmklinux won't try
1172
 
   *   to free those MPNs if the skb needs to be dropped later. Instead,
1173
 
   *   the frags/SGs will be freed when the associated pkt is destroyed
1174
 
   *   by vmkernel.
1175
 
   */
1176
 
   vmklnx_set_skb_frags_owner_vmkernel(skb);
1177
 

	
1178
 
   /*
1158 1179
 
    * Since we removed packet completion in vmklinux, we
1159 1180
 
    * cannot support skb chaining anymore.
1160 1181
 
    */
...
 
@@ -1445,18 +1466,15 @@ skb_release_data(struct sk_buff *skb)
1445 1466
 
            if ((in_irq() || irqs_disabled()) && !vmklnx_is_panic()) {
1446 1467
 
               vmk_PktReleaseIRQ(skb->pkt);
1447 1468
 
            } else {
1448
 
               vmk_NetPoll pollPriv;
1449
 
               struct napi_struct *napi;
1469
 
               vmk_NetPoll netPoll;
1450 1470
 

	
1451 1471
 
               /*
1452 1472
 
                * Try to queue packets in NAPI's compPktList in order to
1453 1473
 
                * release them in batch, but first thoroughly check if we
1454 1474
 
                * got called from a napi context (PR #396873).
1455 1475
 
                */
1456
 
               if (vmk_NetPollGetCurrent(&pollPriv) == VMK_OK && 
1457
 
                   (napi = (struct napi_struct *) vmk_NetPollGetPrivate(pollPriv)) != NULL &&
1458
 
                   napi->net_poll_type == NETPOLL_DEFAULT) {
1459
 
                  vmk_NetPollQueueCompPkt(pollPriv, skb->pkt);
1476
 
               if (vmk_NetPollGetCurrent(&netPoll) == VMK_OK) {
1477
 
                  vmk_NetPollQueueCompPkt(netPoll, skb->pkt);
1460 1478
 
               } else {
1461 1479
 
                  vmk_PktRelease(skb->pkt);
1462 1480
 
               }
...
 
@@ -2282,6 +2300,7 @@ vmklnx_netif_set_poll_cna(struct napi_struct *napi)
2282 2300
 
         pollInit.priv = napi;
2283 2301
 
         pollInit.deliveryCallback = LinuxCNA_Poll;
2284 2302
 
      }
2303
 
      pollInit.priv = pollpriv_embed(pollInit.priv, napi->net_poll_type);
2285 2304
 
      pollInit.features = VMK_NETPOLL_CUSTOM_DELIVERY_CALLBACK;
2286 2305
 
      vmk_NetPollChangeCallback(napi->net_poll, &pollInit);
2287 2306
 
   }
...
 
@@ -6918,7 +6937,7 @@ FlushRxBuffers(void* clientData)
6918 6937
 
{
6919 6938
 
   struct net_device* dev = (struct net_device*)clientData;
6920 6939
 
   struct napi_struct* napi = NULL;
6921
 
   vmk_NetPoll pollPriv;
6940
 
   vmk_NetPoll netPoll;
6922 6941
 

	
6923 6942
 
   VMKLNX_DEBUG(1, "client data, now net_device:%p", dev);
6924 6943
 

	
...
 
@@ -6931,7 +6950,7 @@ FlushRxBuffers(void* clientData)
6931 6950
 
          * Bypass the vswitch to receive the packets when the system is in the
6932 6951
 
          * panic/debug mode.
6933 6952
 
          */
6934
 
         if (vmk_NetPollGetCurrent(&pollPriv) != VMK_OK) { 
6953
 
         if (vmk_NetPollGetCurrent(&netPoll) != VMK_OK) {
6935 6954
 
            if (debugPktList == NULL) {
6936 6955
 
               debugPktList = (vmk_PktList) vmk_HeapAlloc(vmklnxLowHeap,
6937 6956
 
                                                          vmk_PktListSizeInBytes);
1 1
 
/* ****************************************************************
2
 
 * Portions Copyright 1998, 2010 VMware, Inc.
2
 
 * Portions Copyright 1998, 2010, 2013 VMware, Inc.
3 3
 
 *
4 4
 
 * This program is free software; you can redistribute it and/or
5 5
 
 * modify it under the terms of the GNU General Public License
...
 
@@ -696,8 +696,8 @@ SCSILinuxProcessCompletions(scsiLinuxTLS_t *tls,       // IN
696 696
 

	
697 697
 
      case DRIVER_BUSY:
698 698
 
      case DRIVER_SOFT:
699
 
         hostStatus = VMK_SCSI_HOST_OK;
700
 
         deviceStatus = VMK_SCSI_DEVICE_BUSY;
699
 
         hostStatus = VMK_SCSI_HOST_BUS_BUSY;
700
 
         deviceStatus = VMK_SCSI_DEVICE_GOOD;
701 701
 
         break;
702 702
 

	
703 703
 
      case DRIVER_MEDIA:
0 comments (0 inline, 0 general)