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