Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 1 | #ifndef GENL_MAGIC_FUNC_H |
| 2 | #define GENL_MAGIC_FUNC_H |
| 3 | |
| 4 | #include <linux/genl_magic_struct.h> |
| 5 | |
| 6 | /* |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 7 | * Magic: declare tla policy {{{1 |
| 8 | * Magic: declare nested policies |
| 9 | * {{{2 |
| 10 | */ |
| 11 | #undef GENL_mc_group |
| 12 | #define GENL_mc_group(group) |
| 13 | |
| 14 | #undef GENL_notification |
| 15 | #define GENL_notification(op_name, op_num, mcast_group, tla_list) |
| 16 | |
| 17 | #undef GENL_op |
| 18 | #define GENL_op(op_name, op_num, handler, tla_list) |
| 19 | |
| 20 | #undef GENL_struct |
| 21 | #define GENL_struct(tag_name, tag_number, s_name, s_fields) \ |
| 22 | [tag_name] = { .type = NLA_NESTED }, |
| 23 | |
| 24 | static struct nla_policy CONCAT_(GENL_MAGIC_FAMILY, _tla_nl_policy)[] = { |
| 25 | #include GENL_MAGIC_INCLUDE_FILE |
| 26 | }; |
| 27 | |
| 28 | #undef GENL_struct |
| 29 | #define GENL_struct(tag_name, tag_number, s_name, s_fields) \ |
| 30 | static struct nla_policy s_name ## _nl_policy[] __read_mostly = \ |
| 31 | { s_fields }; |
| 32 | |
| 33 | #undef __field |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 34 | #define __field(attr_nr, attr_flag, name, nla_type, _type, __get, \ |
| 35 | __put, __is_signed) \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 36 | [attr_nr] = { .type = nla_type }, |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 37 | |
| 38 | #undef __array |
| 39 | #define __array(attr_nr, attr_flag, name, nla_type, _type, maxlen, \ |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 40 | __get, __put, __is_signed) \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 41 | [attr_nr] = { .type = nla_type, \ |
| 42 | .len = maxlen - (nla_type == NLA_NUL_STRING) }, |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 43 | |
| 44 | #include GENL_MAGIC_INCLUDE_FILE |
| 45 | |
| 46 | #ifndef __KERNEL__ |
| 47 | #ifndef pr_info |
| 48 | #define pr_info(args...) fprintf(stderr, args); |
| 49 | #endif |
| 50 | #endif |
| 51 | |
Lars Ellenberg | 3b98c0c | 2011-03-07 12:49:34 +0100 | [diff] [blame] | 52 | #ifdef GENL_MAGIC_DEBUG |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 53 | static void dprint_field(const char *dir, int nla_type, |
| 54 | const char *name, void *valp) |
| 55 | { |
| 56 | __u64 val = valp ? *(__u32 *)valp : 1; |
| 57 | switch (nla_type) { |
| 58 | case NLA_U8: val = (__u8)val; |
| 59 | case NLA_U16: val = (__u16)val; |
| 60 | case NLA_U32: val = (__u32)val; |
| 61 | pr_info("%s attr %s: %d 0x%08x\n", dir, |
| 62 | name, (int)val, (unsigned)val); |
| 63 | break; |
| 64 | case NLA_U64: |
| 65 | val = *(__u64*)valp; |
| 66 | pr_info("%s attr %s: %lld 0x%08llx\n", dir, |
| 67 | name, (long long)val, (unsigned long long)val); |
| 68 | break; |
| 69 | case NLA_FLAG: |
| 70 | if (val) |
| 71 | pr_info("%s attr %s: set\n", dir, name); |
| 72 | break; |
| 73 | } |
| 74 | } |
| 75 | |
| 76 | static void dprint_array(const char *dir, int nla_type, |
| 77 | const char *name, const char *val, unsigned len) |
| 78 | { |
| 79 | switch (nla_type) { |
| 80 | case NLA_NUL_STRING: |
| 81 | if (len && val[len-1] == '\0') |
| 82 | len--; |
| 83 | pr_info("%s attr %s: [len:%u] '%s'\n", dir, name, len, val); |
| 84 | break; |
| 85 | default: |
| 86 | /* we can always show 4 byte, |
| 87 | * thats what nlattr are aligned to. */ |
| 88 | pr_info("%s attr %s: [len:%u] %02x%02x%02x%02x ...\n", |
| 89 | dir, name, len, val[0], val[1], val[2], val[3]); |
| 90 | } |
| 91 | } |
| 92 | |
| 93 | #define DPRINT_TLA(a, op, b) pr_info("%s %s %s\n", a, op, b); |
| 94 | |
| 95 | /* Name is a member field name of the struct s. |
| 96 | * If s is NULL (only parsing, no copy requested in *_from_attrs()), |
| 97 | * nla is supposed to point to the attribute containing the information |
| 98 | * corresponding to that struct member. */ |
| 99 | #define DPRINT_FIELD(dir, nla_type, name, s, nla) \ |
| 100 | do { \ |
| 101 | if (s) \ |
| 102 | dprint_field(dir, nla_type, #name, &s->name); \ |
| 103 | else if (nla) \ |
| 104 | dprint_field(dir, nla_type, #name, \ |
| 105 | (nla_type == NLA_FLAG) ? NULL \ |
| 106 | : nla_data(nla)); \ |
| 107 | } while (0) |
| 108 | |
| 109 | #define DPRINT_ARRAY(dir, nla_type, name, s, nla) \ |
| 110 | do { \ |
| 111 | if (s) \ |
| 112 | dprint_array(dir, nla_type, #name, \ |
| 113 | s->name, s->name ## _len); \ |
| 114 | else if (nla) \ |
| 115 | dprint_array(dir, nla_type, #name, \ |
| 116 | nla_data(nla), nla_len(nla)); \ |
| 117 | } while (0) |
| 118 | #else |
| 119 | #define DPRINT_TLA(a, op, b) do {} while (0) |
| 120 | #define DPRINT_FIELD(dir, nla_type, name, s, nla) do {} while (0) |
| 121 | #define DPRINT_ARRAY(dir, nla_type, name, s, nla) do {} while (0) |
| 122 | #endif |
| 123 | |
| 124 | /* |
| 125 | * Magic: provide conversion functions {{{1 |
| 126 | * populate struct from attribute table: |
| 127 | * {{{2 |
| 128 | */ |
| 129 | |
| 130 | /* processing of generic netlink messages is serialized. |
| 131 | * use one static buffer for parsing of nested attributes */ |
| 132 | static struct nlattr *nested_attr_tb[128]; |
| 133 | |
| 134 | #ifndef BUILD_BUG_ON |
| 135 | /* Force a compilation error if condition is true */ |
| 136 | #define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition)) |
| 137 | /* Force a compilation error if condition is true, but also produce a |
| 138 | result (of value 0 and type size_t), so the expression can be used |
| 139 | e.g. in a structure initializer (or where-ever else comma expressions |
| 140 | aren't permitted). */ |
| 141 | #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); })) |
| 142 | #define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); })) |
| 143 | #endif |
| 144 | |
| 145 | #undef GENL_struct |
| 146 | #define GENL_struct(tag_name, tag_number, s_name, s_fields) \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 147 | /* *_from_attrs functions are static, but potentially unused */ \ |
| 148 | static int __ ## s_name ## _from_attrs(struct s_name *s, \ |
| 149 | struct genl_info *info, bool exclude_invariants) \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 150 | { \ |
| 151 | const int maxtype = ARRAY_SIZE(s_name ## _nl_policy)-1; \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 152 | struct nlattr *tla = info->attrs[tag_number]; \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 153 | struct nlattr **ntb = nested_attr_tb; \ |
| 154 | struct nlattr *nla; \ |
| 155 | int err; \ |
| 156 | BUILD_BUG_ON(ARRAY_SIZE(s_name ## _nl_policy) > ARRAY_SIZE(nested_attr_tb)); \ |
| 157 | if (!tla) \ |
| 158 | return -ENOMSG; \ |
| 159 | DPRINT_TLA(#s_name, "<=-", #tag_name); \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 160 | err = drbd_nla_parse_nested(ntb, maxtype, tla, s_name ## _nl_policy); \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 161 | if (err) \ |
| 162 | return err; \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 163 | \ |
| 164 | s_fields \ |
| 165 | return 0; \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 166 | } __attribute__((unused)) \ |
| 167 | static int s_name ## _from_attrs(struct s_name *s, \ |
| 168 | struct genl_info *info) \ |
| 169 | { \ |
| 170 | return __ ## s_name ## _from_attrs(s, info, false); \ |
| 171 | } __attribute__((unused)) \ |
| 172 | static int s_name ## _from_attrs_for_change(struct s_name *s, \ |
| 173 | struct genl_info *info) \ |
| 174 | { \ |
| 175 | return __ ## s_name ## _from_attrs(s, info, true); \ |
| 176 | } __attribute__((unused)) \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 177 | |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 178 | #define __assign(attr_nr, attr_flag, name, nla_type, type, assignment...) \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 179 | nla = ntb[attr_nr]; \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 180 | if (nla) { \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 181 | if (exclude_invariants && ((attr_flag) & DRBD_F_INVARIANT)) { \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 182 | pr_info("<< must not change invariant attr: %s\n", #name); \ |
| 183 | return -EEXIST; \ |
| 184 | } \ |
| 185 | assignment; \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 186 | } else if (exclude_invariants && ((attr_flag) & DRBD_F_INVARIANT)) { \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 187 | /* attribute missing from payload, */ \ |
| 188 | /* which was expected */ \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 189 | } else if ((attr_flag) & DRBD_F_REQUIRED) { \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 190 | pr_info("<< missing attr: %s\n", #name); \ |
| 191 | return -ENOMSG; \ |
| 192 | } |
| 193 | |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 194 | #undef __field |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 195 | #define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put, \ |
| 196 | __is_signed) \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 197 | __assign(attr_nr, attr_flag, name, nla_type, type, \ |
| 198 | if (s) \ |
| 199 | s->name = __get(nla); \ |
| 200 | DPRINT_FIELD("<<", nla_type, name, s, nla)) |
| 201 | |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 202 | /* validate_nla() already checked nla_len <= maxlen appropriately. */ |
| 203 | #undef __array |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 204 | #define __array(attr_nr, attr_flag, name, nla_type, type, maxlen, \ |
| 205 | __get, __put, __is_signed) \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 206 | __assign(attr_nr, attr_flag, name, nla_type, type, \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 207 | if (s) \ |
| 208 | s->name ## _len = \ |
| 209 | __get(s->name, nla, maxlen); \ |
Lars Ellenberg | f399002 | 2011-03-23 14:31:09 +0100 | [diff] [blame] | 210 | DPRINT_ARRAY("<<", nla_type, name, s, nla)) |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 211 | |
| 212 | #include GENL_MAGIC_INCLUDE_FILE |
| 213 | |
| 214 | #undef GENL_struct |
| 215 | #define GENL_struct(tag_name, tag_number, s_name, s_fields) |
| 216 | |
| 217 | /* |
| 218 | * Magic: define op number to op name mapping {{{1 |
| 219 | * {{{2 |
| 220 | */ |
| 221 | const char *CONCAT_(GENL_MAGIC_FAMILY, _genl_cmd_to_str)(__u8 cmd) |
| 222 | { |
| 223 | switch (cmd) { |
| 224 | #undef GENL_op |
| 225 | #define GENL_op(op_name, op_num, handler, tla_list) \ |
| 226 | case op_num: return #op_name; |
| 227 | #include GENL_MAGIC_INCLUDE_FILE |
| 228 | default: |
| 229 | return "unknown"; |
| 230 | } |
| 231 | } |
| 232 | |
| 233 | #ifdef __KERNEL__ |
| 234 | #include <linux/stringify.h> |
| 235 | /* |
| 236 | * Magic: define genl_ops {{{1 |
| 237 | * {{{2 |
| 238 | */ |
| 239 | |
| 240 | #undef GENL_op |
| 241 | #define GENL_op(op_name, op_num, handler, tla_list) \ |
| 242 | { \ |
| 243 | handler \ |
| 244 | .cmd = op_name, \ |
| 245 | .policy = CONCAT_(GENL_MAGIC_FAMILY, _tla_nl_policy), \ |
| 246 | }, |
| 247 | |
| 248 | #define ZZZ_genl_ops CONCAT_(GENL_MAGIC_FAMILY, _genl_ops) |
| 249 | static struct genl_ops ZZZ_genl_ops[] __read_mostly = { |
| 250 | #include GENL_MAGIC_INCLUDE_FILE |
| 251 | }; |
| 252 | |
| 253 | #undef GENL_op |
| 254 | #define GENL_op(op_name, op_num, handler, tla_list) |
| 255 | |
| 256 | /* |
| 257 | * Define the genl_family, multicast groups, {{{1 |
| 258 | * and provide register/unregister functions. |
| 259 | * {{{2 |
| 260 | */ |
| 261 | #define ZZZ_genl_family CONCAT_(GENL_MAGIC_FAMILY, _genl_family) |
| 262 | static struct genl_family ZZZ_genl_family __read_mostly = { |
| 263 | .id = GENL_ID_GENERATE, |
| 264 | .name = __stringify(GENL_MAGIC_FAMILY), |
| 265 | .version = GENL_MAGIC_VERSION, |
| 266 | #ifdef GENL_MAGIC_FAMILY_HDRSZ |
| 267 | .hdrsize = NLA_ALIGN(GENL_MAGIC_FAMILY_HDRSZ), |
| 268 | #endif |
| 269 | .maxattr = ARRAY_SIZE(drbd_tla_nl_policy)-1, |
| 270 | }; |
| 271 | |
| 272 | /* |
| 273 | * Magic: define multicast groups |
| 274 | * Magic: define multicast group registration helper |
| 275 | */ |
| 276 | #undef GENL_mc_group |
| 277 | #define GENL_mc_group(group) \ |
| 278 | static struct genl_multicast_group \ |
| 279 | CONCAT_(GENL_MAGIC_FAMILY, _mcg_ ## group) __read_mostly = { \ |
| 280 | .name = #group, \ |
| 281 | }; \ |
| 282 | static int CONCAT_(GENL_MAGIC_FAMILY, _genl_multicast_ ## group)( \ |
| 283 | struct sk_buff *skb, gfp_t flags) \ |
| 284 | { \ |
| 285 | unsigned int group_id = \ |
| 286 | CONCAT_(GENL_MAGIC_FAMILY, _mcg_ ## group).id; \ |
| 287 | if (!group_id) \ |
| 288 | return -EINVAL; \ |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame^] | 289 | return genlmsg_multicast(&ZZZ_genl_family, skb, 0, \ |
| 290 | group_id, flags); \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | #include GENL_MAGIC_INCLUDE_FILE |
| 294 | |
| 295 | int CONCAT_(GENL_MAGIC_FAMILY, _genl_register)(void) |
| 296 | { |
Johannes Berg | c53ed74 | 2013-11-19 15:19:31 +0100 | [diff] [blame] | 297 | int err = genl_register_family_with_ops(&ZZZ_genl_family, ZZZ_genl_ops); |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 298 | if (err) |
| 299 | return err; |
| 300 | #undef GENL_mc_group |
| 301 | #define GENL_mc_group(group) \ |
| 302 | err = genl_register_mc_group(&ZZZ_genl_family, \ |
| 303 | &CONCAT_(GENL_MAGIC_FAMILY, _mcg_ ## group)); \ |
| 304 | if (err) \ |
| 305 | goto fail; \ |
| 306 | else \ |
| 307 | pr_info("%s: mcg %s: %u\n", #group, \ |
| 308 | __stringify(GENL_MAGIC_FAMILY), \ |
| 309 | CONCAT_(GENL_MAGIC_FAMILY, _mcg_ ## group).id); |
| 310 | |
| 311 | #include GENL_MAGIC_INCLUDE_FILE |
| 312 | |
| 313 | #undef GENL_mc_group |
| 314 | #define GENL_mc_group(group) |
| 315 | return 0; |
| 316 | fail: |
| 317 | genl_unregister_family(&ZZZ_genl_family); |
| 318 | return err; |
| 319 | } |
| 320 | |
| 321 | void CONCAT_(GENL_MAGIC_FAMILY, _genl_unregister)(void) |
| 322 | { |
| 323 | genl_unregister_family(&ZZZ_genl_family); |
| 324 | } |
| 325 | |
| 326 | /* |
| 327 | * Magic: provide conversion functions {{{1 |
| 328 | * populate skb from struct. |
| 329 | * {{{2 |
| 330 | */ |
| 331 | |
| 332 | #undef GENL_op |
| 333 | #define GENL_op(op_name, op_num, handler, tla_list) |
| 334 | |
| 335 | #undef GENL_struct |
| 336 | #define GENL_struct(tag_name, tag_number, s_name, s_fields) \ |
| 337 | static int s_name ## _to_skb(struct sk_buff *skb, struct s_name *s, \ |
| 338 | const bool exclude_sensitive) \ |
| 339 | { \ |
| 340 | struct nlattr *tla = nla_nest_start(skb, tag_number); \ |
| 341 | if (!tla) \ |
| 342 | goto nla_put_failure; \ |
| 343 | DPRINT_TLA(#s_name, "-=>", #tag_name); \ |
| 344 | s_fields \ |
| 345 | nla_nest_end(skb, tla); \ |
| 346 | return 0; \ |
| 347 | \ |
| 348 | nla_put_failure: \ |
| 349 | if (tla) \ |
| 350 | nla_nest_cancel(skb, tla); \ |
| 351 | return -EMSGSIZE; \ |
| 352 | } \ |
| 353 | static inline int s_name ## _to_priv_skb(struct sk_buff *skb, \ |
| 354 | struct s_name *s) \ |
| 355 | { \ |
| 356 | return s_name ## _to_skb(skb, s, 0); \ |
| 357 | } \ |
| 358 | static inline int s_name ## _to_unpriv_skb(struct sk_buff *skb, \ |
| 359 | struct s_name *s) \ |
| 360 | { \ |
| 361 | return s_name ## _to_skb(skb, s, 1); \ |
| 362 | } |
| 363 | |
| 364 | |
| 365 | #undef __field |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 366 | #define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put, \ |
| 367 | __is_signed) \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 368 | if (!exclude_sensitive || !((attr_flag) & DRBD_F_SENSITIVE)) { \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 369 | DPRINT_FIELD(">>", nla_type, name, s, NULL); \ |
Andreas Gruenbacher | 26ec928 | 2012-07-11 20:36:03 +0200 | [diff] [blame] | 370 | if (__put(skb, attr_nr, s->name)) \ |
| 371 | goto nla_put_failure; \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | #undef __array |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 375 | #define __array(attr_nr, attr_flag, name, nla_type, type, maxlen, \ |
| 376 | __get, __put, __is_signed) \ |
Andreas Gruenbacher | 5f93592 | 2011-05-19 17:39:28 +0200 | [diff] [blame] | 377 | if (!exclude_sensitive || !((attr_flag) & DRBD_F_SENSITIVE)) { \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 378 | DPRINT_ARRAY(">>",nla_type, name, s, NULL); \ |
Andreas Gruenbacher | 26ec928 | 2012-07-11 20:36:03 +0200 | [diff] [blame] | 379 | if (__put(skb, attr_nr, min_t(int, maxlen, \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 380 | s->name ## _len + (nla_type == NLA_NUL_STRING)),\ |
Andreas Gruenbacher | 26ec928 | 2012-07-11 20:36:03 +0200 | [diff] [blame] | 381 | s->name)) \ |
| 382 | goto nla_put_failure; \ |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 383 | } |
| 384 | |
| 385 | #include GENL_MAGIC_INCLUDE_FILE |
| 386 | |
Andreas Gruenbacher | b966b5d | 2011-05-03 14:56:09 +0200 | [diff] [blame] | 387 | |
| 388 | /* Functions for initializing structs to default values. */ |
| 389 | |
| 390 | #undef __field |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 391 | #define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put, \ |
| 392 | __is_signed) |
Andreas Gruenbacher | b966b5d | 2011-05-03 14:56:09 +0200 | [diff] [blame] | 393 | #undef __array |
Andreas Gruenbacher | 509100e | 2011-05-17 13:29:46 +0200 | [diff] [blame] | 394 | #define __array(attr_nr, attr_flag, name, nla_type, type, maxlen, \ |
| 395 | __get, __put, __is_signed) |
Andreas Gruenbacher | b966b5d | 2011-05-03 14:56:09 +0200 | [diff] [blame] | 396 | #undef __u32_field_def |
| 397 | #define __u32_field_def(attr_nr, attr_flag, name, default) \ |
| 398 | x->name = default; |
Andreas Gruenbacher | 3a45abd | 2011-05-12 12:02:54 +0200 | [diff] [blame] | 399 | #undef __s32_field_def |
| 400 | #define __s32_field_def(attr_nr, attr_flag, name, default) \ |
| 401 | x->name = default; |
Andreas Gruenbacher | b966b5d | 2011-05-03 14:56:09 +0200 | [diff] [blame] | 402 | #undef __flg_field_def |
| 403 | #define __flg_field_def(attr_nr, attr_flag, name, default) \ |
| 404 | x->name = default; |
| 405 | #undef __str_field_def |
| 406 | #define __str_field_def(attr_nr, attr_flag, name, maxlen) \ |
| 407 | memset(x->name, 0, sizeof(x->name)); \ |
| 408 | x->name ## _len = 0; |
| 409 | #undef GENL_struct |
| 410 | #define GENL_struct(tag_name, tag_number, s_name, s_fields) \ |
| 411 | static void set_ ## s_name ## _defaults(struct s_name *x) __attribute__((unused)); \ |
| 412 | static void set_ ## s_name ## _defaults(struct s_name *x) { \ |
| 413 | s_fields \ |
| 414 | } |
| 415 | |
| 416 | #include GENL_MAGIC_INCLUDE_FILE |
| 417 | |
Lars Ellenberg | ec2c35a | 2011-03-07 10:20:08 +0100 | [diff] [blame] | 418 | #endif /* __KERNEL__ */ |
| 419 | |
| 420 | /* }}}1 */ |
| 421 | #endif /* GENL_MAGIC_FUNC_H */ |
| 422 | /* vim: set foldmethod=marker foldlevel=1 nofoldenable : */ |