48     def __init__(self, family, attr_set, attr, value):  argument
49         super().__init__(family, attr_set, attr, value)
73             if self.nested_attrs == family.name:
74                 self.nested_render_name = c_lower(f"{family.ident_name}")
76                 self.nested_render_name = c_lower(f"{family.ident_name}_{self.nested_attrs}")
78             if self.nested_attrs in self.family.consts:
95         return self.family.attr_sets[self.attr_set.subset_of][self.name]
113         if value in self.family.consts:
114             return self.family.consts[value]["value"]
123         if value in self.family.consts:
124             const = self.family.consts[value]
127             return c_upper(f"{self.family['name']}-{value}")
357     def __init__(self, family, attr_set, attr, value):  argument
358         super().__init__(family, attr_set, attr, value)
366         if not family.is_classic():
381             self.is_bitfield = self.family.consts[self.attr['enum']]['type'] == 'flags'
386             self.type_name = self.family.consts[self.attr['enum']].user_type
394             enum = self.family.consts[self.attr['enum']]
420                 enum = self.family.consts[self.attr['enum']]
423                 flags = self.family.consts[self.checks['flags-mask']]
639         enum = self.family.consts[self.attr['enum']]
656         return self.family.pure_nested_structs[self.nested_attrs].recursive
682         pns = self.family.pure_nested_structs[self.nested_attrs]
695         for _, attr in ri.family.pure_nested_structs[self.nested_attrs].member_list():
703     def __init__(self, family, attr_set, attr, value, base_type):  argument
704         super().__init__(family, attr_set, attr, value)
896     def __init__(self, family, attr_set, attr, value):  argument
897         super().__init__(family, attr_set, attr, value)
905         # support external selectors. No family uses sub-messages with external
948     def __init__(self, family, space_name, type_list=None, fixed_header=None,  argument
950         self.family = family
952         self.attr_set = family.attr_sets[space_name]
962         if family.name == c_lower(space_name):
963             self.render_name = c_lower(family.ident_name)
965             self.render_name = c_lower(family.ident_name + '-' + space_name)
967         if self.nested and space_name in family.consts:
1044     def __init__(self, family, yaml):  argument
1045         self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1061         self.value_pfx = yaml.get('name-prefix', f"{family.ident_name}-{yaml['name']}-")
1065         super().__init__(family, yaml)
1081     def __init__(self, family, yaml):  argument
1082         super().__init__(family, yaml)
1087             elif self.name == family.name:
1088                 pfx = family.ident_name + '-a-'
1090                 pfx = f"{family.ident_name}-a-{self.name}-"
1095             self.name_prefix = family.attr_sets[self.subset_of].name_prefix
1096             self.max_name = family.attr_sets[self.subset_of].max_name
1097             self.cnt_name = family.attr_sets[self.subset_of].cnt_name
1107         if self.c_name == self.family.c_name:
1112             t = TypeScalar(self.family, self, elem, value)
1114             t = TypeUnused(self.family, self, elem, value)
1116             t = TypePad(self.family, self, elem, value)
1118             t = TypeFlag(self.family, self, elem, value)
1120             t = TypeString(self.family, self, elem, value)
1123                 t = TypeBinaryStruct(self.family, self, elem, value)
1125                 t = TypeBinaryScalarArray(self.family, self, elem, value)
1127                 t = TypeBinary(self.family, self, elem, value)
1129             t = TypeBitfield32(self.family, self, elem, value)
1131             t = TypeNest(self.family, self, elem, value)
1134                 t = TypeIndexedArray(self.family, self, elem, value)
1138             t = TypeNestTypeValue(self.family, self, elem, value)
1140             t = TypeSubMessage(self.family, self, elem, value)
1145             t = TypeMultiAttr(self.family, self, elem, value, t)
1151     def __init__(self, family, yaml, req_value, rsp_value):  argument
1160         super().__init__(family, yaml, req_value, rsp_value)
1162         self.render_name = c_lower(family.ident_name + '_' + self.name)
1177             self.enum_name = self.family.op_prefix + c_upper(self.name)
1179             self.enum_name = self.family.async_op_prefix + c_upper(self.name)
1186     def __init__(self, family, yaml):  argument
1187         super().__init__(family, yaml)
1189         self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1195 class Family(SpecFamily):  class
1213         self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
1558     def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None):  argument
1559         self.family = family
1566         self.fixed_hdr_len = 'ys->family->hdr_len'
1568             if op.fixed_header != family.fixed_header:
1569                 if family.is_classic():
1597             if attr_set in family.consts:
1610                 self.struct[op_dir] = Struct(family, self.attr_set,
1614             self.struct['reply'] = Struct(family, self.attr_set,
1623         return self.op_mode == 'do' and direction == 'request' and self.family.is_classic()
1907     return f"{ri.family.c_name}{suffix}"
2002 def put_op_name_fwd(family, cw):  argument
2003     cw.write_func_prot('const char *', f'{family.c_name}_op_str', ['int op'], suffix=';')
2006 def put_op_name(family, cw):  argument
2007     map_name = f'{family.c_name}_op_strmap'
2009     for op_name, op in family.msgs.items():
2013             if family.rsp_by_value[op.rsp_value] != op:
2024     _put_enum_to_str_helper(cw, family.c_name + '_op', map_name, 'op')
2027 def put_enum_to_str_fwd(family, cw, enum):  argument
2032 def put_enum_to_str(family, cw, enum):  argument
2109         iter_line = "ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len)"
2110         if ri.op.fixed_header != ri.family.fixed_header:
2111             if ri.family.is_classic():
2165         elif ri.family.is_classic():
2377     if ri.family.is_classic():
2453     if ri.family.is_classic():
2541     ri.cw.block_start(line=f"struct {ri.family.c_name}{suffix}")
2657         ri.cw.p('__u16 family;')
2737     if terminate and ri and policy_should_be_static(struct.family):
2743         if ri and policy_should_be_static(struct.family):
2771 def kernel_can_gen_family_struct(family):  argument
2772     return family.proto == 'genetlink'
2775 def policy_should_be_static(family):  argument
2776     return family.kernel_policy == 'split' or kernel_can_gen_family_struct(family)
2779 def print_kernel_policy_ranges(family, cw):  argument
2781     for _, attr_set in family.attr_sets.items():
2808 def print_kernel_policy_sparse_enum_validates(family, cw):  argument
2810     for _, attr_set in family.attr_sets.items():
2830             enum = family.consts[attr['enum']]
2846 def print_kernel_op_table_fwd(family, cw, terminate):  argument
2847     exported = not kernel_can_gen_family_struct(family)
2850         cw.p(f"/* Ops table for {family.ident_name} */")
2855         struct_type = pol_to_struct[family.kernel_policy]
2859         elif family.kernel_policy == 'split':
2861             for op in family.ops.values():
2867             cnt = len(family.ops)
2870         line = f"{qual} struct {struct_type} {family.c_name}_nl_ops[{cnt}]"
2880     for name in family.hooks['pre']['do']['list']:
2884     for name in family.hooks['post']['do']['list']:
2888     for name in family.hooks['pre']['dump']['list']:
2891     for name in family.hooks['post']['dump']['list']:
2897     for op_name, op in family.ops.items():
2902             name = c_lower(f"{family.ident_name}-nl-{op_name}-doit")
2907             name = c_lower(f"{family.ident_name}-nl-{op_name}-dumpit")
2913 def print_kernel_op_table_hdr(family, cw):  argument
2914     print_kernel_op_table_fwd(family, cw, terminate=True)
2917 def print_kernel_op_table(family, cw):  argument
2918     print_kernel_op_table_fwd(family, cw, terminate=False)
2919     if family.kernel_policy == 'global' or family.kernel_policy == 'per-op':
2920         for op_name, op in family.ops.items():
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'],
2939                 name = c_lower(f"{family.ident_name}-{op_name}-nl-policy")
2946     elif family.kernel_policy == 'split':
2950         for op_name, op in family.ops.items():
2971                 name = c_lower(f"{family.ident_name}-nl-{op_name}-{op_mode}it")
2978                     struct = Struct(family, op['attribute-set'],
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")
2997 def print_kernel_mcgrp_hdr(family, cw):  argument
2998     if not family.mcgrps['list']:
3002     for grp in family.mcgrps['list']:
3003         grp_id = c_upper(f"{family.ident_name}-nlgrp-{grp['name']},")
3009 def print_kernel_mcgrp_src(family, cw):  argument
3010     if not family.mcgrps['list']:
3013     cw.block_start('static const struct genl_multicast_group ' + family.c_name + '_nl_mcgrps[] =')
3014     for grp in family.mcgrps['list']:
3016         grp_id = c_upper(f"{family.ident_name}-nlgrp-{name}")
3022 def print_kernel_family_struct_hdr(family, cw):  argument
3023     if not kernel_can_gen_family_struct(family):
3026     cw.p(f"extern struct genl_family {family.c_name}_nl_family;")
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);')
3034 def print_kernel_family_struct_src(family, cw):  argument
3035     if not kernel_can_gen_family_struct(family):
3038     if 'sock-priv' in family.kernel_family:
3040         cw.write_func("static void", f"__{family.c_name}_nl_sock_priv_init",
3041                       [f"{family.c_name}_nl_sock_priv_init(priv);"],
3044         cw.write_func("static void", f"__{family.c_name}_nl_sock_priv_destroy",
3045                       [f"{family.c_name}_nl_sock_priv_destroy(priv);"],
3049     cw.block_start(f"struct genl_family {family.ident_name}_nl_family __ro_after_init =")
3050     cw.p('.name\t\t= ' + family.fam_key + ',')
3051     cw.p('.version\t= ' + family.ver_key + ',')
3055     if family.kernel_policy == 'per-op':
3056         cw.p(f'.ops\t\t= {family.c_name}_nl_ops,')
3057         cw.p(f'.n_ops\t\t= ARRAY_SIZE({family.c_name}_nl_ops),')
3058     elif family.kernel_policy == 'split':
3059         cw.p(f'.split_ops\t= {family.c_name}_nl_ops,')
3060         cw.p(f'.n_split_ops\t= ARRAY_SIZE({family.c_name}_nl_ops),')
3061     if family.mcgrps['list']:
3062         cw.p(f'.mcgrps\t\t= {family.c_name}_nl_mcgrps,')
3063         cw.p(f'.n_mcgrps\t= ARRAY_SIZE({family.c_name}_nl_mcgrps),')
3064     if 'sock-priv' in family.kernel_family:
3065         cw.p(f'.sock_priv_size\t= sizeof({family.kernel_family["sock-priv"]}),')
3066         cw.p(f'.sock_priv_init\t= __{family.c_name}_nl_sock_priv_init,')
3067         cw.p(f'.sock_priv_destroy = __{family.c_name}_nl_sock_priv_destroy,')
3071 def uapi_enum_start(family, cw, obj, ckey='', enum_name='enum-name'):  argument
3077         start_line = 'enum ' + family.c_name + '_' + c_lower(obj[ckey])
3081 def render_uapi_unified(family, cw, max_by_define, separate_ntf):  argument
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"))
3086     uapi_enum_start(family, cw, family['operations'], 'enum-name')
3088     for op in family.msgs.values():
3108 def render_uapi_directional(family, cw, max_by_define):  argument
3109     max_name = f"{family.op_prefix}USER_MAX"
3110     cnt_name = f"__{family.op_prefix}USER_CNT"
3114     cw.p(c_upper(f'{family.name}_MSG_USER_NONE = 0,'))
3116     for op in family.msgs.values():
3133     max_name = f"{family.op_prefix}KERNEL_MAX"
3134     cnt_name = f"__{family.op_prefix}KERNEL_CNT"
3138     cw.p(c_upper(f'{family.name}_MSG_KERNEL_NONE = 0,'))
3140     for op in family.msgs.values():
3162 def render_uapi(family, cw):  argument
3163     hdr_prot = f"_UAPI_LINUX_{c_upper(family.uapi_header_name)}_H"
3169     defines = [(family.fam_key, family["name"]),
3170                (family.ver_key, family.get('version', 1))]
3175     for const in family['definitions']:
3186             enum = family.consts[const['name']]
3207             uapi_enum_start(family, cw, const, 'name')
3208             name_pfx = const.get('name-prefix', f"{family.ident_name}-{const['name']}-")
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)
3243     for _, attr_set in family.attr_sets.items():
3250         uapi_enum_start(family, cw, attr_set.yaml, 'enum-name')
3269     separate_ntf = 'async-prefix' in family['operations']
3271     if family.msg_id_model == 'unified':
3272         render_uapi_unified(family, cw, max_by_define, separate_ntf)
3273     elif family.msg_id_model == 'directional':
3274         render_uapi_directional(family, cw, max_by_define)
3276         raise Exception(f'Unsupported message enum-model {family.msg_id_model}')
3279         uapi_enum_start(family, cw, family['operations'], enum_name='async-enum')
3280         for op in family.msgs.values():
3293     for grp in family.mcgrps['list']:
3295         defines.append([c_upper(grp.get('c-define-name', f"{family.ident_name}-mcgrp-{name}")),
3306     if not ri.family.is_classic():
3309         crud_op = ri.family.req_by_value[op.rsp_value]
3318 def render_user_family(family, cw, prototype):  argument
3319     symbol = f'const struct ynl_family ynl_{family.c_name}_family'
3324     if family.ntfs:
3325         cw.block_start(line=f"static const struct ynl_ntf_info {family.c_name}_ntf_info[] = ")
3326         for ntf_op_name, ntf_op in family.ntfs.items():
3328                 op = family.ops[ntf_op['notify']]
3329                 ri = RenderInfo(cw, family, "user", op, "notify")
3331                 ri = RenderInfo(cw, family, "user", ntf_op, "event")
3335         for op_name, op in family.ops.items():
3338             ri = RenderInfo(cw, family, "user", op, "event")
3344     cw.p(f'.name\t\t= "{family.c_name}",')
3345     if family.is_classic():
3347         cw.p(f'.classic_id\t= {family.get("protonum")},')
3348     if family.is_classic():
3349         if family.fixed_header:
3350             cw.p(f'.hdr_len\t= sizeof(struct {c_lower(family.fixed_header)}),')
3351     elif family.fixed_header:
3352 …    cw.p(f'.hdr_len\t= sizeof(struct genlmsghdr) + sizeof(struct {c_lower(family.fixed_header)}),')
3355     if family.ntfs:
3356         cw.p(f".ntf_info\t= {family.c_name}_ntf_info,")
3357         cw.p(f".ntf_info_size\t= YNL_ARRAY_SIZE({family.c_name}_ntf_info),")
3361 def family_contains_bitfield32(family):  argument
3362     for _, attr_set in family.attr_sets.items():
3401         parsed = Family(args.spec, exclude_ops)