History

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

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: appletalk: Fix OOPS in atalk_release(). mlx4: Fixing bad size of event queue buffer mlx4: Fixing use after free bonding:typo in comment sctp: Pass __GFP_NOWARN to hash table allocation attempts. connector: convert to synchronous netlink message processing fib: add rtnl locking in ip_fib_net_exit atm/solos-pci: Don't flap VCs when carrier state changes atm/solos-pci: Don't include frame pseudo-header on transmit hex-dump atm/solos-pci: Use VPI.VCI notation uniformly. Atheros, atl2: Fix mem leaks in error paths of atl2_set_eeprom netdev: fix mtu check when TSO is enabled net/usb: Ethernet quirks for the LG-VL600 4G modem phylib: phy_attach_direct: phy_init_hw can fail, add cleanup bridge: mcast snooping, fix length check of snooped MLDv1/2 via-ircc: Pass PCI device pointer to dma_{alloc, free}_coherent() via-ircc: Use pci_{get, set}_drvdata() instead of static pointer variable net: gre: provide multicast mappings for ipv4 and ipv6 bridge: Fix compilation warning in function br_stp_recalculate_bridge_id() net: Fix warnings caused by MAX_SKB_FRAGS change.

Linus Torvalds committed 15 years ago

Commit 84daeb02 parents ecb78ab c100c8f29 files · +543 −224Browse files

Unified · Split

29 files
  1. drivers/atm/solos-pci.c +11 −28
  2. drivers/connector/cn_queue.c +17 −41
  3. drivers/connector/connector.c +12 −35
  4. drivers/net/atlx/atl2.c +14 −8
  5. drivers/net/bonding/bond_alb.h +1 −1
  6. drivers/net/irda/via-ircc.c +21 −73
  7. drivers/net/mlx4/eq.c +3 −1
  8. drivers/net/mlx4/mcg.c +2 −1
  9. drivers/net/phy/phy_device.c +6 −2
  10. drivers/net/usb/Kconfig +15 −0
  11. drivers/net/usb/Makefile +1 −0
  12. drivers/net/usb/cdc_ether.c +15 −6
  13. drivers/net/usb/lg-vl600.c +346 −0
  14. drivers/net/usb/usbnet.c +7 −3
  15. include/linux/atmdev.h +1 −0
  16. include/linux/connector.h +3 −13
  17. include/linux/skbuff.h +1 −1
  18. include/linux/usb/usbnet.h +3 −0
  19. include/net/if_inet6.h +16 −0
  20. include/net/ip.h +8 −0
  21. net/appletalk/ddp.c +6 −5
  22. net/atm/common.c +1 −0
  23. net/bridge/br_multicast.c +1 −1
  24. net/bridge/br_stp_if.c +1 −1
  25. net/core/dev.c +22 −2
  26. net/ipv4/arp.c +3 −0
  27. net/ipv4/fib_frontend.c +2 −0
  28. net/ipv6/ndisc.c +2 −0
  29. net/sctp/protocol.c +2 −2
