37     def __init__(self, family, attr_set, attr, value):  argument
38         super().__init__(family, attr_set, attr, value)
49             if self.nested_attrs == family.name:
50                 self.nested_render_name = f"{family.name}"
52                 self.nested_render_name = f"{family.name}_{c_lower(self.nested_attrs)}"
54             if self.nested_attrs in self.family.consts:
255     def __init__(self, family, attr_set, attr, value):  argument
256         super().__init__(family, attr_set, attr, value)
274             self.is_bitfield = self.family.consts[self.attr['enum']]['type'] == 'flags'
279         if maybe_enum and self.family.consts[self.attr['enum']].enum_name:
280             self.type_name = f"enum {self.family.name}_{c_lower(self.attr['enum'])}"
294                 enum = self.family.consts[self.attr['enum']]
297                 flags = self.family.consts[self.checks['flags-mask']]
304             enum = self.family.consts[self.attr['enum']]
463         for _, attr in ri.family.pure_nested_structs[self.nested_attrs].member_list():
468     def __init__(self, family, attr_set, attr, value, base_type):  argument
469         super().__init__(family, attr_set, attr, value)
595     def __init__(self, family, space_name, type_list=None, inherited=None):  argument
596         self.family = family
598         self.attr_set = family.attr_sets[space_name]
604         if family.name == c_lower(space_name):
605             self.render_name = f"{family.name}"
607             self.render_name = f"{family.name}_{c_lower(space_name)}"
609         if self.nested and space_name in family.consts:
669     def __init__(self, family, yaml):  argument
670         self.render_name = c_lower(family.name + '-' + yaml['name'])
680         self.value_pfx = yaml.get('name-prefix', f"{family.name}-{yaml['name']}-")
682         super().__init__(family, yaml)
698     def __init__(self, family, yaml):  argument
699         super().__init__(family, yaml)
704             elif self.name == family.name:
705                 pfx = family.name + '-a-'
707                 pfx = f"{family.name}-a-{self.name}-"
711             self.name_prefix = family.attr_sets[self.subset_of].name_prefix
712             self.max_name = family.attr_sets[self.subset_of].max_name
722         if self.c_name == self.family.c_name:
727             t = TypeScalar(self.family, self, elem, value)
729             t = TypeUnused(self.family, self, elem, value)
731             t = TypePad(self.family, self, elem, value)
733             t = TypeFlag(self.family, self, elem, value)
735             t = TypeString(self.family, self, elem, value)
737             t = TypeBinary(self.family, self, elem, value)
739             t = TypeNest(self.family, self, elem, value)
741             t = TypeArrayNest(self.family, self, elem, value)
743             t = TypeNestTypeValue(self.family, self, elem, value)
748             t = TypeMultiAttr(self.family, self, elem, value, t)
754     def __init__(self, family, yaml, req_value, rsp_value):  argument
755         super().__init__(family, yaml, req_value, rsp_value)
757         self.render_name = family.name + '_' + c_lower(self.name)
772             self.enum_name = self.family.op_prefix + c_upper(self.name)
774             self.enum_name = self.family.async_op_prefix + c_upper(self.name)
780 class Family(SpecFamily):  class
798         self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
1007     def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None):  argument
1008         self.family = family
1031             if attr_set in family.consts:
1041                 self.struct[op_dir] = Struct(family, self.attr_set,
1044 …          self.struct['reply'] = Struct(family, self.attr_set, type_list=op['event']['attributes'])
1301     return f"{ri.family['name']}{suffix}"
1366 def put_op_name_fwd(family, cw):  argument
1367     cw.write_func_prot('const char *', f'{family.name}_op_str', ['int op'], suffix=';')
1370 def put_op_name(family, cw):  argument
1371     map_name = f'{family.name}_op_strmap'
1373     for op_name, op in family.msgs.items():
1382     _put_enum_to_str_helper(cw, family.name + '_op', map_name, 'op')
1385 def put_enum_to_str_fwd(family, cw, enum):  argument
1392 def put_enum_to_str(family, cw, enum):  argument
1707     ri.cw.block_start(line=f"struct {ri.family['name']}{suffix}")
1796         ri.cw.p('__u16 family;')
1874     if terminate and ri and policy_should_be_static(struct.family):
1880         if ri and policy_should_be_static(struct.family):
1905 def kernel_can_gen_family_struct(family):  argument
1906     return family.proto == 'genetlink'
1909 def policy_should_be_static(family):  argument
1910     return family.kernel_policy == 'split' or kernel_can_gen_family_struct(family)
1913 def print_kernel_op_table_fwd(family, cw, terminate):  argument
1914     exported = not kernel_can_gen_family_struct(family)
1917         cw.p(f"/* Ops table for {family.name} */")
1922         struct_type = pol_to_struct[family.kernel_policy]
1926         elif family.kernel_policy == 'split':
1928             for op in family.ops.values():
1934             cnt = len(family.ops)
1937         line = f"{qual} struct {struct_type} {family.name}_nl_ops[{cnt}]"
1947     for name in family.hooks['pre']['do']['list']:
1951     for name in family.hooks['post']['do']['list']:
1955     for name in family.hooks['pre']['dump']['list']:
1958     for name in family.hooks['post']['dump']['list']:
1964     for op_name, op in family.ops.items():
1969             name = c_lower(f"{family.name}-nl-{op_name}-doit")
1974             name = c_lower(f"{family.name}-nl-{op_name}-dumpit")
1980 def print_kernel_op_table_hdr(family, cw):  argument
1981     print_kernel_op_table_fwd(family, cw, terminate=True)
1984 def print_kernel_op_table(family, cw):  argument
1985     print_kernel_op_table_fwd(family, cw, terminate=False)
1986     if family.kernel_policy == 'global' or family.kernel_policy == 'per-op':
1987         for op_name, op in family.ops.items():
1999                     name = c_lower(f"{family.name}-nl-{op_name}-{op_mode}it")
2001             if family.kernel_policy == 'per-op':
2002                 struct = Struct(family, op['attribute-set'],
2005                 name = c_lower(f"{family.name}-{op_name}-nl-policy")
2012     elif family.kernel_policy == 'split':
2016         for op_name, op in family.ops.items():
2036                 name = c_lower(f"{family.name}-nl-{op_name}-{op_mode}it")
2043                     struct = Struct(family, op['attribute-set'],
2047                         name = c_lower(f"{family.name}-{op_name}-{op_mode}-nl-policy")
2049                         name = c_lower(f"{family.name}-{op_name}-nl-policy")
2061 def print_kernel_mcgrp_hdr(family, cw):  argument
2062     if not family.mcgrps['list']:
2066     for grp in family.mcgrps['list']:
2067         grp_id = c_upper(f"{family.name}-nlgrp-{grp['name']},")
2073 def print_kernel_mcgrp_src(family, cw):  argument
2074     if not family.mcgrps['list']:
2077     cw.block_start('static const struct genl_multicast_group ' + family.name + '_nl_mcgrps[] =')
2078     for grp in family.mcgrps['list']:
2080         grp_id = c_upper(f"{family.name}-nlgrp-{name}")
2086 def print_kernel_family_struct_hdr(family, cw):  argument
2087     if not kernel_can_gen_family_struct(family):
2090     cw.p(f"extern struct genl_family {family.name}_nl_family;")
2094 def print_kernel_family_struct_src(family, cw):  argument
2095     if not kernel_can_gen_family_struct(family):
2098     cw.block_start(f"struct genl_family {family.name}_nl_family __ro_after_init =")
2099     cw.p('.name\t\t= ' + family.fam_key + ',')
2100     cw.p('.version\t= ' + family.ver_key + ',')
2104     if family.kernel_policy == 'per-op':
2105         cw.p(f'.ops\t\t= {family.name}_nl_ops,')
2106         cw.p(f'.n_ops\t\t= ARRAY_SIZE({family.name}_nl_ops),')
2107     elif family.kernel_policy == 'split':
2108         cw.p(f'.split_ops\t= {family.name}_nl_ops,')
2109         cw.p(f'.n_split_ops\t= ARRAY_SIZE({family.name}_nl_ops),')
2110     if family.mcgrps['list']:
2111         cw.p(f'.mcgrps\t\t= {family.name}_nl_mcgrps,')
2112         cw.p(f'.n_mcgrps\t= ARRAY_SIZE({family.name}_nl_mcgrps),')
2116 def uapi_enum_start(family, cw, obj, ckey='', enum_name='enum-name'):  argument
2122         start_line = 'enum ' + family.name + '_' + c_lower(obj[ckey])
2126 def render_uapi(family, cw):  argument
2127     hdr_prot = f"_UAPI_LINUX_{family.name.upper()}_H"
2132     defines = [(family.fam_key, family["name"]),
2133                (family.ver_key, family.get('version', 1))]
2138     for const in family['definitions']:
2146             enum = family.consts[const['name']]
2160             uapi_enum_start(family, cw, const, 'name')
2161             name_pfx = const.get('name-prefix', f"{family.name}-{const['name']}-")
2182             defines.append([c_upper(family.get('c-define-name',
2183                                                f"{family.name}-{const['name']}")),
2190     max_by_define = family.get('max-by-define', False)
2192     for _, attr_set in family.attr_sets.items():
2196         cnt_name = c_upper(family.get('attr-cnt-name', f"__{attr_set.name_prefix}MAX"))
2200         uapi_enum_start(family, cw, attr_set.yaml, 'enum-name')
2218     separate_ntf = 'async-prefix' in family['operations']
2220     max_name = c_upper(family.get('cmd-max-name', f"{family.op_prefix}MAX"))
2221     cnt_name = c_upper(family.get('cmd-cnt-name', f"__{family.op_prefix}MAX"))
2224     uapi_enum_start(family, cw, family['operations'], 'enum-name')
2226     for op in family.msgs.values():
2246         uapi_enum_start(family, cw, family['operations'], enum_name='async-enum')
2247         for op in family.msgs.values():
2260     for grp in family.mcgrps['list']:
2262         defines.append([c_upper(grp.get('c-define-name', f"{family.name}-mcgrp-{name}")),
2281 def render_user_family(family, cw, prototype):  argument
2282     symbol = f'const struct ynl_family ynl_{family.c_name}_family'
2287     if family.ntfs:
2288         cw.block_start(line=f"static const struct ynl_ntf_info {family['name']}_ntf_info[] = ")
2289         for ntf_op_name, ntf_op in family.ntfs.items():
2291                 op = family.ops[ntf_op['notify']]
2292                 ri = RenderInfo(cw, family, "user", op, "notify")
2294                 ri = RenderInfo(cw, family, "user", ntf_op, "event")
2298         for op_name, op in family.ops.items():
2301             ri = RenderInfo(cw, family, "user", op, "event")
2307     cw.p(f'.name\t\t= "{family.name}",')
2308     if family.ntfs:
2309         cw.p(f".ntf_info\t= {family['name']}_ntf_info,")
2310         cw.p(f".ntf_info_size\t= MNL_ARRAY_SIZE({family['name']}_ntf_info),")
2341         parsed = Family(args.spec, exclude_ops)