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 "user_util.h"
25 #include "kern_util.h"
28 #include "mconsole_kern.h"
33 static inline void set_ether_mac(struct net_device
*dev
, unsigned char *addr
)
35 memcpy(dev
->dev_addr
, addr
, ETH_ALEN
);
38 #define DRIVER_NAME "uml-netdev"
40 static DEFINE_SPINLOCK(opened_lock
);
41 static LIST_HEAD(opened
);
43 static int uml_net_rx(struct net_device
*dev
)
45 struct uml_net_private
*lp
= dev
->priv
;
49 /* If we can't allocate memory, try again next round. */
50 skb
= dev_alloc_skb(dev
->mtu
);
52 lp
->stats
.rx_dropped
++;
57 skb_put(skb
, dev
->mtu
);
58 skb
->mac
.raw
= skb
->data
;
59 pkt_len
= (*lp
->read
)(lp
->fd
, &skb
, lp
);
62 skb_trim(skb
, pkt_len
);
63 skb
->protocol
= (*lp
->protocol
)(skb
);
66 lp
->stats
.rx_bytes
+= skb
->len
;
67 lp
->stats
.rx_packets
++;
75 static void uml_dev_close(struct work_struct
*work
)
77 struct uml_net_private
*lp
=
78 container_of(work
, struct uml_net_private
, work
);
82 irqreturn_t
uml_net_interrupt(int irq
, void *dev_id
)
84 struct net_device
*dev
= dev_id
;
85 struct uml_net_private
*lp
= dev
->priv
;
88 if(!netif_running(dev
))
92 while((err
= uml_net_rx(dev
)) > 0) ;
95 "Device '%s' read returned %d, shutting it down\n",
97 /* dev_close can't be called in interrupt context, and takes
99 * And dev_close() can be safely called multiple times on the
100 * same device, since it tests for (dev->flags & IFF_UP). So
101 * there's no harm in delaying the device shutdown.
102 * Furthermore, the workqueue will not re-enqueue an already
103 * enqueued work item. */
104 schedule_work(&lp
->work
);
107 reactivate_fd(lp
->fd
, UM_ETH_IRQ
);
110 spin_unlock(&lp
->lock
);
114 static int uml_net_open(struct net_device
*dev
)
116 struct uml_net_private
*lp
= dev
->priv
;
124 lp
->fd
= (*lp
->open
)(&lp
->user
);
130 err
= um_request_irq(dev
->irq
, lp
->fd
, IRQ_READ
, uml_net_interrupt
,
131 IRQF_DISABLED
| IRQF_SHARED
, dev
->name
, dev
);
133 printk(KERN_ERR
"uml_net_open: failed to get irq(%d)\n", err
);
138 lp
->tl
.data
= (unsigned long) &lp
->user
;
139 netif_start_queue(dev
);
141 /* clear buffer - it can happen that the host side of the interface
142 * is full when we get here. In this case, new data is never queued,
143 * SIGIOs never arrive, and the net never works.
145 while((err
= uml_net_rx(dev
)) > 0) ;
147 spin_lock(&opened_lock
);
148 list_add(&lp
->list
, &opened
);
149 spin_unlock(&opened_lock
);
153 if(lp
->close
!= NULL
) (*lp
->close
)(lp
->fd
, &lp
->user
);
159 static int uml_net_close(struct net_device
*dev
)
161 struct uml_net_private
*lp
= dev
->priv
;
163 netif_stop_queue(dev
);
165 free_irq(dev
->irq
, dev
);
166 if(lp
->close
!= NULL
)
167 (*lp
->close
)(lp
->fd
, &lp
->user
);
170 spin_lock(&opened_lock
);
172 spin_unlock(&opened_lock
);
177 static int uml_net_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
179 struct uml_net_private
*lp
= dev
->priv
;
183 netif_stop_queue(dev
);
185 spin_lock_irqsave(&lp
->lock
, flags
);
187 len
= (*lp
->write
)(lp
->fd
, &skb
, lp
);
189 if(len
== skb
->len
) {
190 lp
->stats
.tx_packets
++;
191 lp
->stats
.tx_bytes
+= skb
->len
;
192 dev
->trans_start
= jiffies
;
193 netif_start_queue(dev
);
195 /* this is normally done in the interrupt when tx finishes */
196 netif_wake_queue(dev
);
199 netif_start_queue(dev
);
200 lp
->stats
.tx_dropped
++;
203 netif_start_queue(dev
);
204 printk(KERN_ERR
"uml_net_start_xmit: failed(%d)\n", len
);
207 spin_unlock_irqrestore(&lp
->lock
, flags
);
214 static struct net_device_stats
*uml_net_get_stats(struct net_device
*dev
)
216 struct uml_net_private
*lp
= dev
->priv
;
220 static void uml_net_set_multicast_list(struct net_device
*dev
)
222 if (dev
->flags
& IFF_PROMISC
) return;
223 else if (dev
->mc_count
) dev
->flags
|= IFF_ALLMULTI
;
224 else dev
->flags
&= ~IFF_ALLMULTI
;
227 static void uml_net_tx_timeout(struct net_device
*dev
)
229 dev
->trans_start
= jiffies
;
230 netif_wake_queue(dev
);
233 static int uml_net_set_mac(struct net_device
*dev
, void *addr
)
235 struct uml_net_private
*lp
= dev
->priv
;
236 struct sockaddr
*hwaddr
= addr
;
238 spin_lock_irq(&lp
->lock
);
239 set_ether_mac(dev
, hwaddr
->sa_data
);
240 spin_unlock_irq(&lp
->lock
);
245 static int uml_net_change_mtu(struct net_device
*dev
, int new_mtu
)
247 struct uml_net_private
*lp
= dev
->priv
;
250 spin_lock_irq(&lp
->lock
);
252 new_mtu
= (*lp
->set_mtu
)(new_mtu
, &lp
->user
);
261 spin_unlock_irq(&lp
->lock
);
265 static void uml_net_get_drvinfo(struct net_device
*dev
,
266 struct ethtool_drvinfo
*info
)
268 strcpy(info
->driver
, DRIVER_NAME
);
269 strcpy(info
->version
, "42");
272 static struct ethtool_ops uml_net_ethtool_ops
= {
273 .get_drvinfo
= uml_net_get_drvinfo
,
274 .get_link
= ethtool_op_get_link
,
277 void uml_net_user_timer_expire(unsigned long _conn
)
280 struct connection
*conn
= (struct connection
*)_conn
;
282 dprintk(KERN_INFO
"uml_net_user_timer_expire [%p]\n", conn
);
287 static void setup_etheraddr(char *str
, unsigned char *addr
)
296 addr
[i
] = simple_strtoul(str
, &end
, 16);
298 ((*end
!= ':') && (*end
!= ',') && (*end
!= '\0'))){
300 "setup_etheraddr: failed to parse '%s' "
301 "as an ethernet address\n", str
);
308 "Attempt to assign a broadcast ethernet address to a "
309 "device disallowed\n");
315 random_ether_addr(addr
);
318 static DEFINE_SPINLOCK(devices_lock
);
319 static LIST_HEAD(devices
);
321 static struct platform_driver uml_net_driver
= {
326 static int driver_registered
;
328 static int eth_configure(int n
, void *init
, char *mac
,
329 struct transport
*transport
)
331 struct uml_net
*device
;
332 struct net_device
*dev
;
333 struct uml_net_private
*lp
;
336 size
= transport
->private_size
+ sizeof(struct uml_net_private
) +
337 sizeof(((struct uml_net_private
*) 0)->user
);
339 device
= kzalloc(sizeof(*device
), GFP_KERNEL
);
340 if (device
== NULL
) {
341 printk(KERN_ERR
"eth_configure failed to allocate uml_net\n");
345 INIT_LIST_HEAD(&device
->list
);
348 spin_lock(&devices_lock
);
349 list_add(&device
->list
, &devices
);
350 spin_unlock(&devices_lock
);
352 setup_etheraddr(mac
, device
->mac
);
354 printk(KERN_INFO
"Netdevice %d ", n
);
355 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
356 device
->mac
[0], device
->mac
[1],
357 device
->mac
[2], device
->mac
[3],
358 device
->mac
[4], device
->mac
[5]);
360 dev
= alloc_etherdev(size
);
362 printk(KERN_ERR
"eth_configure: failed to allocate device\n");
367 /* This points to the transport private data. It's still clear, but we
368 * must memset it to 0 *now*. Let's help the drivers. */
370 INIT_WORK(&lp
->work
, uml_dev_close
);
373 if (!driver_registered
) {
374 platform_driver_register(¨_net_driver
);
375 driver_registered
= 1;
378 device
->pdev
.name
= DRIVER_NAME
;
379 platform_device_register(&device
->pdev
);
380 SET_NETDEV_DEV(dev
,&device
->pdev
.dev
);
382 /* If this name ends up conflicting with an existing registered
383 * netdevice, that is OK, register_netdev{,ice}() will notice this
386 snprintf(dev
->name
, sizeof(dev
->name
), "eth%d", n
);
389 (*transport
->kern
->init
)(dev
, init
);
391 dev
->mtu
= transport
->user
->max_packet
;
392 dev
->open
= uml_net_open
;
393 dev
->hard_start_xmit
= uml_net_start_xmit
;
394 dev
->stop
= uml_net_close
;
395 dev
->get_stats
= uml_net_get_stats
;
396 dev
->set_multicast_list
= uml_net_set_multicast_list
;
397 dev
->tx_timeout
= uml_net_tx_timeout
;
398 dev
->set_mac_address
= uml_net_set_mac
;
399 dev
->change_mtu
= uml_net_change_mtu
;
400 dev
->ethtool_ops
= ¨_net_ethtool_ops
;
401 dev
->watchdog_timeo
= (HZ
>> 1);
402 dev
->irq
= UM_ETH_IRQ
;
405 err
= register_netdevice(dev
);
409 /* XXX: should we call ->remove() here? */
414 /* lp.user is the first four bytes of the transport data, which
415 * has already been initialized. This structure assignment will
416 * overwrite that, so we make sure that .user gets overwritten with
417 * what it already has.
420 *lp
= ((struct uml_net_private
)
421 { .list
= LIST_HEAD_INIT(lp
->list
),
424 .mac
= { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
425 .protocol
= transport
->kern
->protocol
,
426 .open
= transport
->user
->open
,
427 .close
= transport
->user
->close
,
428 .remove
= transport
->user
->remove
,
429 .read
= transport
->kern
->read
,
430 .write
= transport
->kern
->write
,
431 .add_address
= transport
->user
->add_address
,
432 .delete_address
= transport
->user
->delete_address
,
433 .set_mtu
= transport
->user
->set_mtu
,
437 spin_lock_init(&lp
->lock
);
438 lp
->tl
.function
= uml_net_user_timer_expire
;
439 memcpy(lp
->mac
, device
->mac
, sizeof(lp
->mac
));
441 if (transport
->user
->init
)
442 (*transport
->user
->init
)(&lp
->user
, dev
);
444 set_ether_mac(dev
, device
->mac
);
449 static struct uml_net
*find_device(int n
)
451 struct uml_net
*device
;
452 struct list_head
*ele
;
454 spin_lock(&devices_lock
);
455 list_for_each(ele
, &devices
){
456 device
= list_entry(ele
, struct uml_net
, list
);
457 if(device
->index
== n
)
462 spin_unlock(&devices_lock
);
466 static int eth_parse(char *str
, int *index_out
, char **str_out
,
470 int n
, err
= -EINVAL
;;
472 n
= simple_strtoul(str
, &end
, 0);
474 *error_out
= "Bad device number";
480 *error_out
= "Expected '=' after device number";
486 *error_out
= "Device already configured";
496 struct list_head list
;
501 static DEFINE_SPINLOCK(transports_lock
);
502 static LIST_HEAD(transports
);
504 /* Filled in during early boot */
505 struct list_head eth_cmd_line
= LIST_HEAD_INIT(eth_cmd_line
);
507 static int check_transport(struct transport
*transport
, char *eth
, int n
,
508 void **init_out
, char **mac_out
)
512 len
= strlen(transport
->name
);
513 if(strncmp(eth
, transport
->name
, len
))
519 else if(*eth
!= '\0')
522 *init_out
= kmalloc(transport
->setup_size
, GFP_KERNEL
);
523 if(*init_out
== NULL
)
526 if(!transport
->setup(eth
, mac_out
, *init_out
)){
533 void register_transport(struct transport
*new)
535 struct list_head
*ele
, *next
;
536 struct eth_init
*eth
;
541 spin_lock(&transports_lock
);
542 BUG_ON(!list_empty(&new->list
));
543 list_add(&new->list
, &transports
);
544 spin_unlock(&transports_lock
);
546 list_for_each_safe(ele
, next
, ð_cmd_line
){
547 eth
= list_entry(ele
, struct eth_init
, list
);
548 match
= check_transport(new, eth
->init
, eth
->index
, &init
,
552 else if(init
!= NULL
){
553 eth_configure(eth
->index
, init
, mac
, new);
556 list_del(ð
->list
);
560 static int eth_setup_common(char *str
, int index
)
562 struct list_head
*ele
;
563 struct transport
*transport
;
567 list_for_each(ele
, &transports
){
568 transport
= list_entry(ele
, struct transport
, list
);
569 if(!check_transport(transport
, str
, index
, &init
, &mac
))
572 eth_configure(index
, init
, mac
, transport
);
580 static int eth_setup(char *str
)
582 struct eth_init
*new;
586 err
= eth_parse(str
, &n
, &str
, &error
);
588 printk(KERN_ERR
"eth_setup - Couldn't parse '%s' : %s\n",
593 new = alloc_bootmem(sizeof(*new));
595 printk("eth_init : alloc_bootmem failed\n");
599 INIT_LIST_HEAD(&new->list
);
603 list_add_tail(&new->list
, ð_cmd_line
);
607 __setup("eth", eth_setup
);
608 __uml_help(eth_setup
,
609 "eth[0-9]+=<transport>,<options>\n"
610 " Configure a network device.\n\n"
614 static int eth_init(void)
616 struct list_head
*ele
, *next
;
617 struct eth_init
*eth
;
619 list_for_each_safe(ele
, next
, ð_cmd_line
){
620 eth
= list_entry(ele
, struct eth_init
, list
);
622 if(eth_setup_common(eth
->init
, eth
->index
))
623 list_del(ð
->list
);
628 __initcall(eth_init
);
631 static int net_config(char *str
, char **error_out
)
635 err
= eth_parse(str
, &n
, &str
, error_out
);
639 /* This string is broken up and the pieces used by the underlying
640 * driver. So, it is freed only if eth_setup_common fails.
642 str
= kstrdup(str
, GFP_KERNEL
);
644 *error_out
= "net_config failed to strdup string";
647 err
= !eth_setup_common(str
, n
);
653 static int net_id(char **str
, int *start_out
, int *end_out
)
658 n
= simple_strtoul(*str
, &end
, 0);
659 if((*end
!= '\0') || (end
== *str
))
668 static int net_remove(int n
, char **error_out
)
670 struct uml_net
*device
;
671 struct net_device
*dev
;
672 struct uml_net_private
*lp
;
674 device
= find_device(n
);
682 if(lp
->remove
!= NULL
) (*lp
->remove
)(&lp
->user
);
683 unregister_netdev(dev
);
684 platform_device_unregister(&device
->pdev
);
686 list_del(&device
->list
);
692 static struct mc_device net_mc
= {
694 .config
= net_config
,
697 .remove
= net_remove
,
700 static int uml_inetaddr_event(struct notifier_block
*this, unsigned long event
,
703 struct in_ifaddr
*ifa
= ptr
;
704 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
705 struct uml_net_private
*lp
;
706 void (*proc
)(unsigned char *, unsigned char *, void *);
707 unsigned char addr_buf
[4], netmask_buf
[4];
709 if(dev
->open
!= uml_net_open
) return(NOTIFY_DONE
);
716 proc
= lp
->add_address
;
719 proc
= lp
->delete_address
;
723 memcpy(addr_buf
, &ifa
->ifa_address
, sizeof(addr_buf
));
724 memcpy(netmask_buf
, &ifa
->ifa_mask
, sizeof(netmask_buf
));
725 (*proc
)(addr_buf
, netmask_buf
, &lp
->user
);
730 struct notifier_block uml_inetaddr_notifier
= {
731 .notifier_call
= uml_inetaddr_event
,
734 static int uml_net_init(void)
736 struct list_head
*ele
;
737 struct uml_net_private
*lp
;
738 struct in_device
*ip
;
739 struct in_ifaddr
*in
;
741 mconsole_register_dev(&net_mc
);
742 register_inetaddr_notifier(¨_inetaddr_notifier
);
744 /* Devices may have been opened already, so the uml_inetaddr_notifier
745 * didn't get a chance to run for them. This fakes it so that
746 * addresses which have already been set up get handled properly.
748 list_for_each(ele
, &opened
){
749 lp
= list_entry(ele
, struct uml_net_private
, list
);
750 ip
= lp
->dev
->ip_ptr
;
751 if(ip
== NULL
) continue;
754 uml_inetaddr_event(NULL
, NETDEV_UP
, in
);
762 __initcall(uml_net_init
);
764 static void close_devices(void)
766 struct list_head
*ele
;
767 struct uml_net_private
*lp
;
769 list_for_each(ele
, &opened
){
770 lp
= list_entry(ele
, struct uml_net_private
, list
);
771 free_irq(lp
->dev
->irq
, lp
->dev
);
772 if((lp
->close
!= NULL
) && (lp
->fd
>= 0))
773 (*lp
->close
)(lp
->fd
, &lp
->user
);
774 if(lp
->remove
!= NULL
) (*lp
->remove
)(&lp
->user
);
778 __uml_exitcall(close_devices
);
780 struct sk_buff
*ether_adjust_skb(struct sk_buff
*skb
, int extra
)
782 if((skb
!= NULL
) && (skb_tailroom(skb
) < extra
)){
783 struct sk_buff
*skb2
;
785 skb2
= skb_copy_expand(skb
, 0, extra
, GFP_ATOMIC
);
789 if(skb
!= NULL
) skb_put(skb
, extra
);
793 void iter_addresses(void *d
, void (*cb
)(unsigned char *, unsigned char *,
797 struct net_device
*dev
= d
;
798 struct in_device
*ip
= dev
->ip_ptr
;
799 struct in_ifaddr
*in
;
800 unsigned char address
[4], netmask
[4];
802 if(ip
== NULL
) return;
805 memcpy(address
, &in
->ifa_address
, sizeof(address
));
806 memcpy(netmask
, &in
->ifa_mask
, sizeof(netmask
));
807 (*cb
)(address
, netmask
, arg
);
812 int dev_netmask(void *d
, void *m
)
814 struct net_device
*dev
= d
;
815 struct in_device
*ip
= dev
->ip_ptr
;
816 struct in_ifaddr
*in
;
817 __be32
*mask_out
= m
;
826 *mask_out
= in
->ifa_mask
;
830 void *get_output_buffer(int *len_out
)
834 ret
= (void *) __get_free_pages(GFP_KERNEL
, 0);
835 if(ret
) *len_out
= PAGE_SIZE
;
840 void free_output_buffer(void *buffer
)
842 free_pages((unsigned long) buffer
, 0);
845 int tap_setup_common(char *str
, char *type
, char **dev_name
, char **mac_out
,
850 remain
= split_if_spec(str
, dev_name
, mac_out
, gate_addr
, NULL
);
852 printk("tap_setup_common - Extra garbage on specification : "
860 unsigned short eth_protocol(struct sk_buff
*skb
)
862 return(eth_type_trans(skb
, skb
->dev
));