include/linux/vs_network.h

   1 #ifndef _NX_VS_NETWORK_H
   2 #define _NX_VS_NETWORK_H
   3
   4 #include "vserver/network.h"
   5 #include "vserver/debug.h"
   6
   7
   8 #define get_nx_info(i)  __get_nx_info(i,__FILE__,__LINE__)
   9
  10 static inline struct nx_info *__get_nx_info(struct nx_info *nxi,
  11         const char *_file, int _line)
  12 {
  13         if (!nxi)
  14                 return NULL;
  15
  16         vxlprintk(VXD_CBIT(nid, 2), "get_nx_info(%p[#%d.%d])",
  17                 nxi, nxi?nxi->nx_id:0, nxi?atomic_read(&nxi->nx_usecnt):0,
  18                 _file, _line);
  19
  20         atomic_inc(&nxi->nx_usecnt);
  21         return nxi;
  22 }
  23
  24
  25 extern void free_nx_info(struct nx_info *);
  26
  27 #define put_nx_info(i)  __put_nx_info(i,__FILE__,__LINE__)
  28
  29 static inline void __put_nx_info(struct nx_info *nxi, const char *_file, int _line)
  30 {
  31         if (!nxi)
  32                 return;
  33
  34         vxlprintk(VXD_CBIT(nid, 2), "put_nx_info(%p[#%d.%d])",
  35                 nxi, nxi?nxi->nx_id:0, nxi?atomic_read(&nxi->nx_usecnt):0,
  36                 _file, _line);
  37
  38         if (atomic_dec_and_test(&nxi->nx_usecnt))
  39                 free_nx_info(nxi);
  40 }
  41
  42
  43 #define init_nx_info(p,i) __init_nx_info(p,i,__FILE__,__LINE__)
  44
  45 static inline void __init_nx_info(struct nx_info **nxp, struct nx_info *nxi,
  46                 const char *_file, int _line)
  47 {
  48         if (nxi) {
  49                 vxlprintk(VXD_CBIT(nid, 3),
  50                         "init_nx_info(%p[#%d.%d])",
  51                         nxi, nxi?nxi->nx_id:0,
  52                         nxi?atomic_read(&nxi->nx_usecnt):0,
  53                         _file, _line);
  54
  55                 atomic_inc(&nxi->nx_usecnt);
  56         }
  57         *nxp = nxi;
  58 }
  59
  60
  61 #define set_nx_info(p,i) __set_nx_info(p,i,__FILE__,__LINE__)
  62
  63 static inline void __set_nx_info(struct nx_info **nxp, struct nx_info *nxi,
  64         const char *_file, int _line)
  65 {
  66         struct nx_info *nxo;
  67
  68         if (!nxi)
  69                 return;
  70
  71         vxlprintk(VXD_CBIT(nid, 3), "set_nx_info(%p[#%d.%d])",
  72                 nxi, nxi?nxi->nx_id:0,
  73                 nxi?atomic_read(&nxi->nx_usecnt):0,
  74                 _file, _line);
  75
  76         atomic_inc(&nxi->nx_usecnt);
  77         nxo = xchg(nxp, nxi);
  78         BUG_ON(nxo);
  79 }
  80
  81 #define clr_nx_info(p)  __clr_nx_info(p,__FILE__,__LINE__)
  82
  83 static inline void __clr_nx_info(struct nx_info **nxp,
  84         const char *_file, int _line)
  85 {
  86         struct nx_info *nxo;
  87
  88         nxo = xchg(nxp, NULL);
  89         if (!nxo)
  90                 return;
  91
  92         vxlprintk(VXD_CBIT(nid, 3), "clr_nx_info(%p[#%d.%d])",
  93                 nxo, nxo?nxo->nx_id:0,
  94                 nxo?atomic_read(&nxo->nx_usecnt):0,
  95                 _file, _line);
  96
  97         if (atomic_dec_and_test(&nxo->nx_usecnt))
  98                 free_nx_info(nxo);
  99 }
 100
 101
 102 #define claim_nx_info(v,p) __claim_nx_info(v,p,__FILE__,__LINE__)
 103
 104 static inline void __claim_nx_info(struct nx_info *nxi,
 105         struct task_struct *task, const char *_file, int _line)
 106 {
 107         vxlprintk(VXD_CBIT(nid, 3), "claim_nx_info(%p[#%d.%d.%d]) %p",
 108                 nxi, nxi?nxi->nx_id:0,
 109                 nxi?atomic_read(&nxi->nx_usecnt):0,
 110                 nxi?atomic_read(&nxi->nx_tasks):0,
 111                 task, _file, _line);
 112
 113         atomic_inc(&nxi->nx_tasks);
 114 }
 115
 116
 117 extern void unhash_nx_info(struct nx_info *);
 118
 119 #define release_nx_info(v,p) __release_nx_info(v,p,__FILE__,__LINE__)
 120
 121 static inline void __release_nx_info(struct nx_info *nxi,
 122         struct task_struct *task, const char *_file, int _line)
 123 {
 124         vxlprintk(VXD_CBIT(nid, 3), "release_nx_info(%p[#%d.%d.%d]) %p",
 125                 nxi, nxi?nxi->nx_id:0,
 126                 nxi?atomic_read(&nxi->nx_usecnt):0,
 127                 nxi?atomic_read(&nxi->nx_tasks):0,
 128                 task, _file, _line);
 129
 130         might_sleep();
 131
 132         if (atomic_dec_and_test(&nxi->nx_tasks))
 133                 unhash_nx_info(nxi);
 134 }
 135
 136
 137 #define task_get_nx_info(i)     __task_get_nx_info(i,__FILE__,__LINE__)
 138
 139 static __inline__ struct nx_info *__task_get_nx_info(struct task_struct *p,
 140         const char *_file, int _line)
 141 {
 142         struct nx_info *nxi;
 143
 144         task_lock(p);
 145         vxlprintk(VXD_CBIT(nid, 5), "task_get_nx_info(%p)",
 146                 p, _file, _line);
 147         nxi = __get_nx_info(p->nx_info, _file, _line);
 148         task_unlock(p);
 149         return nxi;
 150 }
 151
 152
 153 #define nx_task_nid(t)  ((t)->nid)
 154
 155 #define nx_current_nid() nx_task_nid(current)
 156
 157 #define current_nx_info() (current->nx_info)
 158
 159
 160 #define nx_check(c,m)   __nx_check(nx_current_nid(),c,m)
 161
 162 #define nx_weak_check(c,m)      ((m) ? nx_check(c,m) : 1)
 163
 164
 165 #define __nx_state(v)   ((v) ? ((v)->nx_state) : 0)
 166
 167 #define nx_info_state(v,m)      (__nx_state(v) & (m))
 168
 169
 170 #define __nx_flags(v)   ((v) ? (v)->nx_flags : 0)
 171
 172 #define nx_current_flags()      __nx_flags(current->nx_info)
 173
 174 #define nx_info_flags(v,m,f) \
 175         vx_check_flags(__nx_flags(v),(m),(f))
 176
 177 #define task_nx_flags(t,m,f) \
 178         ((t) && nx_info_flags((t)->nx_info, (m), (f)))
 179
 180 #define nx_flags(m,f)   nx_info_flags(current->nx_info,(m),(f))
 181
 182
 183 /* context caps */
 184
 185 #define __nx_ncaps(v)   ((v) ? (v)->nx_ncaps : 0)
 186
 187 #define nx_current_ncaps()      __nx_ncaps(current->nx_info)
 188
 189 #define nx_info_ncaps(v,c)      (__nx_ncaps(v) & (c))
 190
 191 #define nx_ncaps(c)     nx_info_ncaps(current->nx_info,(c))
 192
 193
 194 static inline int addr_in_nx_info(struct nx_info *nxi, uint32_t addr)
 195 {
 196         int n,i;
 197
 198         if (!nxi)
 199                 return 1;
 200
 201         n = nxi->nbipv4;
 202         if (n && (nxi->ipv4[0] == 0))
 203                 return 1;
 204         for (i=0; i<n; i++) {
 205                 if (nxi->ipv4[i] == addr)
 206                         return 1;
 207         }
 208         return 0;
 209 }
 210
 211 static inline void exit_nx_info(struct task_struct *p)
 212 {
 213         if (p->nx_info)
 214                 release_nx_info(p->nx_info, p);
 215 }
 216
 217
 218 #else
 219 #warning duplicate inclusion
 220 #endif