Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6

-6

drivers/atm/iphase.c

··· 3156 3156 { 3157 3157 struct atm_dev *dev; 3158 3158 IADEV *iadev; 3159 - unsigned long flags; 3160 3159 int ret; 3161 3160 3162 3161 iadev = kzalloc(sizeof(*iadev), GFP_KERNEL); ··· 3187 3188 ia_dev[iadev_count] = iadev; 3188 3189 _ia_dev[iadev_count] = dev; 3189 3190 iadev_count++; 3190 - spin_lock_init(&iadev->misc_lock); 3191 - /* First fixes first. I don't want to think about this now. */ 3192 - spin_lock_irqsave(&iadev->misc_lock, flags); 3193 3191 if (ia_init(dev) || ia_start(dev)) { 3194 3192 IF_INIT(printk("IA register failed!\n");) 3195 3193 iadev_count--; 3196 3194 ia_dev[iadev_count] = NULL; 3197 3195 _ia_dev[iadev_count] = NULL; 3198 - spin_unlock_irqrestore(&iadev->misc_lock, flags); 3199 3196 ret = -EINVAL; 3200 3197 goto err_out_deregister_dev; 3201 3198 } 3202 - spin_unlock_irqrestore(&iadev->misc_lock, flags); 3203 3199 IF_EVENT(printk("iadev_count = %d\n", iadev_count);) 3204 3200 3205 3201 iadev->next_board = ia_boards;

+1 -1

drivers/atm/iphase.h

··· 1022 1022 struct dle_q rx_dle_q; 1023 1023 struct free_desc_q *rx_free_desc_qhead; 1024 1024 struct sk_buff_head rx_dma_q; 1025 - spinlock_t rx_lock, misc_lock; 1025 + spinlock_t rx_lock; 1026 1026 struct atm_vcc **rx_open; /* list of all open VCs */ 1027 1027 u16 num_rx_desc, rx_buf_sz, rxing; 1028 1028 u32 rx_pkt_ram, rx_tmp_cnt;

+5 -3

drivers/atm/solos-pci.c

··· 444 444 struct atm_dev *atmdev = container_of(dev, struct atm_dev, class_dev); 445 445 struct solos_card *card = atmdev->dev_data; 446 446 struct sk_buff *skb; 447 + unsigned int len; 447 448 448 449 spin_lock(&card->cli_queue_lock); 449 450 skb = skb_dequeue(&card->cli_queue[SOLOS_CHAN(atmdev)]); ··· 452 451 if(skb == NULL) 453 452 return sprintf(buf, "No data.\n"); 454 453 455 - memcpy(buf, skb->data, skb->len); 456 - dev_dbg(&card->dev->dev, "len: %d\n", skb->len); 454 + len = skb->len; 455 + memcpy(buf, skb->data, len); 456 + dev_dbg(&card->dev->dev, "len: %d\n", len); 457 457 458 458 kfree_skb(skb); 459 - return skb->len; 459 + return len; 460 460 } 461 461 462 462 static int send_command(struct solos_card *card, int dev, const char *buf, size_t size)

+2 -2

drivers/net/b44.c

