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/kernel.h"
9 #include "linux/netdevice.h"
10 #include "linux/rtnetlink.h"
11 #include "linux/skbuff.h"
12 #include "linux/socket.h"
13 #include "linux/spinlock.h"
14 #include "linux/module.h"
15 #include "linux/init.h"
16 #include "linux/etherdevice.h"
17 #include "linux/list.h"
18 #include "linux/inetdevice.h"
19 #include "linux/ctype.h"
20 #include "linux/bootmem.h"
21 #include "linux/ethtool.h"
22 #include "linux/platform_device.h"
23 #include "asm/uaccess.h"
24 #include "kern_util.h"
27 #include "mconsole_kern.h"
32 static inline void set_ether_mac(struct net_device
*dev
, unsigned char *addr
)
34 memcpy(dev
->dev_addr
, addr
, ETH_ALEN
);
37 #define DRIVER_NAME "uml-netdev"
39 static DEFINE_SPINLOCK(opened_lock
);
40 static LIST_HEAD(opened
);
42 static int uml_net_rx(struct net_device
*dev
)
44 struct uml_net_private
*lp
= dev
->priv
;
48 /* If we can't allocate memory, try again next round. */
49 skb
= dev_alloc_skb(dev
->mtu
);
51 lp
->stats
.rx_dropped
++;
56 skb_put(skb
, dev
->mtu
);
57 skb_reset_mac_header(skb
);
58 pkt_len
= (*lp
->read
)(lp
->fd
, &skb
, lp
);
61 skb_trim(skb
, pkt_len
);
62 skb
->protocol
= (*lp
->protocol
)(skb
);
65 lp
->stats
.rx_bytes
+= skb
->len
;
66 lp
->stats
.rx_packets
++;
74 static void uml_dev_close(struct work_struct
*work
)
76 struct uml_net_private
*lp
=
77 container_of(work
, struct uml_net_private
, work
);
81 irqreturn_t
uml_net_interrupt(int irq
, void *dev_id
)
83 struct net_device
*dev
= dev_id
;
84 struct uml_net_private
*lp
= dev
->priv
;
87 if(!netif_running(dev
))
91 while((err
= uml_net_rx(dev
)) > 0) ;
94 "Device '%s' read returned %d, shutting it down\n",
96 /* dev_close can't be called in interrupt context, and takes
98 * And dev_close() can be safely called multiple times on the
99 * same device, since it tests for (dev->flags & IFF_UP). So
100 * there's no harm in delaying the device shutdown.
101 * Furthermore, the workqueue will not re-enqueue an already
102 * enqueued work item. */
103 schedule_work(&lp
->work
);
106 reactivate_fd(lp
->fd
, UM_ETH_IRQ
);
109 spin_unlock(&lp
->lock
);
113 static int uml_net_open(struct net_device
*dev
)
115 struct uml_net_private
*lp
= dev
->priv
;
123 lp
->fd
= (*lp
->open
)(&lp
->user
);
129 err
= um_request_irq(dev
->irq
, lp
->fd
, IRQ_READ
, uml_net_interrupt
,
130 IRQF_DISABLED
| IRQF_SHARED
, dev
->name
, dev
);
132 printk(KERN_ERR
"uml_net_open: failed to get irq(%d)\n", err
);
137 lp
->tl
.data
= (unsigned long) &lp
->user
;
138 netif_start_queue(dev
);
140 /* clear buffer - it can happen that the host side of the interface
141 * is full when we get here. In this case, new data is never queued,
142 * SIGIOs never arrive, and the net never works.
144 while((err
= uml_net_rx(dev
)) > 0) ;
146 spin_lock(&opened_lock
);
147 list_add(&lp
->list
, &opened
);
148 spin_unlock(&opened_lock
);
152 if(lp
->close
!= NULL
) (*lp
->close
)(lp
->fd
, &lp
->user
);
158 static int uml_net_close(struct net_device
*dev
)
160 struct uml_net_private
*lp
= dev
->priv
;
162 netif_stop_queue(dev
);
164 free_irq(dev
->irq
, dev
);
165 if(lp
->close
!= NULL
)
166 (*lp
->close
)(lp
->fd
, &lp
->user
);
169 spin_lock(&opened_lock
);
171 spin_unlock(&opened_lock
);
176 static int uml_net_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
178 struct uml_net_private
*lp
= dev
->priv
;
182 netif_stop_queue(dev
);
184 spin_lock_irqsave(&lp
->lock
, flags
);
186 len
= (*lp
->write
)(lp
->fd
, &skb
, lp
);
188 if(len
== skb
->len
) {
189 lp
->stats
.tx_packets
++;
190 lp
->stats
.tx_bytes
+= skb
->len
;
191 dev
->trans_start
= jiffies
;
192 netif_start_queue(dev
);
194 /* this is normally done in the interrupt when tx finishes */
195 netif_wake_queue(dev
);
198 netif_start_queue(dev
);
199 lp
->stats
.tx_dropped
++;
202 netif_start_queue(dev
);
203 printk(KERN_ERR
"uml_net_start_xmit: failed(%d)\n", len
);
206 spin_unlock_irqrestore(&lp
->lock
, flags
);
213 static struct net_device_stats
*uml_net_get_stats(struct net_device
*dev
)
215 struct uml_net_private
*lp
= dev
->priv
;
219 static void uml_net_set_multicast_list(struct net_device
*dev
)
221 if (dev
->flags
& IFF_PROMISC
) return;
222 else if (dev
->mc_count
) dev
->flags
|= IFF_ALLMULTI
;
223 else dev
->flags
&= ~IFF_ALLMULTI
;
226 static void uml_net_tx_timeout(struct net_device
*dev
)
228 dev
->trans_start
= jiffies
;
229 netif_wake_queue(dev
);
232 static int uml_net_set_mac(struct net_device
*dev
, void *addr
)
234 struct uml_net_private
*lp
= dev
->priv
;
235 struct sockaddr
*hwaddr
= addr
;
237 spin_lock_irq(&lp
->lock
);
238 set_ether_mac(dev
, hwaddr
->sa_data
);
239 spin_unlock_irq(&lp
->lock
);
244 static int uml_net_change_mtu(struct net_device
*dev
, int new_mtu
)
246 struct uml_net_private
*lp
= dev
->priv
;
249 spin_lock_irq(&lp
->lock
);
251 new_mtu
= (*lp
->set_mtu
)(new_mtu
, &lp
->user
);
260 spin_unlock_irq(&lp
->lock
);
264 static void uml_net_get_drvinfo(struct net_device
*dev
,
265 struct ethtool_drvinfo
*info
)
267 strcpy(info
->driver
, DRIVER_NAME
);
268 strcpy(info
->version
, "42");
271 static struct ethtool_ops uml_net_ethtool_ops
= {
272 .get_drvinfo
= uml_net_get_drvinfo
,
273 .get_link
= ethtool_op_get_link
,
276 void uml_net_user_timer_expire(unsigned long _conn
)
279 struct connection
*conn
= (struct connection
*)_conn
;
281 dprintk(KERN_INFO
"uml_net_user_timer_expire [%p]\n", conn
);
286 static void setup_etheraddr(char *str
, unsigned char *addr
, char *name
)
295 addr
[i
] = simple_strtoul(str
, &end
, 16);
297 ((*end
!= ':') && (*end
!= ',') && (*end
!= '\0'))){
299 "setup_etheraddr: failed to parse '%s' "
300 "as an ethernet address\n", str
);
305 if (is_multicast_ether_addr(addr
)) {
307 "Attempt to assign a multicast ethernet address to a "
308 "device disallowed\n");
311 if (!is_valid_ether_addr(addr
)) {
313 "Attempt to assign an invalid ethernet address to a "
314 "device disallowed\n");
317 if (!is_local_ether_addr(addr
)) {
319 "Warning: attempt to assign a globally valid ethernet address to a "
321 printk(KERN_WARNING
"You should better enable the 2nd rightmost bit "
322 "in the first byte of the MAC, i.e. "
323 "%02x:%02x:%02x:%02x:%02x:%02x\n",
324 addr
[0] | 0x02, addr
[1], addr
[2], addr
[3], addr
[4], addr
[5]);
330 "Choosing a random ethernet address for device %s\n", name
);
331 random_ether_addr(addr
);
334 static DEFINE_SPINLOCK(devices_lock
);
335 static LIST_HEAD(devices
);
337 static struct platform_driver uml_net_driver
= {
342 static int driver_registered
;
344 static void net_device_release(struct device
*dev
)
346 struct uml_net
*device
= dev
->driver_data
;
347 struct net_device
*netdev
= device
->dev
;
348 struct uml_net_private
*lp
= netdev
->priv
;
350 if(lp
->remove
!= NULL
)
351 (*lp
->remove
)(&lp
->user
);
352 list_del(&device
->list
);
357 static void eth_configure(int n
, void *init
, char *mac
,
358 struct transport
*transport
)
360 struct uml_net
*device
;
361 struct net_device
*dev
;
362 struct uml_net_private
*lp
;
365 size
= transport
->private_size
+ sizeof(struct uml_net_private
);
367 device
= kzalloc(sizeof(*device
), GFP_KERNEL
);
368 if (device
== NULL
) {
369 printk(KERN_ERR
"eth_configure failed to allocate struct "
374 dev
= alloc_etherdev(size
);
376 printk(KERN_ERR
"eth_configure: failed to allocate struct "
377 "net_device for eth%d\n", n
);
378 goto out_free_device
;
381 INIT_LIST_HEAD(&device
->list
);
384 /* If this name ends up conflicting with an existing registered
385 * netdevice, that is OK, register_netdev{,ice}() will notice this
388 snprintf(dev
->name
, sizeof(dev
->name
), "eth%d", n
);
390 setup_etheraddr(mac
, device
->mac
, dev
->name
);
392 printk(KERN_INFO
"Netdevice %d ", n
);
393 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
394 device
->mac
[0], device
->mac
[1],
395 device
->mac
[2], device
->mac
[3],
396 device
->mac
[4], device
->mac
[5]);
400 /* This points to the transport private data. It's still clear, but we
401 * must memset it to 0 *now*. Let's help the drivers. */
403 INIT_WORK(&lp
->work
, uml_dev_close
);
406 if (!driver_registered
) {
407 platform_driver_register(¨_net_driver
);
408 driver_registered
= 1;
411 device
->pdev
.name
= DRIVER_NAME
;
412 device
->pdev
.dev
.release
= net_device_release
;
413 device
->pdev
.dev
.driver_data
= device
;
414 if(platform_device_register(&device
->pdev
))
415 goto out_free_netdev
;
416 SET_NETDEV_DEV(dev
,&device
->pdev
.dev
);
421 * These just fill in a data structure, so there's no failure
422 * to be worried about.
424 (*transport
->kern
->init
)(dev
, init
);
426 *lp
= ((struct uml_net_private
)
427 { .list
= LIST_HEAD_INIT(lp
->list
),
430 .mac
= { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
431 .protocol
= transport
->kern
->protocol
,
432 .open
= transport
->user
->open
,
433 .close
= transport
->user
->close
,
434 .remove
= transport
->user
->remove
,
435 .read
= transport
->kern
->read
,
436 .write
= transport
->kern
->write
,
437 .add_address
= transport
->user
->add_address
,
438 .delete_address
= transport
->user
->delete_address
,
439 .set_mtu
= transport
->user
->set_mtu
});
442 spin_lock_init(&lp
->lock
);
443 lp
->tl
.function
= uml_net_user_timer_expire
;
444 memcpy(lp
->mac
, device
->mac
, sizeof(lp
->mac
));
446 if ((transport
->user
->init
!= NULL
) &&
447 ((*transport
->user
->init
)(&lp
->user
, dev
) != 0))
450 set_ether_mac(dev
, device
->mac
);
451 dev
->mtu
= transport
->user
->max_packet
;
452 dev
->open
= uml_net_open
;
453 dev
->hard_start_xmit
= uml_net_start_xmit
;
454 dev
->stop
= uml_net_close
;
455 dev
->get_stats
= uml_net_get_stats
;
456 dev
->set_multicast_list
= uml_net_set_multicast_list
;
457 dev
->tx_timeout
= uml_net_tx_timeout
;
458 dev
->set_mac_address
= uml_net_set_mac
;
459 dev
->change_mtu
= uml_net_change_mtu
;
460 dev
->ethtool_ops
= ¨_net_ethtool_ops
;
461 dev
->watchdog_timeo
= (HZ
>> 1);
462 dev
->irq
= UM_ETH_IRQ
;
465 err
= register_netdevice(dev
);
468 goto out_undo_user_init
;
470 spin_lock(&devices_lock
);
471 list_add(&device
->list
, &devices
);
472 spin_unlock(&devices_lock
);
477 if (transport
->user
->remove
!= NULL
)
478 (*transport
->user
->remove
)(&lp
->user
);
480 platform_device_unregister(&device
->pdev
);
487 static struct uml_net
*find_device(int n
)
489 struct uml_net
*device
;
490 struct list_head
*ele
;
492 spin_lock(&devices_lock
);
493 list_for_each(ele
, &devices
){
494 device
= list_entry(ele
, struct uml_net
, list
);
495 if(device
->index
== n
)
500 spin_unlock(&devices_lock
);
504 static int eth_parse(char *str
, int *index_out
, char **str_out
,
508 int n
, err
= -EINVAL
;;
510 n
= simple_strtoul(str
, &end
, 0);
512 *error_out
= "Bad device number";
518 *error_out
= "Expected '=' after device number";
524 *error_out
= "Device already configured";
534 struct list_head list
;
539 static DEFINE_SPINLOCK(transports_lock
);
540 static LIST_HEAD(transports
);
542 /* Filled in during early boot */
543 static LIST_HEAD(eth_cmd_line
);
545 static int check_transport(struct transport
*transport
, char *eth
, int n
,
546 void **init_out
, char **mac_out
)
550 len
= strlen(transport
->name
);
551 if(strncmp(eth
, transport
->name
, len
))
557 else if(*eth
!= '\0')
560 *init_out
= kmalloc(transport
->setup_size
, GFP_KERNEL
);
561 if(*init_out
== NULL
)
564 if(!transport
->setup(eth
, mac_out
, *init_out
)){
571 void register_transport(struct transport
*new)
573 struct list_head
*ele
, *next
;
574 struct eth_init
*eth
;
579 spin_lock(&transports_lock
);
580 BUG_ON(!list_empty(&new->list
));
581 list_add(&new->list
, &transports
);
582 spin_unlock(&transports_lock
);
584 list_for_each_safe(ele
, next
, ð_cmd_line
){
585 eth
= list_entry(ele
, struct eth_init
, list
);
586 match
= check_transport(new, eth
->init
, eth
->index
, &init
,
590 else if(init
!= NULL
){
591 eth_configure(eth
->index
, init
, mac
, new);
594 list_del(ð
->list
);
598 static int eth_setup_common(char *str
, int index
)
600 struct list_head
*ele
;
601 struct transport
*transport
;
606 spin_lock(&transports_lock
);
607 list_for_each(ele
, &transports
){
608 transport
= list_entry(ele
, struct transport
, list
);
609 if(!check_transport(transport
, str
, index
, &init
, &mac
))
612 eth_configure(index
, init
, mac
, transport
);
619 spin_unlock(&transports_lock
);
623 static int eth_setup(char *str
)
625 struct eth_init
*new;
629 err
= eth_parse(str
, &n
, &str
, &error
);
631 printk(KERN_ERR
"eth_setup - Couldn't parse '%s' : %s\n",
636 new = alloc_bootmem(sizeof(*new));
638 printk("eth_init : alloc_bootmem failed\n");
642 INIT_LIST_HEAD(&new->list
);
646 list_add_tail(&new->list
, ð_cmd_line
);
650 __setup("eth", eth_setup
);
651 __uml_help(eth_setup
,
652 "eth[0-9]+=<transport>,<options>\n"
653 " Configure a network device.\n\n"
656 static int net_config(char *str
, char **error_out
)
660 err
= eth_parse(str
, &n
, &str
, error_out
);
664 /* This string is broken up and the pieces used by the underlying
665 * driver. So, it is freed only if eth_setup_common fails.
667 str
= kstrdup(str
, GFP_KERNEL
);
669 *error_out
= "net_config failed to strdup string";
672 err
= !eth_setup_common(str
, n
);
678 static int net_id(char **str
, int *start_out
, int *end_out
)
683 n
= simple_strtoul(*str
, &end
, 0);
684 if((*end
!= '\0') || (end
== *str
))
693 static int net_remove(int n
, char **error_out
)
695 struct uml_net
*device
;
696 struct net_device
*dev
;
697 struct uml_net_private
*lp
;
699 device
= find_device(n
);
707 unregister_netdev(dev
);
708 platform_device_unregister(&device
->pdev
);
713 static struct mc_device net_mc
= {
714 .list
= LIST_HEAD_INIT(net_mc
.list
),
716 .config
= net_config
,
719 .remove
= net_remove
,
722 static int uml_inetaddr_event(struct notifier_block
*this, unsigned long event
,
725 struct in_ifaddr
*ifa
= ptr
;
726 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
727 struct uml_net_private
*lp
;
728 void (*proc
)(unsigned char *, unsigned char *, void *);
729 unsigned char addr_buf
[4], netmask_buf
[4];
731 if(dev
->open
!= uml_net_open
)
739 proc
= lp
->add_address
;
742 proc
= lp
->delete_address
;
746 memcpy(addr_buf
, &ifa
->ifa_address
, sizeof(addr_buf
));
747 memcpy(netmask_buf
, &ifa
->ifa_mask
, sizeof(netmask_buf
));
748 (*proc
)(addr_buf
, netmask_buf
, &lp
->user
);
753 /* uml_net_init shouldn't be called twice on two CPUs at the same time */
754 struct notifier_block uml_inetaddr_notifier
= {
755 .notifier_call
= uml_inetaddr_event
,
758 static int uml_net_init(void)
760 struct list_head
*ele
;
761 struct uml_net_private
*lp
;
762 struct in_device
*ip
;
763 struct in_ifaddr
*in
;
765 mconsole_register_dev(&net_mc
);
766 register_inetaddr_notifier(¨_inetaddr_notifier
);
768 /* Devices may have been opened already, so the uml_inetaddr_notifier
769 * didn't get a chance to run for them. This fakes it so that
770 * addresses which have already been set up get handled properly.
772 spin_lock(&opened_lock
);
773 list_for_each(ele
, &opened
){
774 lp
= list_entry(ele
, struct uml_net_private
, list
);
775 ip
= lp
->dev
->ip_ptr
;
780 uml_inetaddr_event(NULL
, NETDEV_UP
, in
);
784 spin_unlock(&opened_lock
);
789 __initcall(uml_net_init
);
791 static void close_devices(void)
793 struct list_head
*ele
;
794 struct uml_net_private
*lp
;
796 spin_lock(&opened_lock
);
797 list_for_each(ele
, &opened
){
798 lp
= list_entry(ele
, struct uml_net_private
, list
);
799 free_irq(lp
->dev
->irq
, lp
->dev
);
800 if((lp
->close
!= NULL
) && (lp
->fd
>= 0))
801 (*lp
->close
)(lp
->fd
, &lp
->user
);
802 if(lp
->remove
!= NULL
)
803 (*lp
->remove
)(&lp
->user
);
805 spin_unlock(&opened_lock
);
808 __uml_exitcall(close_devices
);
810 struct sk_buff
*ether_adjust_skb(struct sk_buff
*skb
, int extra
)
812 if((skb
!= NULL
) && (skb_tailroom(skb
) < extra
)){
813 struct sk_buff
*skb2
;
815 skb2
= skb_copy_expand(skb
, 0, extra
, GFP_ATOMIC
);
819 if(skb
!= NULL
) skb_put(skb
, extra
);
823 void iter_addresses(void *d
, void (*cb
)(unsigned char *, unsigned char *,
827 struct net_device
*dev
= d
;
828 struct in_device
*ip
= dev
->ip_ptr
;
829 struct in_ifaddr
*in
;
830 unsigned char address
[4], netmask
[4];
832 if(ip
== NULL
) return;
835 memcpy(address
, &in
->ifa_address
, sizeof(address
));
836 memcpy(netmask
, &in
->ifa_mask
, sizeof(netmask
));
837 (*cb
)(address
, netmask
, arg
);
842 int dev_netmask(void *d
, void *m
)
844 struct net_device
*dev
= d
;
845 struct in_device
*ip
= dev
->ip_ptr
;
846 struct in_ifaddr
*in
;
847 __be32
*mask_out
= m
;
856 *mask_out
= in
->ifa_mask
;
860 void *get_output_buffer(int *len_out
)
864 ret
= (void *) __get_free_pages(GFP_KERNEL
, 0);
865 if(ret
) *len_out
= PAGE_SIZE
;
870 void free_output_buffer(void *buffer
)
872 free_pages((unsigned long) buffer
, 0);
875 int tap_setup_common(char *str
, char *type
, char **dev_name
, char **mac_out
,
880 remain
= split_if_spec(str
, dev_name
, mac_out
, gate_addr
, NULL
);
882 printk("tap_setup_common - Extra garbage on specification : "
890 unsigned short eth_protocol(struct sk_buff
*skb
)
892 return(eth_type_trans(skb
, skb
->dev
));