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/rwlock.h>
  19 #include <linux/skbuff.h>
  20 #include <linux/notifier.h>
  21
  22 #include "xt_idp.h"
  23
  24 enum path_type {
  25         TYPE_INGRESS = 0,
  26 #define TYPE_INGRESS            TYPE_INGRESS
  27         TYPE_EGRESS,
  28 #define TYPE_EGRESS             TYPE_EGRESS
  29         _TYPE_MAX,
  30 };
  31
  32 #define NUM_TYPES               _TYPE_MAX
  33
  34 #define FBLOCK_BIND_IDP         0x0001
  35 #define FBLOCK_UNBIND_IDP       0x0002
  36 #define FBLOCK_SET_OPT          0x0003
  37 #define FBLOCK_DOWN_PREPARE     0x0004
  38 #define FBLOCK_DOWN             0x0005
  39
  40 #endif /* __KERNEL__ */
  41
  42 #define FBNAMSIZ                IFNAMSIZ
  43 #define TYPNAMSIZ               FBNAMSIZ
  44
  45 #ifdef __KERNEL__
  46
  47 extern struct proc_dir_entry *fblock_proc_dir;
  48
  49 struct fblock_bind_msg {
  50         enum path_type dir;
  51         idp_t idp;
  52 };
  53
  54 struct fblock_opt_msg {
  55         char *key;
  56         char *val;
  57 };
  58
  59 struct fblock;
  60
  61 struct fblock_ops {
  62         int (*netfb_rx)(struct fblock *fb, struct sk_buff *skb,
  63                         enum path_type *dir);
  64         int (*event_rx)(struct notifier_block *self, unsigned long cmd,
  65                         void *args);
  66 };
  67
  68 struct fblock_factory {
  69         char type[TYPNAMSIZ];
  70         struct module *owner;
  71         struct fblock *(*ctor)(char *name);
  72         void (*dtor)(struct fblock *fb);
  73 } ____cacheline_aligned;
  74
  75 struct fblock_notifier {
  76         struct fblock *self;
  77         struct fblock *remote;
  78         struct notifier_block nb;
  79         struct fblock_notifier *next;
  80 } ____cacheline_aligned;
  81
  82 struct fblock_subscrib {
  83         struct atomic_notifier_head subscribers;
  84 };
  85
  86 struct fblock {
  87         char name[FBNAMSIZ];
  88         void *private_data;
  89         struct fblock_ops *ops;
  90         struct fblock_factory *factory;
  91         struct fblock_notifier *notifiers;
  92         struct fblock_subscrib *others;
  93         struct fblock *next;
  94         struct rcu_head rcu;
  95         atomic_t refcnt;
  96         idp_t idp;
  97         rwlock_t lock; /* Used in notifiers */
  98 } ____cacheline_aligned;
  99
 100 /*
 101  * Note: __* variants do not hold the rcu_read_lock!
 102  */
 103
 104 /* Allocate/free a new fblock object. */
 105 extern struct fblock *alloc_fblock(gfp_t flags);
 106 extern void kfree_fblock(struct fblock *p);
 107
 108 enum cleanup_mode {
 109         CLEAN_FREE_PRIV,
 110         CLEAN_NOFREE_PRIV,
 111 };
 112
 113 /* Initialize/cleanup a fblock object. */
 114 extern int init_fblock(struct fblock *fb, char *name, void *priv,
 115                        struct fblock_ops *ops);
 116 extern void cleanup_fblock(struct fblock *fb);
 117 extern void cleanup_fblock_ctor(struct fblock *fb);
 118
 119 /*
 120  * Registers a fblock object to the stack. Latter variant allocates
 121  * a new unused idp, former uses a given _free_ idp.
 122  */
 123 extern int register_fblock(struct fblock *p, idp_t idp);
 124 extern int register_fblock_namespace(struct fblock *p);
 125
 126 /*
 127  * Unregisters a fblock object from the stack. Former variant does not
 128  * release the idp to name mapping, latter variant frees it, too.
 129  */
 130 extern int unregister_fblock(struct fblock *p);
 131 extern void unregister_fblock_namespace(struct fblock *p);
 132 extern void unregister_fblock_namespace_no_rcu(struct fblock *p);
 133
 134 /* Returns fblock object specified by idp or name. */
 135 extern struct fblock *search_fblock(idp_t idp);
 136 extern struct fblock *__search_fblock(idp_t idp);
 137 extern struct fblock *search_fblock_n(char *name);
 138 extern struct fblock *__search_fblock_n(char *name);
 139
 140 /* Migrate state from src to dst and drop of dst states */
 141 extern int fblock_migrate(struct fblock *dst, struct fblock *src);
 142
 143 /* Notify fblock of new option. */
 144 extern int fblock_set_option(struct fblock *fb, char *opt_string);
 145 extern int __fblock_set_option(struct fblock *fb, char *opt_string);
 146
 147 /* Binds two fblock objects, increments refcount each. */
 148 extern int fblock_bind(struct fblock *fb1, struct fblock *fb2);
 149 extern int __fblock_bind(struct fblock *fb1, struct fblock *fb2);
 150
 151 /* Unbinds two fblock objects, decrements refcount each. */
 152 extern int fblock_unbind(struct fblock *fb1, struct fblock *fb2);
 153 extern int __fblock_unbind(struct fblock *fb1, struct fblock *fb2);
 154
 155 /* Lookup idp by fblock name. */
 156 extern idp_t get_fblock_namespace_mapping(char *name);
 157 extern idp_t __get_fblock_namespace_mapping(char *name);
 158
 159 /*
 160  * Maps existing fblock name to a new idp, can be used if object has been
 161  * removed via unregister_fblock.
 162  */
 163 extern int change_fblock_namespace_mapping(char *name, idp_t new);
 164 extern int __change_fblock_namespace_mapping(char *name, idp_t new);
 165
 166 extern int subscribe_to_remote_fblock(struct fblock *us,
 167                                       struct fblock *remote);
 168 extern void unsubscribe_from_remote_fblock(struct fblock *us,
 169                                            struct fblock *remote);
 170
 171 static inline void init_fblock_subscriber(struct fblock *fb,
 172                                           struct notifier_block *nb)
 173 {
 174         nb->priority = 0;
 175         nb->notifier_call = fb->ops->event_rx;
 176         nb->next = NULL;
 177 }
 178
 179 static inline int
 180 fblock_register_foreign_subscriber(struct fblock *us,
 181                                    struct notifier_block *remote)
 182 {
 183         return atomic_notifier_chain_register(&rcu_dereference_raw(us->others)->subscribers,
 184                                               remote);
 185 }
 186
 187 static inline void
 188 fblock_unregister_foreign_subscriber(struct fblock *us,
 189                                      struct notifier_block *remote)
 190 {
 191         atomic_notifier_chain_unregister(&rcu_dereference_raw(us->others)->subscribers,
 192                                          remote);
 193 }
 194
 195 static inline int notify_fblock_subscribers(struct fblock *us,
 196                                             unsigned long cmd, void *arg)
 197 {
 198         if (unlikely(!rcu_dereference_raw(us->others)))
 199                 return -ENOENT;
 200         return atomic_notifier_call_chain(&rcu_dereference_raw(us->others)->subscribers,
 201                                           cmd, arg);
 202 }
 203
 204 static inline void get_fblock(struct fblock *fb)
 205 {
 206         atomic_inc(&fb->refcnt);
 207 }
 208
 209 static inline void put_fblock(struct fblock *fb)
 210 {
 211         if (likely(!atomic_dec_and_test(&fb->refcnt)))
 212                 return;
 213         cleanup_fblock(fb);
 214         kfree_fblock(fb);
 215 }
 216
 217 extern int init_fblock_tables(void);
 218 extern void cleanup_fblock_tables(void);
 219
 220 #endif /* __KERNEL__ */
 221 #endif /* XT_FBLOCK_H */