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 /* Initialize/cleanup a fblock object. */
 109 extern int init_fblock(struct fblock *fb, char *name, void *priv,
 110                        struct fblock_ops *ops);
 111 extern void cleanup_fblock(struct fblock *fb);
 112 extern void cleanup_fblock_ctor(struct fblock *fb);
 113
 114 /*
 115  * Registers a fblock object to the stack. Latter variant allocates
 116  * a new unused idp, former uses a given _free_ idp.
 117  */
 118 extern int register_fblock(struct fblock *p, idp_t idp);
 119 extern int register_fblock_namespace(struct fblock *p);
 120
 121 /*
 122  * Unregisters a fblock object from the stack. Former variant does not
 123  * release the idp to name mapping, latter variant frees it, too.
 124  */
 125 extern int unregister_fblock(struct fblock *p);
 126 extern void unregister_fblock_namespace(struct fblock *p);
 127
 128 /* Returns fblock object specified by idp or name. */
 129 extern struct fblock *search_fblock(idp_t idp);
 130 extern struct fblock *__search_fblock(idp_t idp);
 131 extern struct fblock *search_fblock_n(char *name);
 132 extern struct fblock *__search_fblock_n(char *name);
 133
 134 /* Notify fblock of new option. */
 135 extern int fblock_set_option(struct fblock *fb, char *opt_string);
 136 extern int __fblock_set_option(struct fblock *fb, char *opt_string);
 137
 138 /* Binds two fblock objects, increments refcount each. */
 139 extern int fblock_bind(struct fblock *fb1, struct fblock *fb2);
 140 extern int __fblock_bind(struct fblock *fb1, struct fblock *fb2);
 141
 142 /* Unbinds two fblock objects, decrements refcount each. */
 143 extern int fblock_unbind(struct fblock *fb1, struct fblock *fb2);
 144 extern int __fblock_unbind(struct fblock *fb1, struct fblock *fb2);
 145
 146 /* Lookup idp by fblock name. */
 147 extern idp_t get_fblock_namespace_mapping(char *name);
 148 extern idp_t __get_fblock_namespace_mapping(char *name);
 149
 150 /*
 151  * Maps existing fblock name to a new idp, can be used if object has been
 152  * removed via unregister_fblock.
 153  */
 154 extern int change_fblock_namespace_mapping(char *name, idp_t new);
 155 extern int __change_fblock_namespace_mapping(char *name, idp_t new);
 156
 157 extern int subscribe_to_remote_fblock(struct fblock *us,
 158                                       struct fblock *remote);
 159 extern void unsubscribe_from_remote_fblock(struct fblock *us,
 160                                            struct fblock *remote);
 161
 162 static inline void init_fblock_subscriber(struct fblock *fb,
 163                                           struct notifier_block *nb)
 164 {
 165         nb->priority = 0;
 166         nb->notifier_call = fb->ops->event_rx;
 167         nb->next = NULL;
 168 }
 169
 170 static inline int
 171 fblock_register_foreign_subscriber(struct fblock *us,
 172                                    struct notifier_block *remote)
 173 {
 174         return atomic_notifier_chain_register(&us->others->subscribers,
 175                                               remote);
 176 }
 177
 178 static inline void
 179 fblock_unregister_foreign_subscriber(struct fblock *us,
 180                                      struct notifier_block *remote)
 181 {
 182         atomic_notifier_chain_unregister(&us->others->subscribers, remote);
 183 }
 184
 185 static inline int notify_fblock_subscribers(struct fblock *us,
 186                                             unsigned long cmd, void *arg)
 187 {
 188         if (unlikely(!us->others))
 189                 return -ENOENT;
 190         return atomic_notifier_call_chain(&us->others->subscribers, cmd, arg);
 191 }
 192
 193 static inline void get_fblock(struct fblock *fb)
 194 {
 195         atomic_inc(&fb->refcnt);
 196 }
 197
 198 static inline void put_fblock(struct fblock *fb)
 199 {
 200         if (likely(!atomic_dec_and_test(&fb->refcnt)))
 201                 return;
 202         cleanup_fblock(fb);
 203         kfree_fblock(fb);
 204 }
 205
 206 extern int init_fblock_tables(void);
 207 extern void cleanup_fblock_tables(void);
 208
 209 #endif /* __KERNEL__ */
 210 #endif /* XT_FBLOCK_H */