··· 2170 2170 dev->irq = sdev->irq; 2171 2171 SET_ETHTOOL_OPS(dev, &b44_ethtool_ops); 2172 2172 2173 - netif_carrier_off(dev); 2174 - 2175 2173 err = ssb_bus_powerup(sdev->bus, 0); 2176 2174 if (err) { 2177 2175 dev_err(sdev->dev, ··· 2210 2212 dev_err(sdev->dev, "Cannot register net device, aborting\n"); 2211 2213 goto err_out_powerdown; 2212 2214 } 2215 + 2216 + netif_carrier_off(dev); 2213 2217 2214 2218 ssb_set_drvdata(sdev, dev); 2215 2219

+8 -1

drivers/net/ehea/ehea_main.c

··· 533 533 int length = cqe->num_bytes_transfered - 4; /*remove CRC */ 534 534 535 535 skb_put(skb, length); 536 - skb->ip_summed = CHECKSUM_UNNECESSARY; 537 536 skb->protocol = eth_type_trans(skb, dev); 537 + 538 + /* The packet was not an IPV4 packet so a complemented checksum was 539 + calculated. The value is found in the Internet Checksum field. */ 540 + if (cqe->status & EHEA_CQE_BLIND_CKSUM) { 541 + skb->ip_summed = CHECKSUM_COMPLETE; 542 + skb->csum = csum_unfold(~cqe->inet_checksum_value); 543 + } else 544 + skb->ip_summed = CHECKSUM_UNNECESSARY; 538 545 } 539 546 540 547 static inline struct sk_buff *get_skb_by_index(struct sk_buff **skb_array,

+1

drivers/net/ehea/ehea_qmr.h

··· 150 150 #define EHEA_CQE_TYPE_RQ 0x60 151 151 #define EHEA_CQE_STAT_ERR_MASK 0x700F 152 152 #define EHEA_CQE_STAT_FAT_ERR_MASK 0xF 153 + #define EHEA_CQE_BLIND_CKSUM 0x8000 153 154 #define EHEA_CQE_STAT_ERR_TCP 0x4000 154 155 #define EHEA_CQE_STAT_ERR_IP 0x2000 155 156 #define EHEA_CQE_STAT_ERR_CRC 0x1000

+30 -14

drivers/net/fec.c

··· 678 678 { 679 679 struct fec_enet_private *fep = netdev_priv(dev); 680 680 struct phy_device *phy_dev = NULL; 681 - int ret; 681 + char mdio_bus_id[MII_BUS_ID_SIZE]; 682 + char phy_name[MII_BUS_ID_SIZE + 3]; 683 + int phy_id; 682 684 683 685 fep->phy_dev = NULL; 684 686 685 - /* find the first phy */ 686 - phy_dev = phy_find_first(fep->mii_bus); 687 - if (!phy_dev) { 688 - printk(KERN_ERR "%s: no PHY found\n", dev->name); 689 - return -ENODEV; 687 + /* check for attached phy */ 688 + for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) { 689 + if ((fep->mii_bus->phy_mask & (1 << phy_id))) 690 + continue; 691 + if (fep->mii_bus->phy_map[phy_id] == NULL) 692 + continue; 693 + if (fep->mii_bus->phy_map[phy_id]->phy_id == 0) 694 + continue; 695 + strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE); 696 + break; 690 697 } 691 698 692 - /* attach the mac to the phy */ 693 - ret = phy_connect_direct(dev, phy_dev, 694 - &fec_enet_adjust_link, 0, 695 - PHY_INTERFACE_MODE_MII); 696 - if (ret) { 697 - printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); 698 - return ret; 699 + if (phy_id >= PHY_MAX_ADDR) { 700 + printk(KERN_INFO "%s: no PHY, assuming direct connection " 701 + "to switch\n", dev->name); 702 + strncpy(mdio_bus_id, "0", MII_BUS_ID_SIZE); 703 + phy_id = 0; 704 + } 705 + 706 + snprintf(phy_name, MII_BUS_ID_SIZE, PHY_ID_FMT, mdio_bus_id, phy_id); 707 + phy_dev = phy_connect(dev, phy_name, &fec_enet_adjust_link, 0, 708 + PHY_INTERFACE_MODE_MII); 709 + if (IS_ERR(phy_dev)) { 710 + printk(KERN_ERR "%s: could not attach to PHY\n", dev->name); 711 + return PTR_ERR(phy_dev); 699 712 } 700 713 701 714 /* mask with MAC supported features */ ··· 751 738 fep->mii_bus->read = fec_enet_mdio_read; 752 739 fep->mii_bus->write = fec_enet_mdio_write; 753 740 fep->mii_bus->reset = fec_enet_mdio_reset; 754 - snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id); 741 + snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id + 1); 755 742 fep->mii_bus->priv = fep; 756 743 fep->mii_bus->parent = &pdev->dev; 757 744 ··· 1323 1310 ret = fec_enet_mii_init(pdev); 1324 1311 if (ret) 1325 1312 goto failed_mii_init; 1313 + 1314 + /* Carrier starts down, phylib will bring it up */ 1315 + netif_carrier_off(ndev); 1326 1316 1327 1317 ret = register_netdev(ndev); 1328 1318 if (ret)

+35 -30

drivers/net/r8169.c

