src/xt_fblock.h

   1 /*
   2  * Lightweight Autonomic Network Architecture
   3  *
   4  * Copyright 2011 Daniel Borkmann <dborkma@tik.ee.ethz.ch>,
   5  * Swiss federal institute of technology (ETH Zurich)
   6  * Subject to the GPL.
   7  */
   8
   9 #ifndef XT_FBLOCK_H
  10 #define XT_FBLOCK_H
  11
  12 #ifdef __KERNEL__
  13
  14 #include <linux/proc_fs.h>
  15 #include <linux/if.h>
  16 #include <linux/cpu.h>
  17 #include <linux/module.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/skbuff.h>
  20 #include <linux/notifier.h>
  21 #include <linux/radix-tree.h>
  22
  23 #include "xt_idp.h"
  24
  25 enum path_type {
  26         TYPE_INGRESS = 0,
  27 #define TYPE_INGRESS            TYPE_INGRESS
  28         TYPE_EGRESS,
  29 #define TYPE_EGRESS             TYPE_EGRESS
  30         _TYPE_MAX,
  31 };
  32
  33 extern const char *path_names[];
  34
  35 enum fblock_mode {
  36         MODE_SOURCE = 0,
  37 #define MODE_SOURCE             MODE_SOURCE
  38         MODE_SINK,
  39 #define MODE_SINK               MODE_SINK
  40         MODE_DUAL,
  41 #define MODE_DUAL               MODE_DUAL
  42 };
  43
  44 #define NUM_TYPES               _TYPE_MAX
  45
  46 #define FBLOCK_BIND_IDP         0x0001
  47 #define FBLOCK_UNBIND_IDP       0x0002
  48 #define FBLOCK_SET_OPT          0x0003
  49 #define FBLOCK_DOWN_PREPARE     0x0004
  50 #define FBLOCK_DOWN             0x0005
  51
  52 #endif /* __KERNEL__ */
  53
  54 #define FBNAMSIZ                IFNAMSIZ
  55 #define TYPNAMSIZ               FBNAMSIZ
  56
  57 #ifdef __KERNEL__
  58
  59 extern struct proc_dir_entry *fblock_proc_dir;
  60
  61 struct fblock_bind_msg {
  62         enum path_type dir;
  63         idp_t idp;
  64 };
  65
  66 struct fblock_opt_msg {
  67         char *key;
  68         char *val;
  69 };
  70
  71 struct fblock;
  72
  73 struct fblock_factory {
  74         char type[TYPNAMSIZ];
  75         enum fblock_mode mode;
  76         struct module *owner;
  77         struct fblock *(*ctor)(char *name);
  78         void (*dtor)(struct fblock *fb);
  79 } ____cacheline_aligned;
  80
  81 struct fblock_notifier {
  82         struct fblock *self;
  83         struct notifier_block nb;
  84         struct fblock_notifier *next;
  85         idp_t remote;
  86 };
  87
  88 struct fblock_subscrib {
  89         struct atomic_notifier_head subscribers;
  90 };
  91
  92 struct fblock {
  93         char name[FBNAMSIZ];
  94         void __percpu *private_data;
  95         int (*netfb_rx)(const struct fblock * const fb,
  96                         struct sk_buff * const skb,
  97                         enum path_type * const dir);
  98         int (*event_rx)(struct notifier_block *self, unsigned long cmd,
  99                         void *args);
 100         struct fblock_factory *factory;
 101         struct fblock_notifier *notifiers;
 102         struct fblock_subscrib *others;
 103         struct fblock *next;
 104         struct rcu_head rcu;
 105         atomic_t refcnt;
 106         idp_t idp;
 107         spinlock_t lock; /* Used in notifiers */
 108 } ____cacheline_aligned;
 109
 110 extern void free_fblock_rcu(struct rcu_head *rp);
 111
 112 static inline void get_fblock(struct fblock *fb)
 113 {
 114         atomic_inc(&fb->refcnt);
 115 }
 116
 117 static inline void put_fblock(struct fblock *fb)
 118 {
 119         if (likely(!atomic_dec_and_test(&fb->refcnt)))
 120                 return;
 121         call_rcu(&fb->rcu, free_fblock_rcu);
 122 }
 123
 124 /*
 125  * Note: __* variants do not hold the rcu_read_lock!
 126  */
 127
 128 /* Allocate/free a new fblock object. */
 129 extern struct fblock *alloc_fblock(gfp_t flags);
 130 extern void kfree_fblock(struct fblock *p);
 131
 132 /* Initialize/cleanup a fblock object. */
 133 extern int init_fblock(struct fblock *fb, char *name, void __percpu *priv);
 134 extern void cleanup_fblock(struct fblock *fb);
 135 extern void cleanup_fblock_ctor(struct fblock *fb);
 136
 137 /*
 138  * Registers a fblock object to the stack. Latter variant allocates
 139  * a new unused idp, former uses a given _free_ idp.
 140  */
 141 extern int register_fblock(struct fblock *p, idp_t idp);
 142 extern int register_fblock_namespace(struct fblock *p);
 143
 144 /*
 145  * Unregisters a fblock object from the stack. Former variant does not
 146  * release the idp to name mapping, latter variant frees it, too.
 147  */
 148 extern void unregister_fblock(struct fblock *p);
 149 extern void unregister_fblock_namespace(struct fblock *p);
 150 extern void unregister_fblock_namespace_no_rcu(struct fblock *p);
 151
 152 extern struct radix_tree_root fblmap;
 153
 154 /* Caller needs to do a put_fblock() after his work is done! */
 155 /* Called within RCU read lock! */
 156 #define __search_fblock(idp)                                    \
 157 ({                                                              \
 158         struct fblock *ret = radix_tree_lookup(&fblmap, idp);   \
 159         if (likely(ret))                                        \
 160                 get_fblock(ret);                                \
 161         ret;                                                    \
 162 })
 163
 164 /* Returns fblock object specified by idp or name. */
 165 extern struct fblock *search_fblock(idp_t idp);
 166 extern struct fblock *search_fblock_n(char *name);
 167
 168 /* Migrate state from src to dst and drop of dst states */
 169 extern void fblock_migrate_p(struct fblock *dst, struct fblock *src);
 170 extern void fblock_migrate_r(struct fblock *dst, struct fblock *src);
 171
 172 /* Notify fblock of new option. */
 173 extern int fblock_set_option(struct fblock *fb, char *opt_string);
 174 extern int __fblock_set_option(struct fblock *fb, char *opt_string);
 175
 176 /* Binds two fblock objects, increments refcount each. */
 177 extern int fblock_bind(struct fblock *fb1, struct fblock *fb2);
 178 extern int __fblock_bind(struct fblock *fb1, struct fblock *fb2);
 179
 180 /* Unbinds two fblock objects, decrements refcount each. */
 181 extern int fblock_unbind(struct fblock *fb1, struct fblock *fb2);
 182 extern int __fblock_unbind(struct fblock *fb1, struct fblock *fb2);
 183
 184 /* Lookup idp by fblock name. */
 185 extern idp_t get_fblock_namespace_mapping(char *name);
 186 extern idp_t __get_fblock_namespace_mapping(char *name);
 187
 188 /*
 189  * Maps existing fblock name to a new idp, can be used if object has been
 190  * removed via unregister_fblock.
 191  */
 192 extern int change_fblock_namespace_mapping(char *name, idp_t new);
 193 extern int __change_fblock_namespace_mapping(char *name, idp_t new);
 194
 195 extern int subscribe_to_remote_fblock(struct fblock *us,
 196                                       struct fblock *remote);
 197 extern void unsubscribe_from_remote_fblock(struct fblock *us,
 198                                            struct fblock *remote);
 199
 200 static inline void init_fblock_subscriber(struct fblock *fb,
 201                                           struct notifier_block *nb)
 202 {
 203         nb->priority = 0;
 204         nb->notifier_call = fb->event_rx;
 205         nb->next = NULL;
 206 }
 207
 208 static inline int
 209 fblock_register_foreign_subscriber(struct fblock *us,
 210                                    struct notifier_block *remote)
 211 {
 212         return atomic_notifier_chain_register(&rcu_dereference_raw(us->others)->subscribers,
 213                                               remote);
 214 }
 215
 216 static inline void
 217 fblock_unregister_foreign_subscriber(struct fblock *us,
 218                                      struct notifier_block *remote)
 219 {
 220         atomic_notifier_chain_unregister(&rcu_dereference_raw(us->others)->subscribers,
 221                                          remote);
 222 }
 223
 224 static inline int notify_fblock_subscribers(struct fblock *us,
 225                                             unsigned long cmd, void *arg)
 226 {
 227         if (unlikely(!rcu_dereference_raw(us->others)))
 228                 return -ENOENT;
 229         return atomic_notifier_call_chain(&rcu_dereference_raw(us->others)->subscribers,
 230                                           cmd, arg);
 231 }
 232
 233 extern int init_fblock_tables(void);
 234 extern void cleanup_fblock_tables(void);
 235
 236 /* here is the address, e.g. __builtin_return_address(0) */
 237 static inline void fblock_over_panic(struct fblock *fb, void *here)
 238 {
 239         printk(KERN_EMERG "fblock_over_panic: text:%p ptr:%p idp:%u refs:%d "
 240                           "name:%s next:%p priv:%p fac:%p not:%p others: %p\n",
 241                here, fb, fb->idp, atomic_read(&fb->refcnt), fb->name, fb->next,
 242                fb->private_data, fb->factory, fb->notifiers, fb->others);
 243         BUG();
 244 }
 245
 246 #endif /* __KERNEL__ */
 247 #endif /* XT_FBLOCK_H */