Lines Matching +full:nested +full:- +full:attributes
2 # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)
20 return name.upper().replace('-', '_')
24 return name.lower().replace('-', '_')
29 Turn a string limit like u32-max or s64-min into its numerical value
31 if name[0] == 'u' and name.endswith('-min'):
33 width = int(name[1:-4])
35 width -= 1
36 value = (1 << width) - 1
37 if name[0] == 's' and name.endswith('-min'):
38 value = -value - 1
44 return 'ys->family_id'
64 if 'nested-attributes' in attr:
65 nested = attr['nested-attributes']
66 elif 'sub-message' in attr:
67 nested = attr['sub-message']
69 nested = None
71 if nested:
72 self.nested_attrs = nested
127 return c_upper(f"{self.family['name']}-{value}")
131 if 'parent-sub-message' in self.attr:
132 enum_name = self.attr['parent-sub-message'].enum_name
133 elif 'name-prefix' in self.attr:
134 enum_name = f"{self.attr['name-prefix']}{self.name}"
178 return [f'free({var}->{ref}{self.c_name});']
189 spc = ' ' if member[-1] != '*' else ''
202 spc = ' ' if member[-1] != '*' else ''
214 if self.attr.get('byte-order') == 'big-endian':
231 ri.cw.p(f"if ({var}->_{presence}.{self.c_name})")
235 line = f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name})"
258 ri.cw.p(f"{var}->_present.{self.c_name} = 1;")
275 member = f"{var}->{'.'.join(ref)}"
284 presence = f"{var}->{'.'.join(ref[:i] + [''])}_present.{ref[i]}"
287 if i == len(ref) - 1 and self.presence_type() != 'present':
288 presence = f"{var}->{'.'.join(ref[:i] + [''])}_{self.presence_type()}.{ref[i]}"
291 ref_path = '.'.join(ref[:-1])
361 if 'byte-order' in attr:
362 self.byte_order_comment = f" /* {attr['byte-order']} */"
378 if 'enum-as-flags' in self.attr and self.attr['enum-as-flags']:
414 if low < -32768 or high > 32767:
415 self.checks['full-range'] = True
418 if 'flags-mask' in self.checks or self.is_bitfield:
423 flags = self.family.consts[self.checks['flags-mask']]
425 mask = (1 << flag_cnt) - 1
427 elif 'full-range' in self.checks:
449 return f"{var}->{self.c_name} = ynl_attr_get_{self.type}(attr);", None, None
489 if 'exact-len' in self.checks:
490 mem = 'NLA_POLICY_EXACT_LEN(' + self.get_limit_str('exact-len') + ')'
493 if 'max-len' in self.checks:
494 mem += ', .len = ' + self.get_limit_str('max-len')
499 if self.checks.get('unterminated-ok', False):
511 len_mem = var + '->_len.' + self.c_name
513 f"{var}->{self.c_name} = malloc(len + 1);",
514 f"memcpy({var}->{self.c_name}, ynl_attr_get_str(attr), len);",
515 f"{var}->{self.c_name}[len] = 0;"], \
544 if check_name not in {'exact-len', 'min-len', 'max-len'}:
551 elif 'exact-len' in self.checks:
552 mem = 'NLA_POLICY_EXACT_LEN(' + self.get_limit_str('exact-len') + ')'
553 elif 'min-len' in self.checks:
554 mem = 'NLA_POLICY_MIN_LEN(' + self.get_limit_str('min-len') + ')'
555 elif 'max-len' in self.checks:
556 mem = 'NLA_POLICY_MAX_LEN(' + self.get_limit_str('max-len') + ')'
562 f"{var}->{self.c_name}, {var}->_len.{self.c_name})")
565 len_mem = var + '->_len.' + self.c_name
567 f"{var}->{self.c_name} = malloc(len);",
568 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
584 len_mem = var + '->_' + self.presence_type() + '.' + self.c_name
587 f"{var}->{self.c_name} = calloc(1, {struct_sz});",
589 f"{var}->{self.c_name} = malloc(len);",
590 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
597 return [f'__{self.get("sub-type")} *{self.c_name}', 'size_t count']
603 ri.cw.p(f'__{self.get("sub-type")} *{self.c_name};')
607 ri.cw.block_start(line=f"if ({var}->_{presence}.{self.c_name})")
608 ri.cw.p(f"i = {var}->_{presence}.{self.c_name} * sizeof(__{self.get('sub-type')});")
610 f"{var}->{self.c_name}, i);")
614 len_mem = var + '->_count.' + self.c_name
615 return [f"{len_mem} = len / sizeof(__{self.get('sub-type')});",
616 f"len = {len_mem} * sizeof(__{self.get('sub-type')});",
617 f"{var}->{self.c_name} = malloc(len);",
618 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
624 f"count *= sizeof(__{self.get('sub-type')});",
644 line = f"ynl_attr_put(nlh, {self.enum_name}, &{var}->{self.c_name}, sizeof(struct nla_bitfield32))"
648 return f"memcpy(&{var}->{self.c_name}, ynl_attr_data(attr), sizeof(struct nla_bitfield32));", None, None
666 lines += [f'if ({var}->{ref}{self.c_name})']
667 lines += [f'{self.nested_render_name}_free({at}{var}->{ref}{self.c_name});']
679 f"{self.enum_name}, {at}{var}->{self.c_name})")
685 args.append(f'{var}->{sel.name}')
689 f"parg.data = &{var}->{self.c_name};"]
729 raise Exception(f"Sub-type {self.attr['type']} not supported yet")
743 lines += [f"free({var}->{ref}{self.c_name});"]
745 lines += [f"free({var}->{ref}{self.c_name});"]
748 f"for (i = 0; i < {var}->{ref}_count.{self.c_name}; i++)",
749 f"free({var}->{ref}{self.c_name}[i]);",
750 f"free({var}->{ref}{self.c_name});",
754 f"for (i = 0; i < {var}->{ref}_count.{self.c_name}; i++)",
755 f'{self.nested_render_name}_free(&{var}->{ref}{self.c_name}[i]);',
756 f"free({var}->{ref}{self.c_name});",
759 raise Exception(f"Free of MultiAttr sub-type {self.attr['type']} not supported yet")
774 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
775 ri.cw.p(f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name}[i]);")
777 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
778 ri.cw.p(f"ynl_attr_put(nlh, {self.enum_name}, &{var}->{self.c_name}[i], sizeof(struct {c_lower(self.attr['struct'])}));")
780 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
781 ri.cw.p(f"ynl_attr_put_str(nlh, {self.enum_name}, {var}->{self.c_name}[i]->str);")
783 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
785 f"{self.enum_name}, &{var}->{self.c_name}[i])")
787 raise Exception(f"Put of MultiAttr sub-type {self.attr['type']} not supported yet")
802 if 'sub-type' not in self.attr or self.attr['sub-type'] == 'nest':
804 elif self.attr['sub-type'] in scalars:
806 return scalar_pfx + self.attr['sub-type']
807 elif self.attr['sub-type'] == 'binary' and 'exact-len' in self.checks:
810 raise Exception(f"Sub-type {self.attr['sub-type']} not supported yet")
813 if self.sub_type == 'binary' and 'exact-len' in self.checks:
814 return [f'unsigned char (*{self.c_name})[{self.checks["exact-len"]}]',
819 if self.attr['sub-type'] == 'nest':
824 if self.attr['sub-type'] in scalars:
826 elif self.attr['sub-type'] == 'binary' and 'exact-len' in self.checks:
827 return f'.type = YNL_PT_BINARY, .len = {self.checks["exact-len"]}, '
828 elif self.attr['sub-type'] == 'nest':
831 raise Exception(f"Typol for IndexedArray sub-type {self.attr['sub-type']} not supported, yet")
847 ri.cw.block_start(line=f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
848 ri.cw.p(f"ynl_attr_put_{put_type}(nlh, i, {var}->{self.c_name}[i]);")
850 elif self.sub_type == 'binary' and 'exact-len' in self.checks:
851 ri.cw.p(f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
852 ri.cw.p(f"ynl_attr_put(nlh, i, {var}->{self.c_name}[i], {self.checks['exact-len']});")
854 ri.cw.p(f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
855 ri.cw.p(f"{self.nested_render_name}_put(nlh, i, &{var}->{self.c_name}[i]);")
857 raise Exception(f"Put for IndexedArray sub-type {self.attr['sub-type']} not supported, yet")
878 f"parg.data = &{var}->{self.c_name};"]
879 if 'type-value' in self.attr:
880 tv_names = [c_lower(x) for x in self.attr["type-value"]]
883 for level in self.attr["type-value"]:
904 # Reverse-parsing of the policy (ynl_err_walk() in ynl.c) does not
905 # support external selectors. No family uses sub-messages with external
916 sel_var = f"{var}->{sel}"
923 f"parg.data = &{var}->{self.c_name};"]
961 self.nested = type_list is None
965 self.render_name = c_lower(family.ident_name + '-' + space_name)
967 if self.nested and space_name in family.consts:
1045 self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1047 if 'enum-name' in yaml:
1048 if yaml['enum-name']:
1049 self.enum_name = 'enum ' + c_lower(yaml['enum-name'])
1061 self.value_pfx = yaml.get('name-prefix', f"{family.ident_name}-{yaml['name']}-")
1063 self.enum_cnt_name = yaml.get('enum-cnt-name', None)
1074 if high - low + 1 != len(self.entries):
1085 if 'name-prefix' in yaml:
1086 pfx = yaml['name-prefix']
1088 pfx = family.ident_name + '-a-'
1090 pfx = f"{family.ident_name}-a-{self.name}-"
1092 self.max_name = c_upper(self.yaml.get('attr-max-name', f"{self.name_prefix}max"))
1093 self.cnt_name = c_upper(self.yaml.get('attr-cnt-name', f"__{self.name_prefix}max"))
1124 elif elem.get('sub-type') in scalars:
1132 elif elem['type'] == 'indexed-array' and 'sub-type' in elem:
1133 if elem["sub-type"] in ['binary', 'nest', 'u32']:
1136 raise Exception(f'new_attr: unsupported sub-type {elem["sub-type"]}')
1137 elif elem['type'] == 'nest-type-value':
1139 elif elem['type'] == 'sub-message':
1144 if 'multi-attr' in elem and elem['multi-attr']:
1152 # Fill in missing operation properties (for fixed hdr-only msgs)
1156 yaml[mode][direction].setdefault('attributes', [])
1189 self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1213 self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
1214 self.ver_key = c_upper(self.yaml.get('c-version-name', self.yaml["name"] + '_FAMILY_VERSION'))
1219 if 'uapi-header' in self.yaml:
1220 self.uapi_header = self.yaml['uapi-header']
1224 self.uapi_header_name = self.uapi_header[6:-2]
1232 if 'name-prefix' in self.yaml['operations']:
1233 self.op_prefix = c_upper(self.yaml['operations']['name-prefix'])
1235 self.op_prefix = c_upper(self.yaml['name'] + '-cmd-')
1236 if 'async-prefix' in self.yaml['operations']:
1237 self.async_op_prefix = c_upper(self.yaml['operations']['async-prefix'])
1241 self.mcgrps = self.yaml.get('mcast-groups', {'list': []})
1251 # dict space-name -> 'request': set(attrs), 'reply': set(attrs)
1253 # dict space-name -> Struct
1265 self.kernel_policy = self.yaml.get('kernel-policy', 'split')
1282 return self.proto == 'netlink-raw'
1295 'attributes': op['event']['attributes']
1301 if 'attribute-set' not in op:
1308 req_attrs.update(set(op[op_mode]['request']['attributes']))
1310 rsp_attrs.update(set(op[op_mode]['reply']['attributes']))
1312 rsp_attrs.update(set(op['event']['attributes']))
1314 if op['attribute-set'] not in self.root_sets:
1315 self.root_sets[op['attribute-set']] = {'request': req_attrs, 'reply': rsp_attrs}
1317 self.root_sets[op['attribute-set']]['request'].update(req_attrs)
1318 self.root_sets[op['attribute-set']]['reply'].update(rsp_attrs)
1331 if 'nested-attributes' in spec:
1332 nested = spec['nested-attributes']
1333 elif 'sub-message' in spec:
1334 nested = spec.sub_message
1339 if self.pure_nested_structs[nested].recursive:
1341 if nested not in pns_key_seen:
1354 nested = spec['nested-attributes']
1355 if nested not in self.root_sets:
1356 if nested not in self.pure_nested_structs:
1357 self.pure_nested_structs[nested] = \
1358 Struct(self, nested, inherited=inherit,
1359 fixed_header=spec.get('fixed-header'))
1361 raise Exception(f'Using attr set as root and nested not supported - {nested}')
1363 if 'type-value' in spec:
1364 if nested in self.root_sets:
1366 inherit.update(set(spec['type-value']))
1367 elif spec['type'] == 'indexed-array':
1369 self.pure_nested_structs[nested].set_inherited(inherit)
1371 return nested
1374 # Fake the struct type for the sub-message itself
1376 submsg = self.sub_msgs[spec["sub-message"]]
1377 nested = submsg.name
1383 "parent-sub-message": spec,
1385 if 'attribute-set' in fmt:
1388 "nested-attributes": fmt['attribute-set'],
1390 if 'fixed-header' in fmt:
1391 attr |= { "fixed-header": fmt["fixed-header"] }
1392 elif 'fixed-header' in fmt:
1395 "struct": fmt["fixed-header"],
1401 self.attr_sets[nested] = AttrSet(self, {
1402 "name": nested,
1403 "name-pfx": self.name + '-' + spec.name + '-',
1404 "attributes": attrs
1407 if nested not in self.pure_nested_structs:
1408 self.pure_nested_structs[nested] = Struct(self, nested, submsg=submsg)
1410 return nested
1419 if 'nested-attributes' in spec:
1420 nested = self._load_nested_set_nest(spec)
1421 elif 'sub-message' in spec:
1422 nested = self._load_nested_set_submsg(spec)
1426 if nested not in attr_set_seen:
1427 attr_set_queue.append(nested)
1428 attr_set_seen.add(nested)
1432 if 'nested-attributes' in spec:
1433 nested = spec['nested-attributes']
1434 elif 'sub-message' in spec:
1435 nested = spec.sub_message
1437 nested = None
1439 if nested:
1441 self.pure_nested_structs[nested].request = True
1443 self.pure_nested_structs[nested].reply = True
1446 child = self.pure_nested_structs.get(nested)
1457 if 'nested-attributes' in spec:
1458 child_name = spec['nested-attributes']
1459 elif 'sub-message' in spec:
1501 if 'nested-attributes' in spec:
1502 child_name = spec['nested-attributes']
1503 elif 'sub-message' in spec:
1522 if 'attribute-set' not in op:
1526 attr_set_name = op['attribute-set']
1527 if attr_set_name != op['attribute-set']:
1534 global_set.update(req.get('attributes', []))
1566 self.fixed_hdr_len = 'ys->family->hdr_len'
1572 raise Exception("Per-op fixed header not supported, yet")
1590 self.attr_set = op['attribute-set']
1609 type_list = op[op_mode][op_dir]['attributes']
1616 type_list=op['event']['attributes'])
1676 if line[-1] == ':':
1677 ind -= 1
1700 self._ind -= 1
1732 if qual_ret[-1] != '*':
1744 elif qual_ret[-1] != '*':
1748 delta_ind = len(v) - len(ind)
1793 line += '\t' * ((longest - len(define[0]) + 7) // 8)
1806 line += '\t' * ((longest - len(one[0]) - 1 + 7) // 8)
1956 cw.p(f'.max_attr = {i - 1},')
1994 cw.p(f'{arg_name} = ffs({arg_name}) - 1;')
2048 has_array |= arg.type == 'indexed-array'
2077 init_lines.append(f"memcpy(hdr, &obj->_hdr, {struct_sz});")
2103 if struct.nested:
2105 iter_line = f"ynl_attr_for_each_nested_off(attr, nested, sizeof({struct.fixed_header}))"
2107 iter_line = "ynl_attr_for_each_nested(attr, nested)"
2109 iter_line = "ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len)"
2114 raise Exception("Per-op fixed header not supported, yet")
2121 if aspec['type'] == 'indexed-array' and 'sub-type' in aspec:
2122 if aspec["sub-type"] in {'binary', 'nest'}:
2125 elif aspec['sub-type'] in scalars:
2129 raise Exception(f'Not supported sub-type {aspec["sub-type"]}')
2130 if 'multi-attr' in aspec:
2132 needs_parg |= 'nested-attributes' in aspec
2133 needs_parg |= 'sub-message' in aspec
2145 init_lines.append('parg.ys = yarg->ys;')
2160 ri.cw.p(f'dst->{arg} = {arg};')
2163 if struct.nested:
2164 ri.cw.p('hdr = ynl_attr_data(nested);')
2169 ri.cw.p(f"memcpy(&dst->_hdr, hdr, sizeof({struct.fixed_header}));")
2172 ri.cw.p(f"if (dst->{aspec.c_name})")
2193 ri.cw.p(f"dst->{aspec.c_name} = calloc(n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")
2194 ri.cw.p(f"dst->_count.{aspec.c_name} = n_{aspec.c_name};")
2196 if 'nested-attributes' in aspec:
2199 if 'nested-attributes' in aspec:
2200 ri.cw.p(f"parg.data = &dst->{aspec.c_name}[i];")
2204 ri.cw.p(f"dst->{aspec.c_name}[i] = ynl_attr_get_{aspec.sub_type}(attr);")
2205 elif aspec.sub_type == 'binary' and 'exact-len' in aspec.checks:
2207 ri.cw.p(f'memcpy(dst->{aspec.c_name}[i], ynl_attr_data(attr), {aspec.checks["exact-len"]});')
2218 ri.cw.p(f"dst->{aspec.c_name} = calloc(n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")
2219 ri.cw.p(f"dst->_count.{aspec.c_name} = n_{aspec.c_name};")
2221 if 'nested-attributes' in aspec:
2225 if 'nested-attributes' in aspec:
2226 ri.cw.p(f"parg.data = &dst->{aspec.c_name}[i];")
2230 ri.cw.p(f"dst->{aspec.c_name}[i] = ynl_attr_get_{aspec.type}(attr);")
2234 ri.cw.p(f'if (len > sizeof(dst->{aspec.c_name}[0]))')
2235 ri.cw.p(f'len = sizeof(dst->{aspec.c_name}[0]);')
2236 ri.cw.p(f"memcpy(&dst->{aspec.c_name}[i], ynl_attr_data(attr), len);")
2241 ri.cw.p(f'dst->{aspec.c_name}[i] = malloc(sizeof(struct ynl_string) + len + 1);')
2242 ri.cw.p(f"dst->{aspec.c_name}[i]->len = len;")
2243 ri.cw.p(f"memcpy(dst->{aspec.c_name}[i]->str, ynl_attr_get_str(attr), len);")
2244 ri.cw.p(f"dst->{aspec.c_name}[i]->str[len] = 0;")
2253 if struct.nested:
2265 local_vars = {'const struct nlattr *attr = nested;',
2266 f'{struct.ptr_name}{var} = yarg->data;',
2275 ri.cw.p('parg.ys = yarg->ys;')
2290 ri.cw.p(f"{var}->_present.{arg.c_name} = 1;")
2299 'const struct nlattr *nested']
2318 f'{struct.ptr_name}dst = yarg->data;']
2340 init_lines = ['dst = yarg->data;']
2356 ret_err = '-1'
2378 ri.cw.p(f"nlh = ynl_msg_start_req(ys, {ri.op.enum_name}, req->_nlmsg_flags);")
2382 ri.cw.p(f"ys->req_policy = &{ri.struct['request'].render_name}_nest;")
2383 ri.cw.p(f"ys->req_hdr_len = {ri.fixed_hdr_len};")
2389 ri.cw.p("hdr_len = sizeof(req->_hdr);")
2391 ri.cw.p("memcpy(hdr, &req->_hdr, hdr_len);")
2412 ri.cw.p('return -1;')
2459 ri.cw.p("hdr_len = sizeof(req->_hdr);")
2461 ri.cw.p("memcpy(hdr, &req->_hdr, hdr_len);")
2465 ri.cw.p(f"ys->req_policy = &{ri.struct['request'].render_name}_nest;")
2466 ri.cw.p(f"ys->req_hdr_len = {ri.fixed_hdr_len};")
2528 ri.cw.p('req->_nlmsg_flags = nl_flags;')
2716 ri.cw.p('next = rsp->next;')
2762 cw.ifdef_block(ri.op.get('config-cond', None))
2788 if 'full-range' not in attr.checks:
2841 cw.p('return -EINVAL;')
2853 'per-op': 'genl_ops',
2902 name = c_lower(f"{family.ident_name}-nl-{op_name}-doit")
2907 name = c_lower(f"{family.ident_name}-nl-{op_name}-dumpit")
2919 if family.kernel_policy == 'global' or family.kernel_policy == 'per-op':
2924 cw.ifdef_block(op.get('config-cond', None))
2927 if 'dont-validate' in op:
2929 ' | '.join([c_upper('genl-dont-validate-' + x)
2930 for x in op['dont-validate']])), )
2933 name = c_lower(f"{family.ident_name}-nl-{op_name}-{op_mode}it")
2935 if family.kernel_policy == 'per-op':
2936 struct = Struct(family, op['attribute-set'],
2937 type_list=op['do']['request']['attributes'])
2939 name = c_lower(f"{family.ident_name}-{op_name}-nl-policy")
2943 members.append(('flags', ' | '.join([c_upper('genl-' + x) for x in op['flags']])))
2955 cw.ifdef_block(op.get('config-cond', None))
2958 if 'dont-validate' in op:
2960 for x in op['dont-validate']:
2961 if op_mode == 'do' and x in ['dump', 'dump-strict']:
2969 ' | '.join([c_upper('genl-dont-validate-' + x)
2971 name = c_lower(f"{family.ident_name}-nl-{op_name}-{op_mode}it")
2978 struct = Struct(family, op['attribute-set'],
2979 type_list=op[op_mode]['request']['attributes'])
2982 name = c_lower(f"{family.ident_name}-{op_name}-{op_mode}-nl-policy")
2984 name = c_lower(f"{family.ident_name}-{op_name}-nl-policy")
2987 flags = (op['flags'] if 'flags' in op else []) + ['cmd-cap-' + op_mode]
2988 members.append(('flags', ' | '.join([c_upper('genl-' + x) for x in flags])))
3003 grp_id = c_upper(f"{family.ident_name}-nlgrp-{grp['name']},")
3016 grp_id = c_upper(f"{family.ident_name}-nlgrp-{name}")
3028 if 'sock-priv' in family.kernel_family:
3029 cw.p(f'void {family.c_name}_nl_sock_priv_init({family.kernel_family["sock-priv"]} *priv);')
3030 cw.p(f'void {family.c_name}_nl_sock_priv_destroy({family.kernel_family["sock-priv"]} *priv);')
3038 if 'sock-priv' in family.kernel_family:
3055 if family.kernel_policy == 'per-op':
3064 if 'sock-priv' in family.kernel_family:
3065 cw.p(f'.sock_priv_size\t= sizeof({family.kernel_family["sock-priv"]}),')
3071 def uapi_enum_start(family, cw, obj, ckey='', enum_name='enum-name'):
3082 max_name = c_upper(family.get('cmd-max-name', f"{family.op_prefix}MAX"))
3083 cnt_name = c_upper(family.get('cmd-cnt-name', f"__{family.op_prefix}MAX"))
3084 max_value = f"({cnt_name} - 1)"
3086 uapi_enum_start(family, cw, family['operations'], 'enum-name')
3111 max_value = f"({cnt_name} - 1)"
3135 max_value = f"({cnt_name} - 1)"
3196 doc = ' - ' + enum['doc']
3208 name_pfx = const.get('name-prefix', f"{family.ident_name}-{const['name']}-")
3215 if const.get('render-max', False):
3228 cw.p(max_name + ' = (' + c_upper(cnt_name) + ' - 1)')
3232 name_pfx = const.get('name-prefix', f"{family.ident_name}-")
3233 defines.append([c_upper(family.get('c-define-name',
3241 max_by_define = family.get('max-by-define', False)
3247 max_value = f"({attr_set.cnt_name} - 1)"
3250 uapi_enum_start(family, cw, attr_set.yaml, 'enum-name')
3269 separate_ntf = 'async-prefix' in family['operations']
3276 raise Exception(f'Unsupported message enum-model {family.msg_id_model}')
3279 uapi_enum_start(family, cw, family['operations'], enum_name='async-enum')
3295 defines.append([c_upper(grp.get('c-define-name', f"{family.ident_name}-mcgrp-{name}")),
3378 return full_path, sub_path[:-1]
3383 parser.add_argument('--mode', dest='mode', type=str, required=True,
3385 parser.add_argument('--spec', dest='spec', type=str, required=True)
3386 parser.add_argument('--header', dest='header', action='store_true', default=None)
3387 parser.add_argument('--source', dest='header', action='store_false')
3388 parser.add_argument('--user-header', nargs='+', default=[])
3389 parser.add_argument('--cmp-out', action='store_true', default=None,
3391 parser.add_argument('--exclude-op', action='append', default=[])
3392 parser.add_argument('-o', dest='out_file', type=str, default=None)
3396 parser.error("--header or --source is required")
3402 if parsed.license != '((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)':
3404 print('License must be: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)')
3415 cw.p(f'/* SPDX-License-Identifier: {parsed.license} */')
3417 cw.p(f'// SPDX-License-Identifier: {parsed.license}')
3418 cw.p("/* Do not edit directly, auto-generated from: */")
3420 cw.p(f"/* YNL-GEN {args.mode} {'header' if args.header else 'source'} */")
3423 line += ' --user-header '.join([''] + args.user_header)
3424 line += ' --exclude-op '.join([''] + args.exclude_op)
3425 cw.p(f'/* YNL-ARG{line} */')
3439 hdr_file = os.path.basename(args.out_file[:-2]) + ".h"
3464 for definition in parsed['definitions'] + parsed['attribute-sets']:
3492 cw.p('/* Common nested types */')
3506 if parsed.kernel_policy in {'per-op', 'split'}:
3522 cw.p('/* Common nested types */')
3537 if parsed.kernel_policy in {'per-op', 'split'}:
3540 cw.p(f"/* {op.enum_name} - {op_mode} */")
3559 cw.p('/* Common nested types */')
3568 cw.p(f"/* {op.enum_name} - do */")
3580 cw.p(f"/* {op.enum_name} - dump */")
3591 cw.p(f"/* {op.enum_name} - notify */")
3600 cw.p(f"/* {op.enum_name} - event */")
3628 cw.p('/* Common nested types */')
3650 cw.p(f"/* {op.enum_name} - do */")
3659 cw.p(f"/* {op.enum_name} - dump */")
3669 cw.p(f"/* {op.enum_name} - notify */")
3677 cw.p(f"/* {op.enum_name} - event */")