··· 1212 1212 if ((RTL_R8(ChipCmd) & CmdRxEnb) == 0) 1213 1213 return; 1214 1214 1215 - counters = pci_alloc_consistent(tp->pci_dev, sizeof(*counters), &paddr); 1215 + counters = dma_alloc_coherent(&tp->pci_dev->dev, sizeof(*counters), 1216 + &paddr, GFP_KERNEL); 1216 1217 if (!counters) 1217 1218 return; 1218 1219 ··· 1234 1233 RTL_W32(CounterAddrLow, 0); 1235 1234 RTL_W32(CounterAddrHigh, 0); 1236 1235 1237 - pci_free_consistent(tp->pci_dev, sizeof(*counters), counters, paddr); 1236 + dma_free_coherent(&tp->pci_dev->dev, sizeof(*counters), counters, 1237 + paddr); 1238 1238 } 1239 1239 1240 1240 static void rtl8169_get_ethtool_stats(struct net_device *dev, ··· 3294 3292 3295 3293 /* 3296 3294 * Rx and Tx desscriptors needs 256 bytes alignment. 3297 - * pci_alloc_consistent provides more. 3295 + * dma_alloc_coherent provides more. 3298 3296 */ 3299 - tp->TxDescArray = pci_alloc_consistent(pdev, R8169_TX_RING_BYTES, 3300 - &tp->TxPhyAddr); 3297 + tp->TxDescArray = dma_alloc_coherent(&pdev->dev, R8169_TX_RING_BYTES, 3298 + &tp->TxPhyAddr, GFP_KERNEL); 3301 3299 if (!tp->TxDescArray) 3302 3300 goto err_pm_runtime_put; 3303 3301 3304 - tp->RxDescArray = pci_alloc_consistent(pdev, R8169_RX_RING_BYTES, 3305 - &tp->RxPhyAddr); 3302 + tp->RxDescArray = dma_alloc_coherent(&pdev->dev, R8169_RX_RING_BYTES, 3303 + &tp->RxPhyAddr, GFP_KERNEL); 3306 3304 if (!tp->RxDescArray) 3307 3305 goto err_free_tx_0; 3308 3306 ··· 3336 3334 err_release_ring_2: 3337 3335 rtl8169_rx_clear(tp); 3338 3336 err_free_rx_1: 3339 - pci_free_consistent(pdev, R8169_RX_RING_BYTES, tp->RxDescArray, 3340 - tp->RxPhyAddr); 3337 + dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 3338 + tp->RxPhyAddr); 3341 3339 tp->RxDescArray = NULL; 3342 3340 err_free_tx_0: 3343 - pci_free_consistent(pdev, R8169_TX_RING_BYTES, tp->TxDescArray, 3344 - tp->TxPhyAddr); 3341 + dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 3342 + tp->TxPhyAddr); 3345 3343 tp->TxDescArray = NULL; 3346 3344 err_pm_runtime_put: 3347 3345 pm_runtime_put_noidle(&pdev->dev); ··· 3977 3975 { 3978 3976 struct pci_dev *pdev = tp->pci_dev; 3979 3977 3980 - pci_unmap_single(pdev, le64_to_cpu(desc->addr), tp->rx_buf_sz, 3978 + dma_unmap_single(&pdev->dev, le64_to_cpu(desc->addr), tp->rx_buf_sz, 3981 3979 PCI_DMA_FROMDEVICE); 3982 3980 dev_kfree_skb(*sk_buff); 3983 3981 *sk_buff = NULL; ··· 4002 4000 static struct sk_buff *rtl8169_alloc_rx_skb(struct pci_dev *pdev, 4003 4001 struct net_device *dev, 4004 4002 struct RxDesc *desc, int rx_buf_sz, 4005 - unsigned int align) 4003 + unsigned int align, gfp_t gfp) 4006 4004 { 4007 4005 struct sk_buff *skb; 4008 4006 dma_addr_t mapping; ··· 4010 4008 4011 4009 pad = align ? align : NET_IP_ALIGN; 4012 4010 4013 - skb = netdev_alloc_skb(dev, rx_buf_sz + pad); 4011 + skb = __netdev_alloc_skb(dev, rx_buf_sz + pad, gfp); 4014 4012 if (!skb) 4015 4013 goto err_out; 4016 4014 4017 4015 skb_reserve(skb, align ? ((pad - 1) & (unsigned long)skb->data) : pad); 4018 4016 4019 - mapping = pci_map_single(pdev, skb->data, rx_buf_sz, 4017 + mapping = dma_map_single(&pdev->dev, skb->data, rx_buf_sz, 4020 4018 PCI_DMA_FROMDEVICE); 4021 4019 4022 4020 rtl8169_map_to_asic(desc, mapping, rx_buf_sz); ··· 4041 4039 } 4042 4040 4043 4041 static u32 rtl8169_rx_fill(struct rtl8169_private *tp, struct net_device *dev, 4044 - u32 start, u32 end) 4042 + u32 start, u32 end, gfp_t gfp) 4045 4043 { 4046 4044 u32 cur; 4047 4045 ··· 4056 4054 4057 4055 skb = rtl8169_alloc_rx_skb(tp->pci_dev, dev, 4058 4056 tp->RxDescArray + i, 4059 - tp->rx_buf_sz, tp->align); 4057 + tp->rx_buf_sz, tp->align, gfp); 4060 4058 if (!skb) 4061 4059 break; 4062 4060 ··· 4084 4082 memset(tp->tx_skb, 0x0, NUM_TX_DESC * sizeof(struct ring_info)); 4085 4083 memset(tp->Rx_skbuff, 0x0, NUM_RX_DESC * sizeof(struct sk_buff *)); 4086 4084 4087 - if (rtl8169_rx_fill(tp, dev, 0, NUM_RX_DESC) != NUM_RX_DESC) 4085 + if (rtl8169_rx_fill(tp, dev, 0, NUM_RX_DESC, GFP_KERNEL) != NUM_RX_DESC) 4088 4086 goto err_out; 4089 4087 4090 4088 rtl8169_mark_as_last_descriptor(tp->RxDescArray + NUM_RX_DESC - 1); ··· 4101 4099 { 4102 4100 unsigned int len = tx_skb->len; 4103 4101 4104 - pci_unmap_single(pdev, le64_to_cpu(desc->addr), len, PCI_DMA_TODEVICE); 4102 + dma_unmap_single(&pdev->dev, le64_to_cpu(desc->addr), len, 4103 + PCI_DMA_TODEVICE); 4105 4104 desc->opts1 = 0x00; 4106 4105 desc->opts2 = 0x00; 4107 4106 desc->addr = 0x00; ··· 4246 4243 txd = tp->TxDescArray + entry; 4247 4244 len = frag->size; 4248 4245 addr = ((void *) page_address(frag->page)) + frag->page_offset; 4249 - mapping = pci_map_single(tp->pci_dev, addr, len, PCI_DMA_TODEVICE); 4246 + mapping = dma_map_single(&tp->pci_dev->dev, addr, len, 4247 + PCI_DMA_TODEVICE); 4250 4248 4251 4249 /* anti gcc 2.95.3 bugware (sic) */ 4252 4250 status = opts1 | len | (RingEnd * !((entry + 1) % NUM_TX_DESC)); ··· 4317 4313 tp->tx_skb[entry].skb = skb; 4318 4314 } 4319 4315 4320 - mapping = pci_map_single(tp->pci_dev, skb->data, len, PCI_DMA_TODEVICE); 4316 + mapping = dma_map_single(&tp->pci_dev->dev, skb->data, len, 4317 + PCI_DMA_TODEVICE); 4321 4318 4322 4319 tp->tx_skb[entry].len = len; 4323 4320 txd->addr = cpu_to_le64(mapping); ··· 4482 4477 if (!skb) 4483 4478 goto out; 4484 4479 4485 - pci_dma_sync_single_for_cpu(tp->pci_dev, addr, pkt_size, 4486 - PCI_DMA_FROMDEVICE); 4480 + dma_sync_single_for_cpu(&tp->pci_dev->dev, addr, pkt_size, 4481 + PCI_DMA_FROMDEVICE); 4487 4482 skb_copy_from_linear_data(*sk_buff, skb->data, pkt_size); 4488 4483 *sk_buff = skb; 4489 4484 done = true; ··· 4554 4549 rtl8169_rx_csum(skb, desc); 4555 4550 4556 4551 if (rtl8169_try_rx_copy(&skb, tp, pkt_size, addr)) { 4557 - pci_dma_sync_single_for_device(pdev, addr, 4552 + dma_sync_single_for_device(&pdev->dev, addr, 4558 4553 pkt_size, PCI_DMA_FROMDEVICE); 4559 4554 rtl8169_mark_to_asic(desc, tp->rx_buf_sz); 4560 4555 } else { 4561 - pci_unmap_single(pdev, addr, tp->rx_buf_sz, 4556 + dma_unmap_single(&pdev->dev, addr, tp->rx_buf_sz, 4562 4557 PCI_DMA_FROMDEVICE); 4563 4558 tp->Rx_skbuff[entry] = NULL; 4564 4559 } ··· 4588 4583 count = cur_rx - tp->cur_rx; 4589 4584 tp->cur_rx = cur_rx; 4590 4585 4591 - delta = rtl8169_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx); 4586 + delta = rtl8169_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx, GFP_ATOMIC); 4592 4587 if (!delta && count) 4593 4588 netif_info(tp, intr, dev, "no Rx buffer allocated\n"); 4594 4589 tp->dirty_rx += delta; ··· 4774 4769 4775 4770 free_irq(dev->irq, dev); 4776 4771 4777 - pci_free_consistent(pdev, R8169_RX_RING_BYTES, tp->RxDescArray, 4778 - tp->RxPhyAddr); 4779 - pci_free_consistent(pdev, R8169_TX_RING_BYTES, tp->TxDescArray, 4780 - tp->TxPhyAddr); 4772 + dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 4773 + tp->RxPhyAddr); 4774 + dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 4775 + tp->TxPhyAddr); 4781 4776 tp->TxDescArray = NULL; 4782 4777 tp->RxDescArray = NULL; 4783 4778

