tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

drivers:net: Remove unnecessary OOM messages after netdev_alloc_skb

Emitting netdev_alloc_skb and netdev_alloc_skb_ip_align OOM
messages is unnecessary as there is already a dump_stack
after allocation failures.

Other trivial changes around these removals:

Convert a few comparisons of pointer to 0 to !pointer.
Change flow to remove unnecessary label.
Remove now unused variable.
Hoist assignment from if.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Joe Perches and committed by
David S. Miller 720a43ef e8f83e5e

+39 -161
+1 -4
drivers/net/caif/caif_shmcore.c
··· 338 338 /* Get a suitable CAIF packet and copy in data. */ 339 339 skb = netdev_alloc_skb(pshm_drv->pshm_dev->pshm_netdev, 340 340 frm_pck_len + 1); 341 - 342 - if (skb == NULL) { 343 - pr_info("OOM: Try next frame in descriptor\n"); 341 + if (skb == NULL) 344 342 break; 345 - } 346 343 347 344 p = skb_put(skb, frm_pck_len); 348 345 memcpy(p, pbuf->desc_vptr + frm_pck_ofs, frm_pck_len);
+2 -4
drivers/net/ethernet/adi/bfin_mac.c
··· 188 188 189 189 /* allocate a new skb for next time receive */ 190 190 new_skb = netdev_alloc_skb(dev, PKT_BUF_SZ + NET_IP_ALIGN); 191 - if (!new_skb) { 192 - pr_notice("init: low on mem - packet dropped\n"); 191 + if (!new_skb) 193 192 goto init_error; 194 - } 193 + 195 194 skb_reserve(new_skb, NET_IP_ALIGN); 196 195 /* Invidate the data cache of skb->data range when it is write back 197 196 * cache. It will prevent overwritting the new data from DMA ··· 1235 1236 1236 1237 new_skb = netdev_alloc_skb(dev, PKT_BUF_SZ + NET_IP_ALIGN); 1237 1238 if (!new_skb) { 1238 - netdev_notice(dev, "rx: low on mem - packet dropped\n"); 1239 1239 dev->stats.rx_dropped++; 1240 1240 goto out; 1241 1241 }
-2
drivers/net/ethernet/amd/7990.c
··· 318 318 struct sk_buff *skb = netdev_alloc_skb(dev, len + 2); 319 319 320 320 if (!skb) { 321 - printk ("%s: Memory squeeze, deferring packet.\n", 322 - dev->name); 323 321 dev->stats.rx_dropped++; 324 322 rd->mblength = 0; 325 323 rd->rmd1_bits = LE_R1_OWN;
-1
drivers/net/ethernet/amd/a2065.c
··· 293 293 struct sk_buff *skb = netdev_alloc_skb(dev, len + 2); 294 294 295 295 if (!skb) { 296 - netdev_warn(dev, "Memory squeeze, deferring packet\n"); 297 296 dev->stats.rx_dropped++; 298 297 rd->mblength = 0; 299 298 rd->rmd1_bits = LE_R1_OWN;
-1
drivers/net/ethernet/amd/am79c961a.c
··· 528 528 dev->stats.rx_packets++; 529 529 } else { 530 530 am_writeword (dev, hdraddr + 2, RMD_OWN); 531 - printk (KERN_WARNING "%s: memory squeeze, dropping packet.\n", dev->name); 532 531 dev->stats.rx_dropped++; 533 532 break; 534 533 }
-1
drivers/net/ethernet/amd/ariadne.c
··· 193 193 194 194 skb = netdev_alloc_skb(dev, pkt_len + 2); 195 195 if (skb == NULL) { 196 - netdev_warn(dev, "Memory squeeze, deferring packet\n"); 197 196 for (i = 0; i < RX_RING_SIZE; i++) 198 197 if (lowb(priv->rx_ring[(entry + i) % RX_RING_SIZE]->RMD1) & RF_OWN) 199 198 break;
-2
drivers/net/ethernet/amd/atarilance.c
··· 996 996 else { 997 997 skb = netdev_alloc_skb(dev, pkt_len + 2); 998 998 if (skb == NULL) { 999 - DPRINTK( 1, ( "%s: Memory squeeze, deferring packet.\n", 1000 - dev->name )); 1001 999 for( i = 0; i < RX_RING_SIZE; i++ ) 1002 1000 if (MEM->rx_head[(entry+i) & RX_RING_MOD_MASK].flag & 1003 1001 RMD1_OWN_CHIP)
-1
drivers/net/ethernet/amd/au1000_eth.c
··· 727 727 frmlen -= 4; /* Remove FCS */ 728 728 skb = netdev_alloc_skb(dev, frmlen + 2); 729 729 if (skb == NULL) { 730 - netdev_err(dev, "Memory squeeze, dropping packet.\n"); 731 730 dev->stats.rx_dropped++; 732 731 continue; 733 732 }
-2
drivers/net/ethernet/amd/declance.c
··· 607 607 skb = netdev_alloc_skb(dev, len + 2); 608 608 609 609 if (skb == 0) { 610 - printk("%s: Memory squeeze, deferring packet.\n", 611 - dev->name); 612 610 dev->stats.rx_dropped++; 613 611 *rds_ptr(rd, mblength, lp->type) = 0; 614 612 *rds_ptr(rd, rmd1, lp->type) =
-1
drivers/net/ethernet/amd/pcnet32.c
··· 1166 1166 skb = netdev_alloc_skb(dev, pkt_len + NET_IP_ALIGN); 1167 1167 1168 1168 if (skb == NULL) { 1169 - netif_err(lp, drv, dev, "Memory squeeze, dropping packet\n"); 1170 1169 dev->stats.rx_dropped++; 1171 1170 return; 1172 1171 }
-3
drivers/net/ethernet/amd/sun3lance.c
··· 812 812 else { 813 813 skb = netdev_alloc_skb(dev, pkt_len + 2); 814 814 if (skb == NULL) { 815 - DPRINTK( 1, ( "%s: Memory squeeze, deferring packet.\n", 816 - dev->name )); 817 - 818 815 dev->stats.rx_dropped++; 819 816 head->msg_length = 0; 820 817 head->flag |= RMD1_OWN_CHIP;
-4
drivers/net/ethernet/amd/sunlance.c
··· 536 536 skb = netdev_alloc_skb(dev, len + 2); 537 537 538 538 if (skb == NULL) { 539 - printk(KERN_INFO "%s: Memory squeeze, deferring packet.\n", 540 - dev->name); 541 539 dev->stats.rx_dropped++; 542 540 rd->mblength = 0; 543 541 rd->rmd1_bits = LE_R1_OWN; ··· 706 708 skb = netdev_alloc_skb(dev, len + 2); 707 709 708 710 if (skb == NULL) { 709 - printk(KERN_INFO "%s: Memory squeeze, deferring packet.\n", 710 - dev->name); 711 711 dev->stats.rx_dropped++; 712 712 sbus_writew(0, &rd->mblength); 713 713 sbus_writeb(LE_R1_OWN, &rd->rmd1_bits);
+2 -4
drivers/net/ethernet/atheros/atl1e/atl1e_main.c
··· 1420 1420 packet_size = ((prrs->word1 >> RRS_PKT_SIZE_SHIFT) & 1421 1421 RRS_PKT_SIZE_MASK) - 4; /* CRC */ 1422 1422 skb = netdev_alloc_skb_ip_align(netdev, packet_size); 1423 - if (skb == NULL) { 1424 - netdev_warn(netdev, 1425 - "Memory squeeze, deferring packet\n"); 1423 + if (skb == NULL) 1426 1424 goto skip_pkt; 1427 - } 1425 + 1428 1426 memcpy(skb->data, (u8 *)(prrs + 1), packet_size); 1429 1427 skb_put(skb, packet_size); 1430 1428 skb->protocol = eth_type_trans(skb, netdev);
-3
drivers/net/ethernet/atheros/atlx/atl2.c
··· 437 437 /* alloc new buffer */ 438 438 skb = netdev_alloc_skb_ip_align(netdev, rx_size); 439 439 if (NULL == skb) { 440 - printk(KERN_WARNING 441 - "%s: Mem squeeze, deferring packet.\n", 442 - netdev->name); 443 440 /* 444 441 * Check that some rx space is free. If not, 445 442 * free one and mark stats->rx_dropped++.
+1 -3
drivers/net/ethernet/broadcom/bgmac.c
··· 245 245 246 246 /* Alloc skb */ 247 247 slot->skb = netdev_alloc_skb(bgmac->net_dev, BGMAC_RX_BUF_SIZE); 248 - if (!slot->skb) { 249 - bgmac_err(bgmac, "Allocation of skb failed!\n"); 248 + if (!slot->skb) 250 249 return -ENOMEM; 251 - } 252 250 253 251 /* Poison - if everything goes fine, hardware will overwrite it */ 254 252 rx = (struct bgmac_rx_header *)slot->skb->data;
+1 -4
drivers/net/ethernet/broadcom/sb1250-mac.c
··· 831 831 sb_new = netdev_alloc_skb(dev, ENET_PACKET_SIZE + 832 832 SMP_CACHE_BYTES * 2 + 833 833 NET_IP_ALIGN); 834 - if (sb_new == NULL) { 835 - pr_info("%s: sk_buff allocation failed\n", 836 - d->sbdma_eth->sbm_dev->name); 834 + if (sb_new == NULL) 837 835 return -ENOBUFS; 838 - } 839 836 840 837 sbdma_align_skb(sb_new, SMP_CACHE_BYTES, NET_IP_ALIGN); 841 838 }
-1
drivers/net/ethernet/cadence/at91_ether.c
··· 209 209 netif_rx(skb); 210 210 } else { 211 211 lp->stats.rx_dropped++; 212 - netdev_notice(dev, "Memory squeeze, dropping packet.\n"); 213 212 } 214 213 215 214 if (lp->rx_ring[lp->rx_tail].ctrl & MACB_BIT(RX_MHASH_MATCH))
-6
drivers/net/ethernet/cirrus/cs89x0.c
··· 478 478 /* Malloc up new buffer. */ 479 479 skb = netdev_alloc_skb(dev, length + 2); 480 480 if (skb == NULL) { 481 - /* I don't think we want to do this to a stressed system */ 482 - cs89_dbg(0, err, "%s: Memory squeeze, dropping packet\n", 483 - dev->name); 484 481 dev->stats.rx_dropped++; 485 482 486 483 /* AKPM: advance bp to the next frame */ ··· 728 731 /* Malloc up new buffer. */ 729 732 skb = netdev_alloc_skb(dev, length + 2); 730 733 if (skb == NULL) { 731 - #if 0 /* Again, this seems a cruel thing to do */ 732 - pr_warn("%s: Memory squeeze, dropping packet\n", dev->name); 733 - #endif 734 734 dev->stats.rx_dropped++; 735 735 return; 736 736 }
+2 -5
drivers/net/ethernet/dlink/dl2k.c
··· 580 580 581 581 skb = netdev_alloc_skb_ip_align(dev, np->rx_buf_sz); 582 582 np->rx_skbuff[i] = skb; 583 - if (skb == NULL) { 584 - printk (KERN_ERR 585 - "%s: alloc_list: allocate Rx buffer error! ", 586 - dev->name); 583 + if (skb == NULL) 587 584 break; 588 - } 585 + 589 586 /* Rubicon now supports 40 bits of addressing space. */ 590 587 np->rx_ring[i].fraginfo = 591 588 cpu_to_le64 ( pci_map_single (
-2
drivers/net/ethernet/freescale/fec.c
··· 743 743 skb = netdev_alloc_skb(ndev, pkt_len - 4 + NET_IP_ALIGN); 744 744 745 745 if (unlikely(!skb)) { 746 - printk("%s: Memory squeeze, dropping packet.\n", 747 - ndev->name); 748 746 ndev->stats.rx_dropped++; 749 747 } else { 750 748 skb_reserve(skb, NET_IP_ALIGN);
+3 -14
drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
··· 177 177 received++; 178 178 netif_receive_skb(skb); 179 179 } else { 180 - dev_warn(fep->dev, 181 - "Memory squeeze, dropping packet.\n"); 182 180 fep->stats.rx_dropped++; 183 181 skbn = skb; 184 182 } ··· 307 309 received++; 308 310 netif_rx(skb); 309 311 } else { 310 - dev_warn(fep->dev, 311 - "Memory squeeze, dropping packet.\n"); 312 312 fep->stats.rx_dropped++; 313 313 skbn = skb; 314 314 } ··· 501 505 */ 502 506 for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) { 503 507 skb = netdev_alloc_skb(dev, ENET_RX_FRSIZE); 504 - if (skb == NULL) { 505 - dev_warn(fep->dev, 506 - "Memory squeeze, unable to allocate skb\n"); 508 + if (skb == NULL) 507 509 break; 508 - } 510 + 509 511 skb_align(skb, ENET_RX_ALIGN); 510 512 fep->rx_skbuff[i] = skb; 511 513 CBDW_BUFADDR(bdp, ··· 587 593 588 594 /* Alloc new skb */ 589 595 new_skb = netdev_alloc_skb(dev, skb->len + 4); 590 - if (!new_skb) { 591 - if (net_ratelimit()) { 592 - dev_warn(fep->dev, 593 - "Memory squeeze, dropping tx packet.\n"); 594 - } 596 + if (!new_skb) 595 597 return NULL; 596 - } 597 598 598 599 /* Make sure new skb is properly aligned */ 599 600 skb_align(new_skb, 4);
-2
drivers/net/ethernet/fujitsu/fmvj18x_cs.c
··· 1003 1003 } 1004 1004 skb = netdev_alloc_skb(dev, pkt_len + 2); 1005 1005 if (skb == NULL) { 1006 - netdev_notice(dev, "Memory squeeze, dropping packet (len %d)\n", 1007 - pkt_len); 1008 1006 outb(F_SKP_PKT, ioaddr + RX_SKIP); 1009 1007 dev->stats.rx_dropped++; 1010 1008 break;
+3 -5
drivers/net/ethernet/i825xx/82596.c
··· 798 798 #ifdef __mc68000__ 799 799 cache_clear(virt_to_phys(newskb->data), PKT_BUF_SZ); 800 800 #endif 801 - } 802 - else 801 + } else { 803 802 skb = netdev_alloc_skb(dev, pkt_len + 2); 803 + } 804 804 memory_squeeze: 805 805 if (skb == NULL) { 806 806 /* XXX tulip.c can defer packets here!! */ 807 - printk(KERN_WARNING "%s: i596_rx Memory squeeze, dropping packet.\n", dev->name); 808 807 dev->stats.rx_dropped++; 809 - } 810 - else { 808 + } else { 811 809 if (!rx_in_place) { 812 810 /* 16 byte align the data fields */ 813 811 skb_reserve(skb, 2);
+2 -4
drivers/net/ethernet/i825xx/lib82596.c
··· 715 715 rbd->v_data = newskb->data; 716 716 rbd->b_data = SWAP32(dma_addr); 717 717 DMA_WBACK_INV(dev, rbd, sizeof(struct i596_rbd)); 718 - } else 718 + } else { 719 719 skb = netdev_alloc_skb_ip_align(dev, pkt_len); 720 + } 720 721 memory_squeeze: 721 722 if (skb == NULL) { 722 723 /* XXX tulip.c can defer packets here!! */ 723 - printk(KERN_ERR 724 - "%s: i596_rx Memory squeeze, dropping packet.\n", 725 - dev->name); 726 724 dev->stats.rx_dropped++; 727 725 } else { 728 726 if (!rx_in_place) {
+2 -7
drivers/net/ethernet/ibm/ehea/ehea_main.c
··· 402 402 skb_arr_rq1[index] = netdev_alloc_skb(dev, 403 403 EHEA_L_PKT_SIZE); 404 404 if (!skb_arr_rq1[index]) { 405 - netdev_info(dev, "Unable to allocate enough skb in the array\n"); 406 405 pr->rq1_skba.os_skbs = fill_wqes - i; 407 406 break; 408 407 } ··· 431 432 432 433 for (i = 0; i < nr_rq1a; i++) { 433 434 skb_arr_rq1[i] = netdev_alloc_skb(dev, EHEA_L_PKT_SIZE); 434 - if (!skb_arr_rq1[i]) { 435 - netdev_info(dev, "Not enough memory to allocate skb array\n"); 435 + if (!skb_arr_rq1[i]) 436 436 break; 437 - } 438 437 } 439 438 /* Ring doorbell */ 440 439 ehea_update_rq1a(pr->qp, i - 1); ··· 692 695 693 696 skb = netdev_alloc_skb(dev, 694 697 EHEA_L_PKT_SIZE); 695 - if (!skb) { 696 - netdev_err(dev, "Not enough memory to allocate skb\n"); 698 + if (!skb) 697 699 break; 698 - } 699 700 } 700 701 skb_copy_to_linear_data(skb, ((char *)cqe) + 64, 701 702 cqe->num_bytes_transfered - 4);
+2 -3
drivers/net/ethernet/mellanox/mlx4/en_selftest.c
··· 58 58 59 59 /* build the pkt before xmit */ 60 60 skb = netdev_alloc_skb(priv->dev, MLX4_LOOPBACK_TEST_PAYLOAD + ETH_HLEN + NET_IP_ALIGN); 61 - if (!skb) { 62 - en_err(priv, "-LOOPBACK_TEST_XMIT- failed to create skb for xmit\n"); 61 + if (!skb) 63 62 return -ENOMEM; 64 - } 63 + 65 64 skb_reserve(skb, NET_IP_ALIGN); 66 65 67 66 ethh = (struct ethhdr *)skb_put(skb, sizeof(struct ethhdr));
-1
drivers/net/ethernet/natsemi/sonic.c
··· 424 424 /* Malloc up new buffer. */ 425 425 new_skb = netdev_alloc_skb(dev, SONIC_RBSIZE + 2); 426 426 if (new_skb == NULL) { 427 - printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n", dev->name); 428 427 lp->stats.rx_dropped++; 429 428 break; 430 429 }
-2
drivers/net/ethernet/netx-eth.c
··· 152 152 153 153 skb = netdev_alloc_skb(ndev, len); 154 154 if (unlikely(skb == NULL)) { 155 - printk(KERN_NOTICE "%s: Low memory, packet dropped.\n", 156 - ndev->name); 157 155 ndev->stats.rx_dropped++; 158 156 return; 159 157 }
-1
drivers/net/ethernet/nuvoton/w90p910_ether.c
··· 737 737 data = ether->rdesc->recv_buf[ether->cur_rx]; 738 738 skb = netdev_alloc_skb(dev, length + 2); 739 739 if (!skb) { 740 - dev_err(&pdev->dev, "get skb buffer error\n"); 741 740 ether->stats.rx_dropped++; 742 741 return; 743 742 }
-1
drivers/net/ethernet/nvidia/forcedeth.c
··· 5025 5025 pkt_len = ETH_DATA_LEN; 5026 5026 tx_skb = netdev_alloc_skb(dev, pkt_len); 5027 5027 if (!tx_skb) { 5028 - netdev_err(dev, "netdev_alloc_skb() failed during loopback test\n"); 5029 5028 ret = 0; 5030 5029 goto out; 5031 5030 }
-1
drivers/net/ethernet/qlogic/qla3xxx.c
··· 312 312 lrg_buf_cb->skb = netdev_alloc_skb(qdev->ndev, 313 313 qdev->lrg_buffer_len); 314 314 if (unlikely(!lrg_buf_cb->skb)) { 315 - netdev_err(qdev->ndev, "failed netdev_alloc_skb()\n"); 316 315 qdev->lrg_buf_skb_check++; 317 316 } else { 318 317 /*
-6
drivers/net/ethernet/qlogic/qlge/qlge_main.c
··· 1211 1211 netdev_alloc_skb(qdev->ndev, 1212 1212 SMALL_BUFFER_SIZE); 1213 1213 if (sbq_desc->p.skb == NULL) { 1214 - netif_err(qdev, probe, qdev->ndev, 1215 - "Couldn't get an skb.\n"); 1216 1214 rx_ring->sbq_clean_idx = clean_idx; 1217 1215 return; 1218 1216 } ··· 1517 1519 1518 1520 skb = netdev_alloc_skb(ndev, length); 1519 1521 if (!skb) { 1520 - netif_err(qdev, drv, qdev->ndev, 1521 - "Couldn't get an skb, need to unwind!.\n"); 1522 1522 rx_ring->rx_dropped++; 1523 1523 put_page(lbq_desc->p.pg_chunk.page); 1524 1524 return; ··· 1601 1605 /* Allocate new_skb and copy */ 1602 1606 new_skb = netdev_alloc_skb(qdev->ndev, length + NET_IP_ALIGN); 1603 1607 if (new_skb == NULL) { 1604 - netif_err(qdev, probe, qdev->ndev, 1605 - "No skb available, drop the packet.\n"); 1606 1608 rx_ring->rx_dropped++; 1607 1609 return; 1608 1610 }
-1
drivers/net/ethernet/rdc/r6040.c
··· 350 350 do { 351 351 skb = netdev_alloc_skb(dev, MAX_BUF_SIZE); 352 352 if (!skb) { 353 - netdev_err(dev, "failed to alloc skb for rx\n"); 354 353 rc = -ENOMEM; 355 354 goto err_exit; 356 355 }
-2
drivers/net/ethernet/realtek/8139too.c
··· 2041 2041 2042 2042 netif_receive_skb (skb); 2043 2043 } else { 2044 - if (net_ratelimit()) 2045 - netdev_warn(dev, "Memory squeeze, dropping packet\n"); 2046 2044 dev->stats.rx_dropped++; 2047 2045 } 2048 2046 received++;
-2
drivers/net/ethernet/realtek/atp.c
··· 782 782 783 783 skb = netdev_alloc_skb(dev, pkt_len + 2); 784 784 if (skb == NULL) { 785 - printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n", 786 - dev->name); 787 785 dev->stats.rx_dropped++; 788 786 goto done; 789 787 }
+5 -17
drivers/net/ethernet/seeq/ether3.c
··· 651 651 skb->protocol = eth_type_trans(skb, dev); 652 652 netif_rx(skb); 653 653 received ++; 654 - } else 655 - goto dropping; 654 + } else { 655 + ether3_outw(next_ptr >> 8, REG_RECVEND); 656 + dev->stats.rx_dropped++; 657 + goto done; 658 + } 656 659 } else { 657 660 struct net_device_stats *stats = &dev->stats; 658 661 ether3_outw(next_ptr >> 8, REG_RECVEND); ··· 682 679 } 683 680 684 681 return maxcnt; 685 - 686 - dropping:{ 687 - static unsigned long last_warned; 688 - 689 - ether3_outw(next_ptr >> 8, REG_RECVEND); 690 - /* 691 - * Don't print this message too many times... 692 - */ 693 - if (time_after(jiffies, last_warned + 10 * HZ)) { 694 - last_warned = jiffies; 695 - printk("%s: memory squeeze, dropping packet.\n", dev->name); 696 - } 697 - dev->stats.rx_dropped++; 698 - goto done; 699 - } 700 682 } 701 683 702 684 /*
-2
drivers/net/ethernet/seeq/sgiseeq.c
··· 381 381 dev->stats.rx_packets++; 382 382 dev->stats.rx_bytes += len; 383 383 } else { 384 - printk(KERN_NOTICE "%s: Memory squeeze, deferring packet.\n", 385 - dev->name); 386 384 dev->stats.rx_dropped++; 387 385 } 388 386 } else {
+2 -5
drivers/net/ethernet/sis/sis900.c
··· 1841 1841 entry = sis_priv->dirty_rx % NUM_RX_DESC; 1842 1842 1843 1843 if (sis_priv->rx_skbuff[entry] == NULL) { 1844 - if ((skb = netdev_alloc_skb(net_dev, RX_BUF_SIZE)) == NULL) { 1844 + skb = netdev_alloc_skb(net_dev, RX_BUF_SIZE); 1845 + if (skb == NULL) { 1845 1846 /* not enough memory for skbuff, this makes a 1846 1847 * "hole" on the buffer ring, it is not clear 1847 1848 * how the hardware will react to this kind 1848 1849 * of degenerated buffer */ 1849 - if (netif_msg_rx_err(sis_priv)) 1850 - printk(KERN_INFO "%s: Memory squeeze, " 1851 - "deferring packet.\n", 1852 - net_dev->name); 1853 1850 net_dev->stats.rx_dropped++; 1854 1851 break; 1855 1852 }
-2
drivers/net/ethernet/smsc/smc9194.c
··· 1223 1223 dev->stats.multicast++; 1224 1224 1225 1225 skb = netdev_alloc_skb(dev, packet_length + 5); 1226 - 1227 1226 if ( skb == NULL ) { 1228 - printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n"); 1229 1227 dev->stats.rx_dropped++; 1230 1228 goto done; 1231 1229 }
-2
drivers/net/ethernet/smsc/smc91x.c
··· 465 465 */ 466 466 skb = netdev_alloc_skb(dev, packet_len); 467 467 if (unlikely(skb == NULL)) { 468 - printk(KERN_NOTICE "%s: Low memory, packet dropped.\n", 469 - dev->name); 470 468 SMC_WAIT_MMU_BUSY(lp); 471 469 SMC_SET_MMU_CMD(lp, MC_RELEASE); 472 470 dev->stats.rx_dropped++;
+1 -3
drivers/net/ethernet/smsc/smsc9420.c
··· 848 848 BUG_ON(pd->rx_buffers[index].skb); 849 849 BUG_ON(pd->rx_buffers[index].mapping); 850 850 851 - if (unlikely(!skb)) { 852 - smsc_warn(RX_ERR, "Failed to allocate new skb!"); 851 + if (unlikely(!skb)) 853 852 return -ENOMEM; 854 - } 855 853 856 854 mapping = pci_map_single(pd->pdev, skb_tail_pointer(skb), 857 855 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
+1 -4
drivers/net/ethernet/sun/sunqe.c
··· 414 414 struct qe_rxd *this; 415 415 struct sunqe_buffers *qbufs = qep->buffers; 416 416 __u32 qbufs_dvma = qep->buffers_dvma; 417 - int elem = qep->rx_new, drops = 0; 417 + int elem = qep->rx_new; 418 418 u32 flags; 419 419 420 420 this = &rxbase[elem]; ··· 436 436 } else { 437 437 skb = netdev_alloc_skb(dev, len + 2); 438 438 if (skb == NULL) { 439 - drops++; 440 439 dev->stats.rx_dropped++; 441 440 } else { 442 441 skb_reserve(skb, 2); ··· 455 456 this = &rxbase[elem]; 456 457 } 457 458 qep->rx_new = elem; 458 - if (drops) 459 - printk(KERN_NOTICE "%s: Memory squeeze, deferring packet.\n", qep->dev->name); 460 459 } 461 460 462 461 static void qe_tx_reclaim(struct sunqe *qep);
+2 -3
drivers/net/ethernet/tehuti/tehuti.c
··· 1102 1102 dno = bdx_rxdb_available(db) - 1; 1103 1103 while (dno > 0) { 1104 1104 skb = netdev_alloc_skb(priv->ndev, f->m.pktsz + NET_IP_ALIGN); 1105 - if (!skb) { 1106 - pr_err("NO MEM: netdev_alloc_skb failed\n"); 1105 + if (!skb) 1107 1106 break; 1108 - } 1107 + 1109 1108 skb_reserve(skb, NET_IP_ALIGN); 1110 1109 1111 1110 idx = bdx_rxdb_alloc_elem(db);
+1 -3
drivers/net/ethernet/ti/tlan.c
··· 1911 1911 list->frame_size = TLAN_MAX_FRAME_SIZE; 1912 1912 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER; 1913 1913 skb = netdev_alloc_skb_ip_align(dev, TLAN_MAX_FRAME_SIZE + 5); 1914 - if (!skb) { 1915 - netdev_err(dev, "Out of memory for received data\n"); 1914 + if (!skb) 1916 1915 break; 1917 - } 1918 1916 1919 1917 list->buffer[0].address = pci_map_single(priv->pci_dev, 1920 1918 skb->data,
+3 -7
drivers/net/ethernet/xilinx/ll_temac_main.c
··· 273 273 274 274 skb = netdev_alloc_skb_ip_align(ndev, 275 275 XTE_MAX_JUMBO_FRAME_SIZE); 276 - 277 - if (skb == 0) { 278 - dev_err(&ndev->dev, "alloc_skb error %d\n", i); 276 + if (!skb) 279 277 goto out; 280 - } 278 + 281 279 lp->rx_skb[i] = skb; 282 280 /* returns physical address of skb->data */ 283 281 lp->rx_bd_v[i].phys = dma_map_single(ndev->dev.parent, ··· 787 789 788 790 new_skb = netdev_alloc_skb_ip_align(ndev, 789 791 XTE_MAX_JUMBO_FRAME_SIZE); 790 - 791 - if (new_skb == 0) { 792 - dev_err(&ndev->dev, "no memory for new sk_buff\n"); 792 + if (!new_skb) { 793 793 spin_unlock_irqrestore(&lp->rx_lock, flags); 794 794 return; 795 795 }
+3 -6
drivers/net/ethernet/xilinx/xilinx_axienet_main.c
··· 235 235 ((i + 1) % RX_BD_NUM); 236 236 237 237 skb = netdev_alloc_skb_ip_align(ndev, lp->max_frm_size); 238 - if (!skb) { 239 - dev_err(&ndev->dev, "alloc_skb error %d\n", i); 238 + if (!skb) 240 239 goto out; 241 - } 242 240 243 241 lp->rx_bd_v[i].sw_id_offset = (u32) skb; 244 242 lp->rx_bd_v[i].phys = dma_map_single(ndev->dev.parent, ··· 775 777 packets++; 776 778 777 779 new_skb = netdev_alloc_skb_ip_align(ndev, lp->max_frm_size); 778 - if (!new_skb) { 779 - dev_err(&ndev->dev, "no memory for new sk_buff\n"); 780 + if (!new_skb) 780 781 return; 781 - } 782 + 782 783 cur_p->phys = dma_map_single(ndev->dev.parent, new_skb->data, 783 784 lp->max_frm_size, 784 785 DMA_FROM_DEVICE);
-1
drivers/net/ethernet/xircom/xirc2ps_cs.c
··· 1041 1041 /* 1 extra so we can use insw */ 1042 1042 skb = netdev_alloc_skb(dev, pktlen + 3); 1043 1043 if (!skb) { 1044 - pr_notice("low memory, packet dropped (size=%u)\n", pktlen); 1045 1044 dev->stats.rx_dropped++; 1046 1045 } else { /* okay get the packet */ 1047 1046 skb_reserve(skb, 2);