~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/um/drivers/net_kern.c

Version: ~ [ linux-5.12 ] ~ [ linux-5.11.16 ] ~ [ linux-5.10.32 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.114 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.188 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.231 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.267 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.267 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  4  * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and
  5  * James Leu (jleu@mindspring.net).
  6  * Copyright (C) 2001 by various other people who didn't put their name here.
  7  */
  8 
  9 #include <linux/memblock.h>
 10 #include <linux/etherdevice.h>
 11 #include <linux/ethtool.h>
 12 #include <linux/inetdevice.h>
 13 #include <linux/init.h>
 14 #include <linux/list.h>
 15 #include <linux/netdevice.h>
 16 #include <linux/platform_device.h>
 17 #include <linux/rtnetlink.h>
 18 #include <linux/skbuff.h>
 19 #include <linux/slab.h>
 20 #include <linux/spinlock.h>
 21 #include <init.h>
 22 #include <irq_kern.h>
 23 #include <irq_user.h>
 24 #include "mconsole_kern.h"
 25 #include <net_kern.h>
 26 #include <net_user.h>
 27 
 28 #define DRIVER_NAME "uml-netdev"
 29 
 30 static DEFINE_SPINLOCK(opened_lock);
 31 static LIST_HEAD(opened);
 32 
 33 /*
 34  * The drop_skb is used when we can't allocate an skb.  The
 35  * packet is read into drop_skb in order to get the data off the
 36  * connection to the host.
 37  * It is reallocated whenever a maximum packet size is seen which is
 38  * larger than any seen before.  update_drop_skb is called from
 39  * eth_configure when a new interface is added.
 40  */
 41 static DEFINE_SPINLOCK(drop_lock);
 42 static struct sk_buff *drop_skb;
 43 static int drop_max;
 44 
 45 static int update_drop_skb(int max)
 46 {
 47         struct sk_buff *new;
 48         unsigned long flags;
 49         int err = 0;
 50 
 51         spin_lock_irqsave(&drop_lock, flags);
 52 
 53         if (max <= drop_max)
 54                 goto out;
 55 
 56         err = -ENOMEM;
 57         new = dev_alloc_skb(max);
 58         if (new == NULL)
 59                 goto out;
 60 
 61         skb_put(new, max);
 62 
 63         kfree_skb(drop_skb);
 64         drop_skb = new;
 65         drop_max = max;
 66         err = 0;
 67 out:
 68         spin_unlock_irqrestore(&drop_lock, flags);
 69 
 70         return err;
 71 }
 72 
 73 static int uml_net_rx(struct net_device *dev)
 74 {
 75         struct uml_net_private *lp = netdev_priv(dev);
 76         int pkt_len;
 77         struct sk_buff *skb;
 78 
 79         /* If we can't allocate memory, try again next round. */
 80         skb = dev_alloc_skb(lp->max_packet);
 81         if (skb == NULL) {
 82                 drop_skb->dev = dev;
 83                 /* Read a packet into drop_skb and don't do anything with it. */
 84                 (*lp->read)(lp->fd, drop_skb, lp);
 85                 dev->stats.rx_dropped++;
 86                 return 0;
 87         }
 88 
 89         skb->dev = dev;
 90         skb_put(skb, lp->max_packet);
 91         skb_reset_mac_header(skb);
 92         pkt_len = (*lp->read)(lp->fd, skb, lp);
 93 
 94         if (pkt_len > 0) {
 95                 skb_trim(skb, pkt_len);
 96                 skb->protocol = (*lp->protocol)(skb);
 97 
 98                 dev->stats.rx_bytes += skb->len;
 99                 dev->stats.rx_packets++;
100                 netif_rx(skb);
101                 return pkt_len;
102         }
103 
104         kfree_skb(skb);
105         return pkt_len;
106 }
107 
108 static void uml_dev_close(struct work_struct *work)
109 {
110         struct uml_net_private *lp =
111                 container_of(work, struct uml_net_private, work);
112         dev_close(lp->dev);
113 }
114 
115 static irqreturn_t uml_net_interrupt(int irq, void *dev_id)
116 {
117         struct net_device *dev = dev_id;
118         struct uml_net_private *lp = netdev_priv(dev);
119         int err;
120 
121         if (!netif_running(dev))
122                 return IRQ_NONE;
123 
124         spin_lock(&lp->lock);
125         while ((err = uml_net_rx(dev)) > 0) ;
126         if (err < 0) {
127                 printk(KERN_ERR
128                        "Device '%s' read returned %d, shutting it down\n",
129                        dev->name, err);
130                 /* dev_close can't be called in interrupt context, and takes
131                  * again lp->lock.
132                  * And dev_close() can be safely called multiple times on the
133                  * same device, since it tests for (dev->flags & IFF_UP). So
134                  * there's no harm in delaying the device shutdown.
135                  * Furthermore, the workqueue will not re-enqueue an already
136                  * enqueued work item. */
137                 schedule_work(&lp->work);
138                 goto out;
139         }
140 out:
141         spin_unlock(&lp->lock);
142         return IRQ_HANDLED;
143 }
144 
145 static int uml_net_open(struct net_device *dev)
146 {
147         struct uml_net_private *lp = netdev_priv(dev);
148         int err;
149 
150         if (lp->fd >= 0) {
151                 err = -ENXIO;
152                 goto out;
153         }
154 
155         lp->fd = (*lp->open)(&lp->user);
156         if (lp->fd < 0) {
157                 err = lp->fd;
158                 goto out;
159         }
160 
161         err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
162                              IRQF_SHARED, dev->name, dev);
163         if (err != 0) {
164                 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
165                 err = -ENETUNREACH;
166                 goto out_close;
167         }
168 
169         netif_start_queue(dev);
170 
171         /* clear buffer - it can happen that the host side of the interface
172          * is full when we get here.  In this case, new data is never queued,
173          * SIGIOs never arrive, and the net never works.
174          */
175         while ((err = uml_net_rx(dev)) > 0) ;
176 
177         spin_lock(&opened_lock);
178         list_add(&lp->list, &opened);
179         spin_unlock(&opened_lock);
180 
181         return 0;
182 out_close:
183         if (lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
184         lp->fd = -1;
185 out:
186         return err;
187 }
188 
189 static int uml_net_close(struct net_device *dev)
190 {
191         struct uml_net_private *lp = netdev_priv(dev);
192 
193         netif_stop_queue(dev);
194 
195         um_free_irq(dev->irq, dev);
196         if (lp->close != NULL)
197                 (*lp->close)(lp->fd, &lp->user);
198         lp->fd = -1;
199 
200         spin_lock(&opened_lock);
201         list_del(&lp->list);
202         spin_unlock(&opened_lock);
203 
204         return 0;
205 }
206 
207 static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
208 {
209         struct uml_net_private *lp = netdev_priv(dev);
210         unsigned long flags;
211         int len;
212 
213         netif_stop_queue(dev);
214 
215         spin_lock_irqsave(&lp->lock, flags);
216 
217         len = (*lp->write)(lp->fd, skb, lp);
218         skb_tx_timestamp(skb);
219 
220         if (len == skb->len) {
221                 dev->stats.tx_packets++;
222                 dev->stats.tx_bytes += skb->len;
223                 netif_trans_update(dev);
224                 netif_start_queue(dev);
225 
226                 /* this is normally done in the interrupt when tx finishes */
227                 netif_wake_queue(dev);
228         }
229         else if (len == 0) {
230                 netif_start_queue(dev);
231                 dev->stats.tx_dropped++;
232         }
233         else {
234                 netif_start_queue(dev);
235                 printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
236         }
237 
238         spin_unlock_irqrestore(&lp->lock, flags);
239 
240         dev_consume_skb_any(skb);
241 
242         return NETDEV_TX_OK;
243 }
244 
245 static void uml_net_set_multicast_list(struct net_device *dev)
246 {
247         return;
248 }
249 
250 static void uml_net_tx_timeout(struct net_device *dev)
251 {
252         netif_trans_update(dev);
253         netif_wake_queue(dev);
254 }
255 
256 #ifdef CONFIG_NET_POLL_CONTROLLER
257 static void uml_net_poll_controller(struct net_device *dev)
258 {
259         disable_irq(dev->irq);
260         uml_net_interrupt(dev->irq, dev);
261         enable_irq(dev->irq);
262 }
263 #endif
264 
265 static void uml_net_get_drvinfo(struct net_device *dev,
266                                 struct ethtool_drvinfo *info)
267 {
268         strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
269         strlcpy(info->version, "42", sizeof(info->version));
270 }
271 
272 static const struct ethtool_ops uml_net_ethtool_ops = {
273         .get_drvinfo    = uml_net_get_drvinfo,
274         .get_link       = ethtool_op_get_link,
275         .get_ts_info    = ethtool_op_get_ts_info,
276 };
277 
278 static void uml_net_user_timer_expire(struct timer_list *t)
279 {
280 #ifdef undef
281         struct uml_net_private *lp = from_timer(lp, t, tl);
282         struct connection *conn = &lp->user;
283 
284         dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
285         do_connect(conn);
286 #endif
287 }
288 
289 void uml_net_setup_etheraddr(struct net_device *dev, char *str)
290 {
291         unsigned char *addr = dev->dev_addr;
292         char *end;
293         int i;
294 
295         if (str == NULL)
296                 goto random;
297 
298         for (i = 0; i < 6; i++) {
299                 addr[i] = simple_strtoul(str, &end, 16);
300                 if ((end == str) ||
301                    ((*end != ':') && (*end != ',') && (*end != '\0'))) {
302                         printk(KERN_ERR
303                                "setup_etheraddr: failed to parse '%s' "
304                                "as an ethernet address\n", str);
305                         goto random;
306                 }
307                 str = end + 1;
308         }
309         if (is_multicast_ether_addr(addr)) {
310                 printk(KERN_ERR
311                        "Attempt to assign a multicast ethernet address to a "
312                        "device disallowed\n");
313                 goto random;
314         }
315         if (!is_valid_ether_addr(addr)) {
316                 printk(KERN_ERR
317                        "Attempt to assign an invalid ethernet address to a "
318                        "device disallowed\n");
319                 goto random;
320         }
321         if (!is_local_ether_addr(addr)) {
322                 printk(KERN_WARNING
323                        "Warning: Assigning a globally valid ethernet "
324                        "address to a device\n");
325                 printk(KERN_WARNING "You should set the 2nd rightmost bit in "
326                        "the first byte of the MAC,\n");
327                 printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n",
328                        addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
329                        addr[5]);
330         }
331         return;
332 
333 random:
334         printk(KERN_INFO
335                "Choosing a random ethernet address for device %s\n", dev->name);
336         eth_hw_addr_random(dev);
337 }
338 
339 static DEFINE_SPINLOCK(devices_lock);
340 static LIST_HEAD(devices);
341 
342 static struct platform_driver uml_net_driver = {
343         .driver = {
344                 .name  = DRIVER_NAME,
345         },
346 };
347 
348 static void net_device_release(struct device *dev)
349 {
350         struct uml_net *device = dev_get_drvdata(dev);
351         struct net_device *netdev = device->dev;
352         struct uml_net_private *lp = netdev_priv(netdev);
353 
354         if (lp->remove != NULL)
355                 (*lp->remove)(&lp->user);
356         list_del(&device->list);
357         kfree(device);
358         free_netdev(netdev);
359 }
360 
361 static const struct net_device_ops uml_netdev_ops = {
362         .ndo_open               = uml_net_open,
363         .ndo_stop               = uml_net_close,
364         .ndo_start_xmit         = uml_net_start_xmit,
365         .ndo_set_rx_mode        = uml_net_set_multicast_list,
366         .ndo_tx_timeout         = uml_net_tx_timeout,
367         .ndo_set_mac_address    = eth_mac_addr,
368         .ndo_validate_addr      = eth_validate_addr,
369 #ifdef CONFIG_NET_POLL_CONTROLLER
370         .ndo_poll_controller = uml_net_poll_controller,
371 #endif
372 };
373 
374 /*
375  * Ensures that platform_driver_register is called only once by
376  * eth_configure.  Will be set in an initcall.
377  */
378 static int driver_registered;
379 
380 static void eth_configure(int n, void *init, char *mac,
381                           struct transport *transport, gfp_t gfp_mask)
382 {
383         struct uml_net *device;
384         struct net_device *dev;
385         struct uml_net_private *lp;
386         int err, size;
387 
388         size = transport->private_size + sizeof(struct uml_net_private);
389 
390         device = kzalloc(sizeof(*device), gfp_mask);
391         if (device == NULL) {
392                 printk(KERN_ERR "eth_configure failed to allocate struct "
393                        "uml_net\n");
394                 return;
395         }
396 
397         dev = alloc_etherdev(size);
398         if (dev == NULL) {
399                 printk(KERN_ERR "eth_configure: failed to allocate struct "
400                        "net_device for eth%d\n", n);
401                 goto out_free_device;
402         }
403 
404         INIT_LIST_HEAD(&device->list);
405         device->index = n;
406 
407         /* If this name ends up conflicting with an existing registered
408          * netdevice, that is OK, register_netdev{,ice}() will notice this
409          * and fail.
410          */
411         snprintf(dev->name, sizeof(dev->name), "eth%d", n);
412 
413         uml_net_setup_etheraddr(dev, mac);
414 
415         printk(KERN_INFO "Netdevice %d (%pM) : ", n, dev->dev_addr);
416 
417         lp = netdev_priv(dev);
418         /* This points to the transport private data. It's still clear, but we
419          * must memset it to 0 *now*. Let's help the drivers. */
420         memset(lp, 0, size);
421         INIT_WORK(&lp->work, uml_dev_close);
422 
423         /* sysfs register */
424         if (!driver_registered) {
425                 platform_driver_register(&uml_net_driver);
426                 driver_registered = 1;
427         }
428         device->pdev.id = n;
429         device->pdev.name = DRIVER_NAME;
430         device->pdev.dev.release = net_device_release;
431         dev_set_drvdata(&device->pdev.dev, device);
432         if (platform_device_register(&device->pdev))
433                 goto out_free_netdev;
434         SET_NETDEV_DEV(dev,&device->pdev.dev);
435 
436         device->dev = dev;
437 
438         /*
439          * These just fill in a data structure, so there's no failure
440          * to be worried about.
441          */
442         (*transport->kern->init)(dev, init);
443 
444         *lp = ((struct uml_net_private)
445                 { .list                 = LIST_HEAD_INIT(lp->list),
446                   .dev                  = dev,
447                   .fd                   = -1,
448                   .mac                  = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
449                   .max_packet           = transport->user->max_packet,
450                   .protocol             = transport->kern->protocol,
451                   .open                 = transport->user->open,
452                   .close                = transport->user->close,
453                   .remove               = transport->user->remove,
454                   .read                 = transport->kern->read,
455                   .write                = transport->kern->write,
456                   .add_address          = transport->user->add_address,
457                   .delete_address       = transport->user->delete_address });
458 
459         timer_setup(&lp->tl, uml_net_user_timer_expire, 0);
460         spin_lock_init(&lp->lock);
461         memcpy(lp->mac, dev->dev_addr, sizeof(lp->mac));
462 
463         if ((transport->user->init != NULL) &&
464             ((*transport->user->init)(&lp->user, dev) != 0))
465                 goto out_unregister;
466 
467         dev->mtu = transport->user->mtu;
468         dev->netdev_ops = &uml_netdev_ops;
469         dev->ethtool_ops = &uml_net_ethtool_ops;
470         dev->watchdog_timeo = (HZ >> 1);
471         dev->irq = UM_ETH_IRQ;
472 
473         err = update_drop_skb(lp->max_packet);
474         if (err)
475                 goto out_undo_user_init;
476 
477         rtnl_lock();
478         err = register_netdevice(dev);
479         rtnl_unlock();
480         if (err)
481                 goto out_undo_user_init;
482 
483         spin_lock(&devices_lock);
484         list_add(&device->list, &devices);
485         spin_unlock(&devices_lock);
486 
487         return;
488 
489 out_undo_user_init:
490         if (transport->user->remove != NULL)
491                 (*transport->user->remove)(&lp->user);
492 out_unregister:
493         platform_device_unregister(&device->pdev);
494         return; /* platform_device_unregister frees dev and device */
495 out_free_netdev:
496         free_netdev(dev);
497 out_free_device:
498         kfree(device);
499 }
500 
501 static struct uml_net *find_device(int n)
502 {
503         struct uml_net *device;
504         struct list_head *ele;
505 
506         spin_lock(&devices_lock);
507         list_for_each(ele, &devices) {
508                 device = list_entry(ele, struct uml_net, list);
509                 if (device->index == n)
510                         goto out;
511         }
512         device = NULL;
513  out:
514         spin_unlock(&devices_lock);
515         return device;
516 }
517 
518 static int eth_parse(char *str, int *index_out, char **str_out,
519                      char **error_out)
520 {
521         char *end;
522         int n, err = -EINVAL;
523 
524         n = simple_strtoul(str, &end, 0);
525         if (end == str) {
526                 *error_out = "Bad device number";
527                 return err;
528         }
529 
530         str = end;
531         if (*str != '=') {
532                 *error_out = "Expected '=' after device number";
533                 return err;
534         }
535 
536         str++;
537         if (find_device(n)) {
538                 *error_out = "Device already configured";
539                 return err;
540         }
541 
542         *index_out = n;
543         *str_out = str;
544         return 0;
545 }
546 
547 struct eth_init {
548         struct list_head list;
549         char *init;
550         int index;
551 };
552 
553 static DEFINE_SPINLOCK(transports_lock);
554 static LIST_HEAD(transports);
555 
556 /* Filled in during early boot */
557 static LIST_HEAD(eth_cmd_line);
558 
559 static int check_transport(struct transport *transport, char *eth, int n,
560                            void **init_out, char **mac_out, gfp_t gfp_mask)
561 {
562         int len;
563 
564         len = strlen(transport->name);
565         if (strncmp(eth, transport->name, len))
566                 return 0;
567 
568         eth += len;
569         if (*eth == ',')
570                 eth++;
571         else if (*eth != '\0')
572                 return 0;
573 
574         *init_out = kmalloc(transport->setup_size, gfp_mask);
575         if (*init_out == NULL)
576                 return 1;
577 
578         if (!transport->setup(eth, mac_out, *init_out)) {
579                 kfree(*init_out);
580                 *init_out = NULL;
581         }
582         return 1;
583 }
584 
585 void register_transport(struct transport *new)
586 {
587         struct list_head *ele, *next;
588         struct eth_init *eth;
589         void *init;
590         char *mac = NULL;
591         int match;
592 
593         spin_lock(&transports_lock);
594         BUG_ON(!list_empty(&new->list));
595         list_add(&new->list, &transports);
596         spin_unlock(&transports_lock);
597 
598         list_for_each_safe(ele, next, &eth_cmd_line) {
599                 eth = list_entry(ele, struct eth_init, list);
600                 match = check_transport(new, eth->init, eth->index, &init,
601                                         &mac, GFP_KERNEL);
602                 if (!match)
603                         continue;
604                 else if (init != NULL) {
605                         eth_configure(eth->index, init, mac, new, GFP_KERNEL);
606                         kfree(init);
607                 }
608                 list_del(&eth->list);
609         }
610 }
611 
612 static int eth_setup_common(char *str, int index)
613 {
614         struct list_head *ele;
615         struct transport *transport;
616         void *init;
617         char *mac = NULL;
618         int found = 0;
619 
620         spin_lock(&transports_lock);
621         list_for_each(ele, &transports) {
622                 transport = list_entry(ele, struct transport, list);
623                 if (!check_transport(transport, str, index, &init,
624                                         &mac, GFP_ATOMIC))
625                         continue;
626                 if (init != NULL) {
627                         eth_configure(index, init, mac, transport, GFP_ATOMIC);
628                         kfree(init);
629                 }
630                 found = 1;
631                 break;
632         }
633 
634         spin_unlock(&transports_lock);
635         return found;
636 }
637 
638 static int __init eth_setup(char *str)
639 {
640         struct eth_init *new;
641         char *error;
642         int n, err;
643 
644         err = eth_parse(str, &n, &str, &error);
645         if (err) {
646                 printk(KERN_ERR "eth_setup - Couldn't parse '%s' : %s\n",
647                        str, error);
648                 return 1;
649         }
650 
651         new = memblock_alloc(sizeof(*new), SMP_CACHE_BYTES);
652         if (!new)
653                 panic("%s: Failed to allocate %zu bytes\n", __func__,
654                       sizeof(*new));
655 
656         INIT_LIST_HEAD(&new->list);
657         new->index = n;
658         new->init = str;
659 
660         list_add_tail(&new->list, &eth_cmd_line);
661         return 1;
662 }
663 
664 __setup("eth", eth_setup);
665 __uml_help(eth_setup,
666 "eth[0-9]+=<transport>,<options>\n"
667 "    Configure a network device.\n\n"
668 );
669 
670 static int net_config(char *str, char **error_out)
671 {
672         int n, err;
673 
674         err = eth_parse(str, &n, &str, error_out);
675         if (err)
676                 return err;
677 
678         /* This string is broken up and the pieces used by the underlying
679          * driver.  So, it is freed only if eth_setup_common fails.
680          */
681         str = kstrdup(str, GFP_KERNEL);
682         if (str == NULL) {
683                 *error_out = "net_config failed to strdup string";
684                 return -ENOMEM;
685         }
686         err = !eth_setup_common(str, n);
687         if (err)
688                 kfree(str);
689         return err;
690 }
691 
692 static int net_id(char **str, int *start_out, int *end_out)
693 {
694         char *end;
695         int n;
696 
697         n = simple_strtoul(*str, &end, 0);
698         if ((*end != '\0') || (end == *str))
699                 return -1;
700 
701         *start_out = n;
702         *end_out = n;
703         *str = end;
704         return n;
705 }
706 
707 static int net_remove(int n, char **error_out)
708 {
709         struct uml_net *device;
710         struct net_device *dev;
711         struct uml_net_private *lp;
712 
713         device = find_device(n);
714         if (device == NULL)
715                 return -ENODEV;
716 
717         dev = device->dev;
718         lp = netdev_priv(dev);
719         if (lp->fd > 0)
720                 return -EBUSY;
721         unregister_netdev(dev);
722         platform_device_unregister(&device->pdev);
723 
724         return 0;
725 }
726 
727 static struct mc_device net_mc = {
728         .list           = LIST_HEAD_INIT(net_mc.list),
729         .name           = "eth",
730         .config         = net_config,
731         .get_config     = NULL,
732         .id             = net_id,
733         .remove         = net_remove,
734 };
735 
736 #ifdef CONFIG_INET
737 static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
738                               void *ptr)
739 {
740         struct in_ifaddr *ifa = ptr;
741         struct net_device *dev = ifa->ifa_dev->dev;
742         struct uml_net_private *lp;
743         void (*proc)(unsigned char *, unsigned char *, void *);
744         unsigned char addr_buf[4], netmask_buf[4];
745 
746         if (dev->netdev_ops->ndo_open != uml_net_open)
747                 return NOTIFY_DONE;
748 
749         lp = netdev_priv(dev);
750 
751         proc = NULL;
752         switch (event) {
753         case NETDEV_UP:
754                 proc = lp->add_address;
755                 break;
756         case NETDEV_DOWN:
757                 proc = lp->delete_address;
758                 break;
759         }
760         if (proc != NULL) {
761                 memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf));
762                 memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf));
763                 (*proc)(addr_buf, netmask_buf, &lp->user);
764         }
765         return NOTIFY_DONE;
766 }
767 
768 /* uml_net_init shouldn't be called twice on two CPUs at the same time */
769 static struct notifier_block uml_inetaddr_notifier = {
770         .notifier_call          = uml_inetaddr_event,
771 };
772 
773 static void inet_register(void)
774 {
775         struct list_head *ele;
776         struct uml_net_private *lp;
777         struct in_device *ip;
778         struct in_ifaddr *in;
779 
780         register_inetaddr_notifier(&uml_inetaddr_notifier);
781 
782         /* Devices may have been opened already, so the uml_inetaddr_notifier
783          * didn't get a chance to run for them.  This fakes it so that
784          * addresses which have already been set up get handled properly.
785          */
786         spin_lock(&opened_lock);
787         list_for_each(ele, &opened) {
788                 lp = list_entry(ele, struct uml_net_private, list);
789                 ip = lp->dev->ip_ptr;
790                 if (ip == NULL)
791                         continue;
792                 in = ip->ifa_list;
793                 while (in != NULL) {
794                         uml_inetaddr_event(NULL, NETDEV_UP, in);
795                         in = in->ifa_next;
796                 }
797         }
798         spin_unlock(&opened_lock);
799 }
800 #else
801 static inline void inet_register(void)
802 {
803 }
804 #endif
805 
806 static int uml_net_init(void)
807 {
808         mconsole_register_dev(&net_mc);
809         inet_register();
810         return 0;
811 }
812 
813 __initcall(uml_net_init);
814 
815 static void close_devices(void)
816 {
817         struct list_head *ele;
818         struct uml_net_private *lp;
819 
820         spin_lock(&opened_lock);
821         list_for_each(ele, &opened) {
822                 lp = list_entry(ele, struct uml_net_private, list);
823                 um_free_irq(lp->dev->irq, lp->dev);
824                 if ((lp->close != NULL) && (lp->fd >= 0))
825                         (*lp->close)(lp->fd, &lp->user);
826                 if (lp->remove != NULL)
827                         (*lp->remove)(&lp->user);
828         }
829         spin_unlock(&opened_lock);
830 }
831 
832 __uml_exitcall(close_devices);
833 
834 void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *,
835                                         void *),
836                     void *arg)
837 {
838         struct net_device *dev = d;
839         struct in_device *ip = dev->ip_ptr;
840         struct in_ifaddr *in;
841         unsigned char address[4], netmask[4];
842 
843         if (ip == NULL) return;
844         in = ip->ifa_list;
845         while (in != NULL) {
846                 memcpy(address, &in->ifa_address, sizeof(address));
847                 memcpy(netmask, &in->ifa_mask, sizeof(netmask));
848                 (*cb)(address, netmask, arg);
849                 in = in->ifa_next;
850         }
851 }
852 
853 int dev_netmask(void *d, void *m)
854 {
855         struct net_device *dev = d;
856         struct in_device *ip = dev->ip_ptr;
857         struct in_ifaddr *in;
858         __be32 *mask_out = m;
859 
860         if (ip == NULL)
861                 return 1;
862 
863         in = ip->ifa_list;
864         if (in == NULL)
865                 return 1;
866 
867         *mask_out = in->ifa_mask;
868         return 0;
869 }
870 
871 void *get_output_buffer(int *len_out)
872 {
873         void *ret;
874 
875         ret = (void *) __get_free_pages(GFP_KERNEL, 0);
876         if (ret) *len_out = PAGE_SIZE;
877         else *len_out = 0;
878         return ret;
879 }
880 
881 void free_output_buffer(void *buffer)
882 {
883         free_pages((unsigned long) buffer, 0);
884 }
885 
886 int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out,
887                      char **gate_addr)
888 {
889         char *remain;
890 
891         remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
892         if (remain != NULL) {
893                 printk(KERN_ERR "tap_setup_common - Extra garbage on "
894                        "specification : '%s'\n", remain);
895                 return 1;
896         }
897 
898         return 0;
899 }
900 
901 unsigned short eth_protocol(struct sk_buff *skb)
902 {
903         return eth_type_trans(skb, skb->dev);
904 }
905 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp