src/mpls_proto.c

   1 /*****************************************************************************
   2  * MPLS
   3  *      An implementation of the MPLS (MultiProtocol Label
   4  *      Switching) Architecture for Linux.
   5  *
   6  * mpls_proto.c: MPLS Proto management
   7  *
   8  * Copyright (C) David S. Miller (davem@redhat.com),
   9  *               James R. Leu (jleu@mindspring.com)
  10  *
  11  *      This program is free software; you can redistribute it and/or
  12  *      modify it under the terms of the GNU General Public License
  13  *      as published by the Free Software Foundation; either version
  14  *      2 of the License, or (at your option) any later version.
  15  *
  16  * Changes:
  17  *      RCAS: minor changes (formatting) and added addr
  18  *      JLEU: added mpls_prot_cache_flush_all()
  19  *      JLEU: rewrote most of the functions to allow for more
  20  *             families then just IPv4 and IPv6
  21  *****************************************************************************/
  22
  23 #include <linux/autoconf.h>
  24 #include <linux/types.h>
  25 #include <linux/kernel.h>
  26 #include <linux/sched.h>
  27 #include <linux/string.h>
  28 #include <linux/mm.h>
  29 #include <linux/errno.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/skbuff.h>
  32 #include <linux/rculist.h>
  33 #include <net/mpls.h>
  34
  35 DEFINE_SPINLOCK(mpls_proto_lock);
  36 LIST_HEAD(mpls_proto_list);
  37
  38 int mpls_proto_add(struct mpls_prot_driver *proto)
  39 {
  40         spin_lock_bh(&mpls_proto_lock);
  41
  42         atomic_set(&proto->__refcnt, 1);
  43         list_add_rcu(&proto->list, &mpls_proto_list);
  44
  45         spin_unlock_bh(&mpls_proto_lock);
  46         return 0;
  47 }
  48
  49 int mpls_proto_remove(struct mpls_prot_driver *proto)
  50 {
  51         struct mpls_prot_driver *proto1;
  52         int retval = -EPROTONOSUPPORT;
  53
  54         spin_lock_bh(&mpls_proto_lock);
  55
  56         list_for_each_entry(proto1, &mpls_proto_list, list) {
  57                 if (proto == proto1) {
  58                         if (atomic_read(&proto->__refcnt) != 1) {
  59                                 retval = -EADDRINUSE;
  60                         } else {
  61                                 list_del_rcu(&proto->list);
  62                                 retval = 0;
  63                         }
  64                         break;
  65                 }
  66         }
  67         spin_unlock_bh(&mpls_proto_lock);
  68
  69         synchronize_net();
  70         return retval;
  71 }
  72
  73 struct mpls_prot_driver *mpls_proto_find_by_family(unsigned short fam)
  74 {
  75         struct mpls_prot_driver *proto;
  76
  77         rcu_read_lock();
  78         list_for_each_entry_rcu(proto, &mpls_proto_list, list) {
  79                 if (fam == proto->family) {
  80                         mpls_proto_hold(proto);
  81                         goto out;
  82                 }
  83         }
  84         proto = NULL;
  85 out:
  86         rcu_read_unlock();
  87
  88         return proto;
  89 }
  90
  91 struct mpls_prot_driver *mpls_proto_find_by_ethertype(unsigned short type)
  92 {
  93         struct mpls_prot_driver *proto;
  94
  95         rcu_read_lock();
  96         list_for_each_entry_rcu(proto, &mpls_proto_list, list) {
  97                 if (type == proto->ethertype) {
  98                         mpls_proto_hold(proto);
  99                         goto out;
 100                 }
 101         }
 102         proto = NULL;
 103 out:
 104         rcu_read_unlock();
 105
 106         return proto;
 107 }
 108
 109 struct mpls_prot_driver *mpls_proto_find_by_name(char *name)
 110 {
 111         struct mpls_prot_driver *proto;
 112
 113         rcu_read_lock();
 114         list_for_each_entry_rcu(proto, &mpls_proto_list, list) {
 115                 if (!strncmp(name, proto->name, MPLSPROTONAMSIZ)) {
 116                         mpls_proto_hold(proto);
 117                         goto out;
 118                 }
 119         }
 120         proto = NULL;
 121 out:
 122         rcu_read_unlock();
 123
 124         return proto;
 125 }
 126
 127 void mpls_proto_cache_flush_all(struct net *net)
 128 {
 129         struct mpls_prot_driver *proto;
 130
 131         rcu_read_lock();
 132         list_for_each_entry_rcu(proto, &mpls_proto_list, list) {
 133                 proto->cache_flush(net);
 134         }
 135         rcu_read_unlock();
 136 }
 137
 138 void __init mpls_proto_init(void)
 139 {
 140         printk("MPLS: protocol driver interface - <jleu@mindspring.com>\n");
 141 }
 142
 143 void __exit mpls_proto_exit(void)
 144 {
 145 }
 146
 147 EXPORT_SYMBOL(mpls_proto_add);
 148 EXPORT_SYMBOL(mpls_proto_remove);
 149 EXPORT_SYMBOL(mpls_proto_find_by_family);
 150 EXPORT_SYMBOL(mpls_proto_find_by_ethertype);
 151 EXPORT_SYMBOL(mpls_proto_find_by_name);
 152 EXPORT_SYMBOL(mpls_proto_cache_flush_all);
 153 EXPORT_SYMBOL(mpls_proto_lock);
 154 EXPORT_SYMBOL(mpls_proto_list);