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 static 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 return; 260 } 261 262 static void uml_net_tx_timeout(struct net_device *dev) 263 { 264 dev->trans_start = jiffies; 265 netif_wake_queue(dev); 266 } 267 268 static int uml_net_set_mac(struct net_device *dev, void *addr) 269 { 270 struct uml_net_private *lp = dev->priv; 271 struct sockaddr *hwaddr = addr; 272 273 spin_lock_irq(&lp->lock); 274 set_ether_mac(dev, hwaddr->sa_data); 275 spin_unlock_irq(&lp->lock); 276 277 return 0; 278 } 279 280 static int uml_net_change_mtu(struct net_device *dev, int new_mtu) 281 { 282 dev->mtu = new_mtu; 283 284 return 0; 285 } 286 287 static void uml_net_get_drvinfo(struct net_device *dev, 288 struct ethtool_drvinfo *info) 289 { 290 strcpy(info->driver, DRIVER_NAME); 291 strcpy(info->version, "42"); 292 } 293 294 static struct ethtool_ops uml_net_ethtool_ops = { 295 .get_drvinfo = uml_net_get_drvinfo, 296 .get_link = ethtool_op_get_link, 297 }; 298 299 static void uml_net_user_timer_expire(unsigned long _conn) 300 { 301 #ifdef undef 302 struct connection *conn = (struct connection *)_conn; 303 304 dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn); 305 do_connect(conn); 306 #endif 307 } 308 309 static void setup_etheraddr(char *str, unsigned char *addr, char *name) 310 { 311 char *end; 312 int i; 313 314 if (str == NULL) 315 goto random; 316 317 for (i = 0; i < 6; i++) { 318 addr[i] = simple_strtoul(str, &end, 16); 319 if ((end == str) || 320 ((*end != ':') && (*end != ',') && (*end != '\0'))) { 321 printk(KERN_ERR 322 "setup_etheraddr: failed to parse '%s' " 323 "as an ethernet address\n", str); 324 goto random; 325 } 326 str = end + 1; 327 } 328 if (is_multicast_ether_addr(addr)) { 329 printk(KERN_ERR 330 "Attempt to assign a multicast ethernet address to a " 331 "device disallowed\n"); 332 goto random; 333 } 334 if (!is_valid_ether_addr(addr)) { 335 printk(KERN_ERR 336 "Attempt to assign an invalid ethernet address to a " 337 "device disallowed\n"); 338 goto random; 339 } 340 if (!is_local_ether_addr(addr)) { 341 printk(KERN_WARNING 342 "Warning: Assigning a globally valid ethernet " 343 "address to a device\n"); 344 printk(KERN_WARNING "You should set the 2nd rightmost bit in " 345 "the first byte of the MAC,\n"); 346 printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n", 347 addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4], 348 addr[5]); 349 } 350 return; 351 352 random: 353 printk(KERN_INFO 354 "Choosing a random ethernet address for device %s\n", name); 355 random_ether_addr(addr); 356 } 357 358 static DEFINE_SPINLOCK(devices_lock); 359 static LIST_HEAD(devices); 360 361 static struct platform_driver uml_net_driver = { 362 .driver = { 363 .name = DRIVER_NAME, 364 }, 365 }; 366 367 static void net_device_release(struct device *dev) 368 { 369 struct uml_net *device = dev->driver_data; 370 struct net_device *netdev = device->dev; 371 struct uml_net_private *lp = netdev->priv; 372 373 if (lp->remove != NULL) 374 (*lp->remove)(&lp->user); 375 list_del(&device->list); 376 kfree(device); 377 free_netdev(netdev); 378 } 379 380 /* 381 * Ensures that platform_driver_register is called only once by 382 * eth_configure. Will be set in an initcall. 383 */ 384 static int driver_registered; 385 386 static void eth_configure(int n, void *init, char *mac, 387 struct transport *transport) 388 { 389 struct uml_net *device; 390 struct net_device *dev; 391 struct uml_net_private *lp; 392 int err, size; 393 394 size = transport->private_size + sizeof(struct uml_net_private); 395 396 device = kzalloc(sizeof(*device), GFP_KERNEL); 397 if (device == NULL) { 398 printk(KERN_ERR "eth_configure failed to allocate struct " 399 "uml_net\n"); 400 return; 401 } 402 403 dev = alloc_etherdev(size); 404 if (dev == NULL) { 405 printk(KERN_ERR "eth_configure: failed to allocate struct " 406 "net_device for eth%d\n", n); 407 goto out_free_device; 408 } 409 410 INIT_LIST_HEAD(&device->list); 411 device->index = n; 412 413 /* If this name ends up conflicting with an existing registered 414 * netdevice, that is OK, register_netdev{,ice}() will notice this 415 * and fail. 416 */ 417 snprintf(dev->name, sizeof(dev->name), "eth%d", n); 418 419 setup_etheraddr(mac, device->mac, dev->name); 420 421 printk(KERN_INFO "Netdevice %d ", n); 422 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ", 423 device->mac[0], device->mac[1], 424 device->mac[2], device->mac[3], 425 device->mac[4], device->mac[5]); 426 printk(": "); 427 428 lp = dev->priv; 429 /* This points to the transport private data. It's still clear, but we 430 * must memset it to 0 *now*. Let's help the drivers. */ 431 memset(lp, 0, size); 432 INIT_WORK(&lp->work, uml_dev_close); 433 434 /* sysfs register */ 435 if (!driver_registered) { 436 platform_driver_register(¨_net_driver); 437 driver_registered = 1; 438 } 439 device->pdev.id = n; 440 device->pdev.name = DRIVER_NAME; 441 device->pdev.dev.release = net_device_release; 442 device->pdev.dev.driver_data = device; 443 if (platform_device_register(&device->pdev)) 444 goto out_free_netdev; 445 SET_NETDEV_DEV(dev,&device->pdev.dev); 446 447 device->dev = dev; 448 449 /* 450 * These just fill in a data structure, so there's no failure 451 * to be worried about. 452 */ 453 (*transport->kern->init)(dev, init); 454 455 *lp = ((struct uml_net_private) 456 { .list = LIST_HEAD_INIT(lp->list), 457 .dev = dev, 458 .fd = -1, 459 .mac = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0}, 460 .max_packet = transport->user->max_packet, 461 .protocol = transport->kern->protocol, 462 .open = transport->user->open, 463 .close = transport->user->close, 464 .remove = transport->user->remove, 465 .read = transport->kern->read, 466 .write = transport->kern->write, 467 .add_address = transport->user->add_address, 468 .delete_address = transport->user->delete_address }); 469 470 init_timer(&lp->tl); 471 spin_lock_init(&lp->lock); 472 lp->tl.function = uml_net_user_timer_expire; 473 memcpy(lp->mac, device->mac, sizeof(lp->mac)); 474 475 if ((transport->user->init != NULL) && 476 ((*transport->user->init)(&lp->user, dev) != 0)) 477 goto out_unregister; 478 479 set_ether_mac(dev, device->mac); 480 dev->mtu = transport->user->mtu; 481 dev->open = uml_net_open; 482 dev->hard_start_xmit = uml_net_start_xmit; 483 dev->stop = uml_net_close; 484 dev->get_stats = uml_net_get_stats; 485 dev->set_multicast_list = uml_net_set_multicast_list; 486 dev->tx_timeout = uml_net_tx_timeout; 487 dev->set_mac_address = uml_net_set_mac; 488 dev->change_mtu = uml_net_change_mtu; 489 dev->ethtool_ops = ¨_net_ethtool_ops; 490 dev->watchdog_timeo = (HZ >> 1); 491 dev->irq = UM_ETH_IRQ; 492 493 err = update_drop_skb(lp->max_packet); 494 if (err) 495 goto out_undo_user_init; 496 497 rtnl_lock(); 498 err = register_netdevice(dev); 499 rtnl_unlock(); 500 if (err) 501 goto out_undo_user_init; 502 503 spin_lock(&devices_lock); 504 list_add(&device->list, &devices); 505 spin_unlock(&devices_lock); 506 507 return; 508 509 out_undo_user_init: 510 if (transport->user->remove != NULL) 511 (*transport->user->remove)(&lp->user); 512 out_unregister: 513 platform_device_unregister(&device->pdev); 514 return; /* platform_device_unregister frees dev and device */ 515 out_free_netdev: 516 free_netdev(dev); 517 out_free_device: 518 kfree(device); 519 } 520 521 static struct uml_net *find_device(int n) 522 { 523 struct uml_net *device; 524 struct list_head *ele; 525 526 spin_lock(&devices_lock); 527 list_for_each(ele, &devices) { 528 device = list_entry(ele, struct uml_net, list); 529 if (device->index == n) 530 goto out; 531 } 532 device = NULL; 533 out: 534 spin_unlock(&devices_lock); 535 return device; 536 } 537 538 static int eth_parse(char *str, int *index_out, char **str_out, 539 char **error_out) 540 { 541 char *end; 542 int n, err = -EINVAL;; 543 544 n = simple_strtoul(str, &end, 0); 545 if (end == str) { 546 *error_out = "Bad device number"; 547 return err; 548 } 549 550 str = end; 551 if (*str != '=') { 552 *error_out = "Expected '=' after device number"; 553 return err; 554 } 555 556 str++; 557 if (find_device(n)) { 558 *error_out = "Device already configured"; 559 return err; 560 } 561 562 *index_out = n; 563 *str_out = str; 564 return 0; 565 } 566 567 struct eth_init { 568 struct list_head list; 569 char *init; 570 int index; 571 }; 572 573 static DEFINE_SPINLOCK(transports_lock); 574 static LIST_HEAD(transports); 575 576 /* Filled in during early boot */ 577 static LIST_HEAD(eth_cmd_line); 578 579 static int check_transport(struct transport *transport, char *eth, int n, 580 void **init_out, char **mac_out) 581 { 582 int len; 583 584 len = strlen(transport->name); 585 if (strncmp(eth, transport->name, len)) 586 return 0; 587 588 eth += len; 589 if (*eth == ',') 590 eth++; 591 else if (*eth != '\0') 592 return 0; 593 594 *init_out = kmalloc(transport->setup_size, GFP_KERNEL); 595 if (*init_out == NULL) 596 return 1; 597 598 if (!transport->setup(eth, mac_out, *init_out)) { 599 kfree(*init_out); 600 *init_out = NULL; 601 } 602 return 1; 603 } 604 605 void register_transport(struct transport *new) 606 { 607 struct list_head *ele, *next; 608 struct eth_init *eth; 609 void *init; 610 char *mac = NULL; 611 int match; 612 613 spin_lock(&transports_lock); 614 BUG_ON(!list_empty(&new->list)); 615 list_add(&new->list, &transports); 616 spin_unlock(&transports_lock); 617 618 list_for_each_safe(ele, next, ð_cmd_line) { 619 eth = list_entry(ele, struct eth_init, list); 620 match = check_transport(new, eth->init, eth->index, &init, 621 &mac); 622 if (!match) 623 continue; 624 else if (init != NULL) { 625 eth_configure(eth->index, init, mac, new); 626 kfree(init); 627 } 628 list_del(ð->list); 629 } 630 } 631 632 static int eth_setup_common(char *str, int index) 633 { 634 struct list_head *ele; 635 struct transport *transport; 636 void *init; 637 char *mac = NULL; 638 int found = 0; 639 640 spin_lock(&transports_lock); 641 list_for_each(ele, &transports) { 642 transport = list_entry(ele, struct transport, list); 643 if (!check_transport(transport, str, index, &init, &mac)) 644 continue; 645 if (init != NULL) { 646 eth_configure(index, init, mac, transport); 647 kfree(init); 648 } 649 found = 1; 650 break; 651 } 652 653 spin_unlock(&transports_lock); 654 return found; 655 } 656 657 static int __init eth_setup(char *str) 658 { 659 struct eth_init *new; 660 char *error; 661 int n, err; 662 663 err = eth_parse(str, &n, &str, &error); 664 if (err) { 665 printk(KERN_ERR "eth_setup - Couldn't parse '%s' : %s\n", 666 str, error); 667 return 1; 668 } 669 670 new = alloc_bootmem(sizeof(*new)); 671 if (new == NULL) { 672 printk(KERN_ERR "eth_init : alloc_bootmem failed\n"); 673 return 1; 674 } 675 676 INIT_LIST_HEAD(&new->list); 677 new->index = n; 678 new->init = str; 679 680 list_add_tail(&new->list, ð_cmd_line); 681 return 1; 682 } 683 684 __setup("eth", eth_setup); 685 __uml_help(eth_setup, 686 "eth[0-9]+=<transport>,<options>\n" 687 " Configure a network device.\n\n" 688 ); 689 690 static int net_config(char *str, char **error_out) 691 { 692 int n, err; 693 694 err = eth_parse(str, &n, &str, error_out); 695 if (err) 696 return err; 697 698 /* This string is broken up and the pieces used by the underlying 699 * driver. So, it is freed only if eth_setup_common fails. 700 */ 701 str = kstrdup(str, GFP_KERNEL); 702 if (str == NULL) { 703 *error_out = "net_config failed to strdup string"; 704 return -ENOMEM; 705 } 706 err = !eth_setup_common(str, n); 707 if (err) 708 kfree(str); 709 return err; 710 } 711 712 static int net_id(char **str, int *start_out, int *end_out) 713 { 714 char *end; 715 int n; 716 717 n = simple_strtoul(*str, &end, 0); 718 if ((*end != '\0') || (end == *str)) 719 return -1; 720 721 *start_out = n; 722 *end_out = n; 723 *str = end; 724 return n; 725 } 726 727 static int net_remove(int n, char **error_out) 728 { 729 struct uml_net *device; 730 struct net_device *dev; 731 struct uml_net_private *lp; 732 733 device = find_device(n); 734 if (device == NULL) 735 return -ENODEV; 736 737 dev = device->dev; 738 lp = dev->priv; 739 if (lp->fd > 0) 740 return -EBUSY; 741 unregister_netdev(dev); 742 platform_device_unregister(&device->pdev); 743 744 return 0; 745 } 746 747 static struct mc_device net_mc = { 748 .list = LIST_HEAD_INIT(net_mc.list), 749 .name = "eth", 750 .config = net_config, 751 .get_config = NULL, 752 .id = net_id, 753 .remove = net_remove, 754 }; 755 756 #ifdef CONFIG_INET 757 static int uml_inetaddr_event(struct notifier_block *this, unsigned long event, 758 void *ptr) 759 { 760 struct in_ifaddr *ifa = ptr; 761 struct net_device *dev = ifa->ifa_dev->dev; 762 struct uml_net_private *lp; 763 void (*proc)(unsigned char *, unsigned char *, void *); 764 unsigned char addr_buf[4], netmask_buf[4]; 765 766 if (dev->open != uml_net_open) 767 return NOTIFY_DONE; 768 769 lp = dev->priv; 770 771 proc = NULL; 772 switch (event) { 773 case NETDEV_UP: 774 proc = lp->add_address; 775 break; 776 case NETDEV_DOWN: 777 proc = lp->delete_address; 778 break; 779 } 780 if (proc != NULL) { 781 memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf)); 782 memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf)); 783 (*proc)(addr_buf, netmask_buf, &lp->user); 784 } 785 return NOTIFY_DONE; 786 } 787 788 /* uml_net_init shouldn't be called twice on two CPUs at the same time */ 789 static struct notifier_block uml_inetaddr_notifier = { 790 .notifier_call = uml_inetaddr_event, 791 }; 792 793 static void inet_register(void) 794 { 795 struct list_head *ele; 796 struct uml_net_private *lp; 797 struct in_device *ip; 798 struct in_ifaddr *in; 799 800 register_inetaddr_notifier(¨_inetaddr_notifier); 801 802 /* Devices may have been opened already, so the uml_inetaddr_notifier 803 * didn't get a chance to run for them. This fakes it so that 804 * addresses which have already been set up get handled properly. 805 */ 806 spin_lock(&opened_lock); 807 list_for_each(ele, &opened) { 808 lp = list_entry(ele, struct uml_net_private, list); 809 ip = lp->dev->ip_ptr; 810 if (ip == NULL) 811 continue; 812 in = ip->ifa_list; 813 while (in != NULL) { 814 uml_inetaddr_event(NULL, NETDEV_UP, in); 815 in = in->ifa_next; 816 } 817 } 818 spin_unlock(&opened_lock); 819 } 820 #else 821 static inline void inet_register(void) 822 { 823 } 824 #endif 825 826 static int uml_net_init(void) 827 { 828 mconsole_register_dev(&net_mc); 829 inet_register(); 830 return 0; 831 } 832 833 __initcall(uml_net_init); 834 835 static void close_devices(void) 836 { 837 struct list_head *ele; 838 struct uml_net_private *lp; 839 840 spin_lock(&opened_lock); 841 list_for_each(ele, &opened) { 842 lp = list_entry(ele, struct uml_net_private, list); 843 free_irq(lp->dev->irq, lp->dev); 844 if ((lp->close != NULL) && (lp->fd >= 0)) 845 (*lp->close)(lp->fd, &lp->user); 846 if (lp->remove != NULL) 847 (*lp->remove)(&lp->user); 848 } 849 spin_unlock(&opened_lock); 850 } 851 852 __uml_exitcall(close_devices); 853 854 void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *, 855 void *), 856 void *arg) 857 { 858 struct net_device *dev = d; 859 struct in_device *ip = dev->ip_ptr; 860 struct in_ifaddr *in; 861 unsigned char address[4], netmask[4]; 862 863 if (ip == NULL) return; 864 in = ip->ifa_list; 865 while (in != NULL) { 866 memcpy(address, &in->ifa_address, sizeof(address)); 867 memcpy(netmask, &in->ifa_mask, sizeof(netmask)); 868 (*cb)(address, netmask, arg); 869 in = in->ifa_next; 870 } 871 } 872 873 int dev_netmask(void *d, void *m) 874 { 875 struct net_device *dev = d; 876 struct in_device *ip = dev->ip_ptr; 877 struct in_ifaddr *in; 878 __be32 *mask_out = m; 879 880 if (ip == NULL) 881 return 1; 882 883 in = ip->ifa_list; 884 if (in == NULL) 885 return 1; 886 887 *mask_out = in->ifa_mask; 888 return 0; 889 } 890 891 void *get_output_buffer(int *len_out) 892 { 893 void *ret; 894 895 ret = (void *) __get_free_pages(GFP_KERNEL, 0); 896 if (ret) *len_out = PAGE_SIZE; 897 else *len_out = 0; 898 return ret; 899 } 900 901 void free_output_buffer(void *buffer) 902 { 903 free_pages((unsigned long) buffer, 0); 904 } 905 906 int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out, 907 char **gate_addr) 908 { 909 char *remain; 910 911 remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL); 912 if (remain != NULL) { 913 printk(KERN_ERR "tap_setup_common - Extra garbage on " 914 "specification : '%s'\n", remain); 915 return 1; 916 } 917 918 return 0; 919 } 920 921 unsigned short eth_protocol(struct sk_buff *skb) 922 { 923 return eth_type_trans(skb, skb->dev); 924 } 925