git.sesse.net Git - bcachefs-tools-debian/blob - include/linux/percpu.h

   1 #ifndef __TOOLS_LINUX_PERCPU_H
   2 #define __TOOLS_LINUX_PERCPU_H
   3
   4 #include <linux/cpumask.h>
   5
   6 #define __percpu
   7
   8 #define free_percpu(percpu)                             free(percpu)
   9
  10 #define __alloc_percpu_gfp(size, align, gfp)            calloc(1, size)
  11 #define __alloc_percpu(size, align)                     calloc(1, size)
  12
  13 #define alloc_percpu_gfp(type, gfp)                                     \
  14         (typeof(type) __percpu *)__alloc_percpu_gfp(sizeof(type),       \
  15                                                 __alignof__(type), gfp)
  16 #define alloc_percpu(type)                                              \
  17         (typeof(type) __percpu *)__alloc_percpu(sizeof(type),           \
  18                                                 __alignof__(type))
  19
  20 #define __verify_pcpu_ptr(ptr)
  21
  22 #define per_cpu_ptr(ptr, cpu)   (ptr)
  23 #define raw_cpu_ptr(ptr)        (ptr)
  24 #define this_cpu_ptr(ptr)       raw_cpu_ptr(ptr)
  25
  26 #define __pcpu_size_call_return(stem, variable)                         \
  27 ({                                                                      \
  28         typeof(variable) pscr_ret__;                                    \
  29         __verify_pcpu_ptr(&(variable));                                 \
  30         switch(sizeof(variable)) {                                      \
  31         case 1: pscr_ret__ = stem##1(variable); break;                  \
  32         case 2: pscr_ret__ = stem##2(variable); break;                  \
  33         case 4: pscr_ret__ = stem##4(variable); break;                  \
  34         case 8: pscr_ret__ = stem##8(variable); break;                  \
  35         default:                                                        \
  36                 __bad_size_call_parameter(); break;                     \
  37         }                                                               \
  38         pscr_ret__;                                                     \
  39 })
  40
  41 #define __pcpu_size_call_return2(stem, variable, ...)                   \
  42 ({                                                                      \
  43         typeof(variable) pscr2_ret__;                                   \
  44         __verify_pcpu_ptr(&(variable));                                 \
  45         switch(sizeof(variable)) {                                      \
  46         case 1: pscr2_ret__ = stem##1(variable, __VA_ARGS__); break;    \
  47         case 2: pscr2_ret__ = stem##2(variable, __VA_ARGS__); break;    \
  48         case 4: pscr2_ret__ = stem##4(variable, __VA_ARGS__); break;    \
  49         case 8: pscr2_ret__ = stem##8(variable, __VA_ARGS__); break;    \
  50         default:                                                        \
  51                 __bad_size_call_parameter(); break;                     \
  52         }                                                               \
  53         pscr2_ret__;                                                    \
  54 })
  55
  56 /*
  57  * Special handling for cmpxchg_double.  cmpxchg_double is passed two
  58  * percpu variables.  The first has to be aligned to a double word
  59  * boundary and the second has to follow directly thereafter.
  60  * We enforce this on all architectures even if they don't support
  61  * a double cmpxchg instruction, since it's a cheap requirement, and it
  62  * avoids breaking the requirement for architectures with the instruction.
  63  */
  64 #define __pcpu_double_call_return_bool(stem, pcp1, pcp2, ...)           \
  65 ({                                                                      \
  66         bool pdcrb_ret__;                                               \
  67         __verify_pcpu_ptr(&(pcp1));                                     \
  68         BUILD_BUG_ON(sizeof(pcp1) != sizeof(pcp2));                     \
  69         VM_BUG_ON((unsigned long)(&(pcp1)) % (2 * sizeof(pcp1)));       \
  70         VM_BUG_ON((unsigned long)(&(pcp2)) !=                           \
  71                   (unsigned long)(&(pcp1)) + sizeof(pcp1));             \
  72         switch(sizeof(pcp1)) {                                          \
  73         case 1: pdcrb_ret__ = stem##1(pcp1, pcp2, __VA_ARGS__); break;  \
  74         case 2: pdcrb_ret__ = stem##2(pcp1, pcp2, __VA_ARGS__); break;  \
  75         case 4: pdcrb_ret__ = stem##4(pcp1, pcp2, __VA_ARGS__); break;  \
  76         case 8: pdcrb_ret__ = stem##8(pcp1, pcp2, __VA_ARGS__); break;  \
  77         default:                                                        \
  78                 __bad_size_call_parameter(); break;                     \
  79         }                                                               \
  80         pdcrb_ret__;                                                    \
  81 })
  82
  83 #define __pcpu_size_call(stem, variable, ...)                           \
  84 do {                                                                    \
  85         __verify_pcpu_ptr(&(variable));                                 \
  86         switch(sizeof(variable)) {                                      \
  87                 case 1: stem##1(variable, __VA_ARGS__);break;           \
  88                 case 2: stem##2(variable, __VA_ARGS__);break;           \
  89                 case 4: stem##4(variable, __VA_ARGS__);break;           \
  90                 case 8: stem##8(variable, __VA_ARGS__);break;           \
  91                 default:                                                \
  92                         __bad_size_call_parameter();break;              \
  93         }                                                               \
  94 } while (0)
  95
  96 #define raw_cpu_read(pcp)               __pcpu_size_call_return(raw_cpu_read_, pcp)
  97 #define raw_cpu_write(pcp, val)         __pcpu_size_call(raw_cpu_write_, pcp, val)
  98 #define raw_cpu_add(pcp, val)           __pcpu_size_call(raw_cpu_add_, pcp, val)
  99 #define raw_cpu_and(pcp, val)           __pcpu_size_call(raw_cpu_and_, pcp, val)
 100 #define raw_cpu_or(pcp, val)            __pcpu_size_call(raw_cpu_or_, pcp, val)
 101 #define raw_cpu_add_return(pcp, val)    __pcpu_size_call_return2(raw_cpu_add_return_, pcp, val)
 102 #define raw_cpu_xchg(pcp, nval)         __pcpu_size_call_return2(raw_cpu_xchg_, pcp, nval)
 103 #define raw_cpu_cmpxchg(pcp, oval, nval) \
 104         __pcpu_size_call_return2(raw_cpu_cmpxchg_, pcp, oval, nval)
 105 #define raw_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2) \
 106         __pcpu_double_call_return_bool(raw_cpu_cmpxchg_double_, pcp1, pcp2, oval1, oval2, nval1, nval2)
 107
 108 #define raw_cpu_sub(pcp, val)           raw_cpu_add(pcp, -(val))
 109 #define raw_cpu_inc(pcp)                raw_cpu_add(pcp, 1)
 110 #define raw_cpu_dec(pcp)                raw_cpu_sub(pcp, 1)
 111 #define raw_cpu_sub_return(pcp, val)    raw_cpu_add_return(pcp, -(typeof(pcp))(val))
 112 #define raw_cpu_inc_return(pcp)         raw_cpu_add_return(pcp, 1)
 113 #define raw_cpu_dec_return(pcp)         raw_cpu_add_return(pcp, -1)
 114
 115 #define __this_cpu_read(pcp)                                            \
 116 ({                                                                      \
 117         raw_cpu_read(pcp);                                              \
 118 })
 119
 120 #define __this_cpu_write(pcp, val)                                      \
 121 ({                                                                      \
 122         raw_cpu_write(pcp, val);                                        \
 123 })
 124
 125 #define __this_cpu_add(pcp, val)                                        \
 126 ({                                                                      \
 127         raw_cpu_add(pcp, val);                                          \
 128 })
 129
 130 #define __this_cpu_and(pcp, val)                                        \
 131 ({                                                                      \
 132         raw_cpu_and(pcp, val);                                          \
 133 })
 134
 135 #define __this_cpu_or(pcp, val)                                         \
 136 ({                                                                      \
 137         raw_cpu_or(pcp, val);                                           \
 138 })
 139
 140 #define __this_cpu_add_return(pcp, val)                                 \
 141 ({                                                                      \
 142         raw_cpu_add_return(pcp, val);                                   \
 143 })
 144
 145 #define __this_cpu_xchg(pcp, nval)                                      \
 146 ({                                                                      \
 147         raw_cpu_xchg(pcp, nval);                                        \
 148 })
 149
 150 #define __this_cpu_cmpxchg(pcp, oval, nval)                             \
 151 ({                                                                      \
 152         raw_cpu_cmpxchg(pcp, oval, nval);                               \
 153 })
 154
 155 #define __this_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2) \
 156         raw_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2); \
 157 })
 158
 159 #define __this_cpu_sub(pcp, val)        __this_cpu_add(pcp, -(typeof(pcp))(val))
 160 #define __this_cpu_inc(pcp)             __this_cpu_add(pcp, 1)
 161 #define __this_cpu_dec(pcp)             __this_cpu_sub(pcp, 1)
 162 #define __this_cpu_sub_return(pcp, val) __this_cpu_add_return(pcp, -(typeof(pcp))(val))
 163 #define __this_cpu_inc_return(pcp)      __this_cpu_add_return(pcp, 1)
 164 #define __this_cpu_dec_return(pcp)      __this_cpu_add_return(pcp, -1)
 165
 166 #define this_cpu_read(pcp)              ((pcp))
 167 #define this_cpu_write(pcp, val)        ((pcp) = val)
 168 #define this_cpu_add(pcp, val)          ((pcp) += val)
 169 #define this_cpu_and(pcp, val)          ((pcp) &= val)
 170 #define this_cpu_or(pcp, val)           ((pcp) |= val)
 171 #define this_cpu_add_return(pcp, val)   ((pcp) += val)
 172 #define this_cpu_xchg(pcp, nval)                                        \
 173 ({                                                                      \
 174         typeof(pcp) _r = (pcp);                                         \
 175         (pcp) = (nval);                                                 \
 176         _r;                                                             \
 177 })
 178
 179 #define this_cpu_cmpxchg(pcp, oval, nval) \
 180         __pcpu_size_call_return2(this_cpu_cmpxchg_, pcp, oval, nval)
 181 #define this_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2) \
 182         __pcpu_double_call_return_bool(this_cpu_cmpxchg_double_, pcp1, pcp2, oval1, oval2, nval1, nval2)
 183
 184 #define this_cpu_sub(pcp, val)          this_cpu_add(pcp, -(typeof(pcp))(val))
 185 #define this_cpu_inc(pcp)               this_cpu_add(pcp, 1)
 186 #define this_cpu_dec(pcp)               this_cpu_sub(pcp, 1)
 187 #define this_cpu_sub_return(pcp, val)   this_cpu_add_return(pcp, -(typeof(pcp))(val))
 188 #define this_cpu_inc_return(pcp)        this_cpu_add_return(pcp, 1)
 189 #define this_cpu_dec_return(pcp)        this_cpu_add_return(pcp, -1)
 190
 191 #endif /* __TOOLS_LINUX_PERCPU_H */