drivers/net: Remove unnecessary k.alloc/v.alloc OOM messages
authorJoe Perches <joe@perches.com>
Sun, 29 Jan 2012 12:56:23 +0000 (12:56 +0000)
committerDavid S. Miller <davem@davemloft.net>
Tue, 31 Jan 2012 21:20:21 +0000 (16:20 -0500)
alloc failures use dump_stack so emitting an additional
out-of-memory message is an unnecessary duplication.

Remove the allocation failure messages.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
60 files changed:
drivers/net/bonding/bond_alb.c
drivers/net/can/slcan.c
drivers/net/ethernet/amd/ni65.c
drivers/net/ethernet/apple/bmac.c
drivers/net/ethernet/apple/mace.c
drivers/net/ethernet/broadcom/bnx2.c
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
drivers/net/ethernet/brocade/bna/bnad_debugfs.c
drivers/net/ethernet/cisco/enic/enic_main.c
drivers/net/ethernet/cisco/enic/vnic_rq.c
drivers/net/ethernet/cisco/enic/vnic_wq.c
drivers/net/ethernet/i825xx/lp486e.c
drivers/net/ethernet/ibm/emac/rgmii.c
drivers/net/ethernet/ibm/emac/tah.c
drivers/net/ethernet/ibm/emac/zmii.c
drivers/net/ethernet/intel/e1000/e1000_main.c
drivers/net/ethernet/intel/ixgb/ixgb_main.c
drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
drivers/net/ethernet/korina.c
drivers/net/ethernet/marvell/pxa168_eth.c
drivers/net/ethernet/mellanox/mlx4/en_rx.c
drivers/net/ethernet/mellanox/mlx4/en_tx.c
drivers/net/ethernet/micrel/ks8851_mll.c
drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
drivers/net/ethernet/qlogic/netxen/netxen_nic_init.c
drivers/net/ethernet/qlogic/qlge/qlge_dbg.c
drivers/net/ethernet/sis/sis900.c
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
drivers/net/ethernet/sun/cassini.c
drivers/net/ethernet/sun/sunvnet.c
drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
drivers/net/hamradio/yam.c
drivers/net/hippi/rrunner.c
drivers/net/irda/donauboe.c
drivers/net/netconsole.c
drivers/net/ppp/pptp.c
drivers/net/slip/slip.c
drivers/net/tokenring/3c359.c
drivers/net/tokenring/madgemc.c
drivers/net/vmxnet3/vmxnet3_drv.c
drivers/net/wan/c101.c
drivers/net/wan/dscc4.c
drivers/net/wan/lmc/lmc_main.c
drivers/net/wan/n2.c
drivers/net/wan/pc300too.c
drivers/net/wan/pci200syn.c
drivers/net/wan/wanxl.c
drivers/net/wan/x25_asy.c
drivers/net/wireless/ath/ath9k/htc_hst.c
drivers/net/wireless/hostap/hostap_hw.c
drivers/net/wireless/ipw2x00/ipw2100.c
drivers/net/wireless/libertas/if_cs.c
drivers/net/wireless/libertas/if_usb.c
drivers/net/wireless/libertas_tf/if_usb.c
drivers/net/wireless/mwifiex/pcie.c
drivers/net/wireless/mwifiex/sdio.c
drivers/net/wireless/orinoco/main.c
drivers/net/wireless/prism54/islpci_mgt.c
drivers/net/wireless/rtlwifi/rtl8192se/sw.c
drivers/net/xen-netback/netback.c

index f820b26b9db3562e7878feffceeba32f13a0d4f3..9abfde4793166f8d323ad9a229d7a1ec09ab2fab 100644 (file)
@@ -180,11 +180,9 @@ static int tlb_initialize(struct bonding *bond)
        int i;
 
        new_hashtbl = kzalloc(size, GFP_KERNEL);
-       if (!new_hashtbl) {
-               pr_err("%s: Error: Failed to allocate TLB hash table\n",
-                      bond->dev->name);
+       if (!new_hashtbl)
                return -1;
-       }
+
        _lock_tx_hashtbl_bh(bond);
 
        bond_info->tx_hashtbl = new_hashtbl;
@@ -784,11 +782,9 @@ static int rlb_initialize(struct bonding *bond)
        int i;
 
        new_hashtbl = kmalloc(size, GFP_KERNEL);
-       if (!new_hashtbl) {
-               pr_err("%s: Error: Failed to allocate RLB hash table\n",
-                      bond->dev->name);
+       if (!new_hashtbl)
                return -1;
-       }
+
        _lock_rx_hashtbl_bh(bond);
 
        bond_info->rx_hashtbl = new_hashtbl;
index 579e7fca6447c6ee1bf9b0e8cf754280fed0b81b..98a5a7d867f5049d12afd2c9ccc944d1f18c8faf 100644 (file)
@@ -639,10 +639,8 @@ static int __init slcan_init(void)
        printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
 
        slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
-       if (!slcan_devs) {
-               printk(KERN_ERR "slcan: can't allocate slcan device array!\n");
+       if (!slcan_devs)
                return -ENOMEM;
-       }
 
        /* Fill in our line protocol discipline, and register it */
        status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
