include/linux/vs_network.h

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