From nobody Wed Dec 17 04:20:09 2025 Received: from mail-pg1-f201.google.com (mail-pg1-f201.google.com [209.85.215.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 88279270EDF for ; Mon, 5 May 2025 21:24:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480250; cv=none; b=gSpD6tYcQpjteXi2Da16K4GdsjXEnE76bbxfeYN4spD7uK7ajOESjLfqELK3Rw+Co0bKGsmOcavn0ZtrEKznqu0Sf7XG+TzegTvbDSB1XkgS1qJLa7rEGSfdwKpukZT6MLiNNfzbI/54tdE7gRvrNbgWPmfODEQIuZLVHbb10f4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480250; c=relaxed/simple; bh=h0UfvaGWNgOmqj6pRMaE3gGYsMYVBXy/lS+rZ7Qhtes=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=jcM09ySSAcRqOq8PGlGB+CvSrKZ0adzi0gCLzk45vJFhITTC+JYuIwZdTd+wDAornwuan9g7H//5fyVR/FV3WOoNvr6BmDJoSO3eakoLj4OmxsBBvX4srD1yxlbyce8/7REz0Z8r9fKW4Yhw1yGLS0rt//xDMeMuSpIdQgzINtI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=qttSoB1Q; arc=none smtp.client-ip=209.85.215.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="qttSoB1Q" Received: by mail-pg1-f201.google.com with SMTP id 41be03b00d2f7-b00ce246e38so5048529a12.2 for ; Mon, 05 May 2025 14:24:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746480248; x=1747085048; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=aanpIqBEjEkle09/pdhUe09l89jk7xvzFrXGr1sJVPM=; b=qttSoB1QmZXY74s5m1BEmsXpV2IqVx1HV4XRB5H8YM+rIGDWoBCJbt5Rz23QrIxLlw k9sigAwM87n+eoPL0rDB8q4gLhjxYQHEv8zBZ0SzY9Y6QJRoBMgr8TUDPeJjJLzLEjDP 88ONe9YS+4oieVuW7zN2A3p9Ff8wLBHxj176jcAsx8QQhk1T4QhfZGEss/4uF77N83fe nt3gcoUTp6bYm5JCW3AxJIKcdCowSlsoxr9aed24uJZEBk2Mjdt3MHJyKzelCJPpz78L uytF+/n3QYFqLczteapUaAMg6PY8nmtM6mV0P176Bio9VydPPkc1/z3RtgF/RnQe6GBd 5ewQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746480248; x=1747085048; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=aanpIqBEjEkle09/pdhUe09l89jk7xvzFrXGr1sJVPM=; b=m/YOWNh1MipfHi5sWM4nJzbed0shfttyZ51PnZKfvEYdH2B+p4A+wTR9DxO1jdArno CWzEb8n+y09rxtx0KG9TNnZT2rrsCd/XBiN3sq8g6e6ZpqwmT64n9wPCoI4EAj+i8XFi nPnour1qvfShIVv9bUWDt/mB7WMM6YNfZduuUFZ7Jtr8oVTPNorSrMwJL6hd1cvrPQH7 ew16LdK0X+r14uQd8mggn0qdK5/QJ9m8Vr9myxRvsLEjDTZ7yUyWthSdAqHu1XgXY1Aq k9pALkuC5D5WvYGPtzdlA3ESn7Kmd7iJuAAtyh/Cd8ippcVlwRetezeAU7C3c6EOqqMm cVrw== X-Forwarded-Encrypted: i=1; AJvYcCX4UOF8SFlowqfHZT4bsy5/qW138BvW1XMI8h8ARF7B7ddoQU4xhgigdbIs9Qf64dZZ27VBOIKfvyfYoDw=@vger.kernel.org X-Gm-Message-State: AOJu0YyIYUHbhnUmrRPsMDV/k2sWi89PXYOo8qdjW+kCS2gAxFLhFBF0 pfM94wJg+qdGhBU6LE+NPT96FCTvhU799WJXLyK38TbnQt3doTIWlekWnmGkQufQnOIE16gMCc5 zVg+LgmnZjNlGasQUptFhaT8/eA== X-Google-Smtp-Source: AGHT+IGvmIS+oO7hr+WzfoRtTIOqh+Ojdok5QsBrhXjWwQ72p2VVAbulBQaGNKjInA0WtF3dkw1he45K1kbrVt+M2Gw= X-Received: from pglr16.prod.google.com ([2002:a63:5150:0:b0:b01:fc1:931e]) (user=samitolvanen job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a21:9106:b0:20d:df67:4830 with SMTP id adf61e73a8af0-2117df07787mr1275008637.0.1746480247824; Mon, 05 May 2025 14:24:07 -0700 (PDT) Date: Mon, 5 May 2025 21:24:03 +0000 In-Reply-To: <20250505212401.3379699-6-samitolvanen@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250505212401.3379699-6-samitolvanen@google.com> X-Developer-Key: i=samitolvanen@google.com; a=openpgp; fpr=35CCFB63B283D6D3AEB783944CB5F6848BBC56EE X-Developer-Signature: v=1; a=openpgp-sha256; l=3927; i=samitolvanen@google.com; h=from:subject; bh=h0UfvaGWNgOmqj6pRMaE3gGYsMYVBXy/lS+rZ7Qhtes=; b=owGbwMvMwCEWxa662nLh8irG02pJDBmSOoUP98yQCa35V5zy02nT8vj/1/sCLgenitl0L/4+e 6r1kkq3jlIWBjEOBlkxRZaWr6u37v7ulPrqc5EEzBxWJpAhDFycAjCR3hqG/xkdXk9EBWavq1mS q/vuS5Vkf8Tal7X5xb4vQlQ3P3JROcvI0Gd+TqZ79qR+cYlNi8t2MZxfrM1/iTky+eqZA1He/XN m8gMA X-Mailer: git-send-email 2.49.0.967.g6a0df3ecc3-goog Message-ID: <20250505212401.3379699-7-samitolvanen@google.com> Subject: [PATCH v2 1/4] gendwarfksyms: Clean up kABI rule look-ups From: Sami Tolvanen To: Masahiro Yamada Cc: Luis Chamberlain , Petr Pavlu , Daniel Gomez , linux-modules@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, Sami Tolvanen Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Reduce code duplication by moving kABI rule look-ups to separate functions. Signed-off-by: Sami Tolvanen Reviewed-by: Petr Pavlu --- scripts/gendwarfksyms/kabi.c | 101 +++++++++++++++-------------------- 1 file changed, 44 insertions(+), 57 deletions(-) diff --git a/scripts/gendwarfksyms/kabi.c b/scripts/gendwarfksyms/kabi.c index 66f01fcd1607..badf8d46b154 100644 --- a/scripts/gendwarfksyms/kabi.c +++ b/scripts/gendwarfksyms/kabi.c @@ -222,33 +222,55 @@ void kabi_read_rules(int fd) check(elf_end(elf)); } =20 -bool kabi_is_declonly(const char *fqn) +static char *get_enumerator_target(const char *fqn, const char *field) +{ + char *target =3D NULL; + + if (asprintf(&target, "%s %s", fqn, field) < 0) + error("asprintf failed for '%s %s'", fqn, field); + + return target; +} + +static struct rule *find_rule(enum kabi_rule_type type, const char *target) { struct rule *rule; =20 if (!stable) - return false; - if (!fqn || !*fqn) - return false; + return NULL; + if (!target || !*target) + return NULL; =20 hash_for_each_possible(rules, rule, hash, - rule_values_hash(KABI_RULE_TYPE_DECLONLY, fqn)) { - if (rule->type =3D=3D KABI_RULE_TYPE_DECLONLY && - !strcmp(fqn, rule->target)) - return true; + rule_values_hash(type, target)) { + if (rule->type =3D=3D type && !strcmp(target, rule->target)) + return rule; } =20 - return false; + return NULL; } =20 -static char *get_enumerator_target(const char *fqn, const char *field) +static struct rule *find_enumerator_rule(enum kabi_rule_type type, + const char *fqn, const char *field) { - char *target =3D NULL; + struct rule *rule; + char *target; =20 - if (asprintf(&target, "%s %s", fqn, field) < 0) - error("asprintf failed for '%s %s'", fqn, field); + if (!stable) + return NULL; + if (!fqn || !*fqn || !field || !*field) + return NULL; =20 - return target; + target =3D get_enumerator_target(fqn, field); + rule =3D find_rule(type, target); + + free(target); + return rule; +} + +bool kabi_is_declonly(const char *fqn) +{ + return !!find_rule(KABI_RULE_TYPE_DECLONLY, fqn); } =20 static unsigned long get_ulong_value(const char *value) @@ -267,58 +289,23 @@ static unsigned long get_ulong_value(const char *valu= e) =20 bool kabi_is_enumerator_ignored(const char *fqn, const char *field) { - bool match =3D false; - struct rule *rule; - char *target; - - if (!stable) - return false; - if (!fqn || !*fqn || !field || !*field) - return false; - - target =3D get_enumerator_target(fqn, field); - - hash_for_each_possible( - rules, rule, hash, - rule_values_hash(KABI_RULE_TYPE_ENUMERATOR_IGNORE, target)) { - if (rule->type =3D=3D KABI_RULE_TYPE_ENUMERATOR_IGNORE && - !strcmp(target, rule->target)) { - match =3D true; - break; - } - } - - free(target); - return match; + return !!find_enumerator_rule(KABI_RULE_TYPE_ENUMERATOR_IGNORE, fqn, + field); } =20 bool kabi_get_enumerator_value(const char *fqn, const char *field, unsigned long *value) { - bool match =3D false; struct rule *rule; - char *target; =20 - if (!stable) - return false; - if (!fqn || !*fqn || !field || !*field) - return false; - - target =3D get_enumerator_target(fqn, field); - - hash_for_each_possible(rules, rule, hash, - rule_values_hash(KABI_RULE_TYPE_ENUMERATOR_VALUE, - target)) { - if (rule->type =3D=3D KABI_RULE_TYPE_ENUMERATOR_VALUE && - !strcmp(target, rule->target)) { - *value =3D get_ulong_value(rule->value); - match =3D true; - break; - } + rule =3D find_enumerator_rule(KABI_RULE_TYPE_ENUMERATOR_VALUE, fqn, + field); + if (rule) { + *value =3D get_ulong_value(rule->value); + return true; } =20 - free(target); - return match; + return false; } =20 void kabi_free(void) --=20 2.49.0.967.g6a0df3ecc3-goog From nobody Wed Dec 17 04:20:09 2025 Received: from mail-pg1-f201.google.com (mail-pg1-f201.google.com [209.85.215.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D01F027464E for ; Mon, 5 May 2025 21:24:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480251; cv=none; b=AGc/sBchHpp4RtDQzYwftu4J/fIxzgy/nZnAZZlNtHhrkDigzRYkb6ctLkKIXRjcbsN8RWWgwtsMIijePEVBoiEt2hWUxQJ0RgXHAL0mclRWpVMkBYeWsNzqFsc2JO8h/oIZHLpEsUVNQ9YMRYu0UXuTxfoNOfUPzxIE8wstreI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480251; c=relaxed/simple; bh=BMC1eT/RW0qYKHRo26wre0JMFNFS6Nb4HECC0KqU2LQ=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=VBRmsPk8XNgYWfcAJjuoLLqD64Z5v9912tTptmcInYYmy7FeVG4Ys5+cuFlrLWMIqPayVPBrnrvkrFiTS+swn19b58dXq37uMZmPdecBl2pb4cQ2m3ZboJZ3Wy9NbZiWXdiX8o7V8//mS3rnG2zdlvcHLtp5Y1h0yroT1RjNUTI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=ylPwRu0l; arc=none smtp.client-ip=209.85.215.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="ylPwRu0l" Received: by mail-pg1-f201.google.com with SMTP id 41be03b00d2f7-b1f8d149911so4467176a12.0 for ; Mon, 05 May 2025 14:24:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746480249; x=1747085049; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=jC/VZcGrZa9gXKD1hXGwhYDV2p45vd0X27pWQ6osP7g=; b=ylPwRu0lWih8WReUK01TL3g9mQu6WfSePYwH2Rrd0uoD8bbK6aN7qYj0b9RtE3yM8N mfl8tH9TXlu4OTxTtBv6bxHrsbVQZS5YUnlNgKUm0y3lTAR3NwpTbAFgytOdh1hTUmZx Pp2yM5ULZD+hBaEmZEs2f+Md8aXt4uXonr5kehSKdxGpnXZvqEAuIvhjargj7tuWe5gp gzWM/XCQsKdJWu5o7LfeU/WcijUQhHd9A2JF9/xD4SucrD+dLilUfA4OgmKXTLx4yhuf 2gJvH/rbIbAMPNHt6AR5TOJDOMdIoj8fpymzh0oog8kmwJmPLA0+6QVIPODX3fRUTsIl chtQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746480249; x=1747085049; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=jC/VZcGrZa9gXKD1hXGwhYDV2p45vd0X27pWQ6osP7g=; b=kTC+cMpJjBiIYKbKn6AsDFbiMbTUSdHlOWqGTteaTOlQNNpNx+b1lhYTJxwcVtZQhr RD+k79PZibO2uygeSa/Clk/yVj7GD0PdD8i92pCgG+JzJVP8w2kQjKDZJYUgTZSbHRE0 W2vXfjI8STgHl9k7VRRz8lg4ytz8inNhvr56jSV+m2yF6x2k8dwW9kvXXRDKJdhQjIJ8 9sGc3MqQRBqADZkjT0PFRaPdpT9OxCDnh+BqE4Cr5anLqBjyhE202j1L4gAiQ5ob/nli 1Fq6/TSH4u8Hm+QCvq0R074NyhABffWwXFS2yPUKHS0NWlLUTeetAxWiPSpJtfr7gSd/ k+Uw== X-Forwarded-Encrypted: i=1; AJvYcCV+/w3oHSJ0btM60x72r7qoZoPo2qXj+JLD4D7drd2CkjEluRkObLkOjyHp7TDHIC0i0gaRemi2b9NEBvg=@vger.kernel.org X-Gm-Message-State: AOJu0YyGBgauhawB5VBg5titnbL+N/F5AHSqFcIXPQ2iZzZwYo3+rF/C brrN9U0JtyQPlGOnn50buiaoE62trRzW0gW2KhVcdA2rnskqModowURIaIoCdplIFFOdRwuYnvJ smHYJwaw9StbYjgf4LOOOTX9S/w== X-Google-Smtp-Source: AGHT+IHxEC//lhdl50TJGWOgJZvYzQz7UxUELZNKIrK0n3Gj3rXoLO1CenyTo5RcKY7BUjhcP4DyBTN76KDLLYT3nss= X-Received: from pjbsb6.prod.google.com ([2002:a17:90b:50c6:b0:2ef:82c0:cb8d]) (user=samitolvanen job=prod-delivery.src-stubby-dispatcher) by 2002:a17:90b:544e:b0:30a:204e:3271 with SMTP id 98e67ed59e1d1-30a7e0b50c9mr722731a91.17.1746480249164; Mon, 05 May 2025 14:24:09 -0700 (PDT) Date: Mon, 5 May 2025 21:24:04 +0000 In-Reply-To: <20250505212401.3379699-6-samitolvanen@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250505212401.3379699-6-samitolvanen@google.com> X-Developer-Key: i=samitolvanen@google.com; a=openpgp; fpr=35CCFB63B283D6D3AEB783944CB5F6848BBC56EE X-Developer-Signature: v=1; a=openpgp-sha256; l=7598; i=samitolvanen@google.com; h=from:subject; bh=BMC1eT/RW0qYKHRo26wre0JMFNFS6Nb4HECC0KqU2LQ=; b=owGbwMvMwCEWxa662nLh8irG02pJDBmSOkUCH3/PEvJ+fC/Q5kZlYcOMx/o6J2qUDjw04Ny38 LX1z5rHHaUsDGIcDLJiiiwtX1dv3f3dKfXV5yIJmDmsTCBDGLg4BWAie5kY/imt7vkuO808r+an hlrBD5bF9is3xTiynHEIvaz8oHPavDhGhseTFFhrJszZzTbxbutsYcGFX3d+thVSsv7ybOqJk4z LxVgB X-Mailer: git-send-email 2.49.0.967.g6a0df3ecc3-goog Message-ID: <20250505212401.3379699-8-samitolvanen@google.com> Subject: [PATCH v2 2/4] gendwarfksyms: Add a kABI rule to override byte_size attributes From: Sami Tolvanen To: Masahiro Yamada Cc: Luis Chamberlain , Petr Pavlu , Daniel Gomez , linux-modules@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, Sami Tolvanen Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" A data structure can be partially opaque to modules if its allocation is handled by the core kernel, and modules only need to access some of its members. In this situation, it's possible to append new members to the structure without breaking the ABI, as long as the layout for the original members remains unchanged. For example, consider the following struct: struct s { unsigned long a; void *p; }; gendwarfksyms --stable --dump-dies produces the following type expansion: variable structure_type s { member base_type long unsigned int byte_size(8) encoding(7) a data_member_location(0) , member pointer_type { base_type void } byte_size(8) p data_member_location(8) } byte_size(16) To append new members, we can use the KABI_IGNORE() macro to hide them from gendwarfksyms --stable: struct s { /* old members with unchanged layout */ unsigned long a; void *p; /* new members not accessed by modules */ KABI_IGNORE(0, unsigned long n); }; However, we can't hide the fact that adding new members changes the struct size, as seen in the updated type string: variable structure_type s { member base_type long unsigned int byte_size(8) encoding(7) a data_member_location(0) , member pointer_type { base_type void } byte_size(8) p data_member_location(8) } byte_size(24) In order to support this use case, add a kABI rule that makes it possible to override the byte_size attribute for types: /* * struct s allocation is handled by the kernel, so * appending new members without changing the original * layout won't break the ABI. */ KABI_BYTE_SIZE(s, 16); This results in a type string that's unchanged from the original and therefore, won't change versions for symbols that reference the changed structure. Signed-off-by: Sami Tolvanen Reviewed-by: Petr Pavlu --- scripts/gendwarfksyms/dwarf.c | 14 ++++++++++++- scripts/gendwarfksyms/examples/kabi.h | 7 +++++++ scripts/gendwarfksyms/examples/kabi_ex.c | 2 ++ scripts/gendwarfksyms/examples/kabi_ex.h | 22 +++++++++++++++++++++ scripts/gendwarfksyms/gendwarfksyms.h | 1 + scripts/gendwarfksyms/kabi.c | 25 ++++++++++++++++++++++++ 6 files changed, 70 insertions(+), 1 deletion(-) diff --git a/scripts/gendwarfksyms/dwarf.c b/scripts/gendwarfksyms/dwarf.c index eed247d8abfc..13ea7bf1ae7d 100644 --- a/scripts/gendwarfksyms/dwarf.c +++ b/scripts/gendwarfksyms/dwarf.c @@ -228,12 +228,24 @@ static void process_fqn(struct die *cache, Dwarf_Die = *die) DEFINE_PROCESS_UDATA_ATTRIBUTE(accessibility) DEFINE_PROCESS_UDATA_ATTRIBUTE(alignment) DEFINE_PROCESS_UDATA_ATTRIBUTE(bit_size) -DEFINE_PROCESS_UDATA_ATTRIBUTE(byte_size) DEFINE_PROCESS_UDATA_ATTRIBUTE(encoding) DEFINE_PROCESS_UDATA_ATTRIBUTE(data_bit_offset) DEFINE_PROCESS_UDATA_ATTRIBUTE(data_member_location) DEFINE_PROCESS_UDATA_ATTRIBUTE(discr_value) =20 +static void process_byte_size_attr(struct die *cache, Dwarf_Die *die) +{ + Dwarf_Word value; + unsigned long override; + + if (get_udata_attr(die, DW_AT_byte_size, &value)) { + if (stable && kabi_get_byte_size(cache->fqn, &override)) + value =3D override; + + process_fmt(cache, " byte_size(%" PRIu64 ")", value); + } +} + /* Match functions -- die_match_callback_t */ #define DEFINE_MATCH(type) \ static bool match_##type##_type(Dwarf_Die *die) \ diff --git a/scripts/gendwarfksyms/examples/kabi.h b/scripts/gendwarfksyms/= examples/kabi.h index 97a5669b083d..86f4428e0479 100644 --- a/scripts/gendwarfksyms/examples/kabi.h +++ b/scripts/gendwarfksyms/examples/kabi.h @@ -89,6 +89,13 @@ #define KABI_ENUMERATOR_VALUE(fqn, field, value) \ __KABI_RULE(enumerator_value, fqn field, value) =20 +/* + * KABI_BYTE_SIZE(fqn, value) + * Set the byte_size attribute for the struct/union/enum fqn to + * value bytes. + */ +#define KABI_BYTE_SIZE(fqn, value) __KABI_RULE(byte_size, fqn, value) + /* * KABI_RESERVE * Reserve some "padding" in a structure for use by LTS backports. diff --git a/scripts/gendwarfksyms/examples/kabi_ex.c b/scripts/gendwarfksy= ms/examples/kabi_ex.c index 0b7ffd830541..b73ee5399a59 100644 --- a/scripts/gendwarfksyms/examples/kabi_ex.c +++ b/scripts/gendwarfksyms/examples/kabi_ex.c @@ -28,3 +28,5 @@ struct ex2c ex2c; struct ex3a ex3a; struct ex3b ex3b; struct ex3c ex3c; + +struct ex4a ex4a; diff --git a/scripts/gendwarfksyms/examples/kabi_ex.h b/scripts/gendwarfksy= ms/examples/kabi_ex.h index 1736e0f65208..092c8cb7bcd7 100644 --- a/scripts/gendwarfksyms/examples/kabi_ex.h +++ b/scripts/gendwarfksyms/examples/kabi_ex.h @@ -260,4 +260,26 @@ _Static_assert(sizeof(struct ex3a) =3D=3D sizeof(struc= t ex3c), "ex3a size doesn't ma * STABLE-NEXT: } byte_size(16) */ =20 +/* + * Example: An ignored field added to an end of a partially opaque struct, + * while keeping the byte_size attribute unchanged. + */ + +struct ex4a { + unsigned long a; + KABI_IGNORE(0, unsigned long b); +}; + +/* + * This may be safe if the structure allocation is managed by the core ker= nel + * and the layout remains unchanged except for appended new members. + */ +KABI_BYTE_SIZE(ex4a, 8); + +/* + * STABLE: variable structure_type ex4a { + * STABLE-NEXT: member base_type [[ULONG]] byte_size(8) encoding(7) a da= ta_member_location(0) + * STABLE-NEXT: } byte_size(8) + */ + #endif /* __KABI_EX_H__ */ diff --git a/scripts/gendwarfksyms/gendwarfksyms.h b/scripts/gendwarfksyms/= gendwarfksyms.h index 2feec168bf73..2db49c2ad50e 100644 --- a/scripts/gendwarfksyms/gendwarfksyms.h +++ b/scripts/gendwarfksyms/gendwarfksyms.h @@ -287,6 +287,7 @@ void generate_symtypes_and_versions(FILE *file); * kabi.c */ =20 +bool kabi_get_byte_size(const char *fqn, unsigned long *value); bool kabi_is_enumerator_ignored(const char *fqn, const char *field); bool kabi_get_enumerator_value(const char *fqn, const char *field, unsigned long *value); diff --git a/scripts/gendwarfksyms/kabi.c b/scripts/gendwarfksyms/kabi.c index badf8d46b154..61620ff647bd 100644 --- a/scripts/gendwarfksyms/kabi.c +++ b/scripts/gendwarfksyms/kabi.c @@ -54,11 +54,19 @@ */ #define KABI_RULE_TAG_ENUMERATOR_VALUE "enumerator_value" =20 +/* + * Rule: byte_size + * - For the fqn_field in the target field, set the byte_size + * attribute to the value in the value field. + */ +#define KABI_RULE_TAG_BYTE_SIZE "byte_size" + enum kabi_rule_type { KABI_RULE_TYPE_UNKNOWN, KABI_RULE_TYPE_DECLONLY, KABI_RULE_TYPE_ENUMERATOR_IGNORE, KABI_RULE_TYPE_ENUMERATOR_VALUE, + KABI_RULE_TYPE_BYTE_SIZE, }; =20 #define RULE_HASH_BITS 7 @@ -127,6 +135,10 @@ void kabi_read_rules(int fd) .type =3D KABI_RULE_TYPE_ENUMERATOR_VALUE, .tag =3D KABI_RULE_TAG_ENUMERATOR_VALUE, }, + { + .type =3D KABI_RULE_TYPE_BYTE_SIZE, + .tag =3D KABI_RULE_TAG_BYTE_SIZE, + }, }; =20 if (!stable) @@ -308,6 +320,19 @@ bool kabi_get_enumerator_value(const char *fqn, const = char *field, return false; } =20 +bool kabi_get_byte_size(const char *fqn, unsigned long *value) +{ + struct rule *rule; + + rule =3D find_rule(KABI_RULE_TYPE_BYTE_SIZE, fqn); + if (rule) { + *value =3D get_ulong_value(rule->value); + return true; + } + + return false; +} + void kabi_free(void) { struct hlist_node *tmp; --=20 2.49.0.967.g6a0df3ecc3-goog From nobody Wed Dec 17 04:20:09 2025 Received: from mail-pf1-f201.google.com (mail-pf1-f201.google.com [209.85.210.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6893E2749CB for ; Mon, 5 May 2025 21:24:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480253; cv=none; b=cOUCSR1ULXGkxBI0Uwq+UfMnD2l2lGMF32cSyjl6u7FifkkYzJTXs0iP8UlbImvUwyHyPqg1m+dTyJMQHmIev+W2P/416oheoFSIAtPkU6x8bdVbPJBNhtZZYld8sTi++NxOs7KlGSR76GAaYsw7ioii0a+Kv9KXDuiL8U6kj8M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480253; c=relaxed/simple; bh=YRTSlFbj0SA7Uc/V+ldiVlMORzMW2TIQ4ahhg0ZRikw=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=mCiIXBMegk5HdnDEIbdQDWRD/DWojDURhZfoFA8FQtkzjwb/XTIpiZ2Oqy4whZ6zVvcdxxGZl9PbYBGkWvNyCury7ELlt7Uwxr5hsCEhHfhu4byO+SkQL0DBFZyuE9WK95zjCTfo+PlFunvalcRYPXLKi0FQIz/cVgIHxEXIq7c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=AN0PjznP; arc=none smtp.client-ip=209.85.210.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="AN0PjznP" Received: by mail-pf1-f201.google.com with SMTP id d2e1a72fcca58-736a7d0b82fso5909208b3a.1 for ; Mon, 05 May 2025 14:24:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746480251; x=1747085051; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=8m8K3D0qpU4xkcJLM2+2ewnAqTFJC+MNnS9adtsrEgw=; b=AN0PjznPC49pAWTHDl4mfJXSWMj7Lo8lizSNvkKS12zYD4OmFHxF0pBt6Dm6qRHvl7 VeIBviMqnRt8qTc72j+9BZZ/cgfGM/ERZnOZ5zLaanzrnriJ4IzJpW7a/XST1iMFIZrE 2vwndwpHtvpWpxvRCs5sN0XXSFYcssYDmU/lxmXmn3FumxrS4xTdjiRMMGDrjl759Dub yHm/siVxmti873UjT7gumWjDN0j0bXBSRbrZGavrtgWDr/hDfqRamWgfnNeYoON+vpp2 aOxvslTUUEOvzACpQBuLYfe94cbfiXhJTMcRUigFCvcl98BxoYSn4pYsvU0OFyJ/XDFV vl9Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746480251; x=1747085051; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=8m8K3D0qpU4xkcJLM2+2ewnAqTFJC+MNnS9adtsrEgw=; b=MjU2tw5VPEULJ0rHJ7wIiXEBcf++S998SzH85DiqWzH0okE1oFnMgJMCfg6GZhAG2W dgud4PsV1vZMglQfhBL8wg6IL5WafY0yNyzgt3DmawbQh56DJJi2PgM8gzMa6xsfCaX6 svpGUVfPunMCtnGaOgW1ae0WsTfecAGNz/qFHyR3bkN3x3LR77xfXGAkKutiqum0Dbjq ssDIL1WjCeEI9WU+Zcz0Z+Eb6I1SbhcJAR9m+qMCpncbchuS2DtLuc9mG2kRut6xGoBV YJA4tzFsOMn6YFT9Pvz59EjCe8HEQXlq5pZaEBwIIuILvRtJiNUZAkN7HcnZ7fwehriM YDDA== X-Forwarded-Encrypted: i=1; AJvYcCVsIZ9hzOSewZiCN7scpSAMKgNwMmrvo7AxeA/mrL3z1UUumrP7zBPjdAPqUNO3TBUDBJUegB5dZsUjHoI=@vger.kernel.org X-Gm-Message-State: AOJu0Yx5XADtknsmhqFKCcRpBfwteWKS323HjxB3A8Ukf3df8qnakBn7 qVecgqfChGfSqW9+5MaOH2Puo27X/qGNhct+D2X17HRmkQ/+23UdGAOwffEMnLjT4Dcgqj2bvoM ev0yv5sJD/ebcgifwt90FNoxGOg== X-Google-Smtp-Source: AGHT+IFtwnNPyyRDavv9A81ORaoVn1hNWIxzJAnipv72HVlSx0/n2aFPN1kTi5T34UWsoDG7poB4cCrYHshTXDMz8bU= X-Received: from pfud17.prod.google.com ([2002:a05:6a00:10d1:b0:739:56be:f58c]) (user=samitolvanen job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:8d86:b0:73e:598:b2a1 with SMTP id d2e1a72fcca58-7406f0932aemr11741436b3a.1.1746480250728; Mon, 05 May 2025 14:24:10 -0700 (PDT) Date: Mon, 5 May 2025 21:24:05 +0000 In-Reply-To: <20250505212401.3379699-6-samitolvanen@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250505212401.3379699-6-samitolvanen@google.com> X-Developer-Key: i=samitolvanen@google.com; a=openpgp; fpr=35CCFB63B283D6D3AEB783944CB5F6848BBC56EE X-Developer-Signature: v=1; a=openpgp-sha256; l=16692; i=samitolvanen@google.com; h=from:subject; bh=YRTSlFbj0SA7Uc/V+ldiVlMORzMW2TIQ4ahhg0ZRikw=; b=owGbwMvMwCEWxa662nLh8irG02pJDBmSOkVHVbIKuB4e+bt4msmmBYf/ZV9tzVxnKL22JDAyb HbHd1+ZjlIWBjEOBlkxRZaWr6u37v7ulPrqc5EEzBxWJpAhDFycAjCRxsOMDPseHM7+vd+y9dKP A9IiV+zmuuRvEPnrWrNUk/1v6M1jG+8x/BX0VHmbccCrN8KqrV87wO3Xz+6CJVWfve+cDflS5DE 1nB8A X-Mailer: git-send-email 2.49.0.967.g6a0df3ecc3-goog Message-ID: <20250505212401.3379699-9-samitolvanen@google.com> Subject: [PATCH v2 3/4] gendwarfksyms: Add a kABI rule to override type strings From: Sami Tolvanen To: Masahiro Yamada Cc: Luis Chamberlain , Petr Pavlu , Daniel Gomez , linux-modules@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, Sami Tolvanen , Giuliano Procida Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In rare situations where distributions must make significant changes to otherwise opaque data structures that have inadvertently been included in the published ABI, keeping symbol versions stable using the existing kABI macros can become tedious. For example, Android decided to switch to a newer io_uring implementation in the 5.10 GKI kernel "to resolve a huge number of potential, and known, problems with the codebase," requiring "horrible hacks" with genksyms: "A number of the io_uring structures get used in other core kernel structures, only as "opaque" pointers, so there is not any real ABI breakage. But, due to the visibility of the structures going away, the CRC values of many scheduler variables and functions were changed." -- https://r.android.com/2425293 While these specific changes probably could have been hidden from gendwarfksyms using the existing kABI macros, this may not always be the case. Add a last resort kABI rule that allows distribution maintainers to fully override a type string for a symbol or a type. Also add a more informative error message in case we find a non-existent type references when calculating versions. Suggested-by: Giuliano Procida Signed-off-by: Sami Tolvanen Reviewed-by: Petr Pavlu --- scripts/gendwarfksyms/examples/kabi.h | 14 ++- scripts/gendwarfksyms/examples/kabi_ex.c | 5 + scripts/gendwarfksyms/examples/kabi_ex.h | 79 ++++++++++++- scripts/gendwarfksyms/gendwarfksyms.h | 1 + scripts/gendwarfksyms/kabi.c | 25 ++++ scripts/gendwarfksyms/types.c | 140 ++++++++++++++++++++--- 6 files changed, 246 insertions(+), 18 deletions(-) diff --git a/scripts/gendwarfksyms/examples/kabi.h b/scripts/gendwarfksyms/= examples/kabi.h index 86f4428e0479..170733a3fba4 100644 --- a/scripts/gendwarfksyms/examples/kabi.h +++ b/scripts/gendwarfksyms/examples/kabi.h @@ -37,11 +37,14 @@ #define __stringify(x...) __stringify_1(x) #endif =20 -#define __KABI_RULE(hint, target, value) \ +#define ___KABI_RULE(hint, target, value) \ static const char __PASTE(__gendwarfksyms_rule_, \ __COUNTER__)[] __used __aligned(1) \ __section(".discard.gendwarfksyms.kabi_rules") =3D \ - "1\0" #hint "\0" #target "\0" #value + "1\0" #hint "\0" target "\0" value + +#define __KABI_RULE(hint, target, value) \ + ___KABI_RULE(hint, #target, #value) =20 #define __KABI_NORMAL_SIZE_ALIGN(_orig, _new) = \ union { = \ @@ -96,6 +99,13 @@ */ #define KABI_BYTE_SIZE(fqn, value) __KABI_RULE(byte_size, fqn, value) =20 +/* + * KABI_TYPE_STRING(type, str) + * For the given type, override the type string used in symtypes + * output and version calculation with str. + */ +#define KABI_TYPE_STRING(type, str) ___KABI_RULE(type_string, type, str) + /* * KABI_RESERVE * Reserve some "padding" in a structure for use by LTS backports. diff --git a/scripts/gendwarfksyms/examples/kabi_ex.c b/scripts/gendwarfksy= ms/examples/kabi_ex.c index b73ee5399a59..1f799eb7c756 100644 --- a/scripts/gendwarfksyms/examples/kabi_ex.c +++ b/scripts/gendwarfksyms/examples/kabi_ex.c @@ -30,3 +30,8 @@ struct ex3b ex3b; struct ex3c ex3c; =20 struct ex4a ex4a; + +struct ex5a ex5a; +struct ex5b ex5b; + +int ex6a; diff --git a/scripts/gendwarfksyms/examples/kabi_ex.h b/scripts/gendwarfksy= ms/examples/kabi_ex.h index 092c8cb7bcd7..785b211d9c58 100644 --- a/scripts/gendwarfksyms/examples/kabi_ex.h +++ b/scripts/gendwarfksyms/examples/kabi_ex.h @@ -21,6 +21,12 @@ * ./gendwarfksyms --stable --dump-dies \ * examples/kabi_ex.o 2>&1 >/dev/null | \ * FileCheck examples/kabi_ex.h --check-prefix=3DSTABLE + + * $ nm examples/kabi_ex.o | awk '{ print $NF }' | \ + * ./gendwarfksyms --stable --dump-versions \ + * examples/kabi_ex.o 2>&1 >/dev/null | \ + * sort | \ + * FileCheck examples/kabi_ex.h --check-prefix=3DVERSIONS */ =20 #ifndef __KABI_EX_H__ @@ -170,7 +176,7 @@ struct ex2a { /* * STABLE: variable structure_type ex2a { * STABLE-NEXT: member base_type int byte_size(4) encoding(5) a data_mem= ber_location(0) , - * STABLE-NEXT: member base_type [[ULONG:long unsigned int|unsigned long= ]] byte_size(8) encoding(7) b data_member_location(8) + * STABLE-NEXT: member base_type [[ULONG]] byte_size(8) encoding(7) b da= ta_member_location(8) * STABLE-NEXT: member base_type int byte_size(4) encoding(5) c data_mem= ber_location(16) , * STABLE-NEXT: member base_type [[ULONG]] byte_size(8) encoding(7) d da= ta_member_location(24) * STABLE-NEXT: } byte_size(32) @@ -227,7 +233,7 @@ struct ex3a { =20 /* * STABLE: variable structure_type ex3a { - * STABLE-NEXT: member base_type [[ULONG:long unsigned int|unsigned long= ]] byte_size(8) encoding(7) a data_member_location(0) + * STABLE-NEXT: member base_type [[ULONG]] byte_size(8) encoding(7) a da= ta_member_location(0) * STABLE-NEXT: member base_type [[ULONG]] byte_size(8) encoding(7) unus= ed data_member_location(8) * STABLE-NEXT: } byte_size(16) */ @@ -282,4 +288,73 @@ KABI_BYTE_SIZE(ex4a, 8); * STABLE-NEXT: } byte_size(8) */ =20 +/* + * Example: A type string override. + */ + +struct ex5a { + unsigned long a; +}; + +/* + * This may be safe if the structure is fully opaque to modules, even thou= gh + * its definition has inadvertently become part of the ABI. + */ +KABI_TYPE_STRING( + "s#ex5a", + "structure_type ex5a { member pointer_type { s#ex4a } byte_size(8) p data= _member_location(0) } byte_size(8)"); + +/* + * Make sure the fully expanded type string includes ex4a. + * + * VERSIONS: ex5a variable structure_type ex5a { + * VERSIONS-SAME: member pointer_type { + * VERSIONS-SAME: structure_type ex4a { + * VERSIONS-SAME: member base_type [[ULONG:long unsigned int|unsigne= d long]] byte_size(8) encoding(7) a data_member_location(0) + * VERSIONS-SAME: } byte_size(8) + * VERSIONS-SAME: } byte_size(8) p data_member_location(0) + * VERSIONS-SAME: } byte_size(8) + */ + +/* + * Example: A type string definition for a non-existent type. + */ + +struct ex5b { + unsigned long a; +}; + +/* Replace the type string for struct ex5b */ +KABI_TYPE_STRING( + "s#ex5b", + "structure_type ex5b { member pointer_type { s#ex5c } byte_size(8) p data= _member_location(0) } byte_size(8)"); + +/* Define a type string for a non-existent struct ex5c */ +KABI_TYPE_STRING( + "s#ex5c", + "structure_type ex5c { member base_type int byte_size(4) encoding(5) n da= ta_member_location(0) } byte_size(8)"); + +/* + * Make sure the fully expanded type string includes the definition for ex= 5c. + * + * VERSIONS: ex5b variable structure_type ex5b { + * VERSIONS-SAME: member pointer_type { + * VERSIONS-SAME: structure_type ex5c { + * VERSIONS-SAME: member base_type int byte_size(4) encoding(5) n da= ta_member_location(0) + * VERSIONS-SAME: } byte_size(8) + * VERSIONS-SAME: } byte_size(8) p data_member_location(0) + * VERSIONS-SAME: } byte_size(8) + */ + +/* + * Example: A type string override for a symbol. + */ + +KABI_TYPE_STRING("ex6a", "variable s#ex5c"); + +/* + * VERSIONS: ex6a variable structure_type ex5c { + * VERSIONS-SAME: member base_type int byte_size(4) encoding(5) n data_m= ember_location(0) + * VERSIONS-SAME: } byte_size(8) + */ #endif /* __KABI_EX_H__ */ diff --git a/scripts/gendwarfksyms/gendwarfksyms.h b/scripts/gendwarfksyms/= gendwarfksyms.h index 2db49c2ad50e..7dd03ffe0c5c 100644 --- a/scripts/gendwarfksyms/gendwarfksyms.h +++ b/scripts/gendwarfksyms/gendwarfksyms.h @@ -292,6 +292,7 @@ bool kabi_is_enumerator_ignored(const char *fqn, const = char *field); bool kabi_get_enumerator_value(const char *fqn, const char *field, unsigned long *value); bool kabi_is_declonly(const char *fqn); +bool kabi_get_type_string(const char *type, const char **str); =20 void kabi_read_rules(int fd); void kabi_free(void); diff --git a/scripts/gendwarfksyms/kabi.c b/scripts/gendwarfksyms/kabi.c index 61620ff647bd..b3ade713778f 100644 --- a/scripts/gendwarfksyms/kabi.c +++ b/scripts/gendwarfksyms/kabi.c @@ -61,12 +61,20 @@ */ #define KABI_RULE_TAG_BYTE_SIZE "byte_size" =20 +/* + * Rule: type_string + * - For the type reference in the fqn field, use the type string + * in the value field. + */ +#define KABI_RULE_TAG_TYPE_STRING "type_string" + enum kabi_rule_type { KABI_RULE_TYPE_UNKNOWN, KABI_RULE_TYPE_DECLONLY, KABI_RULE_TYPE_ENUMERATOR_IGNORE, KABI_RULE_TYPE_ENUMERATOR_VALUE, KABI_RULE_TYPE_BYTE_SIZE, + KABI_RULE_TYPE_TYPE_STRING, }; =20 #define RULE_HASH_BITS 7 @@ -139,6 +147,10 @@ void kabi_read_rules(int fd) .type =3D KABI_RULE_TYPE_BYTE_SIZE, .tag =3D KABI_RULE_TAG_BYTE_SIZE, }, + { + .type =3D KABI_RULE_TYPE_TYPE_STRING, + .tag =3D KABI_RULE_TAG_TYPE_STRING, + }, }; =20 if (!stable) @@ -333,6 +345,19 @@ bool kabi_get_byte_size(const char *fqn, unsigned long= *value) return false; } =20 +bool kabi_get_type_string(const char *type, const char **str) +{ + struct rule *rule; + + rule =3D find_rule(KABI_RULE_TYPE_TYPE_STRING, type); + if (rule) { + *str =3D rule->value; + return true; + } + + return false; +} + void kabi_free(void) { struct hlist_node *tmp; diff --git a/scripts/gendwarfksyms/types.c b/scripts/gendwarfksyms/types.c index 6f37289104ff..39ce1770e463 100644 --- a/scripts/gendwarfksyms/types.c +++ b/scripts/gendwarfksyms/types.c @@ -100,7 +100,7 @@ static void type_expansion_append(struct type_expansion= *type, const char *s, #define TYPE_HASH_BITS 12 static HASHTABLE_DEFINE(type_map, 1 << TYPE_HASH_BITS); =20 -static int type_map_get(const char *name, struct type_expansion **res) +static int __type_map_get(const char *name, struct type_expansion **res) { struct type_expansion *e; =20 @@ -114,11 +114,12 @@ static int type_map_get(const char *name, struct type= _expansion **res) return -1; } =20 -static void type_map_add(const char *name, struct type_expansion *type) +static struct type_expansion *type_map_add(const char *name, + struct type_expansion *type) { struct type_expansion *e; =20 - if (type_map_get(name, &e)) { + if (__type_map_get(name, &e)) { e =3D xmalloc(sizeof(struct type_expansion)); type_expansion_init(e); e->name =3D xstrdup(name); @@ -130,7 +131,7 @@ static void type_map_add(const char *name, struct type_= expansion *type) } else { /* Use the longest available expansion */ if (type->len <=3D e->len) - return; + return e; =20 type_list_free(&e->expanded); =20 @@ -148,6 +149,34 @@ static void type_map_add(const char *name, struct type= _expansion *type) type_list_write(&e->expanded, stderr); checkp(fputs("\n", stderr)); } + + return e; +} + +static void type_parse(const char *name, const char *str, + struct type_expansion *type); + +static int type_map_get(const char *name, struct type_expansion **res) +{ + struct type_expansion type; + const char *override; + + if (!__type_map_get(name, res)) + return 0; + + /* + * If die_map didn't contain a type, we might still have + * a type_string kABI rule that defines it. + */ + if (stable && kabi_get_type_string(name, &override)) { + type_expansion_init(&type); + type_parse(name, override, &type); + *res =3D type_map_add(name, &type); + type_expansion_free(&type); + return 0; + } + + return -1; } =20 static void type_map_write(FILE *file) @@ -267,15 +296,18 @@ static char *get_type_name(struct die *cache) return name; } =20 -static void __calculate_version(struct version *version, struct list_head = *list) +static void __calculate_version(struct version *version, + struct type_expansion *type) { struct type_list_entry *entry; struct type_expansion *e; =20 /* Calculate a CRC over an expanded type string */ - list_for_each_entry(entry, list, list) { + list_for_each_entry(entry, &type->expanded, list) { if (is_type_prefix(entry->str)) { - check(type_map_get(entry->str, &e)); + if (type_map_get(entry->str, &e)) + error("unknown type reference to '%s' when expanding '%s'", + entry->str, type->name); =20 /* * It's sufficient to expand each type reference just @@ -285,7 +317,7 @@ static void __calculate_version(struct version *version= , struct list_head *list) version_add(version, entry->str); } else { cache_mark_expanded(&expansion_cache, e); - __calculate_version(version, &e->expanded); + __calculate_version(version, e); } } else { version_add(version, entry->str); @@ -293,10 +325,11 @@ static void __calculate_version(struct version *versi= on, struct list_head *list) } } =20 -static void calculate_version(struct version *version, struct list_head *l= ist) +static void calculate_version(struct version *version, + struct type_expansion *type) { version_init(version); - __calculate_version(version, list); + __calculate_version(version, type); cache_free(&expansion_cache); } =20 @@ -372,9 +405,80 @@ static void type_expand(struct die *cache, struct type= _expansion *type, cache_free(&expansion_cache); } =20 +static void type_parse(const char *name, const char *str, + struct type_expansion *type) +{ + char *fragment; + size_t start =3D 0; + size_t end; + size_t pos; + + if (!*str) + error("empty type string override for '%s'", name); + + type_expansion_init(type); + + for (pos =3D 0; str[pos]; ++pos) { + bool empty; + char marker =3D ' '; + + if (!is_type_prefix(&str[pos])) + continue; + + end =3D pos + 2; + + /* + * Find the end of the type reference. If the type name contains + * spaces, it must be in single quotes. + */ + if (str[end] =3D=3D '\'') { + marker =3D '\''; + ++end; + } + while (str[end] && str[end] !=3D marker) + ++end; + + /* Check that we have a non-empty type name */ + if (marker =3D=3D '\'') { + if (str[end] !=3D marker) + error("incomplete %c# type reference for '%s' (string : '%s')", + str[pos], name, str); + empty =3D end =3D=3D pos + 3; + ++end; + } else { + empty =3D end =3D=3D pos + 2; + } + if (empty) + error("empty %c# type name for '%s' (string: '%s')", + str[pos], name, str); + + /* Append the part of the string before the type reference */ + if (pos > start) { + fragment =3D xstrndup(&str[start], pos - start); + type_expansion_append(type, fragment, fragment); + } + + /* + * Append the type reference -- note that if the reference + * is invalid, i.e. points to a non-existent type, we will + * print out an error when calculating versions. + */ + fragment =3D xstrndup(&str[pos], end - pos); + type_expansion_append(type, fragment, fragment); + + start =3D end; + pos =3D end - 1; + } + + /* Append the rest of the type string, if there's any left */ + if (str[start]) + type_expansion_append(type, &str[start], NULL); +} + static void expand_type(struct die *cache, void *arg) { struct type_expansion type; + const char *override; char *name; =20 if (cache->mapped) @@ -399,9 +503,13 @@ static void expand_type(struct die *cache, void *arg) return; =20 debug("%s", name); - type_expand(cache, &type, true); - type_map_add(name, &type); =20 + if (stable && kabi_get_type_string(name, &override)) + type_parse(name, override, &type); + else + type_expand(cache, &type, true); + + type_map_add(name, &type); type_expansion_free(&type); free(name); } @@ -410,6 +518,7 @@ static void expand_symbol(struct symbol *sym, void *arg) { struct type_expansion type; struct version version; + const char *override; struct die *cache; =20 /* @@ -423,11 +532,14 @@ static void expand_symbol(struct symbol *sym, void *a= rg) if (__die_map_get(sym->die_addr, DIE_SYMBOL, &cache)) return; /* We'll warn about missing CRCs later. */ =20 - type_expand(cache, &type, false); + if (stable && kabi_get_type_string(sym->name, &override)) + type_parse(sym->name, override, &type); + else + type_expand(cache, &type, false); =20 /* If the symbol already has a version, don't calculate it again. */ if (sym->state !=3D SYMBOL_PROCESSED) { - calculate_version(&version, &type.expanded); + calculate_version(&version, &type); symbol_set_crc(sym, version.crc); debug("%s =3D %lx", sym->name, version.crc); =20 --=20 2.49.0.967.g6a0df3ecc3-goog From nobody Wed Dec 17 04:20:09 2025 Received: from mail-pg1-f201.google.com (mail-pg1-f201.google.com [209.85.215.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4B95327466E for ; Mon, 5 May 2025 21:24:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480255; cv=none; b=GvM7kezjqP0ktU8PWB4d37kn9UI02jzRKM8S151jCFhQlMoygXWs0FY67cTEgjTjrcorz+uf8SfRMfpxdYOyMC2aa7bEz/zdXTO3u+oL+PojGZKKO2gpHRR4v9gaWoaaBwUNRHsNXxmxAtDUvS0zbD6Y1D8SjeHcoHPHzhOVLbE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746480255; c=relaxed/simple; bh=7s/E4m10J6aoRvjV1yW2+j2HRnsx8mgBbM/r51ocW5A=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=B3tH2viVYIiorAWVf3Drw+1IIbzZDGZjiaN7uPMj9opDnqx/5YOw6EYj/fkjZIOiWj6LBENo57ypoSDER5j2/WF8CRirVvnJw8o0YsG/pLOSym7lnfup8EZq7wg+mQhYuXGQtKDs1GnNk41Aw0AqN7u0T+n5VxXh7eZERYVuon0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=Uqv2uDdA; arc=none smtp.client-ip=209.85.215.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--samitolvanen.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="Uqv2uDdA" Received: by mail-pg1-f201.google.com with SMTP id 41be03b00d2f7-afd1e7f52f7so2580152a12.1 for ; Mon, 05 May 2025 14:24:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746480252; x=1747085052; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=GIPnE82b6i61LEjBTUCqfcsHkZywrijK+35yah+PyEc=; b=Uqv2uDdAt2blx9XF9webmgwyTyPUWjStjeqWDIA9Taow1KF9UtFk8lM1cquMwZT49E mnoL2L+/E/1NOxJEFA4ZiwdAO38u8DinDRM8NYikj5sND3t8P0qrezVISULaRqCHo6fH lM3AWZHFRdGR09wbhdJtBdGQHbAkPy9aZTTlMA993+jIvVWBpEzARDylk8VyjM7cklSa ZgOO8vd47NkA+CcNa0I4UZCLHe0DFB0VcucwSLtKD6/VeXWVEJR7ELplvLmO1r8Sv/IS 90XhBuUX+FuBmvVoQC9qmZaIA4JMXlO7iWaQ90UlsSoQTHNRs+Ctviou2myTkAaxQ3W1 esaw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746480252; x=1747085052; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=GIPnE82b6i61LEjBTUCqfcsHkZywrijK+35yah+PyEc=; b=p1TLARTWSJKUYeRgEL2+EtsAcaAnyhQ/9OfJG5jHovagoiPR8oTRrUIRFfw4nZrhKF xAW96rqZvqT/MfIwVMP1jiOMj0qCPrQY3ESFNJiCZySgmEX+tkn9ehHq/psqCs8wjP1J /jXAz7eC1D8evg7LnlT4JSr8Ok+loPZ0LYIKm1s2KDpwFLQPV/kY9ZBKp72IvE1IefuQ mie812frobN3zz7PwLkn0+CQIueBTzGp3TK7E4q8Sr9bEav7FBUIXfpyqqltrUt+bcv6 Ae9y4lJ/zIxr0FrxfaiwTkWk3WgqgG2c3VW2+ft1GfVMskAP3L+qt0jLemljnKPfITxN Bicw== X-Forwarded-Encrypted: i=1; AJvYcCW1abYlhgYa1YbAZv8qsJHZYP5Y5TsPJ3JR47ih+/8WvVdf7iHmk3PQ6oTFkBjfgBRnqtl86zZYULfM3mo=@vger.kernel.org X-Gm-Message-State: AOJu0YzBmB0QChuK/hxuQjquMemrYbr6337R1UVtVgy53+6RTWY3vvdE zz96dG5VEiovT7dk35INO6mtaR6xkHHUEVAh7lqQk3ZKPliOCagRQgjMv93wZSTm2v1FOcQfqDu OnhLWr5Z2KjmVSl46/jk+Z4q9JQ== X-Google-Smtp-Source: AGHT+IFFmAMe7NdEnE0TKIzz/g3neM1rXjl2OzQV2Y1xfStACjI4PFgGfGajlr+SLVSFArOxlcz0O91imM1sw8QoRSA= X-Received: from pfbfn24.prod.google.com ([2002:a05:6a00:2fd8:b0:736:6fb6:7fc]) (user=samitolvanen job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a21:6d84:b0:1f5:8e33:c417 with SMTP id adf61e73a8af0-21180774d80mr1067658637.2.1746480252274; Mon, 05 May 2025 14:24:12 -0700 (PDT) Date: Mon, 5 May 2025 21:24:06 +0000 In-Reply-To: <20250505212401.3379699-6-samitolvanen@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250505212401.3379699-6-samitolvanen@google.com> X-Developer-Key: i=samitolvanen@google.com; a=openpgp; fpr=35CCFB63B283D6D3AEB783944CB5F6848BBC56EE X-Developer-Signature: v=1; a=openpgp-sha256; l=5930; i=samitolvanen@google.com; h=from:subject; bh=7s/E4m10J6aoRvjV1yW2+j2HRnsx8mgBbM/r51ocW5A=; b=owGbwMvMwCEWxa662nLh8irG02pJDBmSOsUe+i0i6yYU7rNJ0C9jy3eYH6NS0n/i4qyFNirzV 56aZFnaUcrCIMbBICumyNLydfXW3d+dUl99LpKAmcPKBDKEgYtTACZSfojhf0w1N8vmO6vNl058 NFP5k7FD0dLEfM15wsmLJrWVix9OvMrwizmNvehiE0P66Zx2nQbezeoxFStkfRdMvL+XM5d7xet mRgA= X-Mailer: git-send-email 2.49.0.967.g6a0df3ecc3-goog Message-ID: <20250505212401.3379699-10-samitolvanen@google.com> Subject: [PATCH v2 4/4] Documentation/kbuild: Add new gendwarfksyms kABI rules From: Sami Tolvanen To: Masahiro Yamada Cc: Luis Chamberlain , Petr Pavlu , Daniel Gomez , linux-modules@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, Sami Tolvanen Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Document byte_size and type_string kABI stability rules. Also fix the section numbers while we're at it. Signed-off-by: Sami Tolvanen --- Documentation/kbuild/gendwarfksyms.rst | 103 +++++++++++++++++++++++-- 1 file changed, 95 insertions(+), 8 deletions(-) diff --git a/Documentation/kbuild/gendwarfksyms.rst b/Documentation/kbuild/= gendwarfksyms.rst index e4beaae7e456..8b0d7ebbb084 100644 --- a/Documentation/kbuild/gendwarfksyms.rst +++ b/Documentation/kbuild/gendwarfksyms.rst @@ -125,14 +125,17 @@ the rules. The fields are as follows: qualified name of the DWARF Debugging Information Entry (DIE). - `value`: Provides rule-specific data. =20 -The following helper macro, for example, can be used to specify rules +The following helper macros, for example, can be used to specify rules in the source code:: =20 - #define __KABI_RULE(hint, target, value) \ - static const char __PASTE(__gendwarfksyms_rule_, \ + #define ___KABI_RULE(hint, target, value) \ + static const char __PASTE(__gendwarfksyms_rule_, \ __COUNTER__)[] __used __aligned(1) \ __section(".discard.gendwarfksyms.kabi_rules") =3D \ - "1\0" #hint "\0" #target "\0" #value + "1\0" #hint "\0" target "\0" value + + #define __KABI_RULE(hint, target, value) \ + ___KABI_RULE(hint, #target, #value) =20 =20 Currently, only the rules discussed in this section are supported, but @@ -223,7 +226,88 @@ Example usage:: KABI_ENUMERATOR_IGNORE(e, C); KABI_ENUMERATOR_VALUE(e, LAST, 2); =20 -4.3. Adding structure members +4.1.3. Managing structure size changes +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +A data structure can be partially opaque to modules if its allocation is +handled by the core kernel, and modules only need to access some of its +members. In this situation, it's possible to append new members to the +structure without breaking the ABI, as long as the layout for the original +members remains unchanged. + +To append new members, we can hide them from symbol versioning as +described in section :ref:`Hiding members `, but we can't +hide the increase in structure size. The `byte_size` rule allows us to +override the structure size used for symbol versioning. + +The rule fields are expected to be as follows: + +- `type`: "byte_size" +- `target`: The fully qualified name of the target data structure + (as shown in **--dump-dies** output). +- `value`: A positive decimal number indicating the structure size + in bytes. + +Using the `__KABI_RULE` macro, this rule can be defined as:: + + #define KABI_BYTE_SIZE(fqn, value) \ + __KABI_RULE(byte_size, fqn, value) + +Example usage:: + + struct s { + /* Unchanged original members */ + unsigned long a; + void *p; + + /* Appended new members */ + KABI_IGNORE(0, unsigned long n); + }; + + KABI_BYTE_SIZE(s, 16); + +4.1.4. Overriding type strings +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D + +In rare situations where distributions must make significant changes to +otherwise opaque data structures that have inadvertently been included +in the published ABI, keeping symbol versions stable using the more +targeted kABI rules can become tedious. The `type_string` rule allows us +to override the full type string for a type or a symbol, and even add +types for versioning that no longer exist in the kernel. + +The rule fields are expected to be as follows: + +- `type`: "type_string" +- `target`: The fully qualified name of the target data structure + (as shown in **--dump-dies** output) or symbol. +- `value`: A valid type string (as shown in **--symtypes**) output) + to use instead of the real type. + +Using the `__KABI_RULE` macro, this rule can be defined as:: + + #define KABI_TYPE_STRING(type, str) \ + ___KABI_RULE("type_string", type, str) + +Example usage:: + + /* Override type for a structure */ + KABI_TYPE_STRING("s#s", + "structure_type s { " + "member base_type int byte_size(4) " + "encoding(5) n " + "data_member_location(0) " + "} byte_size(8)"); + + /* Override type for a symbol */ + KABI_TYPE_STRING("my_symbol", "variable s#s"); + +The `type_string` rule should be used only as a last resort if maintaining +a stable symbol versions cannot be reasonably achieved using other +means. Overriding a type string increases the risk of actual ABI breakages +going unnoticed as it hides all changes to the type. + +4.2. Adding structure members =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D =20 Perhaps the most common ABI compatible change is adding a member to a @@ -237,7 +321,7 @@ natural method. This section describes gendwarfksyms su= pport for using reserved space in data structures and hiding members that don't change the ABI when calculating symbol versions. =20 -4.3.1. Reserving space and replacing members +4.2.1. Reserving space and replacing members =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =20 Space is typically reserved for later use by appending integer types, or @@ -276,7 +360,9 @@ The examples include `KABI_(RESERVE|USE|REPLACE)*` macr= os that help simplify the process and also ensure the replacement member is correctly aligned and its size won't exceed the reserved space. =20 -4.3.2. Hiding members +.. _hiding_members: + +4.2.2. Hiding members =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =20 Predicting which structures will require changes during the support @@ -305,4 +391,5 @@ member to a union where one of the fields has a name st= arting with unsigned long b; }; =20 -With **--stable**, both versions produce the same symbol version. +With **--stable**, both versions produce the same symbol version. The +examples include a `KABI_IGNORE` macro to simplify the code. --=20 2.49.0.967.g6a0df3ecc3-goog