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