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.
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>
24 #include "mconsole_kern.h"
28 #define DRIVER_NAME "uml-netdev"
30 static DEFINE_SPINLOCK(opened_lock
);
31 static LIST_HEAD(opened
);
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.
41 static DEFINE_SPINLOCK(drop_lock
);
42 static struct sk_buff
*drop_skb
;
45 static int update_drop_skb(int max
)
51 spin_lock_irqsave(&drop_lock
, flags
);
57 new = dev_alloc_skb(max
);
68 spin_unlock_irqrestore(&drop_lock
, flags
);
73 static int uml_net_rx(struct net_device
*dev
)
75 struct uml_net_private
*lp
= netdev_priv(dev
);
79 /* If we can't allocate memory, try again next round. */
80 skb
= dev_alloc_skb(lp
->max_packet
);
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
++;
90 skb_put(skb
, lp
->max_packet
);
91 skb_reset_mac_header(skb
);
92 pkt_len
= (*lp
->read
)(lp
->fd
, skb
, lp
);
95 skb_trim(skb
, pkt_len
);
96 skb
->protocol
= (*lp
->protocol
)(skb
);
98 dev
->stats
.rx_bytes
+= skb
->len
;
99 dev
->stats
.rx_packets
++;
108 static void uml_dev_close(struct work_struct
*work
)
110 struct uml_net_private
*lp
=
111 container_of(work
, struct uml_net_private
, work
);
115 static irqreturn_t
uml_net_interrupt(int irq
, void *dev_id
)
117 struct net_device
*dev
= dev_id
;
118 struct uml_net_private
*lp
= netdev_priv(dev
);
121 if (!netif_running(dev
))
124 spin_lock(&lp
->lock
);
125 while ((err
= uml_net_rx(dev
)) > 0) ;
128 "Device '%s' read returned %d, shutting it down\n",
130 /* dev_close can't be called in interrupt context, and takes
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
);
140 reactivate_fd(lp
->fd
, UM_ETH_IRQ
);
143 spin_unlock(&lp
->lock
);
147 static int uml_net_open(struct net_device
*dev
)
149 struct uml_net_private
*lp
= netdev_priv(dev
);
157 lp
->fd
= (*lp
->open
)(&lp
->user
);
163 err
= um_request_irq(dev
->irq
, lp
->fd
, IRQ_READ
, uml_net_interrupt
,
164 IRQF_SHARED
, dev
->name
, dev
);
166 printk(KERN_ERR
"uml_net_open: failed to get irq(%d)\n", err
);
171 lp
->tl
.data
= (unsigned long) &lp
->user
;
172 netif_start_queue(dev
);
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.
178 while ((err
= uml_net_rx(dev
)) > 0) ;
180 spin_lock(&opened_lock
);
181 list_add(&lp
->list
, &opened
);
182 spin_unlock(&opened_lock
);
186 if (lp
->close
!= NULL
) (*lp
->close
)(lp
->fd
, &lp
->user
);
192 static int uml_net_close(struct net_device
*dev
)
194 struct uml_net_private
*lp
= netdev_priv(dev
);
196 netif_stop_queue(dev
);
198 um_free_irq(dev
->irq
, dev
);
199 if (lp
->close
!= NULL
)
200 (*lp
->close
)(lp
->fd
, &lp
->user
);
203 spin_lock(&opened_lock
);
205 spin_unlock(&opened_lock
);
210 static int uml_net_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
212 struct uml_net_private
*lp
= netdev_priv(dev
);
216 netif_stop_queue(dev
);
218 spin_lock_irqsave(&lp
->lock
, flags
);
220 len
= (*lp
->write
)(lp
->fd
, skb
, lp
);
221 skb_tx_timestamp(skb
);
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
);
229 /* this is normally done in the interrupt when tx finishes */
230 netif_wake_queue(dev
);
233 netif_start_queue(dev
);
234 dev
->stats
.tx_dropped
++;
237 netif_start_queue(dev
);
238 printk(KERN_ERR
"uml_net_start_xmit: failed(%d)\n", len
);
241 spin_unlock_irqrestore(&lp
->lock
, flags
);
248 static void uml_net_set_multicast_list(struct net_device
*dev
)
253 static void uml_net_tx_timeout(struct net_device
*dev
)
255 dev
->trans_start
= jiffies
;
256 netif_wake_queue(dev
);
259 static int uml_net_change_mtu(struct net_device
*dev
, int new_mtu
)
266 #ifdef CONFIG_NET_POLL_CONTROLLER
267 static void uml_net_poll_controller(struct net_device
*dev
)
269 disable_irq(dev
->irq
);
270 uml_net_interrupt(dev
->irq
, dev
);
271 enable_irq(dev
->irq
);
275 static void uml_net_get_drvinfo(struct net_device
*dev
,
276 struct ethtool_drvinfo
*info
)
278 strlcpy(info
->driver
, DRIVER_NAME
, sizeof(info
->driver
));
279 strlcpy(info
->version
, "42", sizeof(info
->version
));
282 static 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
,
288 static void uml_net_user_timer_expire(unsigned long _conn
)
291 struct connection
*conn
= (struct connection
*)_conn
;
293 dprintk(KERN_INFO
"uml_net_user_timer_expire [%p]\n", conn
);
298 static void setup_etheraddr(struct net_device
*dev
, char *str
)
300 unsigned char *addr
= dev
->dev_addr
;
307 for (i
= 0; i
< 6; i
++) {
308 addr
[i
] = simple_strtoul(str
, &end
, 16);
310 ((*end
!= ':') && (*end
!= ',') && (*end
!= '\0'))) {
312 "setup_etheraddr: failed to parse '%s' "
313 "as an ethernet address\n", str
);
318 if (is_multicast_ether_addr(addr
)) {
320 "Attempt to assign a multicast ethernet address to a "
321 "device disallowed\n");
324 if (!is_valid_ether_addr(addr
)) {
326 "Attempt to assign an invalid ethernet address to a "
327 "device disallowed\n");
330 if (!is_local_ether_addr(addr
)) {
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],
344 "Choosing a random ethernet address for device %s\n", dev
->name
);
345 eth_hw_addr_random(dev
);
348 static DEFINE_SPINLOCK(devices_lock
);
349 static LIST_HEAD(devices
);
351 static struct platform_driver uml_net_driver
= {
357 static void net_device_release(struct device
*dev
)
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
);
363 if (lp
->remove
!= NULL
)
364 (*lp
->remove
)(&lp
->user
);
365 list_del(&device
->list
);
370 static 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
,
385 * Ensures that platform_driver_register is called only once by
386 * eth_configure. Will be set in an initcall.
388 static int driver_registered
;
390 static void eth_configure(int n
, void *init
, char *mac
,
391 struct transport
*transport
)
393 struct uml_net
*device
;
394 struct net_device
*dev
;
395 struct uml_net_private
*lp
;
398 size
= transport
->private_size
+ sizeof(struct uml_net_private
);
400 device
= kzalloc(sizeof(*device
), GFP_KERNEL
);
401 if (device
== NULL
) {
402 printk(KERN_ERR
"eth_configure failed to allocate struct "
407 dev
= alloc_etherdev(size
);
409 printk(KERN_ERR
"eth_configure: failed to allocate struct "
410 "net_device for eth%d\n", n
);
411 goto out_free_device
;
414 INIT_LIST_HEAD(&device
->list
);
417 /* If this name ends up conflicting with an existing registered
418 * netdevice, that is OK, register_netdev{,ice}() will notice this
421 snprintf(dev
->name
, sizeof(dev
->name
), "eth%d", n
);
423 setup_etheraddr(dev
, mac
);
425 printk(KERN_INFO
"Netdevice %d (%pM) : ", n
, dev
->dev_addr
);
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. */
431 INIT_WORK(&lp
->work
, uml_dev_close
);
434 if (!driver_registered
) {
435 platform_driver_register(¨_net_driver
);
436 driver_registered
= 1;
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
);
449 * These just fill in a data structure, so there's no failure
450 * to be worried about.
452 (*transport
->kern
->init
)(dev
, init
);
454 *lp
= ((struct uml_net_private
)
455 { .list
= LIST_HEAD_INIT(lp
->list
),
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
});
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
));
474 if ((transport
->user
->init
!= NULL
) &&
475 ((*transport
->user
->init
)(&lp
->user
, dev
) != 0))
478 dev
->mtu
= transport
->user
->mtu
;
479 dev
->netdev_ops
= ¨_netdev_ops
;
480 dev
->ethtool_ops
= ¨_net_ethtool_ops
;
481 dev
->watchdog_timeo
= (HZ
>> 1);
482 dev
->irq
= UM_ETH_IRQ
;
484 err
= update_drop_skb(lp
->max_packet
);
486 goto out_undo_user_init
;
489 err
= register_netdevice(dev
);
492 goto out_undo_user_init
;
494 spin_lock(&devices_lock
);
495 list_add(&device
->list
, &devices
);
496 spin_unlock(&devices_lock
);
501 if (transport
->user
->remove
!= NULL
)
502 (*transport
->user
->remove
)(&lp
->user
);
504 platform_device_unregister(&device
->pdev
);
505 return; /* platform_device_unregister frees dev and device */
512 static struct uml_net
*find_device(int n
)
514 struct uml_net
*device
;
515 struct list_head
*ele
;
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
)
525 spin_unlock(&devices_lock
);
529 static int eth_parse(char *str
, int *index_out
, char **str_out
,
533 int n
, err
= -EINVAL
;
535 n
= simple_strtoul(str
, &end
, 0);
537 *error_out
= "Bad device number";
543 *error_out
= "Expected '=' after device number";
548 if (find_device(n
)) {
549 *error_out
= "Device already configured";
559 struct list_head list
;
564 static DEFINE_SPINLOCK(transports_lock
);
565 static LIST_HEAD(transports
);
567 /* Filled in during early boot */
568 static LIST_HEAD(eth_cmd_line
);
570 static int check_transport(struct transport
*transport
, char *eth
, int n
,
571 void **init_out
, char **mac_out
)
575 len
= strlen(transport
->name
);
576 if (strncmp(eth
, transport
->name
, len
))
582 else if (*eth
!= '\0')
585 *init_out
= kmalloc(transport
->setup_size
, GFP_KERNEL
);
586 if (*init_out
== NULL
)
589 if (!transport
->setup(eth
, mac_out
, *init_out
)) {
596 void register_transport(struct transport
*new)
598 struct list_head
*ele
, *next
;
599 struct eth_init
*eth
;
604 spin_lock(&transports_lock
);
605 BUG_ON(!list_empty(&new->list
));
606 list_add(&new->list
, &transports
);
607 spin_unlock(&transports_lock
);
609 list_for_each_safe(ele
, next
, ð_cmd_line
) {
610 eth
= list_entry(ele
, struct eth_init
, list
);
611 match
= check_transport(new, eth
->init
, eth
->index
, &init
,
615 else if (init
!= NULL
) {
616 eth_configure(eth
->index
, init
, mac
, new);
619 list_del(ð
->list
);
623 static int eth_setup_common(char *str
, int index
)
625 struct list_head
*ele
;
626 struct transport
*transport
;
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
))
637 eth_configure(index
, init
, mac
, transport
);
644 spin_unlock(&transports_lock
);
648 static int __init
eth_setup(char *str
)
650 struct eth_init
*new;
654 err
= eth_parse(str
, &n
, &str
, &error
);
656 printk(KERN_ERR
"eth_setup - Couldn't parse '%s' : %s\n",
661 new = alloc_bootmem(sizeof(*new));
663 printk(KERN_ERR
"eth_init : alloc_bootmem failed\n");
667 INIT_LIST_HEAD(&new->list
);
671 list_add_tail(&new->list
, ð_cmd_line
);
675 __setup("eth", eth_setup
);
676 __uml_help(eth_setup
,
677 "eth[0-9]+=<transport>,<options>\n"
678 " Configure a network device.\n\n"
681 static int net_config(char *str
, char **error_out
)
685 err
= eth_parse(str
, &n
, &str
, error_out
);
689 /* This string is broken up and the pieces used by the underlying
690 * driver. So, it is freed only if eth_setup_common fails.
692 str
= kstrdup(str
, GFP_KERNEL
);
694 *error_out
= "net_config failed to strdup string";
697 err
= !eth_setup_common(str
, n
);
703 static int net_id(char **str
, int *start_out
, int *end_out
)
708 n
= simple_strtoul(*str
, &end
, 0);
709 if ((*end
!= '\0') || (end
== *str
))
718 static int net_remove(int n
, char **error_out
)
720 struct uml_net
*device
;
721 struct net_device
*dev
;
722 struct uml_net_private
*lp
;
724 device
= find_device(n
);
729 lp
= netdev_priv(dev
);
732 unregister_netdev(dev
);
733 platform_device_unregister(&device
->pdev
);
738 static struct mc_device net_mc
= {
739 .list
= LIST_HEAD_INIT(net_mc
.list
),
741 .config
= net_config
,
744 .remove
= net_remove
,
748 static int uml_inetaddr_event(struct notifier_block
*this, unsigned long event
,
751 struct in_ifaddr
*ifa
= ptr
;
752 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
753 struct uml_net_private
*lp
;
754 void (*proc
)(unsigned char *, unsigned char *, void *);
755 unsigned char addr_buf
[4], netmask_buf
[4];
757 if (dev
->netdev_ops
->ndo_open
!= uml_net_open
)
760 lp
= netdev_priv(dev
);
765 proc
= lp
->add_address
;
768 proc
= lp
->delete_address
;
772 memcpy(addr_buf
, &ifa
->ifa_address
, sizeof(addr_buf
));
773 memcpy(netmask_buf
, &ifa
->ifa_mask
, sizeof(netmask_buf
));
774 (*proc
)(addr_buf
, netmask_buf
, &lp
->user
);
779 /* uml_net_init shouldn't be called twice on two CPUs at the same time */
780 static struct notifier_block uml_inetaddr_notifier
= {
781 .notifier_call
= uml_inetaddr_event
,
784 static void inet_register(void)
786 struct list_head
*ele
;
787 struct uml_net_private
*lp
;
788 struct in_device
*ip
;
789 struct in_ifaddr
*in
;
791 register_inetaddr_notifier(¨_inetaddr_notifier
);
793 /* Devices may have been opened already, so the uml_inetaddr_notifier
794 * didn't get a chance to run for them. This fakes it so that
795 * addresses which have already been set up get handled properly.
797 spin_lock(&opened_lock
);
798 list_for_each(ele
, &opened
) {
799 lp
= list_entry(ele
, struct uml_net_private
, list
);
800 ip
= lp
->dev
->ip_ptr
;
805 uml_inetaddr_event(NULL
, NETDEV_UP
, in
);
809 spin_unlock(&opened_lock
);
812 static inline void inet_register(void)
817 static int uml_net_init(void)
819 mconsole_register_dev(&net_mc
);
824 __initcall(uml_net_init
);
826 static void close_devices(void)
828 struct list_head
*ele
;
829 struct uml_net_private
*lp
;
831 spin_lock(&opened_lock
);
832 list_for_each(ele
, &opened
) {
833 lp
= list_entry(ele
, struct uml_net_private
, list
);
834 um_free_irq(lp
->dev
->irq
, lp
->dev
);
835 if ((lp
->close
!= NULL
) && (lp
->fd
>= 0))
836 (*lp
->close
)(lp
->fd
, &lp
->user
);
837 if (lp
->remove
!= NULL
)
838 (*lp
->remove
)(&lp
->user
);
840 spin_unlock(&opened_lock
);
843 __uml_exitcall(close_devices
);
845 void iter_addresses(void *d
, void (*cb
)(unsigned char *, unsigned char *,
849 struct net_device
*dev
= d
;
850 struct in_device
*ip
= dev
->ip_ptr
;
851 struct in_ifaddr
*in
;
852 unsigned char address
[4], netmask
[4];
854 if (ip
== NULL
) return;
857 memcpy(address
, &in
->ifa_address
, sizeof(address
));
858 memcpy(netmask
, &in
->ifa_mask
, sizeof(netmask
));
859 (*cb
)(address
, netmask
, arg
);
864 int dev_netmask(void *d
, void *m
)
866 struct net_device
*dev
= d
;
867 struct in_device
*ip
= dev
->ip_ptr
;
868 struct in_ifaddr
*in
;
869 __be32
*mask_out
= m
;
878 *mask_out
= in
->ifa_mask
;
882 void *get_output_buffer(int *len_out
)
886 ret
= (void *) __get_free_pages(GFP_KERNEL
, 0);
887 if (ret
) *len_out
= PAGE_SIZE
;
892 void free_output_buffer(void *buffer
)
894 free_pages((unsigned long) buffer
, 0);
897 int tap_setup_common(char *str
, char *type
, char **dev_name
, char **mac_out
,
902 remain
= split_if_spec(str
, dev_name
, mac_out
, gate_addr
, NULL
);
903 if (remain
!= NULL
) {
904 printk(KERN_ERR
"tap_setup_common - Extra garbage on "
905 "specification : '%s'\n", remain
);
912 unsigned short eth_protocol(struct sk_buff
*skb
)
914 return eth_type_trans(skb
, skb
->dev
);