net/core/dev_addr_lists.c

   1 /*
   2  * net/core/dev_addr_lists.c - Functions for handling net device lists
   3  * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
   4  *
   5  * This file contains functions for working with unicast, multicast and device
   6  * addresses lists.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <linux/netdevice.h>
  15 #include <linux/rtnetlink.h>
  16 #include <linux/export.h>
  17 #include <linux/list.h>
  18 #include <linux/proc_fs.h>
  19
  20 /*
  21  * General list handling functions
  22  */
  23
  24 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
  25                             unsigned char *addr, int addr_len,
  26                             unsigned char addr_type, bool global)
  27 {
  28         struct netdev_hw_addr *ha;
  29         int alloc_size;
  30
  31         if (addr_len > MAX_ADDR_LEN)
  32                 return -EINVAL;
  33
  34         list_for_each_entry(ha, &list->list, list) {
  35                 if (!memcmp(ha->addr, addr, addr_len) &&
  36                     ha->type == addr_type) {
  37                         if (global) {
  38                                 /* check if addr is already used as global */
  39                                 if (ha->global_use)
  40                                         return 0;
  41                                 else
  42                                         ha->global_use = true;
  43                         }
  44                         ha->refcount++;
  45                         return 0;
  46                 }
  47         }
  48
  49
  50         alloc_size = sizeof(*ha);
  51         if (alloc_size < L1_CACHE_BYTES)
  52                 alloc_size = L1_CACHE_BYTES;
  53         ha = kmalloc(alloc_size, GFP_ATOMIC);
  54         if (!ha)
  55                 return -ENOMEM;
  56         memcpy(ha->addr, addr, addr_len);
  57         ha->type = addr_type;
  58         ha->refcount = 1;
  59         ha->global_use = global;
  60         ha->synced = 0;
  61         list_add_tail_rcu(&ha->list, &list->list);
  62         list->count++;
  63         return 0;
  64 }
  65
  66 static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
  67                          int addr_len, unsigned char addr_type)
  68 {
  69         return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
  70 }
  71
  72 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
  73                             unsigned char *addr, int addr_len,
  74                             unsigned char addr_type, bool global)
  75 {
  76         struct netdev_hw_addr *ha;
  77
  78         list_for_each_entry(ha, &list->list, list) {
  79                 if (!memcmp(ha->addr, addr, addr_len) &&
  80                     (ha->type == addr_type || !addr_type)) {
  81                         if (global) {
  82                                 if (!ha->global_use)
  83                                         break;
  84                                 else
  85                                         ha->global_use = false;
  86                         }
  87                         if (--ha->refcount)
  88                                 return 0;
  89                         list_del_rcu(&ha->list);
  90                         kfree_rcu(ha, rcu_head);
  91                         list->count--;
  92                         return 0;
  93                 }
  94         }
  95         return -ENOENT;
  96 }
  97
  98 static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
  99                          int addr_len, unsigned char addr_type)
 100 {
 101         return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
 102 }
 103
 104 int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
 105                            struct netdev_hw_addr_list *from_list,
 106                            int addr_len, unsigned char addr_type)
 107 {
 108         int err;
 109         struct netdev_hw_addr *ha, *ha2;
 110         unsigned char type;
 111
 112         list_for_each_entry(ha, &from_list->list, list) {
 113                 type = addr_type ? addr_type : ha->type;
 114                 err = __hw_addr_add(to_list, ha->addr, addr_len, type);
 115                 if (err)
 116                         goto unroll;
 117         }
 118         return 0;
 119
 120 unroll:
 121         list_for_each_entry(ha2, &from_list->list, list) {
 122                 if (ha2 == ha)
 123                         break;
 124                 type = addr_type ? addr_type : ha2->type;
 125                 __hw_addr_del(to_list, ha2->addr, addr_len, type);
 126         }
 127         return err;
 128 }
 129 EXPORT_SYMBOL(__hw_addr_add_multiple);
 130
 131 void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
 132                             struct netdev_hw_addr_list *from_list,
 133                             int addr_len, unsigned char addr_type)
 134 {
 135         struct netdev_hw_addr *ha;
 136         unsigned char type;
 137
 138         list_for_each_entry(ha, &from_list->list, list) {
 139                 type = addr_type ? addr_type : ha->type;
 140                 __hw_addr_del(to_list, ha->addr, addr_len, type);
 141         }
 142 }
 143 EXPORT_SYMBOL(__hw_addr_del_multiple);
 144
 145 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
 146                    struct netdev_hw_addr_list *from_list,
 147                    int addr_len)
 148 {
 149         int err = 0;
 150         struct netdev_hw_addr *ha, *tmp;
 151
 152         list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
 153                 if (!ha->synced) {
 154                         err = __hw_addr_add(to_list, ha->addr,
 155                                             addr_len, ha->type);
 156                         if (err)
 157                                 break;
 158                         ha->synced++;
 159                         ha->refcount++;
 160                 } else if (ha->refcount == 1) {
 161                         __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
 162                         __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
 163                 }
 164         }
 165         return err;
 166 }
 167 EXPORT_SYMBOL(__hw_addr_sync);
 168
 169 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
 170                       struct netdev_hw_addr_list *from_list,
 171                       int addr_len)
 172 {
 173         struct netdev_hw_addr *ha, *tmp;
 174
 175         list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
 176                 if (ha->synced) {
 177                         __hw_addr_del(to_list, ha->addr,
 178                                       addr_len, ha->type);
 179                         ha->synced--;
 180                         __hw_addr_del(from_list, ha->addr,
 181                                       addr_len, ha->type);
 182                 }
 183         }
 184 }
 185 EXPORT_SYMBOL(__hw_addr_unsync);
 186
 187 void __hw_addr_flush(struct netdev_hw_addr_list *list)
 188 {
 189         struct netdev_hw_addr *ha, *tmp;
 190
 191         list_for_each_entry_safe(ha, tmp, &list->list, list) {
 192                 list_del_rcu(&ha->list);
 193                 kfree_rcu(ha, rcu_head);
 194         }
 195         list->count = 0;
 196 }
 197 EXPORT_SYMBOL(__hw_addr_flush);
 198
 199 void __hw_addr_init(struct netdev_hw_addr_list *list)
 200 {
 201         INIT_LIST_HEAD(&list->list);
 202         list->count = 0;
 203 }
 204 EXPORT_SYMBOL(__hw_addr_init);
 205
 206 /*
 207  * Device addresses handling functions
 208  */
 209
 210 /**
 211  *      dev_addr_flush - Flush device address list
 212  *      @dev: device
 213  *
 214  *      Flush device address list and reset ->dev_addr.
 215  *
 216  *      The caller must hold the rtnl_mutex.
 217  */
 218 void dev_addr_flush(struct net_device *dev)
 219 {
 220         /* rtnl_mutex must be held here */
 221
 222         __hw_addr_flush(&dev->dev_addrs);
 223         dev->dev_addr = NULL;
 224 }
 225 EXPORT_SYMBOL(dev_addr_flush);
 226
 227 /**
 228  *      dev_addr_init - Init device address list
 229  *      @dev: device
 230  *
 231  *      Init device address list and create the first element,
 232  *      used by ->dev_addr.
 233  *
 234  *      The caller must hold the rtnl_mutex.
 235  */
 236 int dev_addr_init(struct net_device *dev)
 237 {
 238         unsigned char addr[MAX_ADDR_LEN];
 239         struct netdev_hw_addr *ha;
 240         int err;
 241
 242         /* rtnl_mutex must be held here */
 243
 244         __hw_addr_init(&dev->dev_addrs);
 245         memset(addr, 0, sizeof(addr));
 246         err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
 247                             NETDEV_HW_ADDR_T_LAN);
 248         if (!err) {
 249                 /*
 250                  * Get the first (previously created) address from the list
 251                  * and set dev_addr pointer to this location.
 252                  */
 253                 ha = list_first_entry(&dev->dev_addrs.list,
 254                                       struct netdev_hw_addr, list);
 255                 dev->dev_addr = ha->addr;
 256         }
 257         return err;
 258 }
 259 EXPORT_SYMBOL(dev_addr_init);
 260
 261 /**
 262  *      dev_addr_add - Add a device address
 263  *      @dev: device
 264  *      @addr: address to add
 265  *      @addr_type: address type
 266  *
 267  *      Add a device address to the device or increase the reference count if
 268  *      it already exists.
 269  *
 270  *      The caller must hold the rtnl_mutex.
 271  */
 272 int dev_addr_add(struct net_device *dev, unsigned char *addr,
 273                  unsigned char addr_type)
 274 {
 275         int err;
 276
 277         ASSERT_RTNL();
 278
 279         err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
 280         if (!err)
 281                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
 282         return err;
 283 }
 284 EXPORT_SYMBOL(dev_addr_add);
 285
 286 /**
 287  *      dev_addr_del - Release a device address.
 288  *      @dev: device
 289  *      @addr: address to delete
 290  *      @addr_type: address type
 291  *
 292  *      Release reference to a device address and remove it from the device
 293  *      if the reference count drops to zero.
 294  *
 295  *      The caller must hold the rtnl_mutex.
 296  */
 297 int dev_addr_del(struct net_device *dev, unsigned char *addr,
 298                  unsigned char addr_type)
 299 {
 300         int err;
 301         struct netdev_hw_addr *ha;
 302
 303         ASSERT_RTNL();
 304
 305         /*
 306          * We can not remove the first address from the list because
 307          * dev->dev_addr points to that.
 308          */
 309         ha = list_first_entry(&dev->dev_addrs.list,
 310                               struct netdev_hw_addr, list);
 311         if (!memcmp(ha->addr, addr, dev->addr_len) &&
 312             ha->type == addr_type && ha->refcount == 1)
 313                 return -ENOENT;
 314
 315         err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
 316                             addr_type);
 317         if (!err)
 318                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
 319         return err;
 320 }
 321 EXPORT_SYMBOL(dev_addr_del);
 322
 323 /**
 324  *      dev_addr_add_multiple - Add device addresses from another device
 325  *      @to_dev: device to which addresses will be added
 326  *      @from_dev: device from which addresses will be added
 327  *      @addr_type: address type - 0 means type will be used from from_dev
 328  *
 329  *      Add device addresses of the one device to another.
 330  **
 331  *      The caller must hold the rtnl_mutex.
 332  */
 333 int dev_addr_add_multiple(struct net_device *to_dev,
 334                           struct net_device *from_dev,
 335                           unsigned char addr_type)
 336 {
 337         int err;
 338
 339         ASSERT_RTNL();
 340
 341         if (from_dev->addr_len != to_dev->addr_len)
 342                 return -EINVAL;
 343         err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
 344                                      to_dev->addr_len, addr_type);
 345         if (!err)
 346                 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
 347         return err;
 348 }
 349 EXPORT_SYMBOL(dev_addr_add_multiple);
 350
 351 /**
 352  *      dev_addr_del_multiple - Delete device addresses by another device
 353  *      @to_dev: device where the addresses will be deleted
 354  *      @from_dev: device supplying the addresses to be deleted
 355  *      @addr_type: address type - 0 means type will be used from from_dev
 356  *
 357  *      Deletes addresses in to device by the list of addresses in from device.
 358  *
 359  *      The caller must hold the rtnl_mutex.
 360  */
 361 int dev_addr_del_multiple(struct net_device *to_dev,
 362                           struct net_device *from_dev,
 363                           unsigned char addr_type)
 364 {
 365         ASSERT_RTNL();
 366
 367         if (from_dev->addr_len != to_dev->addr_len)
 368                 return -EINVAL;
 369         __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
 370                                to_dev->addr_len, addr_type);
 371         call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
 372         return 0;
 373 }
 374 EXPORT_SYMBOL(dev_addr_del_multiple);
 375
 376 /*
 377  * Unicast list handling functions
 378  */
 379
 380 /**
 381  *      dev_uc_add - Add a secondary unicast address
 382  *      @dev: device
 383  *      @addr: address to add
 384  *
 385  *      Add a secondary unicast address to the device or increase
 386  *      the reference count if it already exists.
 387  */
 388 int dev_uc_add(struct net_device *dev, unsigned char *addr)
 389 {
 390         int err;
 391
 392         netif_addr_lock_bh(dev);
 393         err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
 394                             NETDEV_HW_ADDR_T_UNICAST);
 395         if (!err)
 396                 __dev_set_rx_mode(dev);
 397         netif_addr_unlock_bh(dev);
 398         return err;
 399 }
 400 EXPORT_SYMBOL(dev_uc_add);
 401
 402 /**
 403  *      dev_uc_del - Release secondary unicast address.
 404  *      @dev: device
 405  *      @addr: address to delete
 406  *
 407  *      Release reference to a secondary unicast address and remove it
 408  *      from the device if the reference count drops to zero.
 409  */
 410 int dev_uc_del(struct net_device *dev, unsigned char *addr)
 411 {
 412         int err;
 413
 414         netif_addr_lock_bh(dev);
 415         err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
 416                             NETDEV_HW_ADDR_T_UNICAST);
 417         if (!err)
 418                 __dev_set_rx_mode(dev);
 419         netif_addr_unlock_bh(dev);
 420         return err;
 421 }
 422 EXPORT_SYMBOL(dev_uc_del);
 423
 424 /**
 425  *      dev_uc_sync - Synchronize device's unicast list to another device
 426  *      @to: destination device
 427  *      @from: source device
 428  *
 429  *      Add newly added addresses to the destination device and release
 430  *      addresses that have no users left. The source device must be
 431  *      locked by netif_tx_lock_bh.
 432  *
 433  *      This function is intended to be called from the dev->set_rx_mode
 434  *      function of layered software devices.
 435  */
 436 int dev_uc_sync(struct net_device *to, struct net_device *from)
 437 {
 438         int err = 0;
 439
 440         if (to->addr_len != from->addr_len)
 441                 return -EINVAL;
 442
 443         netif_addr_lock_bh(to);
 444         err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
 445         if (!err)
 446                 __dev_set_rx_mode(to);
 447         netif_addr_unlock_bh(to);
 448         return err;
 449 }
 450 EXPORT_SYMBOL(dev_uc_sync);
 451
 452 /**
 453  *      dev_uc_unsync - Remove synchronized addresses from the destination device
 454  *      @to: destination device
 455  *      @from: source device
 456  *
 457  *      Remove all addresses that were added to the destination device by
 458  *      dev_uc_sync(). This function is intended to be called from the
 459  *      dev->stop function of layered software devices.
 460  */
 461 void dev_uc_unsync(struct net_device *to, struct net_device *from)
 462 {
 463         if (to->addr_len != from->addr_len)
 464                 return;
 465
 466         netif_addr_lock_bh(from);
 467         netif_addr_lock(to);
 468         __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
 469         __dev_set_rx_mode(to);
 470         netif_addr_unlock(to);
 471         netif_addr_unlock_bh(from);
 472 }
 473 EXPORT_SYMBOL(dev_uc_unsync);
 474
 475 /**
 476  *      dev_uc_flush - Flush unicast addresses
 477  *      @dev: device
 478  *
 479  *      Flush unicast addresses.
 480  */
 481 void dev_uc_flush(struct net_device *dev)
 482 {
 483         netif_addr_lock_bh(dev);
 484         __hw_addr_flush(&dev->uc);
 485         netif_addr_unlock_bh(dev);
 486 }
 487 EXPORT_SYMBOL(dev_uc_flush);
 488
 489 /**
 490  *      dev_uc_flush - Init unicast address list
 491  *      @dev: device
 492  *
 493  *      Init unicast address list.
 494  */
 495 void dev_uc_init(struct net_device *dev)
 496 {
 497         __hw_addr_init(&dev->uc);
 498 }
 499 EXPORT_SYMBOL(dev_uc_init);
 500
 501 /*
 502  * Multicast list handling functions
 503  */
 504
 505 static int __dev_mc_add(struct net_device *dev, unsigned char *addr,
 506                         bool global)
 507 {
 508         int err;
 509
 510         netif_addr_lock_bh(dev);
 511         err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
 512                                NETDEV_HW_ADDR_T_MULTICAST, global);
 513         if (!err)
 514                 __dev_set_rx_mode(dev);
 515         netif_addr_unlock_bh(dev);
 516         return err;
 517 }
 518 /**
 519  *      dev_mc_add - Add a multicast address
 520  *      @dev: device
 521  *      @addr: address to add
 522  *
 523  *      Add a multicast address to the device or increase
 524  *      the reference count if it already exists.
 525  */
 526 int dev_mc_add(struct net_device *dev, unsigned char *addr)
 527 {
 528         return __dev_mc_add(dev, addr, false);
 529 }
 530 EXPORT_SYMBOL(dev_mc_add);
 531
 532 /**
 533  *      dev_mc_add_global - Add a global multicast address
 534  *      @dev: device
 535  *      @addr: address to add
 536  *
 537  *      Add a global multicast address to the device.
 538  */
 539 int dev_mc_add_global(struct net_device *dev, unsigned char *addr)
 540 {
 541         return __dev_mc_add(dev, addr, true);
 542 }
 543 EXPORT_SYMBOL(dev_mc_add_global);
 544
 545 static int __dev_mc_del(struct net_device *dev, unsigned char *addr,
 546                         bool global)
 547 {
 548         int err;
 549
 550         netif_addr_lock_bh(dev);
 551         err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
 552                                NETDEV_HW_ADDR_T_MULTICAST, global);
 553         if (!err)
 554                 __dev_set_rx_mode(dev);
 555         netif_addr_unlock_bh(dev);
 556         return err;
 557 }
 558
 559 /**
 560  *      dev_mc_del - Delete a multicast address.
 561  *      @dev: device
 562  *      @addr: address to delete
 563  *
 564  *      Release reference to a multicast address and remove it
 565  *      from the device if the reference count drops to zero.
 566  */
 567 int dev_mc_del(struct net_device *dev, unsigned char *addr)
 568 {
 569         return __dev_mc_del(dev, addr, false);
 570 }
 571 EXPORT_SYMBOL(dev_mc_del);
 572
 573 /**
 574  *      dev_mc_del_global - Delete a global multicast address.
 575  *      @dev: device
 576  *      @addr: address to delete
 577  *
 578  *      Release reference to a multicast address and remove it
 579  *      from the device if the reference count drops to zero.
 580  */
 581 int dev_mc_del_global(struct net_device *dev, unsigned char *addr)
 582 {
 583         return __dev_mc_del(dev, addr, true);
 584 }
 585 EXPORT_SYMBOL(dev_mc_del_global);
 586
 587 /**
 588  *      dev_mc_sync - Synchronize device's unicast list to another device
 589  *      @to: destination device
 590  *      @from: source device
 591  *
 592  *      Add newly added addresses to the destination device and release
 593  *      addresses that have no users left. The source device must be
 594  *      locked by netif_tx_lock_bh.
 595  *
 596  *      This function is intended to be called from the ndo_set_rx_mode
 597  *      function of layered software devices.
 598  */
 599 int dev_mc_sync(struct net_device *to, struct net_device *from)
 600 {
 601         int err = 0;
 602
 603         if (to->addr_len != from->addr_len)
 604                 return -EINVAL;
 605
 606         netif_addr_lock_bh(to);
 607         err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
 608         if (!err)
 609                 __dev_set_rx_mode(to);
 610         netif_addr_unlock_bh(to);
 611         return err;
 612 }
 613 EXPORT_SYMBOL(dev_mc_sync);
 614
 615 /**
 616  *      dev_mc_unsync - Remove synchronized addresses from the destination device
 617  *      @to: destination device
 618  *      @from: source device
 619  *
 620  *      Remove all addresses that were added to the destination device by
 621  *      dev_mc_sync(). This function is intended to be called from the
 622  *      dev->stop function of layered software devices.
 623  */
 624 void dev_mc_unsync(struct net_device *to, struct net_device *from)
 625 {
 626         if (to->addr_len != from->addr_len)
 627                 return;
 628
 629         netif_addr_lock_bh(from);
 630         netif_addr_lock(to);
 631         __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
 632         __dev_set_rx_mode(to);
 633         netif_addr_unlock(to);
 634         netif_addr_unlock_bh(from);
 635 }
 636 EXPORT_SYMBOL(dev_mc_unsync);
 637
 638 /**
 639  *      dev_mc_flush - Flush multicast addresses
 640  *      @dev: device
 641  *
 642  *      Flush multicast addresses.
 643  */
 644 void dev_mc_flush(struct net_device *dev)
 645 {
 646         netif_addr_lock_bh(dev);
 647         __hw_addr_flush(&dev->mc);
 648         netif_addr_unlock_bh(dev);
 649 }
 650 EXPORT_SYMBOL(dev_mc_flush);
 651
 652 /**
 653  *      dev_mc_flush - Init multicast address list
 654  *      @dev: device
 655  *
 656  *      Init multicast address list.
 657  */
 658 void dev_mc_init(struct net_device *dev)
 659 {
 660         __hw_addr_init(&dev->mc);
 661 }
 662 EXPORT_SYMBOL(dev_mc_init);
 663
 664 #ifdef CONFIG_PROC_FS
 665 #include <linux/seq_file.h>
 666
 667 static int dev_mc_seq_show(struct seq_file *seq, void *v)
 668 {
 669         struct netdev_hw_addr *ha;
 670         struct net_device *dev = v;
 671
 672         if (v == SEQ_START_TOKEN)
 673                 return 0;
 674
 675         netif_addr_lock_bh(dev);
 676         netdev_for_each_mc_addr(ha, dev) {
 677                 int i;
 678
 679                 seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
 680                            dev->name, ha->refcount, ha->global_use);
 681
 682                 for (i = 0; i < dev->addr_len; i++)
 683                         seq_printf(seq, "%02x", ha->addr[i]);
 684
 685                 seq_putc(seq, '\n');
 686         }
 687         netif_addr_unlock_bh(dev);
 688         return 0;
 689 }
 690
 691 static const struct seq_operations dev_mc_seq_ops = {
 692         .start = dev_seq_start,
 693         .next  = dev_seq_next,
 694         .stop  = dev_seq_stop,
 695         .show  = dev_mc_seq_show,
 696 };
 697
 698 static int dev_mc_seq_open(struct inode *inode, struct file *file)
 699 {
 700         return seq_open_net(inode, file, &dev_mc_seq_ops,
 701                             sizeof(struct seq_net_private));
 702 }
 703
 704 static const struct file_operations dev_mc_seq_fops = {
 705         .owner   = THIS_MODULE,
 706         .open    = dev_mc_seq_open,
 707         .read    = seq_read,
 708         .llseek  = seq_lseek,
 709         .release = seq_release_net,
 710 };
 711
 712 #endif
 713
 714 static int __net_init dev_mc_net_init(struct net *net)
 715 {
 716         if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
 717                 return -ENOMEM;
 718         return 0;
 719 }
 720
 721 static void __net_exit dev_mc_net_exit(struct net *net)
 722 {
 723         proc_net_remove(net, "dev_mcast");
 724 }
 725
 726 static struct pernet_operations __net_initdata dev_mc_net_ops = {
 727         .init = dev_mc_net_init,
 728         .exit = dev_mc_net_exit,
 729 };
 730
 731 void __init dev_mcast_init(void)
 732 {
 733         register_pernet_subsys(&dev_mc_net_ops);
 734 }
 735