drivers/atm/solos-pci.c+11−28
@@ -165,7 +165,6 @@ static uint32_t fpga_tx(struct solos_card *); · 164 unmodified lines
165165 static irqreturn_t solos_irq(int irq, void *dev_id);
166166 static struct atm_vcc* find_vcc(struct atm_dev *dev, short vpi, int vci);
167167 static int list_vccs(int vci);
168−static void release_vccs(struct atm_dev *dev);
169168 static int atm_init(struct solos_card *, struct device *);
170169 static void atm_remove(struct solos_card *);
171170 static int send_command(struct solos_card *card, int dev, const char *buf, size_t size);
@@ -384,7 +383,6 @@ static int process_status(struct solos_card *card, int port, struct sk_buff *skb · 212 unmodified lines
384383 /* Anything but 'Showtime' is down */
385384 if (strcmp(state_str, "Showtime")) {
386385 atm_dev_signal_change(card->atmdev[port], ATM_PHY_SIG_LOST);
387− release_vccs(card->atmdev[port]);
388386 dev_info(&card->dev->dev, "Port %d: %s\n", port, state_str);
389387 return 0;
390388 }
@@ -697,7 +695,7 @@ void solos_bh(unsigned long card_arg) · 306 unmodified lines
697695 size);
698696 }
699697 if (atmdebug) {
700− dev_info(&card->dev->dev, "Received: device %d\n", port);
698+ dev_info(&card->dev->dev, "Received: port %d\n", port);
701699 dev_info(&card->dev->dev, "size: %d VPI: %d VCI: %d\n",
702700 size, le16_to_cpu(header->vpi),
703701 le16_to_cpu(header->vci));
@@ -710,8 +708,8 @@ void solos_bh(unsigned long card_arg) · 6 unmodified lines
710708 le16_to_cpu(header->vci));
711709 if (!vcc) {
712710 if (net_ratelimit())
713− dev_warn(&card->dev->dev, "Received packet for unknown VCI.VPI %d.%d on port %d\n",
714− le16_to_cpu(header->vci), le16_to_cpu(header->vpi),
711+ dev_warn(&card->dev->dev, "Received packet for unknown VPI.VCI %d.%d on port %d\n",
712+ le16_to_cpu(header->vpi), le16_to_cpu(header->vci),
715713 port);
716714 continue;
717715 }
@@ -830,28 +828,6 @@ static int list_vccs(int vci) · 112 unmodified lines
830828 return num_found;
831829 }
832830
833−static void release_vccs(struct atm_dev *dev)
834−{
835− int i;
836−
837− write_lock_irq(&vcc_sklist_lock);
838− for (i = 0; i < VCC_HTABLE_SIZE; i++) {
839− struct hlist_head *head = &vcc_hash[i];
840− struct hlist_node *node, *tmp;
841− struct sock *s;
842− struct atm_vcc *vcc;
843−
844− sk_for_each_safe(s, node, tmp, head) {
845− vcc = atm_sk(s);
846− if (vcc->dev == dev) {
847− vcc_release_async(vcc, -EPIPE);
848− sk_del_node_init(s);
849− }
850− }
851− }
852− write_unlock_irq(&vcc_sklist_lock);
853−}
854−
855831
856832 static int popen(struct atm_vcc *vcc)
857833 {
@@ -1018,8 +994,15 @@ static uint32_t fpga_tx(struct solos_card *card) · 160 unmodified lines
1018994
1019995 /* Clean up and free oldskb now it's gone */
1020996 if (atmdebug) {
997+ struct pkt_hdr *header = (void *)oldskb->data;
998+ int size = le16_to_cpu(header->size);
999+
1000+ skb_pull(oldskb, sizeof(*header));
10211001 dev_info(&card->dev->dev, "Transmitted: port %d\n",
10221002 port);
1003+ dev_info(&card->dev->dev, "size: %d VPI: %d VCI: %d\n",
1004+ size, le16_to_cpu(header->vpi),
1005+ le16_to_cpu(header->vci));
10231006 print_buffer(oldskb);
10241007 }
10251008
@@ -1262,7 +1245,7 @@ static int atm_init(struct solos_card *card, struct device *parent) · 236 unmodified lines
12621245 card->atmdev[i]->ci_range.vci_bits = 16;
12631246 card->atmdev[i]->dev_data = card;
12641247 card->atmdev[i]->phy_data = (void *)(unsigned long)i;
1265− atm_dev_signal_change(card->atmdev[i], ATM_PHY_SIG_UNKNOWN);
1248+ atm_dev_signal_change(card->atmdev[i], ATM_PHY_SIG_FOUND);
12661249
12671250 skb = alloc_skb(sizeof(*header), GFP_ATOMIC);
12681251 if (!skb) {
drivers/connector/cn_queue.c+17−41
@@ -31,24 +31,9 @@ · 30 unmodified lines
3131 #include <linux/connector.h>
3232 #include <linux/delay.h>
3333
34−void cn_queue_wrapper(struct work_struct *work)
35−{
36− struct cn_callback_entry *cbq =
37− container_of(work, struct cn_callback_entry, work);
38− struct cn_callback_data *d = &cbq->data;
39− struct cn_msg *msg = NLMSG_DATA(nlmsg_hdr(d->skb));
40− struct netlink_skb_parms *nsp = &NETLINK_CB(d->skb);
41−
42− d->callback(msg, nsp);
43−
44− kfree_skb(d->skb);
45− d->skb = NULL;
46−
47− kfree(d->free);
48−}
49−
5034 static struct cn_callback_entry *
51−cn_queue_alloc_callback_entry(const char *name, struct cb_id *id,
35+cn_queue_alloc_callback_entry(struct cn_queue_dev *dev, const char *name,
36+ struct cb_id *id,
5237 void (*callback)(struct cn_msg *, struct netlink_skb_parms *))
5338 {
5439 struct cn_callback_entry *cbq;
@@ -59,17 +44,23 @@ cn_queue_alloc_callback_entry(const char *name, struct cb_id *id, · 4 unmodified lines
5944 return NULL;
6045 }
6146
47+ atomic_set(&cbq->refcnt, 1);
48+
49+ atomic_inc(&dev->refcnt);
50+ cbq->pdev = dev;
51+
6252 snprintf(cbq->id.name, sizeof(cbq->id.name), "%s", name);
6353 memcpy(&cbq->id.id, id, sizeof(struct cb_id));
64− cbq->data.callback = callback;
65−
66− INIT_WORK(&cbq->work, &cn_queue_wrapper);
54+ cbq->callback = callback;
6755 return cbq;
6856 }
6957
70−static void cn_queue_free_callback(struct cn_callback_entry *cbq)
58+void cn_queue_release_callback(struct cn_callback_entry *cbq)
7159 {
72− flush_workqueue(cbq->pdev->cn_queue);
60+ if (!atomic_dec_and_test(&cbq->refcnt))
61+ return;
62+
63+ atomic_dec(&cbq->pdev->refcnt);
7364 kfree(cbq);
7465 }
7566
@@ -85,13 +76,10 @@ int cn_queue_add_callback(struct cn_queue_dev *dev, const char *name, · 9 unmodified lines
8576 struct cn_callback_entry *cbq, *__cbq;
8677 int found = 0;
8778
88− cbq = cn_queue_alloc_callback_entry(name, id, callback);
79+ cbq = cn_queue_alloc_callback_entry(dev, name, id, callback);
8980 if (!cbq)
9081 return -ENOMEM;
9182
92− atomic_inc(&dev->refcnt);
93− cbq->pdev = dev;
94−
9583 spin_lock_bh(&dev->queue_lock);
9684 list_for_each_entry(__cbq, &dev->queue_list, callback_entry) {
9785 if (cn_cb_equal(&__cbq->id.id, id)) {
@@ -104,8 +92,7 @@ int cn_queue_add_callback(struct cn_queue_dev *dev, const char *name, · 6 unmodified lines
10492 spin_unlock_bh(&dev->queue_lock);
10593
10694 if (found) {
107− cn_queue_free_callback(cbq);
108− atomic_dec(&dev->refcnt);
95+ cn_queue_release_callback(cbq);
10996 return -EINVAL;
11097 }
11198
@@ -130,10 +117,8 @@ void cn_queue_del_callback(struct cn_queue_dev *dev, struct cb_id *id) · 18 unmodified lines
130117 }
131118 spin_unlock_bh(&dev->queue_lock);
132119
133− if (found) {
134− cn_queue_free_callback(cbq);
135− atomic_dec(&dev->refcnt);
136− }
120+ if (found)
121+ cn_queue_release_callback(cbq);
137122 }
138123
139124 struct cn_queue_dev *cn_queue_alloc_dev(const char *name, struct sock *nls)
@@ -151,12 +136,6 @@ struct cn_queue_dev *cn_queue_alloc_dev(const char *name, struct sock *nls) · 11 unmodified lines
151136
152137 dev->nls = nls;
153138
154− dev->cn_queue = alloc_ordered_workqueue(dev->name, 0);
155− if (!dev->cn_queue) {
156− kfree(dev);
157− return NULL;
158− }
159−
160139 return dev;
161140 }
162141
@@ -164,9 +143,6 @@ void cn_queue_free_dev(struct cn_queue_dev *dev) · 1 unmodified line
164143 {
165144 struct cn_callback_entry *cbq, *n;
166145
167− flush_workqueue(dev->cn_queue);
168− destroy_workqueue(dev->cn_queue);
169−
170146 spin_lock_bh(&dev->queue_lock);
171147 list_for_each_entry_safe(cbq, n, &dev->queue_list, callback_entry)
172148 list_del(&cbq->callback_entry);
drivers/connector/connector.c+12−35
@@ -122,51 +122,28 @@ EXPORT_SYMBOL_GPL(cn_netlink_send); · 121 unmodified lines
122122 */
123123 static int cn_call_callback(struct sk_buff *skb)
124124 {
125− struct cn_callback_entry *__cbq, *__new_cbq;
125+ struct cn_callback_entry *i, *cbq = NULL;
126126 struct cn_dev *dev = &cdev;
127127 struct cn_msg *msg = NLMSG_DATA(nlmsg_hdr(skb));
128+ struct netlink_skb_parms *nsp = &NETLINK_CB(skb);
128129 int err = -ENODEV;
129130
130131 spin_lock_bh(&dev->cbdev->queue_lock);
131− list_for_each_entry(__cbq, &dev->cbdev->queue_list, callback_entry) {
132− if (cn_cb_equal(&__cbq->id.id, &msg->id)) {
133− if (likely(!work_pending(&__cbq->work) &&
134− __cbq->data.skb == NULL)) {
135− __cbq->data.skb = skb;
136−
137− if (queue_work(dev->cbdev->cn_queue,
138− &__cbq->work))
139− err = 0;
140− else
141− err = -EINVAL;
142− } else {
143− struct cn_callback_data *d;
144−
145− err = -ENOMEM;
146− __new_cbq = kzalloc(sizeof(struct cn_callback_entry), GFP_ATOMIC);
147− if (__new_cbq) {
148− d = &__new_cbq->data;
149− d->skb = skb;
150− d->callback = __cbq->data.callback;
151− d->free = __new_cbq;
152−
153− INIT_WORK(&__new_cbq->work,
154− &cn_queue_wrapper);
155−
156− if (queue_work(dev->cbdev->cn_queue,
157− &__new_cbq->work))
158− err = 0;
159− else {
160− kfree(__new_cbq);
161− err = -EINVAL;
162− }
163− }
164− }
132+ list_for_each_entry(i, &dev->cbdev->queue_list, callback_entry) {
133+ if (cn_cb_equal(&i->id.id, &msg->id)) {
134+ atomic_inc(&i->refcnt);
135+ cbq = i;
165136 break;
166137 }
167138 }
168139 spin_unlock_bh(&dev->cbdev->queue_lock);
169140
141+ if (cbq != NULL) {
142+ cbq->callback(msg, nsp);
143+ kfree_skb(skb);
144+ cn_queue_release_callback(cbq);
145+ }
146+
170147 return err;
171148 }
172149
drivers/net/atlx/atl2.c+14−8
@@ -1996,13 +1996,15 @@ static int atl2_set_eeprom(struct net_device *netdev, · 1995 unmodified lines
19961996 if (!eeprom_buff)
19971997 return -ENOMEM;
19981998
1999− ptr = (u32 *)eeprom_buff;
1999+ ptr = eeprom_buff;
20002000
20012001 if (eeprom->offset & 3) {
20022002 /* need read/modify/write of first changed EEPROM word */
20032003 /* only the second byte of the word is being modified */
2004− if (!atl2_read_eeprom(hw, first_dword*4, &(eeprom_buff[0])))
2005− return -EIO;
2004+ if (!atl2_read_eeprom(hw, first_dword*4, &(eeprom_buff[0]))) {
2005+ ret_val = -EIO;
2006+ goto out;
2007+ }
20062008 ptr++;
20072009 }
20082010 if (((eeprom->offset + eeprom->len) & 3)) {
@@ -2011,18 +2013,22 @@ static int atl2_set_eeprom(struct net_device *netdev, · 2 unmodified lines
20112013 * only the first byte of the word is being modified
20122014 */
20132015 if (!atl2_read_eeprom(hw, last_dword * 4,
2014− &(eeprom_buff[last_dword - first_dword])))
2015− return -EIO;
2016+ &(eeprom_buff[last_dword - first_dword]))) {
2017+ ret_val = -EIO;
2018+ goto out;
2019+ }
20162020 }
20172021
20182022 /* Device's eeprom is always little-endian, word addressable */
20192023 memcpy(ptr, bytes, eeprom->len);
20202024
20212025 for (i = 0; i < last_dword - first_dword + 1; i++) {
2022− if (!atl2_write_eeprom(hw, ((first_dword+i)*4), eeprom_buff[i]))
2023− return -EIO;
2026+ if (!atl2_write_eeprom(hw, ((first_dword+i)*4), eeprom_buff[i])) {
2027+ ret_val = -EIO;
2028+ goto out;
2029+ }
20242030 }
2025−
2031+ out:
20262032 kfree(eeprom_buff);
20272033 return ret_val;
20282034 }
drivers/net/bonding/bond_alb.h+1−1
@@ -74,7 +74,7 @@ struct tlb_client_info { · 73 unmodified lines
7474 * packets to a Client that the Hash function
7575 * gave this entry index.
7676 */
77− u32 tx_bytes; /* Each Client acumulates the BytesTx that
77+ u32 tx_bytes; /* Each Client accumulates the BytesTx that
7878 * were tranmitted to it, and after each
7979 * CallBack the LoadHistory is devided
8080 * by the balance interval
drivers/net/irda/via-ircc.c+21−73
@@ -75,15 +75,9 @@ static int dongle_id = 0; /* default: probe */ · 74 unmodified lines
7575 /* We can't guess the type of connected dongle, user *must* supply it. */
7676 module_param(dongle_id, int, 0);
7777
78−/* FIXME : we should not need this, because instances should be automatically
79− * managed by the PCI layer. Especially that we seem to only be using the
80− * first entry. Jean II */
81−/* Max 4 instances for now */
82−static struct via_ircc_cb *dev_self[] = { NULL, NULL, NULL, NULL };
83−
8478 /* Some prototypes */
85−static int via_ircc_open(int i, chipio_t * info, unsigned int id);
86−static int via_ircc_close(struct via_ircc_cb *self);
79+static int via_ircc_open(struct pci_dev *pdev, chipio_t * info,
80+ unsigned int id);
8781 static int via_ircc_dma_receive(struct via_ircc_cb *self);
8882 static int via_ircc_dma_receive_complete(struct via_ircc_cb *self,
8983 int iobase);
@@ -215,7 +209,7 @@ static int __devinit via_init_one (struct pci_dev *pcidev, const struct pci_devi · 125 unmodified lines
215209 pci_write_config_byte(pcidev,0x42,(bTmp | 0xf0));
216210 pci_write_config_byte(pcidev,0x5a,0xc0);
217211 WriteLPCReg(0x28, 0x70 );
218− if (via_ircc_open(0, &info,0x3076) == 0)
212+ if (via_ircc_open(pcidev, &info, 0x3076) == 0)
219213 rc=0;
220214 } else
221215 rc = -ENODEV; //IR not turn on
@@ -254,7 +248,7 @@ static int __devinit via_init_one (struct pci_dev *pcidev, const struct pci_devi · 32 unmodified lines
254248 info.irq=FirIRQ;
255249 info.dma=FirDRQ1;
256250 info.dma2=FirDRQ0;
257− if (via_ircc_open(0, &info,0x3096) == 0)
251+ if (via_ircc_open(pcidev, &info, 0x3096) == 0)
258252 rc=0;
259253 } else
260254 rc = -ENODEV; //IR not turn on !!!!!
@@ -264,48 +258,10 @@ static int __devinit via_init_one (struct pci_dev *pcidev, const struct pci_devi · 3 unmodified lines
264258 return rc;
265259 }
266260
267−/*
268− * Function via_ircc_clean ()
269− *
270− * Close all configured chips
271− *
272− */
273−static void via_ircc_clean(void)
274−{
275− int i;
276−
277− IRDA_DEBUG(3, "%s()\n", __func__);
278−
279− for (i=0; i < ARRAY_SIZE(dev_self); i++) {
280− if (dev_self[i])
281− via_ircc_close(dev_self[i]);
282− }
283−}
284−
285−static void __devexit via_remove_one (struct pci_dev *pdev)
286−{
287− IRDA_DEBUG(3, "%s()\n", __func__);
288−
289− /* FIXME : This is ugly. We should use pci_get_drvdata(pdev);
290− * to get our driver instance and call directly via_ircc_close().
291− * See vlsi_ir for details...
292− * Jean II */
293− via_ircc_clean();
294−
295− /* FIXME : This should be in via_ircc_close(), because here we may
296− * theoritically disable still configured devices :-( - Jean II */
297− pci_disable_device(pdev);
298−}
299−
300261 static void __exit via_ircc_cleanup(void)
301262 {
302263 IRDA_DEBUG(3, "%s()\n", __func__);
303264
304− /* FIXME : This should be redundant, as pci_unregister_driver()
305− * should call via_remove_one() on each device.
306− * Jean II */
307− via_ircc_clean();
308−
309265 /* Cleanup all instances of the driver */
310266 pci_unregister_driver (&via_driver);
311267 }
@@ -324,12 +280,13 @@ static const struct net_device_ops via_ircc_fir_ops = { · 12 unmodified lines
324280 };
325281
326282 /*
327− * Function via_ircc_open (iobase, irq)
283+ * Function via_ircc_open(pdev, iobase, irq)
328284 *
329285 * Open driver instance
330286 *
331287 */
332−static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id)
288+static __devinit int via_ircc_open(struct pci_dev *pdev, chipio_t * info,
289+ unsigned int id)
333290 {
334291 struct net_device *dev;
335292 struct via_ircc_cb *self;
@@ -337,9 +294,6 @@ static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id) · 1 unmodified line
337294
338295 IRDA_DEBUG(3, "%s()\n", __func__);
339296
340− if (i >= ARRAY_SIZE(dev_self))
341− return -ENOMEM;
342−
343297 /* Allocate new instance of the driver */
344298 dev = alloc_irdadev(sizeof(struct via_ircc_cb));
345299 if (dev == NULL)
@@ -349,13 +303,8 @@ static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id) · 3 unmodified lines
349303 self->netdev = dev;
350304 spin_lock_init(&self->lock);
351305
352− /* FIXME : We should store our driver instance in the PCI layer,
353− * using pci_set_drvdata(), not in this array.
354− * See vlsi_ir for details... - Jean II */
355− /* FIXME : 'i' is always 0 (see via_init_one()) :-( - Jean II */
356− /* Need to store self somewhere */
357− dev_self[i] = self;
358− self->index = i;
306+ pci_set_drvdata(pdev, self);
307+
359308 /* Initialize Resource */
360309 self->io.cfg_base = info->cfg_base;
361310 self->io.fir_base = info->fir_base;
@@ -414,7 +363,7 @@ static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id) · 52 unmodified lines
414363
415364 /* Allocate memory if needed */
416365 self->rx_buff.head =
417− dma_alloc_coherent(NULL, self->rx_buff.truesize,
366+ dma_alloc_coherent(&pdev->dev, self->rx_buff.truesize,
418367 &self->rx_buff_dma, GFP_KERNEL);
419368 if (self->rx_buff.head == NULL) {
420369 err = -ENOMEM;
@@ -423,7 +372,7 @@ static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id) · 2 unmodified lines
423372 memset(self->rx_buff.head, 0, self->rx_buff.truesize);
424373
425374 self->tx_buff.head =
426− dma_alloc_coherent(NULL, self->tx_buff.truesize,
375+ dma_alloc_coherent(&pdev->dev, self->tx_buff.truesize,
427376 &self->tx_buff_dma, GFP_KERNEL);
428377 if (self->tx_buff.head == NULL) {
429378 err = -ENOMEM;
@@ -455,33 +404,32 @@ static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id) · 25 unmodified lines
455404 via_hw_init(self);
456405 return 0;
457406 err_out4:
458− dma_free_coherent(NULL, self->tx_buff.truesize,
407+ dma_free_coherent(&pdev->dev, self->tx_buff.truesize,
459408 self->tx_buff.head, self->tx_buff_dma);
460409 err_out3:
461− dma_free_coherent(NULL, self->rx_buff.truesize,
410+ dma_free_coherent(&pdev->dev, self->rx_buff.truesize,
462411 self->rx_buff.head, self->rx_buff_dma);
463412 err_out2:
464413 release_region(self->io.fir_base, self->io.fir_ext);
465414 err_out1:
415+ pci_set_drvdata(pdev, NULL);
466416 free_netdev(dev);
467− dev_self[i] = NULL;
468417 return err;
469418 }
470419
471420 /*
472− * Function via_ircc_close (self)
421+ * Function via_remove_one(pdev)
473422 *
474423 * Close driver instance
475424 *
476425 */
477−static int via_ircc_close(struct via_ircc_cb *self)
426+static void __devexit via_remove_one(struct pci_dev *pdev)
478427 {
428+ struct via_ircc_cb *self = pci_get_drvdata(pdev);
479429 int iobase;
480430
481431 IRDA_DEBUG(3, "%s()\n", __func__);
482432
483− IRDA_ASSERT(self != NULL, return -1;);
484−
485433 iobase = self->io.fir_base;
486434
487435 ResetChip(iobase, 5); //hardware reset.
@@ -493,16 +441,16 @@ static int via_ircc_close(struct via_ircc_cb *self) · 5 unmodified lines
493441 __func__, self->io.fir_base);
494442 release_region(self->io.fir_base, self->io.fir_ext);
495443 if (self->tx_buff.head)
496− dma_free_coherent(NULL, self->tx_buff.truesize,
444+ dma_free_coherent(&pdev->dev, self->tx_buff.truesize,
497445 self->tx_buff.head, self->tx_buff_dma);
498446 if (self->rx_buff.head)
499− dma_free_coherent(NULL, self->rx_buff.truesize,
447+ dma_free_coherent(&pdev->dev, self->rx_buff.truesize,
500448 self->rx_buff.head, self->rx_buff_dma);
501− dev_self[self->index] = NULL;
449+ pci_set_drvdata(pdev, NULL);
502450
503451 free_netdev(self->netdev);
504452
505− return 0;
453+ pci_disable_device(pdev);
506454 }
507455
508456 /*
drivers/net/mlx4/eq.c+3−1
@@ -603,7 +603,9 @@ int mlx4_init_eq_table(struct mlx4_dev *dev) · 602 unmodified lines
603603 }
604604
605605 for (i = 0; i < dev->caps.num_comp_vectors; ++i) {
606− err = mlx4_create_eq(dev, dev->caps.num_cqs + MLX4_NUM_SPARE_EQE,
606+ err = mlx4_create_eq(dev, dev->caps.num_cqs -
607+ dev->caps.reserved_cqs +
608+ MLX4_NUM_SPARE_EQE,
607609 (dev->flags & MLX4_FLAG_MSI_X) ? i : 0,
608610 &priv->eq_table.eq[i]);
609611 if (err) {
drivers/net/mlx4/mcg.c+2−1
@@ -469,7 +469,6 @@ static int remove_promisc_qp(struct mlx4_dev *dev, u8 vep_num, u8 port, · 468 unmodified lines
469469
470470 /*remove from list of promisc qps */
471471 list_del(&pqp->list);
472− kfree(pqp);
473472
474473 /* set the default entry not to include the removed one */
475474 mailbox = mlx4_alloc_cmd_mailbox(dev);
@@ -528,6 +527,8 @@ out_mailbox: · 52 unmodified lines
528527 out_list:
529528 if (back_to_list)
530529 list_add_tail(&pqp->list, &s_steer->promisc_qps[steer]);
530+ else
531+ kfree(pqp);
531532 out_mutex:
532533 mutex_unlock(&priv->mcg_table.mutex);
533534 return err;
drivers/net/phy/phy_device.c+6−2
@@ -442,11 +442,11 @@ static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, · 441 unmodified lines
442442 u32 flags, phy_interface_t interface)
443443 {
444444 struct device *d = &phydev->dev;
445+ int err;
445446
446447 /* Assume that if there is no driver, that it doesn't
447448 * exist, and we should use the genphy driver. */
448449 if (NULL == d->driver) {
449− int err;
450450 d->driver = &genphy_driver.driver;
451451
452452 err = d->driver->probe(d);
@@ -474,7 +474,11 @@ static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, · 21 unmodified lines
474474 /* Do initial configuration here, now that
475475 * we have certain key parameters
476476 * (dev_flags and interface) */
477− return phy_init_hw(phydev);
477+ err = phy_init_hw(phydev);
478+ if (err)
479+ phy_detach(phydev);
480+
481+ return err;
478482 }
479483
480484 /**
drivers/net/usb/Kconfig+15−0
@@ -433,4 +433,19 @@ config USB_SIERRA_NET · 432 unmodified lines
433433 To compile this driver as a module, choose M here: the
434434 module will be called sierra_net.
435435
436+config USB_VL600
437+ tristate "LG VL600 modem dongle"
438+ depends on USB_NET_CDCETHER
439+ select USB_ACM
440+ help
441+ Select this if you want to use an LG Electronics 4G/LTE usb modem
442+ called VL600. This driver only handles the ethernet
443+ interface exposed by the modem firmware. To establish a connection
444+ you will first need a userspace program that sends the right
445+ command to the modem through its CDC ACM port, and most
446+ likely also a DHCP client. See this thread about using the
447+ 4G modem from Verizon:
448+
449+ http://ubuntuforums.org/showpost.php?p=10589647&postcount=17
450+
436451 endmenu
drivers/net/usb/Makefile+1−0
@@ -27,4 +27,5 @@ obj-$(CONFIG_USB_IPHETH) += ipheth.o · 26 unmodified lines
2727 obj-$(CONFIG_USB_SIERRA_NET) += sierra_net.o
2828 obj-$(CONFIG_USB_NET_CX82310_ETH) += cx82310_eth.o
2929 obj-$(CONFIG_USB_NET_CDC_NCM) += cdc_ncm.o
30+obj-$(CONFIG_USB_VL600) += lg-vl600.o
3031
drivers/net/usb/cdc_ether.c+15−6
@@ -378,7 +378,7 @@ static void dumpspeed(struct usbnet *dev, __le32 *speeds) · 377 unmodified lines
378378 __le32_to_cpu(speeds[1]) / 1000);
379379 }
380380
381−static void cdc_status(struct usbnet *dev, struct urb *urb)
381+void usbnet_cdc_status(struct usbnet *dev, struct urb *urb)
382382 {
383383 struct usb_cdc_notification *event;
384384
@@ -418,8 +418,9 @@ static void cdc_status(struct usbnet *dev, struct urb *urb) · 33 unmodified lines
418418 break;
419419 }
420420 }
421+EXPORT_SYMBOL_GPL(usbnet_cdc_status);
421422
422−static int cdc_bind(struct usbnet *dev, struct usb_interface *intf)
423+int usbnet_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
423424 {
424425 int status;
425426 struct cdc_state *info = (void *) &dev->data;
@@ -441,6 +442,7 @@ static int cdc_bind(struct usbnet *dev, struct usb_interface *intf) · 15 unmodified lines
441442 */
442443 return 0;
443444 }
445+EXPORT_SYMBOL_GPL(usbnet_cdc_bind);
444446
445447 static int cdc_manage_power(struct usbnet *dev, int on)
446448 {
@@ -452,18 +454,18 @@ static const struct driver_info cdc_info = { · 5 unmodified lines
452454 .description = "CDC Ethernet Device",
453455 .flags = FLAG_ETHER,
454456 // .check_connect = cdc_check_connect,
455− .bind = cdc_bind,
457+ .bind = usbnet_cdc_bind,
456458 .unbind = usbnet_cdc_unbind,
457− .status = cdc_status,
459+ .status = usbnet_cdc_status,
458460 .manage_power = cdc_manage_power,
459461 };
460462
461463 static const struct driver_info mbm_info = {
462464 .description = "Mobile Broadband Network Device",
463465 .flags = FLAG_WWAN,
464− .bind = cdc_bind,
466+ .bind = usbnet_cdc_bind,
465467 .unbind = usbnet_cdc_unbind,
466− .status = cdc_status,
468+ .status = usbnet_cdc_status,
467469 .manage_power = cdc_manage_power,
468470 };
469471
@@ -560,6 +562,13 @@ static const struct usb_device_id products [] = { · 90 unmodified lines
560562 .driver_info = 0,
561563 },
562564
565+/* LG Electronics VL600 wants additional headers on every frame */
566+{
567+ USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
568+ USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
569+ .driver_info = 0,
570+},
571+
563572 /*
564573 * WHITELIST!!!
565574 *
drivers/net/usb/lg-vl600.c+346−0
@@ -0,0 +1,346 @@
1+/*
2+ * Ethernet interface part of the LG VL600 LTE modem (4G dongle)
3+ *
4+ * Copyright (C) 2011 Intel Corporation
5+ * Author: Andrzej Zaborowski <balrogg@gmail.com>
6+ *
7+ * This program is free software; you can redistribute it and/or modify
8+ * it under the terms of the GNU General Public License as published by
9+ * the Free Software Foundation; either version 2 of the License, or
10+ * (at your option) any later version.
11+ *
12+ * This program is distributed in the hope that it will be useful,
13+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15+ * GNU General Public License for more details.
16+ *
17+ * You should have received a copy of the GNU General Public License
18+ * along with this program; if not, write to the Free Software
19+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20+ */
21+#include <linux/etherdevice.h>
22+#include <linux/ethtool.h>
23+#include <linux/mii.h>
24+#include <linux/usb.h>
25+#include <linux/usb/cdc.h>
26+#include <linux/usb/usbnet.h>
27+#include <linux/if_ether.h>
28+#include <linux/if_arp.h>
29+#include <linux/inetdevice.h>
30+
31+/*
32+ * The device has a CDC ACM port for modem control (it claims to be
33+ * CDC ACM anyway) and a CDC Ethernet port for actual network data.
34+ * It will however ignore data on both ports that is not encapsulated
35+ * in a specific way, any data returned is also encapsulated the same
36+ * way. The headers don't seem to follow any popular standard.
37+ *
38+ * This driver adds and strips these headers from the ethernet frames
39+ * sent/received from the CDC Ethernet port. The proprietary header
40+ * replaces the standard ethernet header in a packet so only actual
41+ * ethernet frames are allowed. The headers allow some form of
42+ * multiplexing by using non standard values of the .h_proto field.
43+ * Windows/Mac drivers do send a couple of such frames to the device
44+ * during initialisation, with protocol set to 0x0906 or 0x0b06 and (what
45+ * seems to be) a flag in the .dummy_flags. This doesn't seem necessary
46+ * for modem operation but can possibly be used for GPS or other funcitons.
47+ */
48+
49+struct vl600_frame_hdr {
50+ __le32 len;
51+ __le32 serial;
52+ __le32 pkt_cnt;
53+ __le32 dummy_flags;
54+ __le32 dummy;
55+ __le32 magic;
56+} __attribute__((packed));
57+
58+struct vl600_pkt_hdr {
59+ __le32 dummy[2];
60+ __le32 len;
61+ __be16 h_proto;
62+} __attribute__((packed));
63+
64+struct vl600_state {
65+ struct sk_buff *current_rx_buf;
66+};
67+
68+static int vl600_bind(struct usbnet *dev, struct usb_interface *intf)
69+{
70+ int ret;
71+ struct vl600_state *s = kzalloc(sizeof(struct vl600_state), GFP_KERNEL);
72+
73+ if (!s)
74+ return -ENOMEM;
75+
76+ ret = usbnet_cdc_bind(dev, intf);
77+ if (ret) {
78+ kfree(s);
79+ return ret;
80+ }
81+
82+ dev->driver_priv = s;
83+
84+ /* ARP packets don't go through, but they're also of no use. The
85+ * subnet has only two hosts anyway: us and the gateway / DHCP
86+ * server (probably simulated by modem firmware or network operator)
87+ * whose address changes everytime we connect to the intarwebz and
88+ * who doesn't bother answering ARP requests either. So hardware
89+ * addresses have no meaning, the destination and the source of every
90+ * packet depend only on whether it is on the IN or OUT endpoint. */
91+ dev->net->flags |= IFF_NOARP;
92+
93+ return ret;
94+}
95+
96+static void vl600_unbind(struct usbnet *dev, struct usb_interface *intf)
97+{
98+ struct vl600_state *s = dev->driver_priv;
99+
100+ if (s->current_rx_buf)
101+ dev_kfree_skb(s->current_rx_buf);
102+
103+ kfree(s);
104+
105+ return usbnet_cdc_unbind(dev, intf);
106+}
107+
108+static int vl600_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
109+{
110+ struct vl600_frame_hdr *frame;
111+ struct vl600_pkt_hdr *packet;
112+ struct ethhdr *ethhdr;
113+ int packet_len, count;
114+ struct sk_buff *buf = skb;
115+ struct sk_buff *clone;
116+ struct vl600_state *s = dev->driver_priv;
117+
118+ /* Frame lengths are generally 4B multiplies but every couple of
119+ * hours there's an odd number of bytes sized yet correct frame,
120+ * so don't require this. */
121+
122+ /* Allow a packet (or multiple packets batched together) to be
123+ * split across many frames. We don't allow a new batch to
124+ * begin in the same frame another one is ending however, and no
125+ * leading or trailing pad bytes. */
126+ if (s->current_rx_buf) {
127+ frame = (struct vl600_frame_hdr *) s->current_rx_buf->data;
128+ if (skb->len + s->current_rx_buf->len >
129+ le32_to_cpup(&frame->len)) {
130+ netif_err(dev, ifup, dev->net, "Fragment too long\n");
131+ dev->net->stats.rx_length_errors++;
132+ goto error;
133+ }
134+
135+ buf = s->current_rx_buf;
136+ memcpy(skb_put(buf, skb->len), skb->data, skb->len);
137+ } else if (skb->len < 4) {
138+ netif_err(dev, ifup, dev->net, "Frame too short\n");
139+ dev->net->stats.rx_length_errors++;
140+ goto error;
141+ }
142+
143+ frame = (struct vl600_frame_hdr *) buf->data;
144+ /* NOTE: Should check that frame->magic == 0x53544448?
145+ * Otherwise if we receive garbage at the beginning of the frame
146+ * we may end up allocating a huge buffer and saving all the
147+ * future incoming data into it. */
148+
149+ if (buf->len < sizeof(*frame) ||
150+ buf->len != le32_to_cpup(&frame->len)) {
151+ /* Save this fragment for later assembly */
152+ if (s->current_rx_buf)
153+ return 0;
154+
155+ s->current_rx_buf = skb_copy_expand(skb, 0,
156+ le32_to_cpup(&frame->len), GFP_ATOMIC);
157+ if (!s->current_rx_buf) {
158+ netif_err(dev, ifup, dev->net, "Reserving %i bytes "
159+ "for packet assembly failed.\n",
160+ le32_to_cpup(&frame->len));
161+ dev->net->stats.rx_errors++;
162+ }
163+
164+ return 0;
165+ }
166+
167+ count = le32_to_cpup(&frame->pkt_cnt);
168+
169+ skb_pull(buf, sizeof(*frame));
170+
171+ while (count--) {
172+ if (buf->len < sizeof(*packet)) {
173+ netif_err(dev, ifup, dev->net, "Packet too short\n");
174+ goto error;
175+ }
176+
177+ packet = (struct vl600_pkt_hdr *) buf->data;
178+ packet_len = sizeof(*packet) + le32_to_cpup(&packet->len);
179+ if (packet_len > buf->len) {
180+ netif_err(dev, ifup, dev->net,
181+ "Bad packet length stored in header\n");
182+ goto error;
183+ }
184+
185+ /* Packet header is same size as the ethernet header
186+ * (sizeof(*packet) == sizeof(*ethhdr)), additionally
187+ * the h_proto field is in the same place so we just leave it
188+ * alone and fill in the remaining fields.
189+ */
190+ ethhdr = (struct ethhdr *) skb->data;
191+ if (be16_to_cpup(&ethhdr->h_proto) == ETH_P_ARP &&
192+ buf->len > 0x26) {
193+ /* Copy the addresses from packet contents */
194+ memcpy(ethhdr->h_source,
195+ &buf->data[sizeof(*ethhdr) + 0x8],
196+ ETH_ALEN);
197+ memcpy(ethhdr->h_dest,
198+ &buf->data[sizeof(*ethhdr) + 0x12],
199+ ETH_ALEN);
200+ } else {
201+ memset(ethhdr->h_source, 0, ETH_ALEN);
202+ memcpy(ethhdr->h_dest, dev->net->dev_addr, ETH_ALEN);
203+ }
204+
205+ if (count) {
206+ /* Not the last packet in this batch */
207+ clone = skb_clone(buf, GFP_ATOMIC);
208+ if (!clone)
209+ goto error;
210+
211+ skb_trim(clone, packet_len);
212+ usbnet_skb_return(dev, clone);
213+
214+ skb_pull(buf, (packet_len + 3) & ~3);
215+ } else {
216+ skb_trim(buf, packet_len);
217+
218+ if (s->current_rx_buf) {
219+ usbnet_skb_return(dev, buf);
220+ s->current_rx_buf = NULL;
221+ return 0;
222+ }
223+
224+ return 1;
225+ }
226+ }
227+
228+error:
229+ if (s->current_rx_buf) {
230+ dev_kfree_skb_any(s->current_rx_buf);
231+ s->current_rx_buf = NULL;
232+ }
233+ dev->net->stats.rx_errors++;
234+ return 0;
235+}
236+
237+static struct sk_buff *vl600_tx_fixup(struct usbnet *dev,
238+ struct sk_buff *skb, gfp_t flags)
239+{
240+ struct sk_buff *ret;
241+ struct vl600_frame_hdr *frame;
242+ struct vl600_pkt_hdr *packet;
243+ static uint32_t serial = 1;
244+ int orig_len = skb->len - sizeof(struct ethhdr);
245+ int full_len = (skb->len + sizeof(struct vl600_frame_hdr) + 3) & ~3;
246+
247+ frame = (struct vl600_frame_hdr *) skb->data;
248+ if (skb->len > sizeof(*frame) && skb->len == le32_to_cpup(&frame->len))
249+ return skb; /* Already encapsulated? */
250+
251+ if (skb->len < sizeof(struct ethhdr))
252+ /* Drop, device can only deal with ethernet packets */
253+ return NULL;
254+
255+ if (!skb_cloned(skb)) {
256+ int headroom = skb_headroom(skb);
257+ int tailroom = skb_tailroom(skb);
258+
259+ if (tailroom >= full_len - skb->len - sizeof(*frame) &&
260+ headroom >= sizeof(*frame))
261+ /* There's enough head and tail room */
262+ goto encapsulate;
263+
264+ if (headroom + tailroom + skb->len >= full_len) {
265+ /* There's enough total room, just readjust */
266+ skb->data = memmove(skb->head + sizeof(*frame),
267+ skb->data, skb->len);
268+ skb_set_tail_pointer(skb, skb->len);
269+ goto encapsulate;
270+ }
271+ }
272+
273+ /* Alloc a new skb with the required size */
274+ ret = skb_copy_expand(skb, sizeof(struct vl600_frame_hdr), full_len -
275+ skb->len - sizeof(struct vl600_frame_hdr), flags);
276+ dev_kfree_skb_any(skb);
277+ if (!ret)
278+ return ret;
279+ skb = ret;
280+
281+encapsulate:
282+ /* Packet header is same size as ethernet packet header
283+ * (sizeof(*packet) == sizeof(struct ethhdr)), additionally the
284+ * h_proto field is in the same place so we just leave it alone and
285+ * overwrite the remaining fields.
286+ */
287+ packet = (struct vl600_pkt_hdr *) skb->data;
288+ memset(&packet->dummy, 0, sizeof(packet->dummy));
289+ packet->len = cpu_to_le32(orig_len);
290+
291+ frame = (struct vl600_frame_hdr *) skb_push(skb, sizeof(*frame));
292+ memset(frame, 0, sizeof(*frame));
293+ frame->len = cpu_to_le32(full_len);
294+ frame->serial = cpu_to_le32(serial++);
295+ frame->pkt_cnt = cpu_to_le32(1);
296+
297+ if (skb->len < full_len) /* Pad */
298+ skb_put(skb, full_len - skb->len);
299+
300+ return skb;
301+}
302+
303+static const struct driver_info vl600_info = {
304+ .description = "LG VL600 modem",
305+ .flags = FLAG_ETHER | FLAG_RX_ASSEMBLE,
306+ .bind = vl600_bind,
307+ .unbind = vl600_unbind,
308+ .status = usbnet_cdc_status,
309+ .rx_fixup = vl600_rx_fixup,
310+ .tx_fixup = vl600_tx_fixup,
311+};
312+
313+static const struct usb_device_id products[] = {
314+ {
315+ USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
316+ USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
317+ .driver_info = (unsigned long) &vl600_info,
318+ },
319+ {}, /* End */
320+};
321+MODULE_DEVICE_TABLE(usb, products);
322+
323+static struct usb_driver lg_vl600_driver = {
324+ .name = "lg-vl600",
325+ .id_table = products,
326+ .probe = usbnet_probe,
327+ .disconnect = usbnet_disconnect,
328+ .suspend = usbnet_suspend,
329+ .resume = usbnet_resume,
330+};
331+
332+static int __init vl600_init(void)
333+{
334+ return usb_register(&lg_vl600_driver);
335+}
336+module_init(vl600_init);
337+
338+static void __exit vl600_exit(void)
339+{
340+ usb_deregister(&lg_vl600_driver);
341+}
342+module_exit(vl600_exit);
343+
344+MODULE_AUTHOR("Anrzej Zaborowski");
345+MODULE_DESCRIPTION("LG-VL600 modem's ethernet link");
346+MODULE_LICENSE("GPL");
drivers/net/usb/usbnet.c+7−3
@@ -387,8 +387,12 @@ static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags) · 386 unmodified lines
387387 static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
388388 {
389389 if (dev->driver_info->rx_fixup &&
390− !dev->driver_info->rx_fixup (dev, skb))
391− goto error;
390+ !dev->driver_info->rx_fixup (dev, skb)) {
391+ /* With RX_ASSEMBLE, rx_fixup() must update counters */
392+ if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
393+ dev->net->stats.rx_errors++;
394+ goto done;
395+ }
392396 // else network stack removes extra byte if we forced a short packet
393397
394398 if (skb->len) {
@@ -401,8 +405,8 @@ static inline void rx_process (struct usbnet *dev, struct sk_buff *skb) · 6 unmodified lines
401405 }
402406
403407 netif_dbg(dev, rx_err, dev->net, "drop\n");
404−error:
405408 dev->net->stats.rx_errors++;
409+done:
406410 skb_queue_tail(&dev->done, skb);
407411 }
408412
include/linux/atmdev.h+1−0
@@ -443,6 +443,7 @@ void atm_dev_signal_change(struct atm_dev *dev, char signal); · 442 unmodified lines
443443
444444 void vcc_insert_socket(struct sock *sk);
445445
446+void atm_dev_release_vccs(struct atm_dev *dev);
446447
447448 /*
448449 * This is approximately the algorithm used by alloc_skb.
include/linux/connector.h+3−13
@@ -88,8 +88,6 @@ struct cn_queue_dev { · 87 unmodified lines
8888 atomic_t refcnt;
8989 unsigned char name[CN_CBQ_NAMELEN];
9090
91− struct workqueue_struct *cn_queue;
92−
9391 struct list_head queue_list;
9492 spinlock_t queue_lock;
9593
@@ -101,20 +99,13 @@ struct cn_callback_id { · 5 unmodified lines
10199 struct cb_id id;
102100 };
103101
104−struct cn_callback_data {
105− struct sk_buff *skb;
106− void (*callback) (struct cn_msg *, struct netlink_skb_parms *);
107−
108− void *free;
109−};
110−
111102 struct cn_callback_entry {
112103 struct list_head callback_entry;
113− struct work_struct work;
104+ atomic_t refcnt;
114105 struct cn_queue_dev *pdev;
115106
116107 struct cn_callback_id id;
117− struct cn_callback_data data;
108+ void (*callback) (struct cn_msg *, struct netlink_skb_parms *);
118109
119110 u32 seq, group;
120111 };
@@ -138,13 +129,12 @@ int cn_queue_add_callback(struct cn_queue_dev *dev, const char *name, · 17 unmodified lines
138129 struct cb_id *id,
139130 void (*callback)(struct cn_msg *, struct netlink_skb_parms *));
140131 void cn_queue_del_callback(struct cn_queue_dev *dev, struct cb_id *id);
132+void cn_queue_release_callback(struct cn_callback_entry *);
141133
142134 struct cn_queue_dev *cn_queue_alloc_dev(const char *name, struct sock *);
143135 void cn_queue_free_dev(struct cn_queue_dev *dev);
144136
145137 int cn_cb_equal(struct cb_id *, struct cb_id *);
146138
147−void cn_queue_wrapper(struct work_struct *work);
148−
149139 #endif /* __KERNEL__ */
150140 #endif /* __CONNECTOR_H */
include/linux/skbuff.h+1−1
@@ -126,7 +126,7 @@ struct sk_buff; · 125 unmodified lines
126126 * GRO uses frags we allocate at least 16 regardless of page size.
127127 */
128128 #if (65536/PAGE_SIZE + 2) < 16
129−#define MAX_SKB_FRAGS 16
129+#define MAX_SKB_FRAGS 16UL
130130 #else
131131 #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
132132 #endif
include/linux/usb/usbnet.h+3−0
@@ -102,6 +102,7 @@ struct driver_info { · 101 unmodified lines
102102 * Affects statistic (counters) and short packet handling.
103103 */
104104 #define FLAG_MULTI_PACKET 0x1000
105+#define FLAG_RX_ASSEMBLE 0x2000 /* rx packets may span >1 frames */
105106
106107 /* init device ... can sleep, or cause probe() failure */
107108 int (*bind)(struct usbnet *, struct usb_interface *);
@@ -172,7 +173,9 @@ struct cdc_state { · 64 unmodified lines
172173 };
173174
174175 extern int usbnet_generic_cdc_bind(struct usbnet *, struct usb_interface *);
176+extern int usbnet_cdc_bind(struct usbnet *, struct usb_interface *);
175177 extern void usbnet_cdc_unbind(struct usbnet *, struct usb_interface *);
178+extern void usbnet_cdc_status(struct usbnet *, struct urb *);
176179
177180 /* CDC and RNDIS support the same host-chosen packet filters for IN transfers */
178181 #define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \
include/net/if_inet6.h+16−0
@@ -286,5 +286,21 @@ static inline void ipv6_ib_mc_map(const struct in6_addr *addr, · 285 unmodified lines
286286 buf[9] = broadcast[9];
287287 memcpy(buf + 10, addr->s6_addr + 6, 10);
288288 }
289+
290+static inline int ipv6_ipgre_mc_map(const struct in6_addr *addr,
291+ const unsigned char *broadcast, char *buf)
292+{
293+ if ((broadcast[0] | broadcast[1] | broadcast[2] | broadcast[3]) != 0) {
294+ memcpy(buf, broadcast, 4);
295+ } else {
296+ /* v4mapped? */
297+ if ((addr->s6_addr32[0] | addr->s6_addr32[1] |
298+ (addr->s6_addr32[2] ^ htonl(0x0000ffff))) != 0)
299+ return -EINVAL;
300+ memcpy(buf, &addr->s6_addr32[3], 4);
301+ }
302+ return 0;
303+}
304+
289305 #endif
290306 #endif
include/net/ip.h+8−0
@@ -339,6 +339,14 @@ static inline void ip_ib_mc_map(__be32 naddr, const unsigned char *broadcast, ch · 338 unmodified lines
339339 buf[16] = addr & 0x0f;
340340 }
341341
342+static inline void ip_ipgre_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf)
343+{
344+ if ((broadcast[0] | broadcast[1] | broadcast[2] | broadcast[3]) != 0)
345+ memcpy(buf, broadcast, 4);
346+ else
347+ memcpy(buf, &naddr, sizeof(naddr));
348+}
349+
342350 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
343351 #include <linux/ipv6.h>
344352 #endif
net/appletalk/ddp.c+6−5
@@ -1051,16 +1051,17 @@ static int atalk_release(struct socket *sock) · 1050 unmodified lines
10511051 {
10521052 struct sock *sk = sock->sk;
10531053
1054− sock_hold(sk);
1055− lock_sock(sk);
10561054 if (sk) {
1055+ sock_hold(sk);
1056+ lock_sock(sk);
1057+
10571058 sock_orphan(sk);
10581059 sock->sk = NULL;
10591060 atalk_destroy_socket(sk);
1060− }
1061− release_sock(sk);
1062− sock_put(sk);
10631061
1062+ release_sock(sk);
1063+ sock_put(sk);
1064+ }
10641065 return 0;
10651066 }
10661067
net/atm/common.c+1−0
@@ -252,6 +252,7 @@ void atm_dev_release_vccs(struct atm_dev *dev) · 251 unmodified lines
252252 }
253253 write_unlock_irq(&vcc_sklist_lock);
254254 }
255+EXPORT_SYMBOL(atm_dev_release_vccs);
255256
256257 static int adjust_tp(struct atm_trafprm *tp, unsigned char aal)
257258 {
net/bridge/br_multicast.c+1−1
@@ -1475,7 +1475,7 @@ static int br_multicast_ipv6_rcv(struct net_bridge *br, · 1474 unmodified lines
14751475 ip6h->payload_len == 0)
14761476 return 0;
14771477
1478− len = ntohs(ip6h->payload_len);
1478+ len = ntohs(ip6h->payload_len) + sizeof(*ip6h);
14791479 if (skb->len < len)
14801480 return -EINVAL;
14811481
net/bridge/br_stp_if.c+1−1
@@ -213,7 +213,7 @@ bool br_stp_recalculate_bridge_id(struct net_bridge *br) · 212 unmodified lines
213213
214214 /* user has chosen a value so keep it */
215215 if (br->flags & BR_SET_MAC_ADDR)
216− return;
216+ return false;
217217
218218 list_for_each_entry(p, &br->port_list, list) {
219219 if (addr == br_mac_zero ||
net/core/dev.c+22−2
@@ -1454,6 +1454,27 @@ static inline void net_timestamp_check(struct sk_buff *skb) · 1453 unmodified lines
14541454 __net_timestamp(skb);
14551455 }
14561456
1457+static inline bool is_skb_forwardable(struct net_device *dev,
1458+ struct sk_buff *skb)
1459+{
1460+ unsigned int len;
1461+
1462+ if (!(dev->flags & IFF_UP))
1463+ return false;
1464+
1465+ len = dev->mtu + dev->hard_header_len + VLAN_HLEN;
1466+ if (skb->len <= len)
1467+ return true;
1468+
1469+ /* if TSO is enabled, we don't care about the length as the packet
1470+ * could be forwarded without being segmented before
1471+ */
1472+ if (skb_is_gso(skb))
1473+ return true;
1474+
1475+ return false;
1476+}
1477+
14571478 /**
14581479 * dev_forward_skb - loopback an skb to another netif
14591480 *
@@ -1477,8 +1498,7 @@ int dev_forward_skb(struct net_device *dev, struct sk_buff *skb) · 17 unmodified lines
14771498 skb_orphan(skb);
14781499 nf_reset(skb);
14791500
1480− if (unlikely(!(dev->flags & IFF_UP) ||
1481− (skb->len > (dev->mtu + dev->hard_header_len + VLAN_HLEN)))) {
1501+ if (unlikely(!is_skb_forwardable(dev, skb))) {
14821502 atomic_long_inc(&dev->rx_dropped);
14831503 kfree_skb(skb);
14841504 return NET_RX_DROP;
net/ipv4/arp.c+3−0
@@ -215,6 +215,9 @@ int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir) · 214 unmodified lines
215215 case ARPHRD_INFINIBAND:
216216 ip_ib_mc_map(addr, dev->broadcast, haddr);
217217 return 0;
218+ case ARPHRD_IPGRE:
219+ ip_ipgre_mc_map(addr, dev->broadcast, haddr);
220+ return 0;
218221 default:
219222 if (dir) {
220223 memcpy(haddr, dev->broadcast, dev->addr_len);
net/ipv4/fib_frontend.c+2−0
@@ -1068,6 +1068,7 @@ static void ip_fib_net_exit(struct net *net) · 1067 unmodified lines
10681068 fib4_rules_exit(net);
10691069 #endif
10701070
1071+ rtnl_lock();
10711072 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
10721073 struct fib_table *tb;
10731074 struct hlist_head *head;
@@ -1080,6 +1081,7 @@ static void ip_fib_net_exit(struct net *net) · 6 unmodified lines
10801081 fib_free_table(tb);
10811082 }
10821083 }
1084+ rtnl_unlock();
10831085 kfree(net->ipv4.fib_table_hash);
10841086 }
10851087
net/ipv6/ndisc.c+2−0
@@ -341,6 +341,8 @@ int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int d · 340 unmodified lines
341341 case ARPHRD_INFINIBAND:
342342 ipv6_ib_mc_map(addr, dev->broadcast, buf);
343343 return 0;
344+ case ARPHRD_IPGRE:
345+ return ipv6_ipgre_mc_map(addr, dev->broadcast, buf);
344346 default:
345347 if (dir) {
346348 memcpy(buf, dev->broadcast, dev->addr_len);
net/sctp/protocol.c+2−2
@@ -1205,7 +1205,7 @@ SCTP_STATIC __init int sctp_init(void) · 1204 unmodified lines
12051205 if ((sctp_assoc_hashsize > (64 * 1024)) && order > 0)
12061206 continue;
12071207 sctp_assoc_hashtable = (struct sctp_hashbucket *)
1208− __get_free_pages(GFP_ATOMIC, order);
1208+ __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
12091209 } while (!sctp_assoc_hashtable && --order > 0);
12101210 if (!sctp_assoc_hashtable) {
12111211 pr_err("Failed association hash alloc\n");
@@ -1238,7 +1238,7 @@ SCTP_STATIC __init int sctp_init(void) · 26 unmodified lines
12381238 if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
12391239 continue;
12401240 sctp_port_hashtable = (struct sctp_bind_hashbucket *)
1241− __get_free_pages(GFP_ATOMIC, order);
1241+ __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
12421242 } while (!sctp_port_hashtable && --order > 0);
12431243 if (!sctp_port_hashtable) {
12441244 pr_err("Failed bind hash alloc\n");

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t