+4 -2

drivers/net/tg3.c

··· 4666 4666 desc_idx, *post_ptr); 4667 4667 drop_it_no_recycle: 4668 4668 /* Other statistics kept track of by card. */ 4669 - tp->net_stats.rx_dropped++; 4669 + tp->rx_dropped++; 4670 4670 goto next_pkt; 4671 4671 } 4672 4672 ··· 4726 4726 if (len > (tp->dev->mtu + ETH_HLEN) && 4727 4727 skb->protocol != htons(ETH_P_8021Q)) { 4728 4728 dev_kfree_skb(skb); 4729 - goto next_pkt; 4729 + goto drop_it_no_recycle; 4730 4730 } 4731 4731 4732 4732 if (desc->type_flags & RXD_FLAG_VLAN && ··· 9239 9239 9240 9240 stats->rx_missed_errors = old_stats->rx_missed_errors + 9241 9241 get_stat64(&hw_stats->rx_discards); 9242 + 9243 + stats->rx_dropped = tp->rx_dropped; 9242 9244 9243 9245 return stats; 9244 9246 }

+1 -1

drivers/net/tg3.h

··· 2759 2759 2760 2760 2761 2761 /* begin "everything else" cacheline(s) section */ 2762 - struct rtnl_link_stats64 net_stats; 2762 + unsigned long rx_dropped; 2763 2763 struct rtnl_link_stats64 net_stats_prev; 2764 2764 struct tg3_ethtool_stats estats; 2765 2765 struct tg3_ethtool_stats estats_prev;

