cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

net_kern.c (20097B)


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