index 6e6aa7213aab50a7c6118819b5cf83c862510922..735c213798b1bbb691d5d193f8a89287cbf7a400 100644 (file)
@@ -621,10 +621,8 @@ static void *ni65_alloc_mem(struct net_device *dev,char *what,int size,int type)
        }
        else {
                ret = ptr = kmalloc(T_BUF_SIZE,GFP_KERNEL | GFP_DMA);
-               if(!ret) {
-                       printk(KERN_WARNING "%s: unable to allocate %s memory.\n",dev->name,what);
+               if(!ret)
                        return NULL;
-               }
        }
        if( (u32) virt_to_phys(ptr+size) > 0x1000000) {
                printk(KERN_WARNING "%s: unable to allocate %s memory in lower 16MB!\n",dev->name,what);
index d070b229dbf753b9f59afeef69f7391ec32f71a3..4108ac800cf0d86bb6d152ec8b47ca1798fa8736 100644 (file)
@@ -1660,10 +1660,8 @@ static int __init bmac_init(void)
 {
        if (bmac_emergency_rxbuf == NULL) {
                bmac_emergency_rxbuf = kmalloc(RX_BUFLEN, GFP_KERNEL);
-               if (bmac_emergency_rxbuf == NULL) {
-                       printk(KERN_ERR "BMAC: can't allocate emergency RX buffer\n");
+               if (bmac_emergency_rxbuf == NULL)
                        return -ENOMEM;
-               }
        }
 
        return macio_register_driver(&bmac_driver);
index bec87bd9195c018872cd3e1c218b893962e3f7a3..45ba18ee3d6a92ae6d0c775884e33459a762dc4d 100644 (file)
@@ -136,10 +136,8 @@ static int __devinit mace_probe(struct macio_dev *mdev, const struct of_device_i
         */
        if (dummy_buf == NULL) {
                dummy_buf = kmalloc(RX_BUFLEN+2, GFP_KERNEL);
-               if (dummy_buf == NULL) {
-                       printk(KERN_ERR "MACE: couldn't allocate dummy buffer\n");
+               if (dummy_buf == NULL)
                        return -ENOMEM;
-               }
        }
 
        if (macio_request_resources(mdev, "mace")) {
index 021fb818007a7932fa9eb918d188f9507aff517d..0a4c5405dcf4abc8cd388ebcdd25acec8989aa3e 100644 (file)
@@ -2625,10 +2625,8 @@ bnx2_alloc_bad_rbuf(struct bnx2 *bp)
        u32 val;
 
        good_mbuf = kmalloc(512 * sizeof(u16), GFP_KERNEL);
-       if (good_mbuf == NULL) {
-               pr_err("Failed to allocate memory in %s\n", __func__);
+       if (good_mbuf == NULL)
                return -ENOMEM;
-       }
 
        REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
                BNX2_MISC_ENABLE_SET_BITS_RX_MBUF_ENABLE);
index fea96150539199c67d7306efbcb286d3b1d22606..582cbcf5f9fbb44001e544987a121e5b1e6a30fb 100644 (file)
@@ -10894,10 +10894,8 @@ static inline void be16_to_cpu_n(const u8 *_source, u8 *_target, u32 n)
 do {                                                                   \
        u32 len = be32_to_cpu(fw_hdr->arr.len);                         \
        bp->arr = kmalloc(len, GFP_KERNEL);                             \
-       if (!bp->arr) {                                                 \
-               pr_err("Failed to allocate %d bytes for "#arr"\n", len); \
+       if (!bp->arr)                                                   \
                goto lbl;                                               \
-       }                                                               \
        func(bp->firmware->data + be32_to_cpu(fw_hdr->arr.offset),      \
             (u8 *)bp->arr, len);                                       \
 } while (0)
index 592ad3929f530461b71a4412a8ad11d6d63527cd..c9fdceb135f3958702863a25c9151611adf06077 100644 (file)
@@ -62,8 +62,6 @@ bnad_debugfs_open_fwtrc(struct inode *inode, struct file *file)
        if (!fw_debug->debug_buffer) {
                kfree(fw_debug);
                fw_debug = NULL;
-               pr_warn("bna %s: Failed to allocate fwtrc buffer\n",
-                       pci_name(bnad->pcidev));
                return -ENOMEM;
        }
 
@@ -105,8 +103,6 @@ bnad_debugfs_open_fwsave(struct inode *inode, struct file *file)
        if (!fw_debug->debug_buffer) {
                kfree(fw_debug);
                fw_debug = NULL;
-               pr_warn("bna %s: Failed to allocate fwsave buffer\n",
-                       pci_name(bnad->pcidev));
                return -ENOMEM;
        }
 
@@ -208,8 +204,6 @@ bnad_debugfs_open_drvinfo(struct inode *inode, struct file *file)
        if (!drv_info->debug_buffer) {
                kfree(drv_info);
                drv_info = NULL;
-               pr_warn("bna %s: Failed to allocate drv info buffer\n",
-                       pci_name(bnad->pcidev));
                return -ENOMEM;
        }
 
@@ -348,11 +342,8 @@ bnad_debugfs_write_regrd(struct file *file, const char __user *buf,
 
        /* Allocate memory to store the user space buf */
        kern_buf = kzalloc(nbytes, GFP_KERNEL);
-       if (!kern_buf) {
-               pr_warn("bna %s: Failed to allocate user buffer\n",
-                       pci_name(bnad->pcidev));
+       if (!kern_buf)
                return -ENOMEM;
-       }
 
        if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
                kfree(kern_buf);
@@ -373,11 +364,8 @@ bnad_debugfs_write_regrd(struct file *file, const char __user *buf,
        bnad->reglen = 0;
 
        bnad->regdata = kzalloc(len << 2, GFP_KERNEL);
-       if (!bnad->regdata) {
-               pr_warn("bna %s: Failed to allocate regrd buffer\n",
-                       pci_name(bnad->pcidev));
+       if (!bnad->regdata)
                return -ENOMEM;
-       }
 
        bnad->reglen = len << 2;
        rb = bfa_ioc_bar0(ioc);
@@ -421,11 +409,8 @@ bnad_debugfs_write_regwr(struct file *file, const char __user *buf,
 
        /* Allocate memory to store the user space buf */
        kern_buf = kzalloc(nbytes, GFP_KERNEL);
-       if (!kern_buf) {
-               pr_warn("bna %s: Failed to allocate user buffer\n",
-                       pci_name(bnad->pcidev));
+       if (!kern_buf)
                return -ENOMEM;
-       }
 
        if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
                kfree(kern_buf);
index ab3f67f980d8c3f7554d19bf3fdbaf275deefed3..07df13745c43704ff6d5055f244ea0a400cc9efb 100644 (file)
@@ -2388,7 +2388,6 @@ static int __devinit enic_probe(struct pci_dev *pdev,
        /* Allocate structure for port profiles */
        enic->pp = kcalloc(num_pps, sizeof(*enic->pp), GFP_KERNEL);
        if (!enic->pp) {
-               pr_err("port profile alloc failed, aborting\n");
                err = -ENOMEM;
                goto err_out_disable_sriov_pp;
        }
index 34105e0951a5d40a24ef80e2e40bf1b24c898df3..7e1488fc8ab28bc3ab6c5f6565e9cf61c70f62d9 100644 (file)
@@ -38,10 +38,8 @@ static int vnic_rq_alloc_bufs(struct vnic_rq *rq)
 
        for (i = 0; i < blks; i++) {
                rq->bufs[i] = kzalloc(VNIC_RQ_BUF_BLK_SZ(count), GFP_ATOMIC);
-               if (!rq->bufs[i]) {
-                       pr_err("Failed to alloc rq_bufs\n");
+               if (!rq->bufs[i])
                        return -ENOMEM;
-               }
        }
 
        for (i = 0; i < blks; i++) {
index df61bd932ea622ef71b591406383f749db3f7fba..5e0d7a2be9bc4a95c32864ba7fc25d14b0b5f3c9 100644 (file)
@@ -38,10 +38,8 @@ static int vnic_wq_alloc_bufs(struct vnic_wq *wq)
 
        for (i = 0; i < blks; i++) {
                wq->bufs[i] = kzalloc(VNIC_WQ_BUF_BLK_SZ(count), GFP_ATOMIC);
-               if (!wq->bufs[i]) {
-                       pr_err("Failed to alloc wq_bufs\n");
+               if (!wq->bufs[i])
                        return -ENOMEM;
-               }
        }
 
        for (i = 0; i < blks; i++) {
index 414044b3cb113e384ab2ed902305a9ec4e267ef7..02df5f5accb1a7ec1be7281dd4163910dbe08aba 100644 (file)
@@ -454,8 +454,6 @@ init_rx_bufs(struct net_device *dev, int num) {
                        }
 
                        rfd->rbd = rbd;
-               } else {
-                       printk("Could not kmalloc rbd\n");
                }
        }
        lp->rbd_tail->next = rfd->rbd;
index 05484f918ee3f1a9e7385daa943a7f5c8b816362..d3123282e18ec3b8de290899bd6117df14995fa3 100644 (file)
@@ -237,11 +237,8 @@ static int __devinit rgmii_probe(struct platform_device *ofdev)
 
        rc = -ENOMEM;
        dev = kzalloc(sizeof(struct rgmii_instance), GFP_KERNEL);
-       if (dev == NULL) {
-               printk(KERN_ERR "%s: could not allocate RGMII device!\n",
-                      np->full_name);
+       if (dev == NULL)
                goto err_gone;
-       }
 
        mutex_init(&dev->lock);
        dev->ofdev = ofdev;
index 0d9881efe2ff954e0fbbff9ac60a60e55da47ea6..872912ef518d163f6a4df7108e53fad0bb658afc 100644 (file)
@@ -96,11 +96,8 @@ static int __devinit tah_probe(struct platform_device *ofdev)
 
        rc = -ENOMEM;
        dev = kzalloc(sizeof(struct tah_instance), GFP_KERNEL);
-       if (dev == NULL) {
-               printk(KERN_ERR "%s: could not allocate TAH device!\n",
-                      np->full_name);
+       if (dev == NULL)
                goto err_gone;
-       }
 
        mutex_init(&dev->lock);
        dev->ofdev = ofdev;
index e799a6116ba51231ef4e665731cbf62d25bbd6b7..415e9b4d54086ce6e7e8a2afdeeb2ea1582a2f10 100644 (file)
@@ -240,11 +240,8 @@ static int __devinit zmii_probe(struct platform_device *ofdev)
 
        rc = -ENOMEM;
        dev = kzalloc(sizeof(struct zmii_instance), GFP_KERNEL);
-       if (dev == NULL) {
-               printk(KERN_ERR "%s: could not allocate ZMII device!\n",
-                      np->full_name);
+       if (dev == NULL)
                goto err_gone;
-       }
 
        mutex_init(&dev->lock);
        dev->ofdev = ofdev;
index 669ca3800c01a15ced19745c9af8f6312b651f4e..363fd395c75b0235962a575a8078d87586485e98 100644 (file)
@@ -730,10 +730,8 @@ static void e1000_dump_eeprom(struct e1000_adapter *adapter)
        eeprom.offset = 0;
 
        data = kmalloc(eeprom.len, GFP_KERNEL);
-       if (!data) {
-               pr_err("Unable to allocate memory to dump EEPROM data\n");
+       if (!data)
                return;
-       }
 
        ops->get_eeprom(netdev, &eeprom, data);
 
index 9bd5faf64a85c36a9ad7438cd98588354a88b556..002478801a1b655fd3508c05c967ea312838b55b 100644 (file)
@@ -1136,10 +1136,8 @@ ixgb_set_multi(struct net_device *netdev)
                u8 *mta = kmalloc(IXGB_MAX_NUM_MULTICAST_ADDRESSES *
                              ETH_ALEN, GFP_ATOMIC);
                u8 *addr;
-               if (!mta) {
-                       pr_err("allocation of multicast memory failed\n");
+               if (!mta)
                        goto alloc_failed;
-               }
 
                IXGB_WRITE_REG(hw, RCTL, rctl);
 
index bed411bada21bf8d9f349dd360a20daa9f76be23..f3bc9333a082a07a3de0826ecb482ee60dd46785 100644 (file)
@@ -2517,12 +2517,8 @@ int ixgbevf_setup_rx_resources(struct ixgbevf_adapter *adapter,
 
        size = sizeof(struct ixgbevf_rx_buffer) * rx_ring->count;
        rx_ring->rx_buffer_info = vzalloc(size);
-       if (!rx_ring->rx_buffer_info) {
-               hw_dbg(&adapter->hw,
-                      "Unable to vmalloc buffer memory for "
-                      "the receive descriptor ring\n");
+       if (!rx_ring->rx_buffer_info)
                goto alloc_failed;
-       }
 
        /* Round up to nearest 4K */
        rx_ring->size = rx_ring->count * sizeof(union ixgbe_adv_rx_desc);
index 6ad094f176f8b175d6a3c63f1d61b6fbd3e06ec6..341d10130dcae13284ee31480ca09db7731023cd 100644 (file)
@@ -1150,7 +1150,6 @@ static int korina_probe(struct platform_device *pdev)
 
        lp->td_ring = kmalloc(TD_RING_SIZE + RD_RING_SIZE, GFP_KERNEL);
        if (!lp->td_ring) {
-               printk(KERN_ERR DRV_NAME ": cannot allocate descriptors\n");
                rc = -ENXIO;
                goto probe_err_td_ring;
        }
index 953ba5851f7b44174f2800a163214409cc7ebb3a..92b4b4e68e3b7b55071b7bc89cd9a4eeff6db15c 100644 (file)
@@ -1017,10 +1017,9 @@ static int rxq_init(struct net_device *dev)
        /* Allocate RX skb rings */
        pep->rx_skb = kmalloc(sizeof(*pep->rx_skb) * pep->rx_ring_size,
                             GFP_KERNEL);
-       if (!pep->rx_skb) {
-               printk(KERN_ERR "%s: Cannot alloc RX skb ring\n", dev->name);
+       if (!pep->rx_skb)
                return -ENOMEM;
-       }
+
        /* Allocate RX ring */
        pep->rx_desc_count = 0;
        size = pep->rx_ring_size * sizeof(struct rx_desc);
@@ -1081,10 +1080,9 @@ static int txq_init(struct net_device *dev)
 
        pep->tx_skb = kmalloc(sizeof(*pep->tx_skb) * pep->tx_ring_size,
                             GFP_KERNEL);
-       if (!pep->tx_skb) {
-               printk(KERN_ERR "%s: Cannot alloc TX skb ring\n", dev->name);
+       if (!pep->tx_skb)
                return -ENOMEM;
-       }
+
        /* Allocate TX ring */
        pep->tx_desc_count = 0;
        size = pep->tx_ring_size * sizeof(struct tx_desc);
index 971d4b6b8dfee21aed00724fd3af8a36fc8f6608..f61d0e08f52bbd93f2b4cd329cd393ace17f6829 100644 (file)
@@ -281,10 +281,9 @@ int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
        tmp = size * roundup_pow_of_two(MLX4_EN_MAX_RX_FRAGS *
                                        sizeof(struct skb_frag_struct));
        ring->rx_info = vmalloc(tmp);
-       if (!ring->rx_info) {
-               en_err(priv, "Failed allocating rx_info ring\n");
+       if (!ring->rx_info)
                return -ENOMEM;
-       }
+
        en_dbg(DRV, priv, "Allocated rx_info ring at addr:%p size:%d\n",
                 ring->rx_info, tmp);
 
index 9ef9038d0629972315a77a3019a8d565395761d0..ff3250586584f9a7229aa97b4b2f290e36348f7e 100644 (file)
@@ -71,16 +71,14 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
 
        tmp = size * sizeof(struct mlx4_en_tx_info);
        ring->tx_info = vmalloc(tmp);
-       if (!ring->tx_info) {
-               en_err(priv, "Failed allocating tx_info ring\n");
+       if (!ring->tx_info)
                return -ENOMEM;
-       }
+
        en_dbg(DRV, priv, "Allocated tx_info ring at addr:%p size:%d\n",
                 ring->tx_info, tmp);
 
        ring->bounce_buf = kmalloc(MAX_DESC_SIZE, GFP_KERNEL);
        if (!ring->bounce_buf) {
-               en_err(priv, "Failed allocating bounce buffer\n");
                err = -ENOMEM;
                goto err_tx;
        }
index a37264e61a20215815f21ecc853200b964a6dcb9..4a9d57fb9fb458825e497c41a4b4f4ce40ba5a29 100644 (file)
@@ -1501,10 +1501,8 @@ static int ks_hw_init(struct ks_net *ks)
        ks->mcast_lst_size = 0;
 
        ks->frame_head_info = kmalloc(MHEADER_SIZE, GFP_KERNEL);
-       if (!ks->frame_head_info) {
-               pr_err("Error: Fail to allocate frame memory\n");
+       if (!ks->frame_head_info)
                return false;
-       }
 
        ks_set_mac(ks, KS_DEFAULT_MAC_ADDRESS);
        return true;
index 3ead111111e1f1bec8eaa10e3f5c9dee0650f4a9..0217991fede7ed8370ca03b536f77f0dc5dd661e 100644 (file)
@@ -1587,10 +1587,8 @@ int pch_gbe_setup_tx_resources(struct pch_gbe_adapter *adapter,
 
        size = (int)sizeof(struct pch_gbe_buffer) * tx_ring->count;
        tx_ring->buffer_info = vzalloc(size);
-       if (!tx_ring->buffer_info) {
-               pr_err("Unable to allocate memory for the buffer information\n");
+       if (!tx_ring->buffer_info)
                return -ENOMEM;
-       }
 
        tx_ring->size = tx_ring->count * (int)sizeof(struct pch_gbe_tx_desc);
 
@@ -1636,10 +1634,9 @@ int pch_gbe_setup_rx_resources(struct pch_gbe_adapter *adapter,
 
        size = (int)sizeof(struct pch_gbe_buffer) * rx_ring->count;
        rx_ring->buffer_info = vzalloc(size);
-       if (!rx_ring->buffer_info) {
-               pr_err("Unable to allocate memory for the receive descriptor ring\n");
+       if (!rx_ring->buffer_info)
                return -ENOMEM;
-       }
+
        rx_ring->size = rx_ring->count * (int)sizeof(struct pch_gbe_rx_desc);
        rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
                                           &rx_ring->dma, GFP_KERNEL);
index a8259cc19a63484e7eefc609514fffd6ac88f0bb..094d26c51816a260d60797c8b5eb5ed83b91fa2f 100644 (file)
@@ -280,13 +280,10 @@ int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
 
                }
                rds_ring->rx_buf_arr = vzalloc(RCV_BUFF_RINGSIZE(rds_ring));
-               if (rds_ring->rx_buf_arr == NULL) {
-                       printk(KERN_ERR "%s: Failed to allocate "
-                               "rx buffer ring %d\n",
-                               netdev->name, ring);
+               if (rds_ring->rx_buf_arr == NULL)
                        /* free whatever was already allocated */
                        goto err_out;
-               }
+
                INIT_LIST_HEAD(&rds_ring->free_list);
                /*
                 * Now go through all of them, set reference handles
@@ -480,11 +477,8 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter)
        }
 
        buf = kcalloc(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
-       if (buf == NULL) {
-               printk("%s: netxen_pinit_from_rom: Unable to calloc memory.\n",
-                               netxen_nic_driver_name);
+       if (buf == NULL)
                return -ENOMEM;
-       }
 
        for (i = 0; i < n; i++) {
                if (netxen_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
index fca804f36d61a2e6f2d79140945adee3732a2ec1..58185b604b729c131c9215bbdf9c8cfbbb53f24c 100644 (file)
@@ -1824,10 +1824,8 @@ void ql_dump_hw_cb(struct ql_adapter *qdev, int size, u32 bit, u16 q_id)
        pr_err("%s: Enter\n", __func__);
 
        ptr = kmalloc(size, GFP_ATOMIC);
-       if (ptr == NULL) {
-               pr_err("%s: Couldn't allocate a buffer\n", __func__);
+       if (ptr == NULL)
                return;
-       }
 
        if (ql_write_cfg(qdev, ptr, size, bit, q_id)) {
                pr_err("%s: Failed to upload control block!\n", __func__);
index c8efc708c792a63d47bb608d1ff16659613bd0c5..91c44688bc3e84200de847de4518a1fa97db4869 100644 (file)
@@ -619,7 +619,6 @@ static int __devinit sis900_mii_probe(struct net_device * net_dev)
                }
 
                if ((mii_phy = kmalloc(sizeof(struct mii_phy), GFP_KERNEL)) == NULL) {
-                       printk(KERN_WARNING "Cannot allocate mem for struct mii_phy\n");
                        mii_phy = sis_priv->first_mii;
                        while (mii_phy) {
                                struct mii_phy *phy;
index 96fa2da307630f1e46df75441af10c91f0fd4c79..ffc7581879b1e5fb65faa05ca941897e89700334 100644 (file)
@@ -954,10 +954,9 @@ static int stmmac_open(struct net_device *dev)
 
 #ifdef CONFIG_STMMAC_TIMER
        priv->tm = kzalloc(sizeof(struct stmmac_timer *), GFP_KERNEL);
-       if (unlikely(priv->tm == NULL)) {
-               pr_err("%s: ERROR: timer memory alloc failed\n", __func__);
+       if (unlikely(priv->tm == NULL))
                return -ENOMEM;
-       }
+
        priv->tm->freq = tmrate;
 
        /* Test if the external timer can be actually used.
index f10665f594c4f8aaaf37b1e81632e80513f28447..46d84abe553d6a60a6e9ffdb30b124a3a445d50d 100644 (file)
@@ -835,7 +835,6 @@ static int cas_saturn_firmware_init(struct cas *cp)
        cp->fw_data = vmalloc(cp->fw_size);
        if (!cp->fw_data) {
                err = -ENOMEM;
-               pr_err("\"%s\" Failed %d\n", fw_name, err);
                goto out;
        }
        memcpy(cp->fw_data, &fw->data[2], cp->fw_size);
index 8c6c059f34899d98d50bc6e1d1b2afc65c7aedb1..2896f6e9672b8d79e726f2edfd028d07fa9ef668 100644 (file)
@@ -949,10 +949,9 @@ static int __devinit vnet_port_alloc_tx_bufs(struct vnet_port *port)
                int map_len = (ETH_FRAME_LEN + 7) & ~7;
 
                err = -ENOMEM;
-               if (!buf) {
-                       pr_err("TX buffer allocation failure\n");
+               if (!buf)
                        goto err_out;
-               }
+
                err = -EFAULT;
                if ((unsigned long)buf & (8UL - 1)) {
                        pr_err("TX buffer misaligned\n");
@@ -1165,10 +1164,8 @@ static int __devinit vnet_port_probe(struct vio_dev *vdev,
 
        port = kzalloc(sizeof(*port), GFP_KERNEL);
        err = -ENOMEM;
-       if (!port) {
-               pr_err("Cannot allocate vnet_port\n");
+       if (!port)
                goto err_out_put_mdesc;
-       }
 
        for (i = 0; i < ETH_ALEN; i++)
                port->raddr[i] = (*rmac >> (5 - i) * 8) & 0xff;
index fd4ed7f8cfa102afe368a497add1f7ef1365079d..5c14f82c49549ca2089c5b2d3af1a84519a2bf4c 100644 (file)
@@ -1621,10 +1621,9 @@ static void gelic_wl_scan_complete_event(struct gelic_wl_info *wl)
                kfree(target->hwinfo);
                target->hwinfo = kzalloc(be16_to_cpu(scan_info->size),
                                         GFP_KERNEL);
-               if (!target->hwinfo) {
-                       pr_info("%s: kzalloc failed\n", __func__);
+               if (!target->hwinfo)
                        continue;
-               }
+
                /* copy hw scan info */
                memcpy(target->hwinfo, scan_info, scan_info->size);
                target->essid_len = strnlen(scan_info->essid,
index 96a98d2ff1513e3c5f0b682ed8a5a0d5c3ba9118..696327773fbe468e91edbf527d01ec0be54cd450 100644 (file)
@@ -403,7 +403,6 @@ static unsigned char *add_mcs(unsigned char *bits, int bitrate,
 
        /* Allocate a new mcs */
        if ((p = kmalloc(sizeof(struct yam_mcs), GFP_KERNEL)) == NULL) {
-               printk(KERN_WARNING "YAM: no memory to allocate mcs\n");
                release_firmware(fw);
                return NULL;
        }
index e68c941926f16cf44feebe7ef103947592b0263e..2a51363d9fed2947e8c60831a6c106b077266302 100644 (file)
@@ -1600,12 +1600,8 @@ static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                }
 
                image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
-               if (!image){
-                       printk(KERN_ERR "%s: Unable to allocate memory "
-                              "for EEPROM image\n", dev->name);
+               if (!image)
                        return -ENOMEM;
-               }
-
 
                if (rrpriv->fw_running){
                        printk("%s: Firmware already running\n", dev->name);
@@ -1637,8 +1633,6 @@ static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
                oldimage = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
                if (!image || !oldimage) {
-                       printk(KERN_ERR "%s: Unable to allocate memory "
-                              "for EEPROM image\n", dev->name);
                        error = -ENOMEM;
                        goto wf_out;
                }
index 64f403da101cab6d4446328fd4dc972e506ffe20..617a446d126c0d158bfdba1ac5b2c21a9401ad35 100644 (file)
@@ -1608,7 +1608,6 @@ toshoboe_open (struct pci_dev *pci_dev, const struct pci_device_id *pdid)
   self->ringbuf = kmalloc(OBOE_RING_LEN << 1, GFP_KERNEL);
   if (!self->ringbuf)
     {
-      printk (KERN_ERR DRIVER_NAME ": can't allocate DMA buffers\n");
       err = -ENOMEM;
       goto freeregion;
     }
@@ -1647,7 +1646,6 @@ toshoboe_open (struct pci_dev *pci_dev, const struct pci_device_id *pdid)
 
   if (!ok)
     {
-      printk (KERN_ERR DRIVER_NAME ": can't allocate rx/tx buffers\n");
       err = -ENOMEM;
       goto freebufs;
     }
index e8882023576b94206d5cc13773c27b3af20761ea..f9347ea3d381e113d20c6a13ec32f0f51c5fc04c 100644 (file)
@@ -169,10 +169,8 @@ static struct netconsole_target *alloc_param_target(char *target_config)
         * Note that these targets get their config_item fields zeroed-out.
         */
        nt = kzalloc(sizeof(*nt), GFP_KERNEL);
-       if (!nt) {
-               printk(KERN_ERR "netconsole: failed to allocate memory\n");
+       if (!nt)
                goto fail;
-       }
 
        nt->np.name = "netconsole";
        strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
@@ -551,10 +549,8 @@ static struct config_item *make_netconsole_target(struct config_group *group,
         * Target is disabled at creation (enabled == 0).
         */
        nt = kzalloc(sizeof(*nt), GFP_KERNEL);
-       if (!nt) {
-               printk(KERN_ERR "netconsole: failed to allocate memory\n");
+       if (!nt)
                return ERR_PTR(-ENOMEM);
-       }
 
        nt->np.name = "netconsole";
        strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
index df884dde2a511c27b95db1edef5848886b6c9abd..234cd9d87ed91db55efbbfaf312861525988407f 100644 (file)
@@ -670,10 +670,8 @@ static int __init pptp_init_module(void)
        pr_info("PPTP driver version " PPTP_DRIVER_VERSION "\n");
 
        callid_sock = vzalloc((MAX_CALLID + 1) * sizeof(void *));
-       if (!callid_sock) {
-               pr_err("PPTP: cann't allocate memory\n");
+       if (!callid_sock)
                return -ENOMEM;
-       }
 
        err = gre_add_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
        if (err) {
index ba08341fb92c6b4f5c3752c316d8de3d156e8c4a..69345dfae0fdcef3773b94d21f394b0814c20ae0 100644 (file)
@@ -1296,10 +1296,8 @@ static int __init slip_init(void)
 
        slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
                                                                GFP_KERNEL);
-       if (!slip_devs) {
-               printk(KERN_ERR "SLIP: Can't allocate slip devices array.\n");
+       if (!slip_devs)
                return -ENOMEM;
-       }
 
        /* Fill in our line protocol discipline, and register it */
        status = tty_register_ldisc(N_SLIP, &sl_ldisc);
index ef9fdf3652f6cda144ace331db52ff67a2a2c43a..d7c292aa76b1528f9b979afe3a6c17d48e080a02 100644 (file)
@@ -674,15 +674,11 @@ static int xl_open(struct net_device *dev)
        /* These MUST be on 8 byte boundaries */
        xl_priv->xl_tx_ring = kzalloc((sizeof(struct xl_tx_desc) * XL_TX_RING_SIZE) + 7, GFP_DMA | GFP_KERNEL);
        if (xl_priv->xl_tx_ring == NULL) {
-               printk(KERN_WARNING "%s: Not enough memory to allocate tx buffers.\n",
-                                    dev->name);
                free_irq(dev->irq,dev);
                return -ENOMEM;
        }
        xl_priv->xl_rx_ring = kzalloc((sizeof(struct xl_rx_desc) * XL_RX_RING_SIZE) +7, GFP_DMA | GFP_KERNEL);
        if (xl_priv->xl_rx_ring == NULL) {
-               printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers.\n",
-                                    dev->name);
                free_irq(dev->irq,dev);
                kfree(xl_priv->xl_tx_ring);
                return -ENOMEM;
index 6153cfd696b62647ae5ca50dfa16cd58d93679b1..1cdc034f6aecd7bfef9ebb828956994886a534ce 100644 (file)
@@ -171,7 +171,6 @@ static int __devinit madgemc_probe(struct device *device)
 
        card = kmalloc(sizeof(struct card_info), GFP_KERNEL);
        if (card==NULL) {
-               printk("madgemc: unable to allocate card struct\n");
                ret = -ENOMEM;
                goto getout1;
        }
index be6aa353f6a1f8c525f0bc673fe79eb03a1a1e10..87c0b586f11f8e87b05c19d97401d16b2b2bdf44 100644 (file)
@@ -537,11 +537,8 @@ vmxnet3_tq_create(struct vmxnet3_tx_queue *tq,
 
        tq->buf_info = kcalloc(tq->tx_ring.size, sizeof(tq->buf_info[0]),
                               GFP_KERNEL);
-       if (!tq->buf_info) {
-               printk(KERN_ERR "%s: failed to allocate tx bufinfo\n",
-                      adapter->netdev->name);
+       if (!tq->buf_info)
                goto err;
-       }
 
        return 0;
 
@@ -1519,11 +1516,9 @@ vmxnet3_rq_create(struct vmxnet3_rx_queue *rq, struct vmxnet3_adapter *adapter)
        sz = sizeof(struct vmxnet3_rx_buf_info) * (rq->rx_ring[0].size +
                                                   rq->rx_ring[1].size);
        bi = kzalloc(sz, GFP_KERNEL);
-       if (!bi) {
-               printk(KERN_ERR "%s: failed to allocate rx bufinfo\n",
-                      adapter->netdev->name);
+       if (!bi)
                goto err;
-       }
+
        rq->buf_info[0] = bi;
        rq->buf_info[1] = bi + rq->rx_ring[0].size;
 
@@ -2964,8 +2959,6 @@ vmxnet3_probe_device(struct pci_dev *pdev,
 
        adapter->pm_conf = kmalloc(sizeof(struct Vmxnet3_PMConf), GFP_KERNEL);
        if (adapter->pm_conf == NULL) {
-               printk(KERN_ERR "Failed to allocate memory for %s\n",
-                       pci_name(pdev));
                err = -ENOMEM;
                goto err_alloc_pm;
        }
@@ -2974,8 +2967,6 @@ vmxnet3_probe_device(struct pci_dev *pdev,
 
        adapter->rss_conf = kmalloc(sizeof(struct UPT1_RSSConf), GFP_KERNEL);
        if (adapter->rss_conf == NULL) {
-               printk(KERN_ERR "Failed to allocate memory for %s\n",
-                      pci_name(pdev));
                err = -ENOMEM;
                goto err_alloc_rss;
        }
index 54f995f4a5a3d64ad35a80fa213f4428af7b655e..09a50751763b1990f1b778ef62051c06743675c2 100644 (file)
@@ -325,10 +325,8 @@ static int __init c101_run(unsigned long irq, unsigned long winbase)
        }
 
        card = kzalloc(sizeof(card_t), GFP_KERNEL);
-       if (card == NULL) {
-               pr_err("unable to allocate memory\n");
+       if (card == NULL)
                return -ENOBUFS;
-       }
 
        card->dev = alloc_hdlcdev(card);
        if (!card->dev) {
index 058e1697c17447074c7c38619029904cdc2e4709..fe8d060d8fffb153b78791fa11f802b7c2d911cc 100644 (file)
@@ -903,10 +903,8 @@ static int dscc4_found1(struct pci_dev *pdev, void __iomem *ioaddr)
        int i, ret = -ENOMEM;
 
        root = kcalloc(dev_per_card, sizeof(*root), GFP_KERNEL);
-       if (!root) {
-               pr_err("can't allocate data\n");
+       if (!root)
                goto err_out;
-       }
 
        for (i = 0; i < dev_per_card; i++) {
                root[i].dev = alloc_hdlcdev(root + i);
@@ -915,10 +913,8 @@ static int dscc4_found1(struct pci_dev *pdev, void __iomem *ioaddr)
        }
 
        ppriv = kzalloc(sizeof(*ppriv), GFP_KERNEL);
-       if (!ppriv) {
-               pr_err("can't allocate private data\n");
+       if (!ppriv)
                goto err_free_dev;
-       }
 
        ppriv->root = root;
        spin_lock_init(&ppriv->lock);
index b7f2358d23befa7bc2d097b41c55fbf9ce18b506..76a8a4a522e9355219a5f12c001c72265718dcef 100644 (file)
@@ -497,7 +497,6 @@ int lmc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) /*fold00*/
 
                     data = kmalloc(xc.len, GFP_KERNEL);
                     if (!data) {
-                            printk(KERN_WARNING "%s: Failed to allocate memory for copy\n", dev->name);
                             ret = -ENOMEM;
                             break;
                     }
index 5129ad514d26773069e63acef30bf6c7e185332a..315bf09d6a2026aea0068eee58b893ef1431fcae 100644 (file)
@@ -358,10 +358,8 @@ static int __init n2_run(unsigned long io, unsigned long irq,
        }
 
        card = kzalloc(sizeof(card_t), GFP_KERNEL);
-       if (card == NULL) {
-               pr_err("unable to allocate memory\n");
+       if (card == NULL)
                return -ENOBUFS;
-       }
 
        card->ports[0].dev = alloc_hdlcdev(&card->ports[0]);
        card->ports[1].dev = alloc_hdlcdev(&card->ports[1]);
index c49c1b3c7aad6b30866008378788d486cb115bdf..5fe246e060d7b8288f933e8f83856eade0e37271 100644 (file)
@@ -320,7 +320,6 @@ static int __devinit pc300_pci_init_one(struct pci_dev *pdev,
 
        card = kzalloc(sizeof(card_t), GFP_KERNEL);
        if (card == NULL) {
-               pr_err("unable to allocate memory\n");
                pci_release_regions(pdev);
                pci_disable_device(pdev);
                return -ENOBUFS;
index 1ce21163c776804d211764d42cfac534364bd0a8..9659fcaa34ed5001f973f62ed600aebc4e314885 100644 (file)
@@ -299,7 +299,6 @@ static int __devinit pci200_pci_init_one(struct pci_dev *pdev,
 
        card = kzalloc(sizeof(card_t), GFP_KERNEL);
        if (card == NULL) {
-               pr_err("unable to allocate memory\n");
                pci_release_regions(pdev);
                pci_disable_device(pdev);
                return -ENOBUFS;
index 44b707197258948fa3351de4cc8ca246676d922c..feb7541b33fbb8191928581eaaacc024dc193e5c 100644 (file)
@@ -604,7 +604,6 @@ static int __devinit wanxl_pci_init_one(struct pci_dev *pdev,
        alloc_size = sizeof(card_t) + ports * sizeof(port_t);
        card = kzalloc(alloc_size, GFP_KERNEL);
        if (card == NULL) {
-               pr_err("%s: unable to allocate memory\n", pci_name(pdev));
                pci_release_regions(pdev);
                pci_disable_device(pdev);
                return -ENOBUFS;
index 8a10bb730d5acbddc5aa380d00b462dbc7d167ff..e862369b4a6dd694b150a6ff19abef3764da29c9 100644 (file)
@@ -786,10 +786,8 @@ static int __init init_x25_asy(void)
 
        x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device *),
                                GFP_KERNEL);
-       if (!x25_asy_devs) {
-               pr_warn("Can't allocate x25_asy_ctrls[] array! Uaargh! (-> No X.25 available)\n");
+       if (!x25_asy_devs)
                return -ENOMEM;
-       }
 
        return tty_register_ldisc(N_X25, &x25_ldisc);
 }
index 1b90ed8795c345a087d59a88a4715a873c3ebf90..c25226a32ddc44c5410e515f932b39ce14fcc08e 100644 (file)
@@ -431,11 +431,8 @@ struct htc_target *ath9k_htc_hw_alloc(void *hif_handle,
        struct htc_target *target;
 
        target = kzalloc(sizeof(struct htc_target), GFP_KERNEL);
-       if (!target) {
-               printk(KERN_ERR "Unable to allocate memory for"
-                       "target device\n");
+       if (!target)
                return NULL;
-       }
 
        init_completion(&target->target_wait);
        init_completion(&target->cmd_wait);
index a8bddd81b4d1d472cdccdff5f89befb1d06bdd61..aa15cc4269a18f4ff5a5b24c42c80427567c127e 100644 (file)
@@ -347,11 +347,9 @@ static int hfa384x_cmd(struct net_device *dev, u16 cmd, u16 param0,
                return -EINTR;
 
        entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
-       if (entry == NULL) {
-               printk(KERN_DEBUG "%s: hfa384x_cmd - kmalloc failed\n",
-                      dev->name);
+       if (entry == NULL)
                return -ENOMEM;
-       }
+
        atomic_set(&entry->usecnt, 1);
        entry->type = CMD_SLEEP;
        entry->cmd = cmd;
@@ -515,11 +513,9 @@ static int hfa384x_cmd_callback(struct net_device *dev, u16 cmd, u16 param0,
        }
 
        entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
-       if (entry == NULL) {
-               printk(KERN_DEBUG "%s: hfa384x_cmd_callback - kmalloc "
-                      "failed\n", dev->name);
+       if (entry == NULL)
                return -ENOMEM;
-       }
+
        atomic_set(&entry->usecnt, 1);
        entry->type = CMD_CALLBACK;
        entry->cmd = cmd;
@@ -2978,11 +2974,9 @@ static int prism2_set_tim(struct net_device *dev, int aid, int set)
        local = iface->local;
 
        new_entry = kzalloc(sizeof(*new_entry), GFP_ATOMIC);
-       if (new_entry == NULL) {
-               printk(KERN_DEBUG "%s: prism2_set_tim: kmalloc failed\n",
-                      local->dev->name);
+       if (new_entry == NULL)
                return -ENOMEM;
-       }
+
        new_entry->aid = aid;
        new_entry->set = set;
 
index a0e5c21d36576c74c1c402984a7392869926bdea..e847737ccc9d122783bdf7d337bf2f32e734a605 100644 (file)
@@ -3464,11 +3464,8 @@ static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
        priv->msg_buffers =
            kmalloc(IPW_COMMAND_POOL_SIZE * sizeof(struct ipw2100_tx_packet),
                    GFP_KERNEL);
-       if (!priv->msg_buffers) {
-               printk(KERN_ERR DRV_NAME ": %s: PCI alloc failed for msg "
-                      "buffers.\n", priv->net_dev->name);
+       if (!priv->msg_buffers)
                return -ENOMEM;
-       }
 
        for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
                v = pci_alloc_consistent(priv->pci_dev,
index 3f7bf4d912b614e828abcd1a94e95aff6e0ee9b3..234ee88dec95400f4e6fce337d6e500251a805f8 100644 (file)
@@ -815,10 +815,9 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
        lbs_deb_enter(LBS_DEB_CS);
 
        card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL);
-       if (!card) {
-               pr_err("error in kzalloc\n");
+       if (!card)
                goto out;
-       }
+
        card->p_dev = p_dev;
        p_dev->priv = card;
 
index b5fbbc7947dfc89738f08a4d18663f739d1ef2a7..74da5f1ea243eae088c227ecc15861a640f95bca 100644 (file)
@@ -261,10 +261,8 @@ static int if_usb_probe(struct usb_interface *intf,
        udev = interface_to_usbdev(intf);
 
        cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
-       if (!cardp) {
-               pr_err("Out of memory allocating private data\n");
+       if (!cardp)
                goto error;
-       }
 
        setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp);
        init_waitqueue_head(&cardp->fw_wq);
index aff8b5743af0c1999159553e66bfd25d6afcf281..7ced130f4f9e2abe6c5593c18f871426fb98621a 100644 (file)
@@ -153,10 +153,8 @@ static int if_usb_probe(struct usb_interface *intf,
        udev = interface_to_usbdev(intf);
 
        cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
-       if (!cardp) {
-               pr_err("Out of memory allocating private data.\n");
+       if (!cardp)
                goto error;
-       }
 
        setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp);
        init_waitqueue_head(&cardp->fw_wq);
index 405350940a45aad728059f0909cdcdd6098de0b3..f4fbad95d3e392fa7ce324566ed9d3634a075071 100644 (file)
@@ -86,10 +86,8 @@ static int mwifiex_pcie_probe(struct pci_dev *pdev,
                                pdev->vendor, pdev->device, pdev->revision);
 
        card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
-       if (!card) {
-               pr_err("%s: failed to alloc memory\n", __func__);
+       if (!card)
                return -ENOMEM;
-       }
 
        card->dev = pdev;
 
index d39d8457f25284b8b81f871eddcb36937d4a268d..8359027502313da830a1c73e5c57a82465d51bf3 100644 (file)
@@ -70,10 +70,8 @@ mwifiex_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
               func->vendor, func->device, func->class, func->num);
 
        card = kzalloc(sizeof(struct sdio_mmc_card), GFP_KERNEL);
-       if (!card) {
-               pr_err("%s: failed to alloc memory\n", __func__);
+       if (!card)
                return -ENOMEM;
-       }
 
        card->func = func;
 
index 9fb77d0319f5de9ffde985de3691d0b4554cf152..dd6c64ac406e8f28d87e69d81dff7b4d8171e19c 100644 (file)
@@ -941,11 +941,9 @@ void __orinoco_ev_rx(struct net_device *dev, struct hermes *hw)
 
        /* Add desc and skb to rx queue */
        rx_data = kzalloc(sizeof(*rx_data), GFP_ATOMIC);
-       if (!rx_data) {
-               printk(KERN_WARNING "%s: Can't allocate RX packet\n",
-                       dev->name);
+       if (!rx_data)
                goto drop;
-       }
+
        rx_data->desc = desc;
        rx_data->skb = skb;
        list_add_tail(&rx_data->list, &priv->rx_list);
index a5224f6160e4b8f913ba3150a1891c1beb0e7d15..851fa10241e1e94d8ffa8a6635e7b80e14d2fead 100644 (file)
@@ -192,11 +192,9 @@ islpci_mgt_transmit(struct net_device *ndev, int operation, unsigned long oid,
 
        err = -ENOMEM;
        p = buf.mem = kmalloc(frag_len, GFP_KERNEL);
-       if (!buf.mem) {
-               printk(KERN_DEBUG "%s: cannot allocate mgmt frame\n",
-                      ndev->name);
+       if (!buf.mem)
                goto error;
-       }
+
        buf.size = frag_len;
 
        /* create the header directly in the fragment data area */
index 78723cf59491264706b636be638d68eb5585818f..36140ccf2abdb5a26451d28cf76868070ba60c94 100644 (file)
@@ -186,11 +186,8 @@ static int rtl92s_init_sw_vars(struct ieee80211_hw *hw)
 
        /* for firmware buf */
        rtlpriv->rtlhal.pfirmware = vzalloc(sizeof(struct rt_firmware));
-       if (!rtlpriv->rtlhal.pfirmware) {
-               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
-                        ("Can't alloc buffer for fw.\n"));
+       if (!rtlpriv->rtlhal.pfirmware)
                return 1;
-       }
 
        pr_info("Driver for Realtek RTL8192SE/RTL8191SE\n"
                "Loading firmware %s\n", rtlpriv->cfg->fw_name);
index 59effac15f36ad0d87b92858223436b2152225c5..2596401308a86e24210efd65d531d91d6be60746 100644 (file)
@@ -1639,10 +1639,8 @@ static int __init netback_init(void)
 
        xen_netbk_group_nr = num_online_cpus();
        xen_netbk = vzalloc(sizeof(struct xen_netbk) * xen_netbk_group_nr);
-       if (!xen_netbk) {
-               printk(KERN_ALERT "%s: out of memory\n", __func__);
+       if (!xen_netbk)
                return -ENOMEM;
-       }
 
        for (group = 0; group < xen_netbk_group_nr; group++) {
                struct xen_netbk *netbk = &xen_netbk[group];