+13 -13

drivers/net/wimax/i2400m/rx.c

··· 1244 1244 int i, result; 1245 1245 struct device *dev = i2400m_dev(i2400m); 1246 1246 const struct i2400m_msg_hdr *msg_hdr; 1247 - size_t pl_itr, pl_size, skb_len; 1247 + size_t pl_itr, pl_size; 1248 1248 unsigned long flags; 1249 - unsigned num_pls, single_last; 1249 + unsigned num_pls, single_last, skb_len; 1250 1250 1251 1251 skb_len = skb->len; 1252 - d_fnstart(4, dev, "(i2400m %p skb %p [size %zu])\n", 1252 + d_fnstart(4, dev, "(i2400m %p skb %p [size %u])\n", 1253 1253 i2400m, skb, skb_len); 1254 1254 result = -EIO; 1255 1255 msg_hdr = (void *) skb->data; 1256 - result = i2400m_rx_msg_hdr_check(i2400m, msg_hdr, skb->len); 1256 + result = i2400m_rx_msg_hdr_check(i2400m, msg_hdr, skb_len); 1257 1257 if (result < 0) 1258 1258 goto error_msg_hdr_check; 1259 1259 result = -EIO; ··· 1261 1261 pl_itr = sizeof(*msg_hdr) + /* Check payload descriptor(s) */ 1262 1262 num_pls * sizeof(msg_hdr->pld[0]); 1263 1263 pl_itr = ALIGN(pl_itr, I2400M_PL_ALIGN); 1264 - if (pl_itr > skb->len) { /* got all the payload descriptors? */ 1264 + if (pl_itr > skb_len) { /* got all the payload descriptors? */ 1265 1265 dev_err(dev, "RX: HW BUG? message too short (%u bytes) for " 1266 1266 "%u payload descriptors (%zu each, total %zu)\n", 1267 - skb->len, num_pls, sizeof(msg_hdr->pld[0]), pl_itr); 1267 + skb_len, num_pls, sizeof(msg_hdr->pld[0]), pl_itr); 1268 1268 goto error_pl_descr_short; 1269 1269 } 1270 1270 /* Walk each payload payload--check we really got it */ ··· 1272 1272 /* work around old gcc warnings */ 1273 1273 pl_size = i2400m_pld_size(&msg_hdr->pld[i]); 1274 1274 result = i2400m_rx_pl_descr_check(i2400m, &msg_hdr->pld[i], 1275 - pl_itr, skb->len); 1275 + pl_itr, skb_len); 1276 1276 if (result < 0) 1277 1277 goto error_pl_descr_check; 1278 1278 single_last = num_pls == 1 || i == num_pls - 1; ··· 1290 1290 if (i < i2400m->rx_pl_min) 1291 1291 i2400m->rx_pl_min = i; 1292 1292 i2400m->rx_num++; 1293 - i2400m->rx_size_acc += skb->len; 1294 - if (skb->len < i2400m->rx_size_min) 1295 - i2400m->rx_size_min = skb->len; 1296 - if (skb->len > i2400m->rx_size_max) 1297 - i2400m->rx_size_max = skb->len; 1293 + i2400m->rx_size_acc += skb_len; 1294 + if (skb_len < i2400m->rx_size_min) 1295 + i2400m->rx_size_min = skb_len; 1296 + if (skb_len > i2400m->rx_size_max) 1297 + i2400m->rx_size_max = skb_len; 1298 1298 spin_unlock_irqrestore(&i2400m->rx_lock, flags); 1299 1299 error_pl_descr_check: 1300 1300 error_pl_descr_short: 1301 1301 error_msg_hdr_check: 1302 - d_fnend(4, dev, "(i2400m %p skb %p [size %zu]) = %d\n", 1302 + d_fnend(4, dev, "(i2400m %p skb %p [size %u]) = %d\n", 1303 1303 i2400m, skb, skb_len, result); 1304 1304 return result; 1305 1305 }

+1 -1

net/atm/mpc.c

··· 778 778 eg->packets_rcvd++; 779 779 mpc->eg_ops->put(eg); 780 780 781 - memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data)); 781 + memset(ATM_SKB(new_skb), 0, sizeof(struct atm_skb_data)); 782 782 netif_rx(new_skb); 783 783 } 784 784

+3 -3

net/core/ethtool.c

··· 397 397 (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index)) 398 398 return -ENOMEM; 399 399 full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size; 400 - indir = kmalloc(full_size, GFP_USER); 400 + indir = kzalloc(full_size, GFP_USER); 401 401 if (!indir) 402 402 return -ENOMEM; 403 403 ··· 538 538 539 539 gstrings.len = ret; 540 540 541 - data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER); 541 + data = kzalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER); 542 542 if (!data) 543 543 return -ENOMEM; 544 544 ··· 775 775 if (regs.len > reglen) 776 776 regs.len = reglen; 777 777 778 - regbuf = kmalloc(reglen, GFP_USER); 778 + regbuf = kzalloc(reglen, GFP_USER); 779 779 if (!regbuf) 780 780 return -ENOMEM; 781 781

Configure Feed

Configure Feed