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