blob: b305f8247909563551a9d4a9ba20c81c000e9722 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Dikecd1ae0e2007-10-16 01:27:29 -07002 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
Jeff Dikef28169d2007-02-10 01:43:53 -08003 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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
Jeff Dikecd1ae0e2007-10-16 01:27:29 -07009#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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/slab.h>
Jeff Dikecd1ae0e2007-10-16 01:27:29 -070020#include <linux/spinlock.h>
Al Viro37185b32012-10-08 03:27:32 +010021#include <init.h>
22#include <irq_kern.h>
23#include <irq_user.h>
Jeff Dikecd1ae0e2007-10-16 01:27:29 -070024#include "mconsole_kern.h"
Al Viro37185b32012-10-08 03:27:32 +010025#include <net_kern.h>
26#include <net_user.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
28#define DRIVER_NAME "uml-netdev"
29
30static DEFINE_SPINLOCK(opened_lock);
Jeff Dike90107722006-01-06 00:18:54 -080031static LIST_HEAD(opened);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Jeff Dike605c1e52007-10-16 01:27:32 -070033/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070073static int uml_net_rx(struct net_device *dev)
74{
Wang Chen17c324f2008-12-04 15:07:33 -080075 struct uml_net_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 int pkt_len;
77 struct sk_buff *skb;
78
79 /* If we can't allocate memory, try again next round. */
Jeff Dikeb53f35a2007-10-16 01:27:31 -070080 skb = dev_alloc_skb(lp->max_packet);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 if (skb == NULL) {
Jeff Dike605c1e52007-10-16 01:27:32 -070082 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);
Stephen Hemmingercfa87072009-03-26 15:11:16 +000085 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 return 0;
87 }
88
89 skb->dev = dev;
Jeff Dikeb53f35a2007-10-16 01:27:31 -070090 skb_put(skb, lp->max_packet);
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -070091 skb_reset_mac_header(skb);
Jeff Dikeb53f35a2007-10-16 01:27:31 -070092 pkt_len = (*lp->read)(lp->fd, skb, lp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 if (pkt_len > 0) {
95 skb_trim(skb, pkt_len);
96 skb->protocol = (*lp->protocol)(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Stephen Hemmingercfa87072009-03-26 15:11:16 +000098 dev->stats.rx_bytes += skb->len;
99 dev->stats.rx_packets++;
Julia Lawall505a41d2007-12-10 17:14:46 -0800100 netif_rx(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 return pkt_len;
102 }
103
104 kfree_skb(skb);
105 return pkt_len;
106}
107
Peter Zijlstraeff3b632006-12-13 00:33:50 -0800108static void uml_dev_close(struct work_struct *work)
Paolo 'Blaisorblade' Giarrusso71c8d4c2006-01-18 17:42:56 -0800109{
Peter Zijlstraeff3b632006-12-13 00:33:50 -0800110 struct uml_net_private *lp =
111 container_of(work, struct uml_net_private, work);
112 dev_close(lp->dev);
Paolo 'Blaisorblade' Giarrusso71c8d4c2006-01-18 17:42:56 -0800113}
114
WANG Cong074a0db2008-04-28 02:13:57 -0700115static irqreturn_t uml_net_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
117 struct net_device *dev = dev_id;
Wang Chen17c324f2008-12-04 15:07:33 -0800118 struct uml_net_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 int err;
120
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700121 if (!netif_running(dev))
122 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124 spin_lock(&lp->lock);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700125 while ((err = uml_net_rx(dev)) > 0) ;
126 if (err < 0) {
Jeff Dikef28169d2007-02-10 01:43:53 -0800127 printk(KERN_ERR
128 "Device '%s' read returned %d, shutting it down\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 dev->name, err);
Paolo 'Blaisorblade' Giarrusso71c8d4c2006-01-18 17:42:56 -0800130 /* 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
Peter Zijlstraeff3b632006-12-13 00:33:50 -0800134 * 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 goto out;
139 }
140 reactivate_fd(lp->fd, UM_ETH_IRQ);
141
Paolo 'Blaisorblade' Giarrusso71c8d4c2006-01-18 17:42:56 -0800142out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 spin_unlock(&lp->lock);
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800144 return IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
147static int uml_net_open(struct net_device *dev)
148{
Wang Chen17c324f2008-12-04 15:07:33 -0800149 struct uml_net_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 int err;
151
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700152 if (lp->fd >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 err = -ENXIO;
154 goto out;
155 }
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 lp->fd = (*lp->open)(&lp->user);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700158 if (lp->fd < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 err = lp->fd;
160 goto out;
161 }
162
163 err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
Yong Zhangc0b79a92011-09-22 16:58:46 +0800164 IRQF_SHARED, dev->name, dev);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700165 if (err != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 err = -ENETUNREACH;
Jeff Dike14d9ead2006-02-07 12:58:42 -0800168 goto out_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 }
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 netif_start_queue(dev);
172
173 /* clear buffer - it can happen that the host side of the interface
174 * is full when we get here. In this case, new data is never queued,
175 * SIGIOs never arrive, and the net never works.
176 */
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700177 while ((err = uml_net_rx(dev)) > 0) ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Jeff Dike14d9ead2006-02-07 12:58:42 -0800179 spin_lock(&opened_lock);
180 list_add(&lp->list, &opened);
181 spin_unlock(&opened_lock);
182
183 return 0;
184out_close:
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700185 if (lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
Jeff Dike14d9ead2006-02-07 12:58:42 -0800186 lp->fd = -1;
187out:
Jeff Dike14d9ead2006-02-07 12:58:42 -0800188 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189}
190
191static int uml_net_close(struct net_device *dev)
192{
Wang Chen17c324f2008-12-04 15:07:33 -0800193 struct uml_net_private *lp = netdev_priv(dev);
Jeff Dikef28169d2007-02-10 01:43:53 -0800194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 netif_stop_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Richard Weinbergerfa7a0442012-04-17 22:37:13 +0200197 um_free_irq(dev->irq, dev);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700198 if (lp->close != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 (*lp->close)(lp->fd, &lp->user);
200 lp->fd = -1;
201
Jeff Dike14d9ead2006-02-07 12:58:42 -0800202 spin_lock(&opened_lock);
203 list_del(&lp->list);
204 spin_unlock(&opened_lock);
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 return 0;
207}
208
209static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
210{
Wang Chen17c324f2008-12-04 15:07:33 -0800211 struct uml_net_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 unsigned long flags;
213 int len;
214
215 netif_stop_queue(dev);
216
217 spin_lock_irqsave(&lp->lock, flags);
218
Jeff Dikeb53f35a2007-10-16 01:27:31 -0700219 len = (*lp->write)(lp->fd, skb, lp);
Paul Chavent55ea1cf2012-12-06 16:25:05 +0100220 skb_tx_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700222 if (len == skb->len) {
Stephen Hemmingercfa87072009-03-26 15:11:16 +0000223 dev->stats.tx_packets++;
224 dev->stats.tx_bytes += skb->len;
Florian Westphal860e9532016-05-03 16:33:13 +0200225 netif_trans_update(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 netif_start_queue(dev);
227
228 /* this is normally done in the interrupt when tx finishes */
229 netif_wake_queue(dev);
Jeff Dikef28169d2007-02-10 01:43:53 -0800230 }
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700231 else if (len == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 netif_start_queue(dev);
Stephen Hemmingercfa87072009-03-26 15:11:16 +0000233 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 }
235 else {
236 netif_start_queue(dev);
237 printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
238 }
239
240 spin_unlock_irqrestore(&lp->lock, flags);
241
Eric W. Biedermanfabfb912014-03-15 15:27:14 -0700242 dev_consume_skb_any(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Patrick McHardy6ed10652009-06-23 06:03:08 +0000244 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247static void uml_net_set_multicast_list(struct net_device *dev)
248{
Patrick McHardyf70c1762008-03-26 00:16:29 -0700249 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250}
251
252static void uml_net_tx_timeout(struct net_device *dev)
253{
Florian Westphal860e9532016-05-03 16:33:13 +0200254 netif_trans_update(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 netif_wake_queue(dev);
256}
257
Richard Weinbergerdd71dc42011-07-25 17:12:48 -0700258#ifdef CONFIG_NET_POLL_CONTROLLER
259static void uml_net_poll_controller(struct net_device *dev)
260{
261 disable_irq(dev->irq);
262 uml_net_interrupt(dev->irq, dev);
263 enable_irq(dev->irq);
264}
265#endif
266
Christoph Hellwig6d387482005-11-07 06:21:21 +0100267static void uml_net_get_drvinfo(struct net_device *dev,
268 struct ethtool_drvinfo *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
Jiri Pirko7826d432013-01-06 00:44:26 +0000270 strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
271 strlcpy(info->version, "42", sizeof(info->version));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272}
273
Stephen Hemminger0fc0b732009-09-02 01:03:33 -0700274static const struct ethtool_ops uml_net_ethtool_ops = {
Christoph Hellwig6d387482005-11-07 06:21:21 +0100275 .get_drvinfo = uml_net_get_drvinfo,
276 .get_link = ethtool_op_get_link,
Paul Chavent55ea1cf2012-12-06 16:25:05 +0100277 .get_ts_info = ethtool_op_get_ts_info,
Christoph Hellwig6d387482005-11-07 06:21:21 +0100278};
279
Kees Cook02ab4fc2017-10-16 17:29:40 -0700280static void uml_net_user_timer_expire(struct timer_list *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
282#ifdef undef
Kees Cook02ab4fc2017-10-16 17:29:40 -0700283 struct uml_net_private *lp = from_timer(lp, t, tl);
284 struct connection *conn = &lp->user;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
287 do_connect(conn);
288#endif
289}
290
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000291static void setup_etheraddr(struct net_device *dev, char *str)
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700292{
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000293 unsigned char *addr = dev->dev_addr;
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700294 char *end;
295 int i;
296
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700297 if (str == NULL)
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700298 goto random;
299
Jeff Dike2278c5a2008-02-04 22:31:25 -0800300 for (i = 0; i < 6; i++) {
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700301 addr[i] = simple_strtoul(str, &end, 16);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700302 if ((end == str) ||
303 ((*end != ':') && (*end != ',') && (*end != '\0'))) {
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700304 printk(KERN_ERR
305 "setup_etheraddr: failed to parse '%s' "
306 "as an ethernet address\n", str);
307 goto random;
308 }
309 str = end + 1;
310 }
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700311 if (is_multicast_ether_addr(addr)) {
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700312 printk(KERN_ERR
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700313 "Attempt to assign a multicast ethernet address to a "
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700314 "device disallowed\n");
315 goto random;
316 }
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700317 if (!is_valid_ether_addr(addr)) {
318 printk(KERN_ERR
319 "Attempt to assign an invalid ethernet address to a "
320 "device disallowed\n");
321 goto random;
322 }
323 if (!is_local_ether_addr(addr)) {
324 printk(KERN_WARNING
Jeff Dike2278c5a2008-02-04 22:31:25 -0800325 "Warning: Assigning a globally valid ethernet "
Jeff Dike7d982302007-05-08 00:35:04 -0700326 "address to a device\n");
Jeff Dike2278c5a2008-02-04 22:31:25 -0800327 printk(KERN_WARNING "You should set the 2nd rightmost bit in "
328 "the first byte of the MAC,\n");
Jeff Dike7d982302007-05-08 00:35:04 -0700329 printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n",
330 addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
331 addr[5]);
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700332 }
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000333 return;
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700334
335random:
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700336 printk(KERN_INFO
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000337 "Choosing a random ethernet address for device %s\n", dev->name);
338 eth_hw_addr_random(dev);
Jeff Dikeb10aeee2006-09-29 01:58:50 -0700339}
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341static DEFINE_SPINLOCK(devices_lock);
Jeff Dike90107722006-01-06 00:18:54 -0800342static LIST_HEAD(devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Russell King3ae5eae2005-11-09 22:32:44 +0000344static struct platform_driver uml_net_driver = {
345 .driver = {
346 .name = DRIVER_NAME,
347 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Jeff Dike2e3f5252007-05-06 14:51:29 -0700350static void net_device_release(struct device *dev)
351{
Greg Kroah-Hartman8691b972009-05-04 12:40:54 -0700352 struct uml_net *device = dev_get_drvdata(dev);
Jeff Dike2e3f5252007-05-06 14:51:29 -0700353 struct net_device *netdev = device->dev;
Wang Chen17c324f2008-12-04 15:07:33 -0800354 struct uml_net_private *lp = netdev_priv(netdev);
Jeff Dike2e3f5252007-05-06 14:51:29 -0700355
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700356 if (lp->remove != NULL)
Jeff Dike2e3f5252007-05-06 14:51:29 -0700357 (*lp->remove)(&lp->user);
358 list_del(&device->list);
359 kfree(device);
360 free_netdev(netdev);
361}
362
Stephen Hemminger8bb95b32009-03-26 15:11:17 +0000363static const struct net_device_ops uml_netdev_ops = {
364 .ndo_open = uml_net_open,
365 .ndo_stop = uml_net_close,
366 .ndo_start_xmit = uml_net_start_xmit,
Jiri Pirkoafc4b132011-08-16 06:29:01 +0000367 .ndo_set_rx_mode = uml_net_set_multicast_list,
Stephen Hemminger8bb95b32009-03-26 15:11:17 +0000368 .ndo_tx_timeout = uml_net_tx_timeout,
Boaz Harrosh93370572010-09-29 08:34:27 +0000369 .ndo_set_mac_address = eth_mac_addr,
Stephen Hemminger8bb95b32009-03-26 15:11:17 +0000370 .ndo_validate_addr = eth_validate_addr,
Richard Weinbergerdd71dc42011-07-25 17:12:48 -0700371#ifdef CONFIG_NET_POLL_CONTROLLER
372 .ndo_poll_controller = uml_net_poll_controller,
373#endif
Stephen Hemminger8bb95b32009-03-26 15:11:17 +0000374};
375
Jeff Dike80e39312008-02-04 22:31:17 -0800376/*
377 * Ensures that platform_driver_register is called only once by
378 * eth_configure. Will be set in an initcall.
379 */
380static int driver_registered;
381
Jeff Dikef34d9d22007-05-06 14:51:04 -0700382static void eth_configure(int n, void *init, char *mac,
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530383 struct transport *transport, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
385 struct uml_net *device;
386 struct net_device *dev;
387 struct uml_net_private *lp;
Paolo 'Blaisorblade' Giarrussoc74c69b2007-05-06 14:51:15 -0700388 int err, size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Paolo 'Blaisorblade' Giarrussoc74c69b2007-05-06 14:51:15 -0700390 size = transport->private_size + sizeof(struct uml_net_private);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530392 device = kzalloc(sizeof(*device), gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (device == NULL) {
Paolo 'Blaisorblade' Giarrusso8c840832007-05-06 14:51:14 -0700394 printk(KERN_ERR "eth_configure failed to allocate struct "
395 "uml_net\n");
Jeff Dikef34d9d22007-05-06 14:51:04 -0700396 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 }
398
Paolo 'Blaisorblade' Giarrusso8c840832007-05-06 14:51:14 -0700399 dev = alloc_etherdev(size);
400 if (dev == NULL) {
401 printk(KERN_ERR "eth_configure: failed to allocate struct "
402 "net_device for eth%d\n", n);
403 goto out_free_device;
404 }
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 INIT_LIST_HEAD(&device->list);
407 device->index = n;
408
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700409 /* If this name ends up conflicting with an existing registered
410 * netdevice, that is OK, register_netdev{,ice}() will notice this
411 * and fail.
412 */
Paolo 'Blaisorblade' Giarrusso8c840832007-05-06 14:51:14 -0700413 snprintf(dev->name, sizeof(dev->name), "eth%d", n);
Paolo 'Blaisorblade' Giarrussoe0247152007-05-06 14:51:13 -0700414
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000415 setup_etheraddr(dev, mac);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000417 printk(KERN_INFO "Netdevice %d (%pM) : ", n, dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Wang Chen17c324f2008-12-04 15:07:33 -0800419 lp = netdev_priv(dev);
Paolo 'Blaisorblade' Giarrussoe56a7882006-01-18 17:42:55 -0800420 /* This points to the transport private data. It's still clear, but we
421 * must memset it to 0 *now*. Let's help the drivers. */
422 memset(lp, 0, size);
Peter Zijlstraeff3b632006-12-13 00:33:50 -0800423 INIT_WORK(&lp->work, uml_dev_close);
Paolo 'Blaisorblade' Giarrussoe56a7882006-01-18 17:42:55 -0800424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 /* sysfs register */
426 if (!driver_registered) {
Russell King3ae5eae2005-11-09 22:32:44 +0000427 platform_driver_register(&uml_net_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 driver_registered = 1;
429 }
430 device->pdev.id = n;
431 device->pdev.name = DRIVER_NAME;
Jeff Dike2e3f5252007-05-06 14:51:29 -0700432 device->pdev.dev.release = net_device_release;
Greg Kroah-Hartman8691b972009-05-04 12:40:54 -0700433 dev_set_drvdata(&device->pdev.dev, device);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700434 if (platform_device_register(&device->pdev))
Jeff Dikef34d9d22007-05-06 14:51:04 -0700435 goto out_free_netdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 SET_NETDEV_DEV(dev,&device->pdev.dev);
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 device->dev = dev;
439
Jeff Dikef34d9d22007-05-06 14:51:04 -0700440 /*
441 * These just fill in a data structure, so there's no failure
442 * to be worried about.
443 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 (*transport->kern->init)(dev, init);
445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 *lp = ((struct uml_net_private)
447 { .list = LIST_HEAD_INIT(lp->list),
448 .dev = dev,
449 .fd = -1,
450 .mac = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
Jeff Dikeb53f35a2007-10-16 01:27:31 -0700451 .max_packet = transport->user->max_packet,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 .protocol = transport->kern->protocol,
453 .open = transport->user->open,
454 .close = transport->user->close,
455 .remove = transport->user->remove,
456 .read = transport->kern->read,
457 .write = transport->kern->write,
458 .add_address = transport->user->add_address,
Jeff Dikeb53f35a2007-10-16 01:27:31 -0700459 .delete_address = transport->user->delete_address });
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Kees Cook02ab4fc2017-10-16 17:29:40 -0700461 timer_setup(&lp->tl, uml_net_user_timer_expire, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 spin_lock_init(&lp->lock);
Jiri Pirko646cbcd2013-01-01 03:30:18 +0000463 memcpy(lp->mac, dev->dev_addr, sizeof(lp->mac));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
Jeff Dikef34d9d22007-05-06 14:51:04 -0700465 if ((transport->user->init != NULL) &&
466 ((*transport->user->init)(&lp->user, dev) != 0))
467 goto out_unregister;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Jeff Dikeb53f35a2007-10-16 01:27:31 -0700469 dev->mtu = transport->user->mtu;
Stephen Hemminger8bb95b32009-03-26 15:11:17 +0000470 dev->netdev_ops = &uml_netdev_ops;
Jeff Dikef34d9d22007-05-06 14:51:04 -0700471 dev->ethtool_ops = &uml_net_ethtool_ops;
472 dev->watchdog_timeo = (HZ >> 1);
473 dev->irq = UM_ETH_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Jeff Dike605c1e52007-10-16 01:27:32 -0700475 err = update_drop_skb(lp->max_packet);
476 if (err)
477 goto out_undo_user_init;
478
Jeff Dikef34d9d22007-05-06 14:51:04 -0700479 rtnl_lock();
480 err = register_netdevice(dev);
481 rtnl_unlock();
482 if (err)
483 goto out_undo_user_init;
484
485 spin_lock(&devices_lock);
486 list_add(&device->list, &devices);
487 spin_unlock(&devices_lock);
488
489 return;
490
491out_undo_user_init:
Paolo 'Blaisorblade' Giarrusso8c840832007-05-06 14:51:14 -0700492 if (transport->user->remove != NULL)
Jeff Dikef34d9d22007-05-06 14:51:04 -0700493 (*transport->user->remove)(&lp->user);
494out_unregister:
495 platform_device_unregister(&device->pdev);
Jeff Dike7d982302007-05-08 00:35:04 -0700496 return; /* platform_device_unregister frees dev and device */
Jeff Dikef34d9d22007-05-06 14:51:04 -0700497out_free_netdev:
498 free_netdev(dev);
Paolo 'Blaisorblade' Giarrusso8c840832007-05-06 14:51:14 -0700499out_free_device:
Jeff Dikef34d9d22007-05-06 14:51:04 -0700500 kfree(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503static struct uml_net *find_device(int n)
504{
505 struct uml_net *device;
506 struct list_head *ele;
507
508 spin_lock(&devices_lock);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700509 list_for_each(ele, &devices) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 device = list_entry(ele, struct uml_net, list);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700511 if (device->index == n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 goto out;
513 }
514 device = NULL;
515 out:
516 spin_unlock(&devices_lock);
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800517 return device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518}
519
Jeff Dikef28169d2007-02-10 01:43:53 -0800520static int eth_parse(char *str, int *index_out, char **str_out,
521 char **error_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
523 char *end;
Joe Perchesa419aef2009-08-18 11:18:35 -0700524 int n, err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 n = simple_strtoul(str, &end, 0);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700527 if (end == str) {
Jeff Dikef28169d2007-02-10 01:43:53 -0800528 *error_out = "Bad device number";
529 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 }
Jeff Dikef28169d2007-02-10 01:43:53 -0800531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 str = end;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700533 if (*str != '=') {
Jeff Dikef28169d2007-02-10 01:43:53 -0800534 *error_out = "Expected '=' after device number";
535 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 }
Jeff Dikef28169d2007-02-10 01:43:53 -0800537
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 str++;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700539 if (find_device(n)) {
Jeff Dikef28169d2007-02-10 01:43:53 -0800540 *error_out = "Device already configured";
541 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
Jeff Dikef28169d2007-02-10 01:43:53 -0800543
544 *index_out = n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 *str_out = str;
Jeff Dikef28169d2007-02-10 01:43:53 -0800546 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
549struct eth_init {
550 struct list_head list;
551 char *init;
552 int index;
553};
554
Jeff Diked3b7f692007-02-10 01:43:56 -0800555static DEFINE_SPINLOCK(transports_lock);
556static LIST_HEAD(transports);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558/* Filled in during early boot */
Jeff Dikec862fc32007-02-10 01:44:04 -0800559static LIST_HEAD(eth_cmd_line);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561static int check_transport(struct transport *transport, char *eth, int n,
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530562 void **init_out, char **mac_out, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563{
564 int len;
565
566 len = strlen(transport->name);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700567 if (strncmp(eth, transport->name, len))
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800568 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 eth += len;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700571 if (*eth == ',')
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 eth++;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700573 else if (*eth != '\0')
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800574 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530576 *init_out = kmalloc(transport->setup_size, gfp_mask);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700577 if (*init_out == NULL)
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800578 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700580 if (!transport->setup(eth, mac_out, *init_out)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 kfree(*init_out);
582 *init_out = NULL;
583 }
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800584 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585}
586
587void register_transport(struct transport *new)
588{
589 struct list_head *ele, *next;
590 struct eth_init *eth;
591 void *init;
592 char *mac = NULL;
593 int match;
594
Jeff Diked3b7f692007-02-10 01:43:56 -0800595 spin_lock(&transports_lock);
596 BUG_ON(!list_empty(&new->list));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 list_add(&new->list, &transports);
Jeff Diked3b7f692007-02-10 01:43:56 -0800598 spin_unlock(&transports_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700600 list_for_each_safe(ele, next, &eth_cmd_line) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 eth = list_entry(ele, struct eth_init, list);
602 match = check_transport(new, eth->init, eth->index, &init,
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530603 &mac, GFP_KERNEL);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700604 if (!match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 continue;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700606 else if (init != NULL) {
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530607 eth_configure(eth->index, init, mac, new, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 kfree(init);
609 }
610 list_del(&eth->list);
611 }
612}
613
614static int eth_setup_common(char *str, int index)
615{
616 struct list_head *ele;
617 struct transport *transport;
618 void *init;
619 char *mac = NULL;
Jeff Dikec862fc32007-02-10 01:44:04 -0800620 int found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Jeff Dikec862fc32007-02-10 01:44:04 -0800622 spin_lock(&transports_lock);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700623 list_for_each(ele, &transports) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 transport = list_entry(ele, struct transport, list);
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530625 if (!check_transport(transport, str, index, &init,
626 &mac, GFP_ATOMIC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 continue;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700628 if (init != NULL) {
Saurabh Sengare17c6d72015-10-29 21:00:32 +0530629 eth_configure(index, init, mac, transport, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 kfree(init);
631 }
Jeff Dikec862fc32007-02-10 01:44:04 -0800632 found = 1;
633 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
Jeff Dikec862fc32007-02-10 01:44:04 -0800635
636 spin_unlock(&transports_lock);
637 return found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638}
639
Jeff Dike97a1fcb2007-07-23 18:43:48 -0700640static int __init eth_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641{
642 struct eth_init *new;
Jeff Dikef28169d2007-02-10 01:43:53 -0800643 char *error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 int n, err;
645
Jeff Dikef28169d2007-02-10 01:43:53 -0800646 err = eth_parse(str, &n, &str, &error);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700647 if (err) {
Jeff Dikef28169d2007-02-10 01:43:53 -0800648 printk(KERN_ERR "eth_setup - Couldn't parse '%s' : %s\n",
649 str, error);
Jeff Dike1183dc92006-09-27 01:50:43 -0700650 return 1;
Jeff Dikef28169d2007-02-10 01:43:53 -0800651 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Jeff Dike1183dc92006-09-27 01:50:43 -0700653 new = alloc_bootmem(sizeof(*new));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 INIT_LIST_HEAD(&new->list);
656 new->index = n;
657 new->init = str;
658
659 list_add_tail(&new->list, &eth_cmd_line);
Jeff Dike1183dc92006-09-27 01:50:43 -0700660 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661}
662
663__setup("eth", eth_setup);
664__uml_help(eth_setup,
665"eth[0-9]+=<transport>,<options>\n"
666" Configure a network device.\n\n"
667);
668
Jeff Dikef28169d2007-02-10 01:43:53 -0800669static int net_config(char *str, char **error_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 int n, err;
672
Jeff Dikef28169d2007-02-10 01:43:53 -0800673 err = eth_parse(str, &n, &str, error_out);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700674 if (err)
Jeff Dikef28169d2007-02-10 01:43:53 -0800675 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Jeff Dikef28169d2007-02-10 01:43:53 -0800677 /* This string is broken up and the pieces used by the underlying
678 * driver. So, it is freed only if eth_setup_common fails.
679 */
Jeff Dike970d6e32006-01-06 00:18:48 -0800680 str = kstrdup(str, GFP_KERNEL);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700681 if (str == NULL) {
Jeff Dikef28169d2007-02-10 01:43:53 -0800682 *error_out = "net_config failed to strdup string";
683 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
685 err = !eth_setup_common(str, n);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700686 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 kfree(str);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700688 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689}
690
Jeff Dike29d56cf2005-06-25 14:55:25 -0700691static int net_id(char **str, int *start_out, int *end_out)
692{
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700693 char *end;
694 int n;
Jeff Dike29d56cf2005-06-25 14:55:25 -0700695
696 n = simple_strtoul(*str, &end, 0);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700697 if ((*end != '\0') || (end == *str))
Jeff Dike29d56cf2005-06-25 14:55:25 -0700698 return -1;
699
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700700 *start_out = n;
701 *end_out = n;
702 *str = end;
703 return n;
Jeff Dike29d56cf2005-06-25 14:55:25 -0700704}
705
Jeff Dikef28169d2007-02-10 01:43:53 -0800706static int net_remove(int n, char **error_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 struct uml_net *device;
709 struct net_device *dev;
710 struct uml_net_private *lp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
712 device = find_device(n);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700713 if (device == NULL)
Jeff Dike29d56cf2005-06-25 14:55:25 -0700714 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
716 dev = device->dev;
Wang Chen17c324f2008-12-04 15:07:33 -0800717 lp = netdev_priv(dev);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700718 if (lp->fd > 0)
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800719 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 unregister_netdev(dev);
721 platform_device_unregister(&device->pdev);
722
Jeff Dike29d56cf2005-06-25 14:55:25 -0700723 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724}
725
726static struct mc_device net_mc = {
Jeff Dike84f48d42007-02-10 01:44:01 -0800727 .list = LIST_HEAD_INIT(net_mc.list),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 .name = "eth",
729 .config = net_config,
730 .get_config = NULL,
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800731 .id = net_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 .remove = net_remove,
733};
734
Jeff Dike32f862c2007-11-14 17:00:28 -0800735#ifdef CONFIG_INET
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
737 void *ptr)
738{
739 struct in_ifaddr *ifa = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct net_device *dev = ifa->ifa_dev->dev;
741 struct uml_net_private *lp;
742 void (*proc)(unsigned char *, unsigned char *, void *);
743 unsigned char addr_buf[4], netmask_buf[4];
744
Miklos Szerediebe28bb2009-04-02 16:56:49 -0700745 if (dev->netdev_ops->ndo_open != uml_net_open)
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800746 return NOTIFY_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Wang Chen17c324f2008-12-04 15:07:33 -0800748 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
750 proc = NULL;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700751 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 case NETDEV_UP:
753 proc = lp->add_address;
754 break;
755 case NETDEV_DOWN:
756 proc = lp->delete_address;
757 break;
758 }
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700759 if (proc != NULL) {
Bodo Stroesser0e764222005-11-07 00:58:47 -0800760 memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf));
761 memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 (*proc)(addr_buf, netmask_buf, &lp->user);
763 }
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800764 return NOTIFY_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765}
766
Jeff Dikec862fc32007-02-10 01:44:04 -0800767/* uml_net_init shouldn't be called twice on two CPUs at the same time */
WANG Cong074a0db2008-04-28 02:13:57 -0700768static struct notifier_block uml_inetaddr_notifier = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 .notifier_call = uml_inetaddr_event,
770};
771
Jeff Dike32f862c2007-11-14 17:00:28 -0800772static void inet_register(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
774 struct list_head *ele;
Jeff Dikef28169d2007-02-10 01:43:53 -0800775 struct uml_net_private *lp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 struct in_device *ip;
777 struct in_ifaddr *in;
778
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 register_inetaddr_notifier(&uml_inetaddr_notifier);
780
781 /* Devices may have been opened already, so the uml_inetaddr_notifier
782 * didn't get a chance to run for them. This fakes it so that
783 * addresses which have already been set up get handled properly.
784 */
Jeff Dikec862fc32007-02-10 01:44:04 -0800785 spin_lock(&opened_lock);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700786 list_for_each(ele, &opened) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 lp = list_entry(ele, struct uml_net_private, list);
788 ip = lp->dev->ip_ptr;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700789 if (ip == NULL)
Jeff Dikec862fc32007-02-10 01:44:04 -0800790 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 in = ip->ifa_list;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700792 while (in != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 uml_inetaddr_event(NULL, NETDEV_UP, in);
794 in = in->ifa_next;
795 }
Jeff Dikef28169d2007-02-10 01:43:53 -0800796 }
Jeff Dikec862fc32007-02-10 01:44:04 -0800797 spin_unlock(&opened_lock);
Jeff Dike32f862c2007-11-14 17:00:28 -0800798}
799#else
800static inline void inet_register(void)
801{
802}
803#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Jeff Dike32f862c2007-11-14 17:00:28 -0800805static int uml_net_init(void)
806{
807 mconsole_register_dev(&net_mc);
808 inet_register();
Jeff Dikec862fc32007-02-10 01:44:04 -0800809 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
812__initcall(uml_net_init);
813
814static void close_devices(void)
815{
816 struct list_head *ele;
817 struct uml_net_private *lp;
818
Jeff Dikec862fc32007-02-10 01:44:04 -0800819 spin_lock(&opened_lock);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700820 list_for_each(ele, &opened) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 lp = list_entry(ele, struct uml_net_private, list);
Richard Weinbergerfa7a0442012-04-17 22:37:13 +0200822 um_free_irq(lp->dev->irq, lp->dev);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700823 if ((lp->close != NULL) && (lp->fd >= 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 (*lp->close)(lp->fd, &lp->user);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700825 if (lp->remove != NULL)
Jeff Dikec862fc32007-02-10 01:44:04 -0800826 (*lp->remove)(&lp->user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 }
Jeff Dikec862fc32007-02-10 01:44:04 -0800828 spin_unlock(&opened_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
831__uml_exitcall(close_devices);
832
Jeff Dikef28169d2007-02-10 01:43:53 -0800833void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *,
834 void *),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 void *arg)
836{
837 struct net_device *dev = d;
838 struct in_device *ip = dev->ip_ptr;
839 struct in_ifaddr *in;
840 unsigned char address[4], netmask[4];
841
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700842 if (ip == NULL) return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 in = ip->ifa_list;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700844 while (in != NULL) {
Bodo Stroesser0e764222005-11-07 00:58:47 -0800845 memcpy(address, &in->ifa_address, sizeof(address));
846 memcpy(netmask, &in->ifa_mask, sizeof(netmask));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 (*cb)(address, netmask, arg);
848 in = in->ifa_next;
849 }
850}
851
852int dev_netmask(void *d, void *m)
853{
854 struct net_device *dev = d;
855 struct in_device *ip = dev->ip_ptr;
856 struct in_ifaddr *in;
Al Viroa144ea42006-09-28 18:00:55 -0700857 __be32 *mask_out = m;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700859 if (ip == NULL)
860 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
862 in = ip->ifa_list;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700863 if (in == NULL)
864 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866 *mask_out = in->ifa_mask;
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700867 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868}
869
870void *get_output_buffer(int *len_out)
871{
872 void *ret;
873
874 ret = (void *) __get_free_pages(GFP_KERNEL, 0);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700875 if (ret) *len_out = PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 else *len_out = 0;
Jeff Dike4ea21cd2007-02-10 01:43:56 -0800877 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878}
879
880void free_output_buffer(void *buffer)
881{
882 free_pages((unsigned long) buffer, 0);
883}
884
Jeff Dikef28169d2007-02-10 01:43:53 -0800885int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 char **gate_addr)
887{
888 char *remain;
889
890 remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700891 if (remain != NULL) {
892 printk(KERN_ERR "tap_setup_common - Extra garbage on "
893 "specification : '%s'\n", remain);
894 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 }
896
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700897 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898}
899
900unsigned short eth_protocol(struct sk_buff *skb)
901{
Jeff Dikecd1ae0e2007-10-16 01:27:29 -0700902 return eth_type_trans(skb, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903}