49     def __init__(self, family, attr_set, attr, value):  argument
50         super().__init__(family, attr_set, attr, value)
74             if self.nested_attrs == family.name:
75                 self.nested_render_name = c_lower(f"{family.ident_name}")
77                 self.nested_render_name = c_lower(f"{family.ident_name}_{self.nested_attrs}")
79             if self.nested_attrs in self.family.consts:
96         return self.family.attr_sets[self.attr_set.subset_of][self.name]
114         if value in self.family.consts:
115             return self.family.consts[value]["value"]
124         if value in self.family.consts:
125             const = self.family.consts[value]
128             return c_upper(f"{self.family['name']}-{value}")
362     def __init__(self, family, attr_set, attr, value):  argument
363         super().__init__(family, attr_set, attr, value)
371         if not family.is_classic():
386             self.is_bitfield = self.family.consts[self.attr['enum']]['type'] == 'flags'
391             self.type_name = self.family.consts[self.attr['enum']].user_type
399             enum = self.family.consts[self.attr['enum']]
425                 enum = self.family.consts[self.attr['enum']]
428                 flags = self.family.consts[self.checks['flags-mask']]
644         enum = self.family.consts[self.attr['enum']]
661         return self.family.pure_nested_structs[self.nested_attrs].recursive
687         pns = self.family.pure_nested_structs[self.nested_attrs]
700         for _, attr in ri.family.pure_nested_structs[self.nested_attrs].member_list():
708     def __init__(self, family, attr_set, attr, value, base_type):  argument
709         super().__init__(family, attr_set, attr, value)
890     def __init__(self, family, attr_set, attr, value):  argument
891         super().__init__(family, attr_set, attr, value)
899         # support external selectors. No family uses sub-messages with external
942     def __init__(self, family, space_name, type_list=None, fixed_header=None,  argument
944         self.family = family
946         self.attr_set = family.attr_sets[space_name]
956         if family.name == c_lower(space_name):
957             self.render_name = c_lower(family.ident_name)
959             self.render_name = c_lower(family.ident_name + '-' + space_name)
961         if self.nested and space_name in family.consts:
1038     def __init__(self, family, yaml):  argument
1039         self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1055         self.value_pfx = yaml.get('name-prefix', f"{family.ident_name}-{yaml['name']}-")
1059         super().__init__(family, yaml)
1075     def __init__(self, family, yaml):  argument
1076         super().__init__(family, yaml)
1081             elif self.name == family.name:
1082                 pfx = family.ident_name + '-a-'
1084                 pfx = f"{family.ident_name}-a-{self.name}-"
1089             self.name_prefix = family.attr_sets[self.subset_of].name_prefix
1090             self.max_name = family.attr_sets[self.subset_of].max_name
1091             self.cnt_name = family.attr_sets[self.subset_of].cnt_name
1101         if self.c_name == self.family.c_name:
1106             t = TypeScalar(self.family, self, elem, value)
1108             t = TypeUnused(self.family, self, elem, value)
1110             t = TypePad(self.family, self, elem, value)
1112             t = TypeFlag(self.family, self, elem, value)
1114             t = TypeString(self.family, self, elem, value)
1117                 t = TypeBinaryStruct(self.family, self, elem, value)
1119                 t = TypeBinaryScalarArray(self.family, self, elem, value)
1121                 t = TypeBinary(self.family, self, elem, value)
1123             t = TypeBitfield32(self.family, self, elem, value)
1125             t = TypeNest(self.family, self, elem, value)
1128                 t = TypeArrayNest(self.family, self, elem, value)
1132             t = TypeNestTypeValue(self.family, self, elem, value)
1134             t = TypeSubMessage(self.family, self, elem, value)
1139             t = TypeMultiAttr(self.family, self, elem, value, t)
1145     def __init__(self, family, yaml, req_value, rsp_value):  argument
1154         super().__init__(family, yaml, req_value, rsp_value)
1156         self.render_name = c_lower(family.ident_name + '_' + self.name)
1171             self.enum_name = self.family.op_prefix + c_upper(self.name)
1173             self.enum_name = self.family.async_op_prefix + c_upper(self.name)
1180     def __init__(self, family, yaml):  argument
1181         super().__init__(family, yaml)
1183         self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1189 class Family(SpecFamily):  class
1207         self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
1552     def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None):  argument
1553         self.family = family
1560         self.fixed_hdr_len = 'ys->family->hdr_len'
1562             if op.fixed_header != family.fixed_header:
1563                 if family.is_classic():
1591             if attr_set in family.consts:
1604                 self.struct[op_dir] = Struct(family, self.attr_set,
1608             self.struct['reply'] = Struct(family, self.attr_set,
1617         return self.op_mode == 'do' and direction == 'request' and self.family.is_classic()
1901     return f"{ri.family.c_name}{suffix}"
1996 def put_op_name_fwd(family, cw):  argument
1997     cw.write_func_prot('const char *', f'{family.c_name}_op_str', ['int op'], suffix=';')
2000 def put_op_name(family, cw):  argument
2001     map_name = f'{family.c_name}_op_strmap'
2003     for op_name, op in family.msgs.items():
2007             if family.rsp_by_value[op.rsp_value] != op:
2018     _put_enum_to_str_helper(cw, family.c_name + '_op', map_name, 'op')
2021 def put_enum_to_str_fwd(family, cw, enum):  argument
2026 def put_enum_to_str(family, cw, enum):  argument
2097         iter_line = "ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len)"
2098         if ri.op.fixed_header != ri.family.fixed_header:
2099             if ri.family.is_classic():
2145         elif ri.family.is_classic():
2360     if ri.family.is_classic():
2433     if ri.family.is_classic():
2521     ri.cw.block_start(line=f"struct {ri.family.c_name}{suffix}")
2637         ri.cw.p('__u16 family;')
2717     if terminate and ri and policy_should_be_static(struct.family):
2723         if ri and policy_should_be_static(struct.family):
2751 def kernel_can_gen_family_struct(family):  argument
2752     return family.proto == 'genetlink'
2755 def policy_should_be_static(family):  argument
2756     return family.kernel_policy == 'split' or kernel_can_gen_family_struct(family)
2759 def print_kernel_policy_ranges(family, cw):  argument
2761     for _, attr_set in family.attr_sets.items():
2788 def print_kernel_policy_sparse_enum_validates(family, cw):  argument
2790     for _, attr_set in family.attr_sets.items():
2812             enum = family.consts[attr['enum']]
2828 def print_kernel_op_table_fwd(family, cw, terminate):  argument
2829     exported = not kernel_can_gen_family_struct(family)
2832         cw.p(f"/* Ops table for {family.ident_name} */")
2837         struct_type = pol_to_struct[family.kernel_policy]
2841         elif family.kernel_policy == 'split':
2843             for op in family.ops.values():
2849             cnt = len(family.ops)
2852         line = f"{qual} struct {struct_type} {family.c_name}_nl_ops[{cnt}]"
2862     for name in family.hooks['pre']['do']['list']:
2866     for name in family.hooks['post']['do']['list']:
2870     for name in family.hooks['pre']['dump']['list']:
2873     for name in family.hooks['post']['dump']['list']:
2879     for op_name, op in family.ops.items():
2884             name = c_lower(f"{family.ident_name}-nl-{op_name}-doit")
2889             name = c_lower(f"{family.ident_name}-nl-{op_name}-dumpit")
2895 def print_kernel_op_table_hdr(family, cw):  argument
2896     print_kernel_op_table_fwd(family, cw, terminate=True)
2899 def print_kernel_op_table(family, cw):  argument
2900     print_kernel_op_table_fwd(family, cw, terminate=False)
2901     if family.kernel_policy == 'global' or family.kernel_policy == 'per-op':
2902         for op_name, op in family.ops.items():
2915                     name = c_lower(f"{family.ident_name}-nl-{op_name}-{op_mode}it")
2917             if family.kernel_policy == 'per-op':
2918                 struct = Struct(family, op['attribute-set'],
2921                 name = c_lower(f"{family.ident_name}-{op_name}-nl-policy")
2928     elif family.kernel_policy == 'split':
2932         for op_name, op in family.ops.items():
2953                 name = c_lower(f"{family.ident_name}-nl-{op_name}-{op_mode}it")
2960                     struct = Struct(family, op['attribute-set'],
2964                         name = c_lower(f"{family.ident_name}-{op_name}-{op_mode}-nl-policy")
2966                         name = c_lower(f"{family.ident_name}-{op_name}-nl-policy")
2979 def print_kernel_mcgrp_hdr(family, cw):  argument
2980     if not family.mcgrps['list']:
2984     for grp in family.mcgrps['list']:
2985         grp_id = c_upper(f"{family.ident_name}-nlgrp-{grp['name']},")
2991 def print_kernel_mcgrp_src(family, cw):  argument
2992     if not family.mcgrps['list']:
2995     cw.block_start('static const struct genl_multicast_group ' + family.c_name + '_nl_mcgrps[] =')
2996     for grp in family.mcgrps['list']:
2998         grp_id = c_upper(f"{family.ident_name}-nlgrp-{name}")
3004 def print_kernel_family_struct_hdr(family, cw):  argument
3005     if not kernel_can_gen_family_struct(family):
3008     cw.p(f"extern struct genl_family {family.c_name}_nl_family;")
3010     if 'sock-priv' in family.kernel_family:
3011         cw.p(f'void {family.c_name}_nl_sock_priv_init({family.kernel_family["sock-priv"]} *priv);')
3012 …     cw.p(f'void {family.c_name}_nl_sock_priv_destroy({family.kernel_family["sock-priv"]} *priv);')
3016 def print_kernel_family_struct_src(family, cw):  argument
3017     if not kernel_can_gen_family_struct(family):
3020     if 'sock-priv' in family.kernel_family:
3022         cw.write_func("static void", f"__{family.c_name}_nl_sock_priv_init",
3023                       [f"{family.c_name}_nl_sock_priv_init(priv);"],
3026         cw.write_func("static void", f"__{family.c_name}_nl_sock_priv_destroy",
3027                       [f"{family.c_name}_nl_sock_priv_destroy(priv);"],
3031     cw.block_start(f"struct genl_family {family.ident_name}_nl_family __ro_after_init =")
3032     cw.p('.name\t\t= ' + family.fam_key + ',')
3033     cw.p('.version\t= ' + family.ver_key + ',')
3037     if family.kernel_policy == 'per-op':
3038         cw.p(f'.ops\t\t= {family.c_name}_nl_ops,')
3039         cw.p(f'.n_ops\t\t= ARRAY_SIZE({family.c_name}_nl_ops),')
3040     elif family.kernel_policy == 'split':
3041         cw.p(f'.split_ops\t= {family.c_name}_nl_ops,')
3042         cw.p(f'.n_split_ops\t= ARRAY_SIZE({family.c_name}_nl_ops),')
3043     if family.mcgrps['list']:
3044         cw.p(f'.mcgrps\t\t= {family.c_name}_nl_mcgrps,')
3045         cw.p(f'.n_mcgrps\t= ARRAY_SIZE({family.c_name}_nl_mcgrps),')
3046     if 'sock-priv' in family.kernel_family:
3047         cw.p(f'.sock_priv_size\t= sizeof({family.kernel_family["sock-priv"]}),')
3048         cw.p(f'.sock_priv_init\t= __{family.c_name}_nl_sock_priv_init,')
3049         cw.p(f'.sock_priv_destroy = __{family.c_name}_nl_sock_priv_destroy,')
3053 def uapi_enum_start(family, cw, obj, ckey='', enum_name='enum-name'):  argument
3059         start_line = 'enum ' + family.c_name + '_' + c_lower(obj[ckey])
3063 def render_uapi_unified(family, cw, max_by_define, separate_ntf):  argument
3064     max_name = c_upper(family.get('cmd-max-name', f"{family.op_prefix}MAX"))
3065     cnt_name = c_upper(family.get('cmd-cnt-name', f"__{family.op_prefix}MAX"))
3068     uapi_enum_start(family, cw, family['operations'], 'enum-name')
3070     for op in family.msgs.values():
3090 def render_uapi_directional(family, cw, max_by_define):  argument
3091     max_name = f"{family.op_prefix}USER_MAX"
3092     cnt_name = f"__{family.op_prefix}USER_CNT"
3096     cw.p(c_upper(f'{family.name}_MSG_USER_NONE = 0,'))
3098     for op in family.msgs.values():
3115     max_name = f"{family.op_prefix}KERNEL_MAX"
3116     cnt_name = f"__{family.op_prefix}KERNEL_CNT"
3120     cw.p(c_upper(f'{family.name}_MSG_KERNEL_NONE = 0,'))
3122     for op in family.msgs.values():
3144 def render_uapi(family, cw):  argument
3145     hdr_prot = f"_UAPI_LINUX_{c_upper(family.uapi_header_name)}_H"
3151     defines = [(family.fam_key, family["name"]),
3152                (family.ver_key, family.get('version', 1))]
3157     for const in family['definitions']:
3168             enum = family.consts[const['name']]
3189             uapi_enum_start(family, cw, const, 'name')
3190             name_pfx = const.get('name-prefix', f"{family.ident_name}-{const['name']}-")
3214             defines.append([c_upper(family.get('c-define-name',
3215                                                f"{family.ident_name}-{const['name']}")),
3222     max_by_define = family.get('max-by-define', False)
3224     for _, attr_set in family.attr_sets.items():
3231         uapi_enum_start(family, cw, attr_set.yaml, 'enum-name')
3250     separate_ntf = 'async-prefix' in family['operations']
3252     if family.msg_id_model == 'unified':
3253         render_uapi_unified(family, cw, max_by_define, separate_ntf)
3254     elif family.msg_id_model == 'directional':
3255         render_uapi_directional(family, cw, max_by_define)
3257         raise Exception(f'Unsupported message enum-model {family.msg_id_model}')
3260         uapi_enum_start(family, cw, family['operations'], enum_name='async-enum')
3261         for op in family.msgs.values():
3274     for grp in family.mcgrps['list']:
3276         defines.append([c_upper(grp.get('c-define-name', f"{family.ident_name}-mcgrp-{name}")),
3287     if not ri.family.is_classic():
3290         crud_op = ri.family.req_by_value[op.rsp_value]
3299 def render_user_family(family, cw, prototype):  argument
3300     symbol = f'const struct ynl_family ynl_{family.c_name}_family'
3305     if family.ntfs:
3306         cw.block_start(line=f"static const struct ynl_ntf_info {family.c_name}_ntf_info[] = ")
3307         for ntf_op_name, ntf_op in family.ntfs.items():
3309                 op = family.ops[ntf_op['notify']]
3310                 ri = RenderInfo(cw, family, "user", op, "notify")
3312                 ri = RenderInfo(cw, family, "user", ntf_op, "event")
3316         for op_name, op in family.ops.items():
3319             ri = RenderInfo(cw, family, "user", op, "event")
3325     cw.p(f'.name\t\t= "{family.c_name}",')
3326     if family.is_classic():
3328         cw.p(f'.classic_id\t= {family.get("protonum")},')
3329     if family.is_classic():
3330         if family.fixed_header:
3331             cw.p(f'.hdr_len\t= sizeof(struct {c_lower(family.fixed_header)}),')
3332     elif family.fixed_header:
3333 …    cw.p(f'.hdr_len\t= sizeof(struct genlmsghdr) + sizeof(struct {c_lower(family.fixed_header)}),')
3336     if family.ntfs:
3337         cw.p(f".ntf_info\t= {family.c_name}_ntf_info,")
3338         cw.p(f".ntf_info_size\t= YNL_ARRAY_SIZE({family.c_name}_ntf_info),")
3342 def family_contains_bitfield32(family):  argument
3343     for _, attr_set in family.attr_sets.items():
3382         parsed = Family(args.spec, exclude_ops)