From: Greg Kroah-Hartman Date: Mon, 8 Jun 2026 16:02:41 +0000 (+0200) Subject: 6.18-stable patches X-Git-Tag: v6.12.93~8 X-Git-Url: http://git.ipfire.org/gitweb/?a=commitdiff_plain;h=4f06c63b1e906363f13ebbcef4f9ed2de6a41a14;p=thirdparty%2Fkernel%2Fstable-queue.git 6.18-stable patches added patches: tools-ynl-add-scope-qualifier-for-definitions.patch --- diff --git a/queue-6.18/series b/queue-6.18/series index e4211462d6..83cb6a41fd 100644 --- a/queue-6.18/series +++ b/queue-6.18/series @@ -311,3 +311,4 @@ mailbox-fix-null-message-support-in-mbox_send_message.patch drm-i915-psr-use-dc_off-wake-reference-to-block-dc6-on-vblank-enable.patch thunderbolt-property-cap-recursion-depth-in-__tb_property_parse_dir.patch usb-core-fix-superspeed-root-hub-wmaxpacketsize.patch +tools-ynl-add-scope-qualifier-for-definitions.patch diff --git a/queue-6.18/tools-ynl-add-scope-qualifier-for-definitions.patch b/queue-6.18/tools-ynl-add-scope-qualifier-for-definitions.patch new file mode 100644 index 0000000000..cbf50c78a5 --- /dev/null +++ b/queue-6.18/tools-ynl-add-scope-qualifier-for-definitions.patch @@ -0,0 +1,181 @@ +From fbf5df34a4dbcd09d433dd4f0916bf9b2ddb16de Mon Sep 17 00:00:00 2001 +From: Jakub Kicinski +Date: Sun, 10 May 2026 12:29:01 -0700 +Subject: tools: ynl: add scope qualifier for definitions + +From: Jakub Kicinski + +commit fbf5df34a4dbcd09d433dd4f0916bf9b2ddb16de upstream. + +Using definitions in kernel policies is awkward right now. +On one hand we want defines for max values and such. +On the other we don't have a way of adding kernel-only defines. +Adding unnecessary defines to uAPI is a bad idea, we won't +be able to delete them. And when it comes to policy user +space should just query it via the policy dump, not use +hard coded defines. + +Add a "scope" property to definitions, which will let us tell +the codegen that a definition is for kernel use only. Support +following values: + - uapi: render into the uAPI header (default, today's behavior) + - kernel: render to kernel header only + - user: same as kernel but for the user-side generated header + +Definitions may have a header property (definition is "external", +provided by existing header). Extend the scope to headers, too. +If definition has both scope and header properties we will only +generate the includes in the right scope. + +Signed-off-by: Jakub Kicinski +Link: https://patch.msgid.link/20260510192904.3987113-8-kuba@kernel.org +Signed-off-by: Paolo Abeni +Signed-off-by: Greg Kroah-Hartman +--- + Documentation/netlink/genetlink-c.yaml | 9 ++++++++ + Documentation/netlink/genetlink-legacy.yaml | 9 ++++++++ + Documentation/netlink/genetlink.yaml | 9 ++++++++ + Documentation/netlink/netlink-raw.yaml | 9 ++++++++ + tools/net/ynl/pyynl/ynl_gen_c.py | 31 ++++++++++++++++++++++++++-- + 5 files changed, 65 insertions(+), 2 deletions(-) + +--- a/Documentation/netlink/genetlink-c.yaml ++++ b/Documentation/netlink/genetlink-c.yaml +@@ -69,6 +69,15 @@ properties: + header: + description: For C-compatible languages, header which already defines this value. + type: string ++ scope: ++ description: | ++ Visibility of this definition. "uapi" (default) renders into ++ the uAPI header, "kernel" renders into the kernel-side ++ generated header, "user" renders into the user-side ++ generated header. When combined with `header:`, the ++ definition is not rendered, and the named header is ++ included only by code matching the scope. ++ enum: [ uapi, kernel, user ] + type: + enum: [ const, enum, flags ] + doc: +--- a/Documentation/netlink/genetlink-legacy.yaml ++++ b/Documentation/netlink/genetlink-legacy.yaml +@@ -83,6 +83,15 @@ properties: + header: + description: For C-compatible languages, header which already defines this value. + type: string ++ scope: ++ description: | ++ Visibility of this definition. "uapi" (default) renders into ++ the uAPI header, "kernel" renders into the kernel-side ++ generated header, "user" renders into the user-side ++ generated header. When combined with `header:`, the ++ definition is not rendered, and the named header is ++ included only by code matching the scope. ++ enum: [ uapi, kernel, user ] + type: + enum: [ const, enum, flags, struct ] # Trim + doc: +--- a/Documentation/netlink/genetlink.yaml ++++ b/Documentation/netlink/genetlink.yaml +@@ -55,6 +55,15 @@ properties: + header: + description: For C-compatible languages, header which already defines this value. + type: string ++ scope: ++ description: | ++ Visibility of this definition. "uapi" (default) renders into ++ the uAPI header, "kernel" renders into the kernel-side ++ generated header, "user" renders into the user-side ++ generated header. When combined with `header:`, the ++ definition is not rendered, and the named header is ++ included only by code matching the scope. ++ enum: [ uapi, kernel, user ] + type: + enum: [ const, enum, flags ] + doc: +--- a/Documentation/netlink/netlink-raw.yaml ++++ b/Documentation/netlink/netlink-raw.yaml +@@ -81,6 +81,15 @@ properties: + header: + description: For C-compatible languages, header which already defines this value. + type: string ++ scope: ++ description: | ++ Visibility of this definition. "uapi" (default) renders into ++ the uAPI header, "kernel" renders into the kernel-side ++ generated header, "user" renders into the user-side ++ generated header. When combined with `header:`, the ++ definition is not rendered, and the named header is ++ included only by code matching the scope. ++ enum: [ uapi, kernel, user ] + type: + enum: [ const, enum, flags, struct ] # Trim + doc: +--- a/tools/net/ynl/pyynl/ynl_gen_c.py ++++ b/tools/net/ynl/pyynl/ynl_gen_c.py +@@ -3187,6 +3187,8 @@ def render_uapi(family, cw): + for const in family['definitions']: + if const.get('header'): + continue ++ if const.get('scope', 'uapi') != 'uapi': ++ continue + + if const['type'] != 'const': + cw.writes_defines(defines) +@@ -3314,6 +3316,25 @@ def render_uapi(family, cw): + cw.p(f'#endif /* {hdr_prot} */') + + ++def render_scoped_consts(family, cw, scope): ++ defines = [] ++ for const in family['definitions']: ++ if const['type'] != 'const': ++ continue ++ if const.get('header'): ++ continue ++ if const.get('scope') != scope: ++ continue ++ name_pfx = const.get('name-prefix', f"{family.ident_name}-") ++ defines.append([ ++ c_upper(family.get('c-define-name', ++ f"{name_pfx}{const['name']}")), ++ const['value']]) ++ if defines: ++ cw.writes_defines(defines) ++ cw.nl() ++ ++ + def _render_user_ntf_entry(ri, op): + if not ri.family.is_classic(): + ri.cw.block_start(line=f"[{op.enum_name}] = ") +@@ -3474,8 +3495,12 @@ def main(): + cw.p('#include "ynl.h"') + headers = [] + for definition in parsed['definitions'] + parsed['attribute-sets']: +- if 'header' in definition: +- headers.append(definition['header']) ++ if 'header' not in definition: ++ continue ++ scope = definition.get('scope', 'uapi') ++ if scope != 'uapi' and scope != args.mode: ++ continue ++ headers.append(definition['header']) + if args.mode == 'user': + headers.append(parsed.uapi_header) + seen_header = [] +@@ -3492,6 +3517,7 @@ def main(): + for one in args.user_header: + cw.p(f'#include "{one}"') + else: ++ render_scoped_consts(parsed, cw, 'user') + cw.p('struct ynl_sock;') + cw.nl() + render_user_family(parsed, cw, True) +@@ -3499,6 +3525,7 @@ def main(): + + if args.mode == "kernel": + if args.header: ++ render_scoped_consts(parsed, cw, 'kernel') + for _, struct in sorted(parsed.pure_nested_structs.items()): + if struct.request: + cw.p('/* Common nested types */')