Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'tools-ynl-gen-split-presence-metadata'
Jakub Kicinski says:
====================
tools: ynl-gen: split presence metadata
The presence metadata indicates whether given attribute was/should be
added to the Netlink message. We have 3 types of such metadata:
- bit presence for simple values like integers,
- len presence for variable size attrs, like binary and strings,
- count for arrays.
Previously this information was spread around with first two types
living in a dedicated sub-struct called _present. The counts resided
directly in the main struct with an n_ prefix.
Reshuffle these an uniformly store them in dedicated sub-structs.
The immediate motivation is that current scheme causes name collisions
for TC.
====================
Link: https://patch.msgid.link/20250505165208.248049-1-kuba@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+45
-50
+37
-43
tools/net/ynl/pyynl/ynl_gen_c.py
+37
-43
tools/net/ynl/pyynl/ynl_gen_c.py
···
142
142
return self.is_recursive() and not ri.op
143
143
144
144
def presence_type(self):
145
-
return 'bit'
145
+
return 'present'
146
146
147
147
def presence_member(self, space, type_filter):
148
148
if self.presence_type() != type_filter:
149
149
return
150
150
151
-
if self.presence_type() == 'bit':
151
+
if self.presence_type() == 'present':
152
152
pfx = '__' if space == 'user' else ''
153
153
return f"{pfx}u32 {self.c_name}:1;"
154
154
155
-
if self.presence_type() == 'len':
155
+
if self.presence_type() in {'len', 'count'}:
156
156
pfx = '__' if space == 'user' else ''
157
-
return f"{pfx}u32 {self.c_name}_len;"
157
+
return f"{pfx}u32 {self.c_name};"
158
158
159
159
def _complex_member_type(self, ri):
160
160
return None
···
185
185
def struct_member(self, ri):
186
186
member = self._complex_member_type(ri)
187
187
if member:
188
-
if self.is_multi_val():
189
-
ri.cw.p(f"unsigned int n_{self.c_name};")
190
188
ptr = '*' if self.is_multi_val() else ''
191
189
if self.is_recursive_for_op(ri):
192
190
ptr = '*'
···
215
217
cw.p(f'[{self.enum_name}] = {"{"} .name = "{self.name}", {typol}{"}"},')
216
218
217
219
def _attr_put_line(self, ri, var, line):
218
-
if self.presence_type() == 'bit':
219
-
ri.cw.p(f"if ({var}->_present.{self.c_name})")
220
-
elif self.presence_type() == 'len':
221
-
ri.cw.p(f"if ({var}->_present.{self.c_name}_len)")
220
+
presence = self.presence_type()
221
+
if presence in {'present', 'len'}:
222
+
ri.cw.p(f"if ({var}->_{presence}.{self.c_name})")
222
223
ri.cw.p(f"{line};")
223
224
224
225
def _attr_put_simple(self, ri, var, put_type):
···
247
250
if not self.is_multi_val():
248
251
ri.cw.p("if (ynl_attr_validate(yarg, attr))")
249
252
ri.cw.p("return YNL_PARSE_CB_ERROR;")
250
-
if self.presence_type() == 'bit':
253
+
if self.presence_type() == 'present':
251
254
ri.cw.p(f"{var}->_present.{self.c_name} = 1;")
252
255
253
256
if init_lines:
···
278
281
presence = f"{var}->{'.'.join(ref[:i] + [''])}_present.{ref[i]}"
279
282
# Every layer below last is a nest, so we know it uses bit presence
280
283
# last layer is "self" and may be a complex type
281
-
if i == len(ref) - 1 and self.presence_type() != 'bit':
284
+
if i == len(ref) - 1 and self.presence_type() != 'present':
285
+
presence = f"{var}->{'.'.join(ref[:i] + [''])}_{self.presence_type()}.{ref[i]}"
282
286
continue
283
287
code.append(presence + ' = 1;')
284
288
ref_path = '.'.join(ref[:-1])
···
499
501
self._attr_put_simple(ri, var, 'str')
500
502
501
503
def _attr_get(self, ri, var):
502
-
len_mem = var + '->_present.' + self.c_name + '_len'
504
+
len_mem = var + '->_len.' + self.c_name
503
505
return [f"{len_mem} = len;",
504
506
f"{var}->{self.c_name} = malloc(len + 1);",
505
507
f"memcpy({var}->{self.c_name}, ynl_attr_get_str(attr), len);",
···
508
510
['unsigned int len;']
509
511
510
512
def _setter_lines(self, ri, member, presence):
511
-
return [f"{presence}_len = strlen({self.c_name});",
512
-
f"{member} = malloc({presence}_len + 1);",
513
-
f'memcpy({member}, {self.c_name}, {presence}_len);',
514
-
f'{member}[{presence}_len] = 0;']
513
+
return [f"{presence} = strlen({self.c_name});",
514
+
f"{member} = malloc({presence} + 1);",
515
+
f'memcpy({member}, {self.c_name}, {presence});',
516
+
f'{member}[{presence}] = 0;']
515
517
516
518
517
519
class TypeBinary(Type):
···
550
552
551
553
def attr_put(self, ri, var):
552
554
self._attr_put_line(ri, var, f"ynl_attr_put(nlh, {self.enum_name}, " +
553
-
f"{var}->{self.c_name}, {var}->_present.{self.c_name}_len)")
555
+
f"{var}->{self.c_name}, {var}->_len.{self.c_name})")
554
556
555
557
def _attr_get(self, ri, var):
556
-
len_mem = var + '->_present.' + self.c_name + '_len'
558
+
len_mem = var + '->_len.' + self.c_name
557
559
return [f"{len_mem} = len;",
558
560
f"{var}->{self.c_name} = malloc(len);",
559
561
f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
···
561
563
['unsigned int len;']
562
564
563
565
def _setter_lines(self, ri, member, presence):
564
-
return [f"{presence}_len = len;",
565
-
f"{member} = malloc({presence}_len);",
566
-
f'memcpy({member}, {self.c_name}, {presence}_len);']
566
+
return [f"{presence} = len;",
567
+
f"{member} = malloc({presence});",
568
+
f'memcpy({member}, {self.c_name}, {presence});']
567
569
568
570
569
571
class TypeBitfield32(Type):
···
676
678
lines += [f"free({var}->{ref}{self.c_name});"]
677
679
elif self.attr['type'] == 'string':
678
680
lines += [
679
-
f"for (i = 0; i < {var}->{ref}n_{self.c_name}; i++)",
681
+
f"for (i = 0; i < {var}->{ref}_count.{self.c_name}; i++)",
680
682
f"free({var}->{ref}{self.c_name}[i]);",
681
683
f"free({var}->{ref}{self.c_name});",
682
684
]
683
685
elif 'type' not in self.attr or self.attr['type'] == 'nest':
684
686
lines += [
685
-
f"for (i = 0; i < {var}->{ref}n_{self.c_name}; i++)",
687
+
f"for (i = 0; i < {var}->{ref}_count.{self.c_name}; i++)",
686
688
f'{self.nested_render_name}_free(&{var}->{ref}{self.c_name}[i]);',
687
689
f"free({var}->{ref}{self.c_name});",
688
690
]
···
702
704
def attr_put(self, ri, var):
703
705
if self.attr['type'] in scalars:
704
706
put_type = self.type
705
-
ri.cw.p(f"for (i = 0; i < {var}->n_{self.c_name}; i++)")
707
+
ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
706
708
ri.cw.p(f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name}[i]);")
707
709
elif self.attr['type'] == 'binary' and 'struct' in self.attr:
708
-
ri.cw.p(f"for (i = 0; i < {var}->n_{self.c_name}; i++)")
710
+
ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
709
711
ri.cw.p(f"ynl_attr_put(nlh, {self.enum_name}, &{var}->{self.c_name}[i], sizeof(struct {c_lower(self.attr['struct'])}));")
710
712
elif self.attr['type'] == 'string':
711
-
ri.cw.p(f"for (i = 0; i < {var}->n_{self.c_name}; i++)")
713
+
ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
712
714
ri.cw.p(f"ynl_attr_put_str(nlh, {self.enum_name}, {var}->{self.c_name}[i]->str);")
713
715
elif 'type' not in self.attr or self.attr['type'] == 'nest':
714
-
ri.cw.p(f"for (i = 0; i < {var}->n_{self.c_name}; i++)")
716
+
ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
715
717
self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
716
718
f"{self.enum_name}, &{var}->{self.c_name}[i])")
717
719
else:
718
720
raise Exception(f"Put of MultiAttr sub-type {self.attr['type']} not supported yet")
719
721
720
722
def _setter_lines(self, ri, member, presence):
721
-
# For multi-attr we have a count, not presence, hack up the presence
722
-
presence = presence[:-(len('_present.') + len(self.c_name))] + "n_" + self.c_name
723
723
return [f"{member} = {self.c_name};",
724
724
f"{presence} = n_{self.c_name};"]
725
725
···
760
764
'ynl_attr_for_each_nested(attr2, attr) {',
761
765
'\tif (ynl_attr_validate(yarg, attr2))',
762
766
'\t\treturn YNL_PARSE_CB_ERROR;',
763
-
f'\t{var}->n_{self.c_name}++;',
767
+
f'\t{var}->_count.{self.c_name}++;',
764
768
'}']
765
769
return get_lines, None, local_vars
766
770
···
768
772
ri.cw.p(f'array = ynl_attr_nest_start(nlh, {self.enum_name});')
769
773
if self.sub_type in scalars:
770
774
put_type = self.sub_type
771
-
ri.cw.block_start(line=f'for (i = 0; i < {var}->n_{self.c_name}; i++)')
775
+
ri.cw.block_start(line=f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
772
776
ri.cw.p(f"ynl_attr_put_{put_type}(nlh, i, {var}->{self.c_name}[i]);")
773
777
ri.cw.block_end()
774
778
elif self.sub_type == 'binary' and 'exact-len' in self.checks:
775
-
ri.cw.p(f'for (i = 0; i < {var}->n_{self.c_name}; i++)')
779
+
ri.cw.p(f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
776
780
ri.cw.p(f"ynl_attr_put(nlh, i, {var}->{self.c_name}[i], {self.checks['exact-len']});")
777
781
else:
778
782
raise Exception(f"Put for ArrayNest sub-type {self.attr['sub-type']} not supported, yet")
779
783
ri.cw.p('ynl_attr_nest_end(nlh, array);')
780
784
781
785
def _setter_lines(self, ri, member, presence):
782
-
# For multi-attr we have a count, not presence, hack up the presence
783
-
presence = presence[:-(len('_present.') + len(self.c_name))] + "n_" + self.c_name
784
786
return [f"{member} = {self.c_name};",
785
787
f"{presence} = n_{self.c_name};"]
786
788
···
1878
1884
1879
1885
ri.cw.block_start(line=f"if (n_{aspec.c_name})")
1880
1886
ri.cw.p(f"dst->{aspec.c_name} = calloc(n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")
1881
-
ri.cw.p(f"dst->n_{aspec.c_name} = n_{aspec.c_name};")
1887
+
ri.cw.p(f"dst->_count.{aspec.c_name} = n_{aspec.c_name};")
1882
1888
ri.cw.p('i = 0;')
1883
1889
if 'nested-attributes' in aspec:
1884
1890
ri.cw.p(f"parg.rsp_policy = &{aspec.nested_render_name}_nest;")
···
1903
1909
aspec = struct[anest]
1904
1910
ri.cw.block_start(line=f"if (n_{aspec.c_name})")
1905
1911
ri.cw.p(f"dst->{aspec.c_name} = calloc(n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")
1906
-
ri.cw.p(f"dst->n_{aspec.c_name} = n_{aspec.c_name};")
1912
+
ri.cw.p(f"dst->_count.{aspec.c_name} = n_{aspec.c_name};")
1907
1913
ri.cw.p('i = 0;')
1908
1914
if 'nested-attributes' in aspec:
1909
1915
ri.cw.p(f"parg.rsp_policy = &{aspec.nested_render_name}_nest;")
···
2180
2186
ri.cw.p(ri.fixed_hdr + ' _hdr;')
2181
2187
ri.cw.nl()
2182
2188
2183
-
meta_started = False
2184
-
for _, attr in struct.member_list():
2185
-
for type_filter in ['len', 'bit']:
2189
+
for type_filter in ['present', 'len', 'count']:
2190
+
meta_started = False
2191
+
for _, attr in struct.member_list():
2186
2192
line = attr.presence_member(ri.ku_space, type_filter)
2187
2193
if line:
2188
2194
if not meta_started:
2189
2195
ri.cw.block_start(line=f"struct")
2190
2196
meta_started = True
2191
2197
ri.cw.p(line)
2192
-
if meta_started:
2193
-
ri.cw.block_end(line='_present;')
2194
-
ri.cw.nl()
2198
+
if meta_started:
2199
+
ri.cw.block_end(line=f'_{type_filter};')
2200
+
ri.cw.nl()
2195
2201
2196
2202
for arg in struct.inherited:
2197
2203
ri.cw.p(f"__u32 {arg};")
+4
-3
tools/net/ynl/samples/devlink.c
+4
-3
tools/net/ynl/samples/devlink.c
···
22
22
ynl_dump_foreach(devs, d) {
23
23
struct devlink_info_get_req *info_req;
24
24
struct devlink_info_get_rsp *info_rsp;
25
+
unsigned i;
25
26
26
27
printf("%s/%s:\n", d->bus_name, d->dev_name);
27
28
···
35
34
if (!info_rsp)
36
35
goto err_free_devs;
37
36
38
-
if (info_rsp->_present.info_driver_name_len)
37
+
if (info_rsp->_len.info_driver_name)
39
38
printf(" driver: %s\n", info_rsp->info_driver_name);
40
-
if (info_rsp->n_info_version_running)
39
+
if (info_rsp->_count.info_version_running)
41
40
printf(" running fw:\n");
42
-
for (unsigned i = 0; i < info_rsp->n_info_version_running; i++)
41
+
for (i = 0; i < info_rsp->_count.info_version_running; i++)
43
42
printf(" %s: %s\n",
44
43
info_rsp->info_version_running[i].info_version_name,
45
44
info_rsp->info_version_running[i].info_version_value);
+2
-2
tools/net/ynl/samples/rt-addr.c
+2
-2
tools/net/ynl/samples/rt-addr.c
···
20
20
if (name)
21
21
printf("%16s: ", name);
22
22
23
-
switch (a->_present.address_len) {
23
+
switch (a->_len.address) {
24
24
case 4:
25
25
addr = inet_ntop(AF_INET, a->address,
26
26
addr_str, sizeof(addr_str));
···
36
36
if (addr)
37
37
printf("%s", addr);
38
38
else
39
-
printf("[%d]", a->_present.address_len);
39
+
printf("[%d]", a->_len.address);
40
40
41
41
printf("\n");
42
42
}
+2
-2
tools/net/ynl/samples/rt-route.c
+2
-2
tools/net/ynl/samples/rt-route.c
···
26
26
printf("oif: %-16s ", name);
27
27
}
28
28
29
-
if (r->_present.dst_len) {
29
+
if (r->_len.dst) {
30
30
route = inet_ntop(r->_hdr.rtm_family, r->dst,
31
31
route_str, sizeof(route_str));
32
32
printf("dst: %s/%d", route, r->_hdr.rtm_dst_len);
33
33
}
34
34
35
-
if (r->_present.gateway_len) {
35
+
if (r->_len.gateway) {
36
36
route = inet_ntop(r->_hdr.rtm_family, r->gateway,
37
37
route_str, sizeof(route_str));
38
38
printf("gateway: %s ", route);