2 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and
3 * James Leu (jleu@mindspring.net).
4 * Copyright (C) 2001 by various other people who didn't put their name here.
5 * Licensed under the GPL.
8 #include "linux/config.h"
9 #include "linux/kernel.h"
10 #include "linux/netdevice.h"
11 #include "linux/rtnetlink.h"
12 #include "linux/skbuff.h"
13 #include "linux/socket.h"
14 #include "linux/spinlock.h"
15 #include "linux/module.h"
16 #include "linux/init.h"
17 #include "linux/etherdevice.h"
18 #include "linux/list.h"
19 #include "linux/inetdevice.h"
20 #include "linux/ctype.h"
21 #include "linux/bootmem.h"
22 #include "linux/ethtool.h"
23 #include "linux/platform_device.h"
24 #include "asm/uaccess.h"
25 #include "user_util.h"
26 #include "kern_util.h"
29 #include "mconsole_kern.h"
34 #define DRIVER_NAME "uml-netdev"
36 static DEFINE_SPINLOCK(opened_lock);
37 static LIST_HEAD(opened);
39 static int uml_net_rx(struct net_device *dev)
41 struct uml_net_private *lp = dev->priv;
45 /* If we can't allocate memory, try again next round. */
46 skb = dev_alloc_skb(dev->mtu);
48 lp->stats.rx_dropped++;
53 skb_put(skb, dev->mtu);
54 skb->mac.raw = skb->data;
55 pkt_len = (*lp->read)(lp->fd, &skb, lp);
58 skb_trim(skb, pkt_len);
59 skb->protocol = (*lp->protocol)(skb);
62 lp->stats.rx_bytes += skb->len;
63 lp->stats.rx_packets++;
71 irqreturn_t uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
73 struct net_device *dev = dev_id;
74 struct uml_net_private *lp = dev->priv;
77 if(!netif_running(dev))
81 while((err = uml_net_rx(dev)) > 0) ;
84 "Device '%s' read returned %d, shutting it down\n",
89 reactivate_fd(lp->fd, UM_ETH_IRQ);
92 spin_unlock(&lp->lock);
96 static int uml_net_open(struct net_device *dev)
98 struct uml_net_private *lp = dev->priv;
101 spin_lock(&lp->lock);
109 dev_ip_addr(dev, &lp->mac[2]);
110 set_ether_mac(dev, lp->mac);
113 lp->fd = (*lp->open)(&lp->user);
119 err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
120 SA_INTERRUPT | SA_SHIRQ, dev->name, dev);
122 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
123 if(lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
128 lp->tl.data = (unsigned long) &lp->user;
129 netif_start_queue(dev);
131 /* clear buffer - it can happen that the host side of the interface
132 * is full when we get here. In this case, new data is never queued,
133 * SIGIOs never arrive, and the net never works.
135 while((err = uml_net_rx(dev)) > 0) ;
138 spin_unlock(&lp->lock);
142 static int uml_net_close(struct net_device *dev)
144 struct uml_net_private *lp = dev->priv;
146 netif_stop_queue(dev);
147 spin_lock(&lp->lock);
149 free_irq(dev->irq, dev);
150 if(lp->close != NULL)
151 (*lp->close)(lp->fd, &lp->user);
155 spin_unlock(&lp->lock);
159 static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
161 struct uml_net_private *lp = dev->priv;
165 netif_stop_queue(dev);
167 spin_lock_irqsave(&lp->lock, flags);
169 len = (*lp->write)(lp->fd, &skb, lp);
171 if(len == skb->len) {
172 lp->stats.tx_packets++;
173 lp->stats.tx_bytes += skb->len;
174 dev->trans_start = jiffies;
175 netif_start_queue(dev);
177 /* this is normally done in the interrupt when tx finishes */
178 netif_wake_queue(dev);
181 netif_start_queue(dev);
182 lp->stats.tx_dropped++;
185 netif_start_queue(dev);
186 printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
189 spin_unlock_irqrestore(&lp->lock, flags);
196 static struct net_device_stats *uml_net_get_stats(struct net_device *dev)
198 struct uml_net_private *lp = dev->priv;
202 static void uml_net_set_multicast_list(struct net_device *dev)
204 if (dev->flags & IFF_PROMISC) return;
205 else if (dev->mc_count) dev->flags |= IFF_ALLMULTI;
206 else dev->flags &= ~IFF_ALLMULTI;
209 static void uml_net_tx_timeout(struct net_device *dev)
211 dev->trans_start = jiffies;
212 netif_wake_queue(dev);
215 static int uml_net_set_mac(struct net_device *dev, void *addr)
217 struct uml_net_private *lp = dev->priv;
218 struct sockaddr *hwaddr = addr;
220 spin_lock(&lp->lock);
221 memcpy(dev->dev_addr, hwaddr->sa_data, ETH_ALEN);
222 spin_unlock(&lp->lock);
227 static int uml_net_change_mtu(struct net_device *dev, int new_mtu)
229 struct uml_net_private *lp = dev->priv;
232 spin_lock(&lp->lock);
234 new_mtu = (*lp->set_mtu)(new_mtu, &lp->user);
243 spin_unlock(&lp->lock);
247 static void uml_net_get_drvinfo(struct net_device *dev,
248 struct ethtool_drvinfo *info)
250 strcpy(info->driver, DRIVER_NAME);
251 strcpy(info->version, "42");
254 static struct ethtool_ops uml_net_ethtool_ops = {
255 .get_drvinfo = uml_net_get_drvinfo,
256 .get_link = ethtool_op_get_link,
259 void uml_net_user_timer_expire(unsigned long _conn)
262 struct connection *conn = (struct connection *)_conn;
264 dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
269 static DEFINE_SPINLOCK(devices_lock);
270 static LIST_HEAD(devices);
272 static struct platform_driver uml_net_driver = {
277 static int driver_registered;
279 static int eth_configure(int n, void *init, char *mac,
280 struct transport *transport)
282 struct uml_net *device;
283 struct net_device *dev;
284 struct uml_net_private *lp;
287 size = transport->private_size + sizeof(struct uml_net_private) +
288 sizeof(((struct uml_net_private *) 0)->user);
290 device = kmalloc(sizeof(*device), GFP_KERNEL);
291 if (device == NULL) {
292 printk(KERN_ERR "eth_configure failed to allocate uml_net\n");
296 memset(device, 0, sizeof(*device));
297 INIT_LIST_HEAD(&device->list);
300 spin_lock(&devices_lock);
301 list_add(&device->list, &devices);
302 spin_unlock(&devices_lock);
304 if (setup_etheraddr(mac, device->mac))
305 device->have_mac = 1;
307 printk(KERN_INFO "Netdevice %d ", n);
308 if (device->have_mac)
309 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
310 device->mac[0], device->mac[1],
311 device->mac[2], device->mac[3],
312 device->mac[4], device->mac[5]);
314 dev = alloc_etherdev(size);
316 printk(KERN_ERR "eth_configure: failed to allocate device\n");
321 if (!driver_registered) {
322 platform_driver_register(¨_net_driver);
323 driver_registered = 1;
326 device->pdev.name = DRIVER_NAME;
327 platform_device_register(&device->pdev);
328 SET_NETDEV_DEV(dev,&device->pdev.dev);
330 /* If this name ends up conflicting with an existing registered
331 * netdevice, that is OK, register_netdev{,ice}() will notice this
334 snprintf(dev->name, sizeof(dev->name), "eth%d", n);
337 (*transport->kern->init)(dev, init);
339 dev->mtu = transport->user->max_packet;
340 dev->open = uml_net_open;
341 dev->hard_start_xmit = uml_net_start_xmit;
342 dev->stop = uml_net_close;
343 dev->get_stats = uml_net_get_stats;
344 dev->set_multicast_list = uml_net_set_multicast_list;
345 dev->tx_timeout = uml_net_tx_timeout;
346 dev->set_mac_address = uml_net_set_mac;
347 dev->change_mtu = uml_net_change_mtu;
348 dev->ethtool_ops = ¨_net_ethtool_ops;
349 dev->watchdog_timeo = (HZ >> 1);
350 dev->irq = UM_ETH_IRQ;
353 err = register_netdevice(dev);
357 /* XXX: should we call ->remove() here? */
363 /* lp.user is the first four bytes of the transport data, which
364 * has already been initialized. This structure assignment will
365 * overwrite that, so we make sure that .user gets overwritten with
366 * what it already has.
369 *lp = ((struct uml_net_private)
370 { .list = LIST_HEAD_INIT(lp->list),
373 .mac = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
374 .have_mac = device->have_mac,
375 .protocol = transport->kern->protocol,
376 .open = transport->user->open,
377 .close = transport->user->close,
378 .remove = transport->user->remove,
379 .read = transport->kern->read,
380 .write = transport->kern->write,
381 .add_address = transport->user->add_address,
382 .delete_address = transport->user->delete_address,
383 .set_mtu = transport->user->set_mtu,
387 spin_lock_init(&lp->lock);
388 lp->tl.function = uml_net_user_timer_expire;
390 memcpy(lp->mac, device->mac, sizeof(lp->mac));
392 if (transport->user->init)
393 (*transport->user->init)(&lp->user, dev);
395 if (device->have_mac)
396 set_ether_mac(dev, device->mac);
398 spin_lock(&opened_lock);
399 list_add(&lp->list, &opened);
400 spin_unlock(&opened_lock);
405 static struct uml_net *find_device(int n)
407 struct uml_net *device;
408 struct list_head *ele;
410 spin_lock(&devices_lock);
411 list_for_each(ele, &devices){
412 device = list_entry(ele, struct uml_net, list);
413 if(device->index == n)
418 spin_unlock(&devices_lock);
422 static int eth_parse(char *str, int *index_out, char **str_out)
427 n = simple_strtoul(str, &end, 0);
429 printk(KERN_ERR "eth_setup: Failed to parse '%s'\n", str);
433 printk(KERN_ERR "eth_setup: device %d is negative\n", n);
439 "eth_setup: expected '=' after device number\n");
444 printk(KERN_ERR "eth_setup: Device %d already configured\n",
448 if(index_out) *index_out = n;
454 struct list_head list;
459 /* Filled in at boot time. Will need locking if the transports become
462 struct list_head transports = LIST_HEAD_INIT(transports);
464 /* Filled in during early boot */
465 struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
467 static int check_transport(struct transport *transport, char *eth, int n,
468 void **init_out, char **mac_out)
472 len = strlen(transport->name);
473 if(strncmp(eth, transport->name, len))
479 else if(*eth != '\0')
482 *init_out = kmalloc(transport->setup_size, GFP_KERNEL);
483 if(*init_out == NULL)
486 if(!transport->setup(eth, mac_out, *init_out)){
493 void register_transport(struct transport *new)
495 struct list_head *ele, *next;
496 struct eth_init *eth;
501 list_add(&new->list, &transports);
503 list_for_each_safe(ele, next, ð_cmd_line){
504 eth = list_entry(ele, struct eth_init, list);
505 match = check_transport(new, eth->init, eth->index, &init,
509 else if(init != NULL){
510 eth_configure(eth->index, init, mac, new);
513 list_del(ð->list);
517 static int eth_setup_common(char *str, int index)
519 struct list_head *ele;
520 struct transport *transport;
524 list_for_each(ele, &transports){
525 transport = list_entry(ele, struct transport, list);
526 if(!check_transport(transport, str, index, &init, &mac))
529 eth_configure(index, init, mac, transport);
537 static int eth_setup(char *str)
539 struct eth_init *new;
542 err = eth_parse(str, &n, &str);
545 new = alloc_bootmem(sizeof(new));
547 printk("eth_init : alloc_bootmem failed\n");
551 INIT_LIST_HEAD(&new->list);
555 list_add_tail(&new->list, ð_cmd_line);
559 __setup("eth", eth_setup);
560 __uml_help(eth_setup,
561 "eth[0-9]+=<transport>,<options>\n"
562 " Configure a network device.\n\n"
566 static int eth_init(void)
568 struct list_head *ele, *next;
569 struct eth_init *eth;
571 list_for_each_safe(ele, next, ð_cmd_line){
572 eth = list_entry(ele, struct eth_init, list);
574 if(eth_setup_common(eth->init, eth->index))
575 list_del(ð->list);
580 __initcall(eth_init);
583 static int net_config(char *str)
587 err = eth_parse(str, &n, &str);
590 str = kstrdup(str, GFP_KERNEL);
592 printk(KERN_ERR "net_config failed to strdup string\n");
595 err = !eth_setup_common(str, n);
601 static int net_id(char **str, int *start_out, int *end_out)
606 n = simple_strtoul(*str, &end, 0);
607 if((*end != '\0') || (end == *str))
616 static int net_remove(int n)
618 struct uml_net *device;
619 struct net_device *dev;
620 struct uml_net_private *lp;
622 device = find_device(n);
630 if(lp->remove != NULL) (*lp->remove)(&lp->user);
631 unregister_netdev(dev);
632 platform_device_unregister(&device->pdev);
634 list_del(&device->list);
640 static struct mc_device net_mc = {
642 .config = net_config,
645 .remove = net_remove,
648 static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
651 struct in_ifaddr *ifa = ptr;
652 struct net_device *dev = ifa->ifa_dev->dev;
653 struct uml_net_private *lp;
654 void (*proc)(unsigned char *, unsigned char *, void *);
655 unsigned char addr_buf[4], netmask_buf[4];
657 if(dev->open != uml_net_open) return(NOTIFY_DONE);
664 proc = lp->add_address;
667 proc = lp->delete_address;
671 memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf));
672 memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf));
673 (*proc)(addr_buf, netmask_buf, &lp->user);
678 struct notifier_block uml_inetaddr_notifier = {
679 .notifier_call = uml_inetaddr_event,
682 static int uml_net_init(void)
684 struct list_head *ele;
685 struct uml_net_private *lp;
686 struct in_device *ip;
687 struct in_ifaddr *in;
689 mconsole_register_dev(&net_mc);
690 register_inetaddr_notifier(¨_inetaddr_notifier);
692 /* Devices may have been opened already, so the uml_inetaddr_notifier
693 * didn't get a chance to run for them. This fakes it so that
694 * addresses which have already been set up get handled properly.
696 list_for_each(ele, &opened){
697 lp = list_entry(ele, struct uml_net_private, list);
698 ip = lp->dev->ip_ptr;
699 if(ip == NULL) continue;
702 uml_inetaddr_event(NULL, NETDEV_UP, in);
710 __initcall(uml_net_init);
712 static void close_devices(void)
714 struct list_head *ele;
715 struct uml_net_private *lp;
717 list_for_each(ele, &opened){
718 lp = list_entry(ele, struct uml_net_private, list);
719 free_irq(lp->dev->irq, lp->dev);
720 if((lp->close != NULL) && (lp->fd >= 0))
721 (*lp->close)(lp->fd, &lp->user);
722 if(lp->remove != NULL) (*lp->remove)(&lp->user);
726 __uml_exitcall(close_devices);
728 int setup_etheraddr(char *str, unsigned char *addr)
736 addr[i] = simple_strtoul(str, &end, 16);
738 ((*end != ':') && (*end != ',') && (*end != '\0'))){
740 "setup_etheraddr: failed to parse '%s' "
741 "as an ethernet address\n", str);
748 "Attempt to assign a broadcast ethernet address to a "
749 "device disallowed\n");
755 void dev_ip_addr(void *d, unsigned char *bin_buf)
757 struct net_device *dev = d;
758 struct in_device *ip = dev->ip_ptr;
759 struct in_ifaddr *in;
761 if((ip == NULL) || ((in = ip->ifa_list) == NULL)){
762 printk(KERN_WARNING "dev_ip_addr - device not assigned an "
766 memcpy(bin_buf, &in->ifa_address, sizeof(in->ifa_address));
769 void set_ether_mac(void *d, unsigned char *addr)
771 struct net_device *dev = d;
773 memcpy(dev->dev_addr, addr, ETH_ALEN);
776 struct sk_buff *ether_adjust_skb(struct sk_buff *skb, int extra)
778 if((skb != NULL) && (skb_tailroom(skb) < extra)){
779 struct sk_buff *skb2;
781 skb2 = skb_copy_expand(skb, 0, extra, GFP_ATOMIC);
785 if(skb != NULL) skb_put(skb, extra);
789 void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *,
793 struct net_device *dev = d;
794 struct in_device *ip = dev->ip_ptr;
795 struct in_ifaddr *in;
796 unsigned char address[4], netmask[4];
798 if(ip == NULL) return;
801 memcpy(address, &in->ifa_address, sizeof(address));
802 memcpy(netmask, &in->ifa_mask, sizeof(netmask));
803 (*cb)(address, netmask, arg);
808 int dev_netmask(void *d, void *m)
810 struct net_device *dev = d;
811 struct in_device *ip = dev->ip_ptr;
812 struct in_ifaddr *in;
822 *mask_out = in->ifa_mask;
826 void *get_output_buffer(int *len_out)
830 ret = (void *) __get_free_pages(GFP_KERNEL, 0);
831 if(ret) *len_out = PAGE_SIZE;
836 void free_output_buffer(void *buffer)
838 free_pages((unsigned long) buffer, 0);
841 int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out,
846 remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
848 printk("tap_setup_common - Extra garbage on specification : "
856 unsigned short eth_protocol(struct sk_buff *skb)
858 return(eth_type_trans(skb, skb->dev));
862 * Overrides for Emacs so that we follow Linus's tabbing style.
863 * Emacs will notice this stuff at the end of the file and automatically
864 * adjust the settings for this buffer only. This must remain at the end
866 * ---------------------------------------------------------------------------
868 * c-file-style: "linux"