arch/um/drivers/net_kern.c

   1 /*
   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.
   7  */
   8
   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/spinlock.h>
  20 #include "init.h"
  21 #include "irq_kern.h"
  22 #include "irq_user.h"
  23 #include "mconsole_kern.h"
  24 #include "net_kern.h"
  25 #include "net_user.h"
  26
  27 static inline void set_ether_mac(struct net_device *dev, unsigned char *addr)
  28 {
  29         memcpy(dev->dev_addr, addr, ETH_ALEN);
  30 }
  31
  32 #define DRIVER_NAME "uml-netdev"
  33
  34 static DEFINE_SPINLOCK(opened_lock);
  35 static LIST_HEAD(opened);
  36
  37 /*
  38  * The drop_skb is used when we can't allocate an skb.  The
  39  * packet is read into drop_skb in order to get the data off the
  40  * connection to the host.
  41  * It is reallocated whenever a maximum packet size is seen which is
  42  * larger than any seen before.  update_drop_skb is called from
  43  * eth_configure when a new interface is added.
  44  */
  45 static DEFINE_SPINLOCK(drop_lock);
  46 static struct sk_buff *drop_skb;
  47 static int drop_max;
  48
  49 static int update_drop_skb(int max)
  50 {
  51         struct sk_buff *new;
  52         unsigned long flags;
  53         int err = 0;
  54
  55         spin_lock_irqsave(&drop_lock, flags);
  56
  57         if (max <= drop_max)
  58                 goto out;
  59
  60         err = -ENOMEM;
  61         new = dev_alloc_skb(max);
  62         if (new == NULL)
  63                 goto out;
  64
  65         skb_put(new, max);
  66
  67         kfree_skb(drop_skb);
  68         drop_skb = new;
  69         drop_max = max;
  70         err = 0;
  71 out:
  72         spin_unlock_irqrestore(&drop_lock, flags);
  73
  74         return err;
  75 }
  76
  77 static int uml_net_rx(struct net_device *dev)
  78 {
  79         struct uml_net_private *lp = dev->priv;
  80         int pkt_len;
  81         struct sk_buff *skb;
  82
  83         /* If we can't allocate memory, try again next round. */
  84         skb = dev_alloc_skb(lp->max_packet);
  85         if (skb == NULL) {
  86                 drop_skb->dev = dev;
  87                 /* Read a packet into drop_skb and don't do anything with it. */
  88                 (*lp->read)(lp->fd, drop_skb, lp);
  89                 lp->stats.rx_dropped++;
  90                 return 0;
  91         }
  92
  93         skb->dev = dev;
  94         skb_put(skb, lp->max_packet);
  95         skb_reset_mac_header(skb);
  96         pkt_len = (*lp->read)(lp->fd, skb, lp);
  97
  98         if (pkt_len > 0) {
  99                 skb_trim(skb, pkt_len);
 100                 skb->protocol = (*lp->protocol)(skb);
 101
 102                 lp->stats.rx_bytes += skb->len;
 103                 lp->stats.rx_packets++;
 104                 netif_rx(skb);
 105                 return pkt_len;
 106         }
 107
 108         kfree_skb(skb);
 109         return pkt_len;
 110 }
 111
 112 static void uml_dev_close(struct work_struct *work)
 113 {
 114         struct uml_net_private *lp =
 115                 container_of(work, struct uml_net_private, work);
 116         dev_close(lp->dev);
 117 }
 118
 119 irqreturn_t uml_net_interrupt(int irq, void *dev_id)
 120 {
 121         struct net_device *dev = dev_id;
 122         struct uml_net_private *lp = dev->priv;
 123         int err;
 124
 125         if (!netif_running(dev))
 126                 return IRQ_NONE;
 127
 128         spin_lock(&lp->lock);
 129         while ((err = uml_net_rx(dev)) > 0) ;
 130         if (err < 0) {
 131                 printk(KERN_ERR
 132                        "Device '%s' read returned %d, shutting it down\n",
 133                        dev->name, err);
 134                 /* dev_close can't be called in interrupt context, and takes
 135                  * again lp->lock.
 136                  * And dev_close() can be safely called multiple times on the
 137                  * same device, since it tests for (dev->flags & IFF_UP). So
 138                  * there's no harm in delaying the device shutdown.
 139                  * Furthermore, the workqueue will not re-enqueue an already
 140                  * enqueued work item. */
 141                 schedule_work(&lp->work);
 142                 goto out;
 143         }
 144         reactivate_fd(lp->fd, UM_ETH_IRQ);
 145
 146 out:
 147         spin_unlock(&lp->lock);
 148         return IRQ_HANDLED;
 149 }
 150
 151 static int uml_net_open(struct net_device *dev)
 152 {
 153         struct uml_net_private *lp = dev->priv;
 154         int err;
 155
 156         if (lp->fd >= 0) {
 157                 err = -ENXIO;
 158                 goto out;
 159         }
 160
 161         lp->fd = (*lp->open)(&lp->user);
 162         if (lp->fd < 0) {
 163                 err = lp->fd;
 164                 goto out;
 165         }
 166
 167         err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
 168                              IRQF_DISABLED | IRQF_SHARED, dev->name, dev);
 169         if (err != 0) {
 170                 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
 171                 err = -ENETUNREACH;
 172                 goto out_close;
 173         }
 174
 175         lp->tl.data = (unsigned long) &lp->user;
 176         netif_start_queue(dev);
 177
 178         /* clear buffer - it can happen that the host side of the interface
 179          * is full when we get here.  In this case, new data is never queued,
 180          * SIGIOs never arrive, and the net never works.
 181          */
 182         while ((err = uml_net_rx(dev)) > 0) ;
 183
 184         spin_lock(&opened_lock);
 185         list_add(&lp->list, &opened);
 186         spin_unlock(&opened_lock);
 187
 188         return 0;
 189 out_close:
 190         if (lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
 191         lp->fd = -1;
 192 out:
 193         return err;
 194 }
 195
 196 static int uml_net_close(struct net_device *dev)
 197 {
 198         struct uml_net_private *lp = dev->priv;
 199
 200         netif_stop_queue(dev);
 201
 202         free_irq(dev->irq, dev);
 203         if (lp->close != NULL)
 204                 (*lp->close)(lp->fd, &lp->user);
 205         lp->fd = -1;
 206
 207         spin_lock(&opened_lock);
 208         list_del(&lp->list);
 209         spin_unlock(&opened_lock);
 210
 211         return 0;
 212 }
 213
 214 static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
 215 {
 216         struct uml_net_private *lp = dev->priv;
 217         unsigned long flags;
 218         int len;
 219
 220         netif_stop_queue(dev);
 221
 222         spin_lock_irqsave(&lp->lock, flags);
 223
 224         len = (*lp->write)(lp->fd, skb, lp);
 225
 226         if (len == skb->len) {
 227                 lp->stats.tx_packets++;
 228                 lp->stats.tx_bytes += skb->len;
 229                 dev->trans_start = jiffies;
 230                 netif_start_queue(dev);
 231
 232                 /* this is normally done in the interrupt when tx finishes */
 233                 netif_wake_queue(dev);
 234         }
 235         else if (len == 0) {
 236                 netif_start_queue(dev);
 237                 lp->stats.tx_dropped++;
 238         }
 239         else {
 240                 netif_start_queue(dev);
 241                 printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
 242         }
 243
 244         spin_unlock_irqrestore(&lp->lock, flags);
 245
 246         dev_kfree_skb(skb);
 247
 248         return 0;
 249 }
 250
 251 static struct net_device_stats *uml_net_get_stats(struct net_device *dev)
 252 {
 253         struct uml_net_private *lp = dev->priv;
 254         return &lp->stats;
 255 }
 256
 257 static void uml_net_set_multicast_list(struct net_device *dev)
 258 {
 259         if (dev->flags & IFF_PROMISC)
 260                 return;
 261         else if (dev->mc_count)
 262                 dev->flags |= IFF_ALLMULTI;
 263         else dev->flags &= ~IFF_ALLMULTI;
 264 }
 265
 266 static void uml_net_tx_timeout(struct net_device *dev)
 267 {
 268         dev->trans_start = jiffies;
 269         netif_wake_queue(dev);
 270 }
 271
 272 static int uml_net_set_mac(struct net_device *dev, void *addr)
 273 {
 274         struct uml_net_private *lp = dev->priv;
 275         struct sockaddr *hwaddr = addr;
 276
 277         spin_lock_irq(&lp->lock);
 278         set_ether_mac(dev, hwaddr->sa_data);
 279         spin_unlock_irq(&lp->lock);
 280
 281         return 0;
 282 }
 283
 284 static int uml_net_change_mtu(struct net_device *dev, int new_mtu)
 285 {
 286         dev->mtu = new_mtu;
 287
 288         return 0;
 289 }
 290
 291 static void uml_net_get_drvinfo(struct net_device *dev,
 292                                 struct ethtool_drvinfo *info)
 293 {
 294         strcpy(info->driver, DRIVER_NAME);
 295         strcpy(info->version, "42");
 296 }
 297
 298 static struct ethtool_ops uml_net_ethtool_ops = {
 299         .get_drvinfo    = uml_net_get_drvinfo,
 300         .get_link       = ethtool_op_get_link,
 301 };
 302
 303 void uml_net_user_timer_expire(unsigned long _conn)
 304 {
 305 #ifdef undef
 306         struct connection *conn = (struct connection *)_conn;
 307
 308         dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
 309         do_connect(conn);
 310 #endif
 311 }
 312
 313 static void setup_etheraddr(char *str, unsigned char *addr, char *name)
 314 {
 315         char *end;
 316         int i;
 317
 318         if (str == NULL)
 319                 goto random;
 320
 321         for (i = 0; i < 6; i++) {
 322                 addr[i] = simple_strtoul(str, &end, 16);
 323                 if ((end == str) ||
 324                    ((*end != ':') && (*end != ',') && (*end != '\0'))) {
 325                         printk(KERN_ERR
 326                                "setup_etheraddr: failed to parse '%s' "
 327                                "as an ethernet address\n", str);
 328                         goto random;
 329                 }
 330                 str = end + 1;
 331         }
 332         if (is_multicast_ether_addr(addr)) {
 333                 printk(KERN_ERR
 334                        "Attempt to assign a multicast ethernet address to a "
 335                        "device disallowed\n");
 336                 goto random;
 337         }
 338         if (!is_valid_ether_addr(addr)) {
 339                 printk(KERN_ERR
 340                        "Attempt to assign an invalid ethernet address to a "
 341                        "device disallowed\n");
 342                 goto random;
 343         }
 344         if (!is_local_ether_addr(addr)) {
 345                 printk(KERN_WARNING
 346                        "Warning: Assigning a globally valid ethernet "
 347                        "address to a device\n");
 348                 printk(KERN_WARNING "You should set the 2nd rightmost bit in "
 349                        "the first byte of the MAC,\n");
 350                 printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n",
 351                        addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
 352                        addr[5]);
 353         }
 354         return;
 355
 356 random:
 357         printk(KERN_INFO
 358                "Choosing a random ethernet address for device %s\n", name);
 359         random_ether_addr(addr);
 360 }
 361
 362 static DEFINE_SPINLOCK(devices_lock);
 363 static LIST_HEAD(devices);
 364
 365 static struct platform_driver uml_net_driver = {
 366         .driver = {
 367                 .name  = DRIVER_NAME,
 368         },
 369 };
 370
 371 static void net_device_release(struct device *dev)
 372 {
 373         struct uml_net *device = dev->driver_data;
 374         struct net_device *netdev = device->dev;
 375         struct uml_net_private *lp = netdev->priv;
 376
 377         if (lp->remove != NULL)
 378                 (*lp->remove)(&lp->user);
 379         list_del(&device->list);
 380         kfree(device);
 381         free_netdev(netdev);
 382 }
 383
 384 /*
 385  * Ensures that platform_driver_register is called only once by
 386  * eth_configure.  Will be set in an initcall.
 387  */
 388 static int driver_registered;
 389
 390 static void eth_configure(int n, void *init, char *mac,
 391                           struct transport *transport)
 392 {
 393         struct uml_net *device;
 394         struct net_device *dev;
 395         struct uml_net_private *lp;
 396         int err, size;
 397
 398         size = transport->private_size + sizeof(struct uml_net_private);
 399
 400         device = kzalloc(sizeof(*device), GFP_KERNEL);
 401         if (device == NULL) {
 402                 printk(KERN_ERR "eth_configure failed to allocate struct "
 403                        "uml_net\n");
 404                 return;
 405         }
 406
 407         dev = alloc_etherdev(size);
 408         if (dev == NULL) {
 409                 printk(KERN_ERR "eth_configure: failed to allocate struct "
 410                        "net_device for eth%d\n", n);
 411                 goto out_free_device;
 412         }
 413
 414         INIT_LIST_HEAD(&device->list);
 415         device->index = n;
 416
 417         /* If this name ends up conflicting with an existing registered
 418          * netdevice, that is OK, register_netdev{,ice}() will notice this
 419          * and fail.
 420          */
 421         snprintf(dev->name, sizeof(dev->name), "eth%d", n);
 422
 423         setup_etheraddr(mac, device->mac, dev->name);
 424
 425         printk(KERN_INFO "Netdevice %d ", n);
 426         printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
 427                device->mac[0], device->mac[1],
 428                device->mac[2], device->mac[3],
 429                device->mac[4], device->mac[5]);
 430         printk(": ");
 431
 432         lp = dev->priv;
 433         /* This points to the transport private data. It's still clear, but we
 434          * must memset it to 0 *now*. Let's help the drivers. */
 435         memset(lp, 0, size);
 436         INIT_WORK(&lp->work, uml_dev_close);
 437
 438         /* sysfs register */
 439         if (!driver_registered) {
 440                 platform_driver_register(&uml_net_driver);
 441                 driver_registered = 1;
 442         }
 443         device->pdev.id = n;
 444         device->pdev.name = DRIVER_NAME;
 445         device->pdev.dev.release = net_device_release;
 446         device->pdev.dev.driver_data = device;
 447         if (platform_device_register(&device->pdev))
 448                 goto out_free_netdev;
 449         SET_NETDEV_DEV(dev,&device->pdev.dev);
 450
 451         device->dev = dev;
 452
 453         /*
 454          * These just fill in a data structure, so there's no failure
 455          * to be worried about.
 456          */
 457         (*transport->kern->init)(dev, init);
 458
 459         *lp = ((struct uml_net_private)
 460                 { .list                 = LIST_HEAD_INIT(lp->list),
 461                   .dev                  = dev,
 462                   .fd                   = -1,
 463                   .mac                  = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
 464                   .max_packet           = transport->user->max_packet,
 465                   .protocol             = transport->kern->protocol,
 466                   .open                 = transport->user->open,
 467                   .close                = transport->user->close,
 468                   .remove               = transport->user->remove,
 469                   .read                 = transport->kern->read,
 470                   .write                = transport->kern->write,
 471                   .add_address          = transport->user->add_address,
 472                   .delete_address       = transport->user->delete_address });
 473
 474         init_timer(&lp->tl);
 475         spin_lock_init(&lp->lock);
 476         lp->tl.function = uml_net_user_timer_expire;
 477         memcpy(lp->mac, device->mac, sizeof(lp->mac));
 478
 479         if ((transport->user->init != NULL) &&
 480             ((*transport->user->init)(&lp->user, dev) != 0))
 481                 goto out_unregister;
 482
 483         set_ether_mac(dev, device->mac);
 484         dev->mtu = transport->user->mtu;
 485         dev->open = uml_net_open;
 486         dev->hard_start_xmit = uml_net_start_xmit;
 487         dev->stop = uml_net_close;
 488         dev->get_stats = uml_net_get_stats;
 489         dev->set_multicast_list = uml_net_set_multicast_list;
 490         dev->tx_timeout = uml_net_tx_timeout;
 491         dev->set_mac_address = uml_net_set_mac;
 492         dev->change_mtu = uml_net_change_mtu;
 493         dev->ethtool_ops = &uml_net_ethtool_ops;
 494         dev->watchdog_timeo = (HZ >> 1);
 495         dev->irq = UM_ETH_IRQ;
 496
 497         err = update_drop_skb(lp->max_packet);
 498         if (err)
 499                 goto out_undo_user_init;
 500
 501         rtnl_lock();
 502         err = register_netdevice(dev);
 503         rtnl_unlock();
 504         if (err)
 505                 goto out_undo_user_init;
 506
 507         spin_lock(&devices_lock);
 508         list_add(&device->list, &devices);
 509         spin_unlock(&devices_lock);
 510
 511         return;
 512
 513 out_undo_user_init:
 514         if (transport->user->remove != NULL)
 515                 (*transport->user->remove)(&lp->user);
 516 out_unregister:
 517         platform_device_unregister(&device->pdev);
 518         return; /* platform_device_unregister frees dev and device */
 519 out_free_netdev:
 520         free_netdev(dev);
 521 out_free_device:
 522         kfree(device);
 523 }
 524
 525 static struct uml_net *find_device(int n)
 526 {
 527         struct uml_net *device;
 528         struct list_head *ele;
 529
 530         spin_lock(&devices_lock);
 531         list_for_each(ele, &devices) {
 532                 device = list_entry(ele, struct uml_net, list);
 533                 if (device->index == n)
 534                         goto out;
 535         }
 536         device = NULL;
 537  out:
 538         spin_unlock(&devices_lock);
 539         return device;
 540 }
 541
 542 static int eth_parse(char *str, int *index_out, char **str_out,
 543                      char **error_out)
 544 {
 545         char *end;
 546         int n, err = -EINVAL;;
 547
 548         n = simple_strtoul(str, &end, 0);
 549         if (end == str) {
 550                 *error_out = "Bad device number";
 551                 return err;
 552         }
 553
 554         str = end;
 555         if (*str != '=') {
 556                 *error_out = "Expected '=' after device number";
 557                 return err;
 558         }
 559
 560         str++;
 561         if (find_device(n)) {
 562                 *error_out = "Device already configured";
 563                 return err;
 564         }
 565
 566         *index_out = n;
 567         *str_out = str;
 568         return 0;
 569 }
 570
 571 struct eth_init {
 572         struct list_head list;
 573         char *init;
 574         int index;
 575 };
 576
 577 static DEFINE_SPINLOCK(transports_lock);
 578 static LIST_HEAD(transports);
 579
 580 /* Filled in during early boot */
 581 static LIST_HEAD(eth_cmd_line);
 582
 583 static int check_transport(struct transport *transport, char *eth, int n,
 584                            void **init_out, char **mac_out)
 585 {
 586         int len;
 587
 588         len = strlen(transport->name);
 589         if (strncmp(eth, transport->name, len))
 590                 return 0;
 591
 592         eth += len;
 593         if (*eth == ',')
 594                 eth++;
 595         else if (*eth != '\0')
 596                 return 0;
 597
 598         *init_out = kmalloc(transport->setup_size, GFP_KERNEL);
 599         if (*init_out == NULL)
 600                 return 1;
 601
 602         if (!transport->setup(eth, mac_out, *init_out)) {
 603                 kfree(*init_out);
 604                 *init_out = NULL;
 605         }
 606         return 1;
 607 }
 608
 609 void register_transport(struct transport *new)
 610 {
 611         struct list_head *ele, *next;
 612         struct eth_init *eth;
 613         void *init;
 614         char *mac = NULL;
 615         int match;
 616
 617         spin_lock(&transports_lock);
 618         BUG_ON(!list_empty(&new->list));
 619         list_add(&new->list, &transports);
 620         spin_unlock(&transports_lock);
 621
 622         list_for_each_safe(ele, next, &eth_cmd_line) {
 623                 eth = list_entry(ele, struct eth_init, list);
 624                 match = check_transport(new, eth->init, eth->index, &init,
 625                                         &mac);
 626                 if (!match)
 627                         continue;
 628                 else if (init != NULL) {
 629                         eth_configure(eth->index, init, mac, new);
 630                         kfree(init);
 631                 }
 632                 list_del(&eth->list);
 633         }
 634 }
 635
 636 static int eth_setup_common(char *str, int index)
 637 {
 638         struct list_head *ele;
 639         struct transport *transport;
 640         void *init;
 641         char *mac = NULL;
 642         int found = 0;
 643
 644         spin_lock(&transports_lock);
 645         list_for_each(ele, &transports) {
 646                 transport = list_entry(ele, struct transport, list);
 647                 if (!check_transport(transport, str, index, &init, &mac))
 648                         continue;
 649                 if (init != NULL) {
 650                         eth_configure(index, init, mac, transport);
 651                         kfree(init);
 652                 }
 653                 found = 1;
 654                 break;
 655         }
 656
 657         spin_unlock(&transports_lock);
 658         return found;
 659 }
 660
 661 static int __init eth_setup(char *str)
 662 {
 663         struct eth_init *new;
 664         char *error;
 665         int n, err;
 666
 667         err = eth_parse(str, &n, &str, &error);
 668         if (err) {
 669                 printk(KERN_ERR "eth_setup - Couldn't parse '%s' : %s\n",
 670                        str, error);
 671                 return 1;
 672         }
 673
 674         new = alloc_bootmem(sizeof(*new));
 675         if (new == NULL) {
 676                 printk(KERN_ERR "eth_init : alloc_bootmem failed\n");
 677                 return 1;
 678         }
 679
 680         INIT_LIST_HEAD(&new->list);
 681         new->index = n;
 682         new->init = str;
 683
 684         list_add_tail(&new->list, &eth_cmd_line);
 685         return 1;
 686 }
 687
 688 __setup("eth", eth_setup);
 689 __uml_help(eth_setup,
 690 "eth[0-9]+=<transport>,<options>\n"
 691 "    Configure a network device.\n\n"
 692 );
 693
 694 static int net_config(char *str, char **error_out)
 695 {
 696         int n, err;
 697
 698         err = eth_parse(str, &n, &str, error_out);
 699         if (err)
 700                 return err;
 701
 702         /* This string is broken up and the pieces used by the underlying
 703          * driver.  So, it is freed only if eth_setup_common fails.
 704          */
 705         str = kstrdup(str, GFP_KERNEL);
 706         if (str == NULL) {
 707                 *error_out = "net_config failed to strdup string";
 708                 return -ENOMEM;
 709         }
 710         err = !eth_setup_common(str, n);
 711         if (err)
 712                 kfree(str);
 713         return err;
 714 }
 715
 716 static int net_id(char **str, int *start_out, int *end_out)
 717 {
 718         char *end;
 719         int n;
 720
 721         n = simple_strtoul(*str, &end, 0);
 722         if ((*end != '\0') || (end == *str))
 723                 return -1;
 724
 725         *start_out = n;
 726         *end_out = n;
 727         *str = end;
 728         return n;
 729 }
 730
 731 static int net_remove(int n, char **error_out)
 732 {
 733         struct uml_net *device;
 734         struct net_device *dev;
 735         struct uml_net_private *lp;
 736
 737         device = find_device(n);
 738         if (device == NULL)
 739                 return -ENODEV;
 740
 741         dev = device->dev;
 742         lp = dev->priv;
 743         if (lp->fd > 0)
 744                 return -EBUSY;
 745         unregister_netdev(dev);
 746         platform_device_unregister(&device->pdev);
 747
 748         return 0;
 749 }
 750
 751 static struct mc_device net_mc = {
 752         .list           = LIST_HEAD_INIT(net_mc.list),
 753         .name           = "eth",
 754         .config         = net_config,
 755         .get_config     = NULL,
 756         .id             = net_id,
 757         .remove         = net_remove,
 758 };
 759
 760 #ifdef CONFIG_INET
 761 static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
 762                               void *ptr)
 763 {
 764         struct in_ifaddr *ifa = ptr;
 765         struct net_device *dev = ifa->ifa_dev->dev;
 766         struct uml_net_private *lp;
 767         void (*proc)(unsigned char *, unsigned char *, void *);
 768         unsigned char addr_buf[4], netmask_buf[4];
 769
 770         if (dev->open != uml_net_open)
 771                 return NOTIFY_DONE;
 772
 773         lp = dev->priv;
 774
 775         proc = NULL;
 776         switch (event) {
 777         case NETDEV_UP:
 778                 proc = lp->add_address;
 779                 break;
 780         case NETDEV_DOWN:
 781                 proc = lp->delete_address;
 782                 break;
 783         }
 784         if (proc != NULL) {
 785                 memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf));
 786                 memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf));
 787                 (*proc)(addr_buf, netmask_buf, &lp->user);
 788         }
 789         return NOTIFY_DONE;
 790 }
 791
 792 /* uml_net_init shouldn't be called twice on two CPUs at the same time */
 793 struct notifier_block uml_inetaddr_notifier = {
 794         .notifier_call          = uml_inetaddr_event,
 795 };
 796
 797 static void inet_register(void)
 798 {
 799         struct list_head *ele;
 800         struct uml_net_private *lp;
 801         struct in_device *ip;
 802         struct in_ifaddr *in;
 803
 804         register_inetaddr_notifier(&uml_inetaddr_notifier);
 805
 806         /* Devices may have been opened already, so the uml_inetaddr_notifier
 807          * didn't get a chance to run for them.  This fakes it so that
 808          * addresses which have already been set up get handled properly.
 809          */
 810         spin_lock(&opened_lock);
 811         list_for_each(ele, &opened) {
 812                 lp = list_entry(ele, struct uml_net_private, list);
 813                 ip = lp->dev->ip_ptr;
 814                 if (ip == NULL)
 815                         continue;
 816                 in = ip->ifa_list;
 817                 while (in != NULL) {
 818                         uml_inetaddr_event(NULL, NETDEV_UP, in);
 819                         in = in->ifa_next;
 820                 }
 821         }
 822         spin_unlock(&opened_lock);
 823 }
 824 #else
 825 static inline void inet_register(void)
 826 {
 827 }
 828 #endif
 829
 830 static int uml_net_init(void)
 831 {
 832         mconsole_register_dev(&net_mc);
 833         inet_register();
 834         return 0;
 835 }
 836
 837 __initcall(uml_net_init);
 838
 839 static void close_devices(void)
 840 {
 841         struct list_head *ele;
 842         struct uml_net_private *lp;
 843
 844         spin_lock(&opened_lock);
 845         list_for_each(ele, &opened) {
 846                 lp = list_entry(ele, struct uml_net_private, list);
 847                 free_irq(lp->dev->irq, lp->dev);
 848                 if ((lp->close != NULL) && (lp->fd >= 0))
 849                         (*lp->close)(lp->fd, &lp->user);
 850                 if (lp->remove != NULL)
 851                         (*lp->remove)(&lp->user);
 852         }
 853         spin_unlock(&opened_lock);
 854 }
 855
 856 __uml_exitcall(close_devices);
 857
 858 void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *,
 859                                         void *),
 860                     void *arg)
 861 {
 862         struct net_device *dev = d;
 863         struct in_device *ip = dev->ip_ptr;
 864         struct in_ifaddr *in;
 865         unsigned char address[4], netmask[4];
 866
 867         if (ip == NULL) return;
 868         in = ip->ifa_list;
 869         while (in != NULL) {
 870                 memcpy(address, &in->ifa_address, sizeof(address));
 871                 memcpy(netmask, &in->ifa_mask, sizeof(netmask));
 872                 (*cb)(address, netmask, arg);
 873                 in = in->ifa_next;
 874         }
 875 }
 876
 877 int dev_netmask(void *d, void *m)
 878 {
 879         struct net_device *dev = d;
 880         struct in_device *ip = dev->ip_ptr;
 881         struct in_ifaddr *in;
 882         __be32 *mask_out = m;
 883
 884         if (ip == NULL)
 885                 return 1;
 886
 887         in = ip->ifa_list;
 888         if (in == NULL)
 889                 return 1;
 890
 891         *mask_out = in->ifa_mask;
 892         return 0;
 893 }
 894
 895 void *get_output_buffer(int *len_out)
 896 {
 897         void *ret;
 898
 899         ret = (void *) __get_free_pages(GFP_KERNEL, 0);
 900         if (ret) *len_out = PAGE_SIZE;
 901         else *len_out = 0;
 902         return ret;
 903 }
 904
 905 void free_output_buffer(void *buffer)
 906 {
 907         free_pages((unsigned long) buffer, 0);
 908 }
 909
 910 int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out,
 911                      char **gate_addr)
 912 {
 913         char *remain;
 914
 915         remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
 916         if (remain != NULL) {
 917                 printk(KERN_ERR "tap_setup_common - Extra garbage on "
 918                        "specification : '%s'\n", remain);
 919                 return 1;
 920         }
 921
 922         return 0;
 923 }
 924
 925 unsigned short eth_protocol(struct sk_buff *skb)
 926 {
 927         return eth_type_trans(skb, skb->dev);
 928 }