This source file includes following definitions.
- update_drop_skb
- uml_net_rx
- uml_dev_close
- uml_net_interrupt
- uml_net_open
- uml_net_close
- uml_net_start_xmit
- uml_net_set_multicast_list
- uml_net_tx_timeout
- uml_net_poll_controller
- uml_net_get_drvinfo
- uml_net_user_timer_expire
- uml_net_setup_etheraddr
- net_device_release
- eth_configure
- find_device
- eth_parse
- check_transport
- register_transport
- eth_setup_common
- eth_setup
- net_config
- net_id
- net_remove
- uml_inetaddr_event
- inet_register
- inet_register
- uml_net_init
- close_devices
- iter_addresses
- dev_netmask
- get_output_buffer
- free_output_buffer
- tap_setup_common
- eth_protocol
1
2
3
4
5
6
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
35
36
37
38
39
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
80 skb = dev_alloc_skb(lp->max_packet);
81 if (skb == NULL) {
82 drop_skb->dev = dev;
83
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
131
132
133
134
135
136
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
172
173
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
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
376
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
408
409
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
419
420 memset(lp, 0, size);
421 INIT_WORK(&lp->work, uml_dev_close);
422
423
424 if (!driver_registered) {
425 platform_driver_register(¨_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
440
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 = ¨_netdev_ops;
469 dev->ethtool_ops = ¨_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;
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
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, ð_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(ð->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, ð_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
679
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
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(¨_inetaddr_notifier);
781
782
783
784
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 }