From patchwork Thu Jan 2 23:26:10 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925002 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1622C1B6CF3; Thu, 2 Jan 2025 23:25:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=B5gcVekYw53eKHczar3WP3IXdvwA+qtueNGJZML3PjdCvK8VuCR4NChn3aEe9EnzZ4fm9S2P/CaxRynF03zNIfObP/t+aw6PYSK/AKMkCakkJZEtOdhCb5zr80DK17TqalfJLoOxg0Tk4gxpNP+zS/Oh6wHkFm+1wHC+NcInc8Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=0PiWUTn4HS2+6Hqtdbt7AAKDTj3gjdoEBm3Jr4CL3Cs=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=hWDsvZ5BiKMZZOIk8hoQNuCJRd3sABOGwyeJkr2aUc9XJe/OzsAyJHqFHv0BOOeiGnPa410nRcb1AhaaiE+xpq7+/Bufo3w52hepLLBztGgGiPDmWmhIFbWNdDLOUwfeAOwy0bd5Lf9ycMHsTCfeuj71vcBMMyGeGt9wnHjfLg0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id AC1F3C4CED7; Thu, 2 Jan 2025 23:25:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaW-00000005YrG-3w38; Thu, 02 Jan 2025 18:26:48 -0500 Message-ID: <20250102232648.800610480@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:10 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 01/16] scripts/sorttable: Remove unused macro defines References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt The code of sorttable.h was copied from the recordmcount.h which defined a bunch of Elf MACROs so that they could be used between 32bit and 64bit functions. But there's several MACROs that sorttable.h does not use but was copied over. Remove them to clean up the code. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.h | 27 --------------------------- 1 file changed, 27 deletions(-) diff --git a/scripts/sorttable.h b/scripts/sorttable.h index 7bd0184380d3..2a9ec5046e9a 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -27,19 +27,10 @@ #undef Elf_Ehdr #undef Elf_Shdr #undef Elf_Rel -#undef Elf_Rela #undef Elf_Sym -#undef ELF_R_SYM -#undef Elf_r_sym -#undef ELF_R_INFO -#undef Elf_r_info -#undef ELF_ST_BIND #undef ELF_ST_TYPE -#undef fn_ELF_R_SYM -#undef fn_ELF_R_INFO #undef uint_t #undef _r -#undef _w #ifdef SORTTABLE_64 # define extable_ent_size 16 @@ -52,19 +43,10 @@ # define Elf_Ehdr Elf64_Ehdr # define Elf_Shdr Elf64_Shdr # define Elf_Rel Elf64_Rel -# define Elf_Rela Elf64_Rela # define Elf_Sym Elf64_Sym -# define ELF_R_SYM ELF64_R_SYM -# define Elf_r_sym Elf64_r_sym -# define ELF_R_INFO ELF64_R_INFO -# define Elf_r_info Elf64_r_info -# define ELF_ST_BIND ELF64_ST_BIND # define ELF_ST_TYPE ELF64_ST_TYPE -# define fn_ELF_R_SYM fn_ELF64_R_SYM -# define fn_ELF_R_INFO fn_ELF64_R_INFO # define uint_t uint64_t # define _r r8 -# define _w w8 #else # define extable_ent_size 8 # define compare_extable compare_extable_32 @@ -76,19 +58,10 @@ # define Elf_Ehdr Elf32_Ehdr # define Elf_Shdr Elf32_Shdr # define Elf_Rel Elf32_Rel -# define Elf_Rela Elf32_Rela # define Elf_Sym Elf32_Sym -# define ELF_R_SYM ELF32_R_SYM -# define Elf_r_sym Elf32_r_sym -# define ELF_R_INFO ELF32_R_INFO -# define Elf_r_info Elf32_r_info -# define ELF_ST_BIND ELF32_ST_BIND # define ELF_ST_TYPE ELF32_ST_TYPE -# define fn_ELF_R_SYM fn_ELF32_R_SYM -# define fn_ELF_R_INFO fn_ELF32_R_INFO # define uint_t uint32_t # define _r r -# define _w w #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) From patchwork Thu Jan 2 23:26:11 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925001 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1616FC13D; Thu, 2 Jan 2025 23:25:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=le0VZfjgCYZ8iaFXxcWVZht4gSt+w3bCgdbdVLtHlO8WfBrmbgBTZg+w128WSNAqAHcdz/zMtY0pONR24tDhGl7LyEnzQVO7tknOgStnmaYKpbIU0k5GL7szYH215Op/Z/sOaXG+2Q2dpamXvOfdHrLdhbkPLLAx+J/WLRnTBnE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=dtsZSR5PGN9lZfaBFK/cPKjmy4rRTW/a7uREJxy5Oaw=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=ZXkNkpkD1z9lvQld1vBwG+x6xh26cLQNbrDmISTVosyR8W4Fz5hCSCM8+KppzvU7S2cu2P3GXXss/xMwVyic1VmAnlvkIoUopjnAFs7QSYzjeYGUa3nqPkvDoh4ImNTQL4baaYWfTE7EqH9hEKhZ0LUZvqZkAdN58IDvSWYmnuw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id CA09EC4CEDE; Thu, 2 Jan 2025 23:25:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaX-00000005Yrn-0SxA; Thu, 02 Jan 2025 18:26:49 -0500 Message-ID: <20250102232648.958831401@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:11 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 02/16] scripts/sorttable: Remove unused write functions References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt The code of sorttable.h was copied from the recordmcount.h which defined various write functions for different sizes (2, 4, 8 byte lengths). But sorttable only uses the 4 byte writes. Remove the extra versions as they are not used. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 83cdb843d92f..4dcdbf7a5e26 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -68,8 +68,6 @@ static uint32_t (*r)(const uint32_t *); static uint16_t (*r2)(const uint16_t *); static uint64_t (*r8)(const uint64_t *); static void (*w)(uint32_t, uint32_t *); -static void (*w2)(uint16_t, uint16_t *); -static void (*w8)(uint64_t, uint64_t *); typedef void (*table_sort_t)(char *, int); /* @@ -146,31 +144,11 @@ static void wbe(uint32_t val, uint32_t *x) put_unaligned_be32(val, x); } -static void w2be(uint16_t val, uint16_t *x) -{ - put_unaligned_be16(val, x); -} - -static void w8be(uint64_t val, uint64_t *x) -{ - put_unaligned_be64(val, x); -} - static void wle(uint32_t val, uint32_t *x) { put_unaligned_le32(val, x); } -static void w2le(uint16_t val, uint16_t *x) -{ - put_unaligned_le16(val, x); -} - -static void w8le(uint64_t val, uint64_t *x) -{ - put_unaligned_le64(val, x); -} - /* * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of * the way to -256..-1, to avoid conflicting with real section @@ -277,16 +255,12 @@ static int do_file(char const *const fname, void *addr) r2 = r2le; r8 = r8le; w = wle; - w2 = w2le; - w8 = w8le; break; case ELFDATA2MSB: r = rbe; r2 = r2be; r8 = r8be; w = wbe; - w2 = w2be; - w8 = w8be; break; default: fprintf(stderr, "unrecognized ELF data encoding %d: %s\n", From patchwork Thu Jan 2 23:26:12 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925004 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 544F21BD9F2; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=blzXP+EIzHRBGiTO8by341/IwkD93pEn7/MUQ88sh3rA9ln3Q+j0WsEfO5AZMv3blYdjowZFKAkTZ81Pq6Mds1PZVY9GvCS8UhYJCS7fujra3Jj60qEAQBAOuP0bF+y83I/4Osycv4p9WwK6FlW/aduhk4u+9u9/TpTmL6ZPT9M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=Xi5Kd6v+5PObKO7g322knu3becI+HlpZMSy5XBPm7ZY=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=rGnbU6Qaz0wQDrVKMZ0Jx6IvxQuT/P7qe5G3YGUoDaxV5iOZRy5+7IKHAO6flAs6StkZ110FRQrpTv1WVNmfLnhfGcrN0TEvR6xFqBVGv4Cd3r6HpJHrkXwl7ZWB5NX/381dljsck1cGF+ropMHuwRFSkpNf+4oFmkC7cc3pjf8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id EE9FCC4CEE4; Thu, 2 Jan 2025 23:25:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaX-00000005YsH-18ii; Thu, 02 Jan 2025 18:26:49 -0500 Message-ID: <20250102232649.133222659@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:12 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 03/16] scripts/sorttable: Remove unneeded Elf_Rel References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt The code had references to initialize the Elf_Rel relocation tables, but it was never used. Remove it. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.h | 23 ++--------------------- 1 file changed, 2 insertions(+), 21 deletions(-) diff --git a/scripts/sorttable.h b/scripts/sorttable.h index 2a9ec5046e9a..aa7a8499a516 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -26,7 +26,6 @@ #undef Elf_Addr #undef Elf_Ehdr #undef Elf_Shdr -#undef Elf_Rel #undef Elf_Sym #undef ELF_ST_TYPE #undef uint_t @@ -42,7 +41,6 @@ # define Elf_Addr Elf64_Addr # define Elf_Ehdr Elf64_Ehdr # define Elf_Shdr Elf64_Shdr -# define Elf_Rel Elf64_Rel # define Elf_Sym Elf64_Sym # define ELF_ST_TYPE ELF64_ST_TYPE # define uint_t uint64_t @@ -57,7 +55,6 @@ # define Elf_Addr Elf32_Addr # define Elf_Ehdr Elf32_Ehdr # define Elf_Shdr Elf32_Shdr -# define Elf_Rel Elf32_Rel # define Elf_Sym Elf32_Sym # define ELF_ST_TYPE ELF32_ST_TYPE # define uint_t uint32_t @@ -245,14 +242,10 @@ static int do_sort(Elf_Ehdr *ehdr, Elf32_Word *symtab_shndx = NULL; Elf_Sym *sort_needed_sym = NULL; Elf_Shdr *sort_needed_sec; - Elf_Rel *relocs = NULL; - int relocs_size = 0; uint32_t *sort_needed_loc; const char *secstrings; const char *strtab; char *extab_image; - int extab_index = 0; - int i; int idx; unsigned int shnum; unsigned int shstrndx; @@ -276,23 +269,15 @@ static int do_sort(Elf_Ehdr *ehdr, if (shnum == SHN_UNDEF) shnum = _r(&shdr[0].sh_size); - for (i = 0, s = shdr; s < shdr + shnum; i++, s++) { + for (s = shdr; s < shdr + shnum; s++) { idx = r(&s->sh_name); - if (!strcmp(secstrings + idx, "__ex_table")) { + if (!strcmp(secstrings + idx, "__ex_table")) extab_sec = s; - extab_index = i; - } if (!strcmp(secstrings + idx, ".symtab")) symtab_sec = s; if (!strcmp(secstrings + idx, ".strtab")) strtab_sec = s; - if ((r(&s->sh_type) == SHT_REL || - r(&s->sh_type) == SHT_RELA) && - r(&s->sh_info) == extab_index) { - relocs = (void *)ehdr + _r(&s->sh_offset); - relocs_size = _r(&s->sh_size); - } if (r(&s->sh_type) == SHT_SYMTAB_SHNDX) symtab_shndx = (Elf32_Word *)((const char *)ehdr + _r(&s->sh_offset)); @@ -394,10 +379,6 @@ static int do_sort(Elf_Ehdr *ehdr, extable_ent_size, compare_extable); } - /* If there were relocations, we no longer need them. */ - if (relocs) - memset(relocs, 0, relocs_size); - /* find the flag main_extable_sort_needed */ for (sym = (void *)ehdr + _r(&symtab_sec->sh_offset); sym < sym + _r(&symtab_sec->sh_size) / sizeof(Elf_Sym); From patchwork Thu Jan 2 23:26:13 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925006 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A02541BEF75; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=MLY445iefML3D6YWRGQyvNjDLEMxUz3cRgL39u6ddpOwqzWTzYb4grpujdBdM2TPchXkTuxGWck/rZMzI3GtfIyZ4bDAI3c/wjtec/VTeiZ7oqRHZZsqfUS1H83ZgQwE3ER04sf19C+VC6/qBpwG+WNu/TncCHVV5lsebPNLsBU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=vpefdYnotZYqFb3OuaEaxQCVmosOhU+jvix41HPEufg=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=YzqCHSyaaKgrumAvjclyJBa68HAii4Buc4Vb3QExPOtTk4xfosPBFJE2rIFmASAeOfBYQi9mHu5Uqc8WX8qyuObG/jIuMKj0aAVkZXzXlB1hensDasD/57A0H6CPqKGeeai2YJelrSFLIy/iByru3Va7USd3ik+wVhMoeKjIlus= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4DE28C4CED0; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaX-00000005Ysl-1sS3; Thu, 02 Jan 2025 18:26:49 -0500 Message-ID: <20250102232649.293540958@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:13 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 04/16] scripts/sorttable: Have the ORC code use the _r() functions to read References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt The ORC code reads the section information directly from the file. This currently works because the default read function is for 64bit little endian machines. But if for some reason that ever changes, this will break. Instead of having a surprise breakage, use the _r() functions that will read the values from the file properly. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/scripts/sorttable.h b/scripts/sorttable.h index aa7a8499a516..7c06a754e31a 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -296,14 +296,14 @@ static int do_sort(Elf_Ehdr *ehdr, #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) /* locate the ORC unwind tables */ if (!strcmp(secstrings + idx, ".orc_unwind_ip")) { - orc_ip_size = s->sh_size; + orc_ip_size = _r(&s->sh_size); g_orc_ip_table = (int *)((void *)ehdr + - s->sh_offset); + _r(&s->sh_offset)); } if (!strcmp(secstrings + idx, ".orc_unwind")) { - orc_size = s->sh_size; + orc_size = _r(&s->sh_size); g_orc_table = (struct orc_entry *)((void *)ehdr + - s->sh_offset); + _r(&s->sh_offset)); } #endif } /* for loop */ From patchwork Thu Jan 2 23:26:14 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925005 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 869591BEF68; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=AToUc/1xuFIdY0Kb9dyJG/g4s3mst7xAxO1GsIt9e+trFfV+bH6FIyJBT4oUVZlq+BUi+PYyrWDUiUS6YLGhmxvwteilN14lyTNBpbGDFI5E3BNXD2HkgsTVsLeDuH8jcHMFjMs/xUi07BdCE3fURx7duKZUo5mgpMSubDtGDcY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=+QyYpeRbkgo4EmCdCfQnmv4zRztB3F8BzX4bjwL9FGk=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=asnpg4UlWEFTKI3BGpff3c+3FG/kfQeclcazcmrdaBjJhVXJqapW5Z0YbZ/8S8eIMwUCaISMbCa+fz05czHrkZMDdn12X0M/4lMjqy0mMsdtyN2o7Tf/QK+PlGMMebqBlCuYV0JYM9XBiX1VffPob0NF48njEwQRHIIpnKg4lnU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 575D4C4CED7; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaX-00000005YtH-2cEh; Thu, 02 Jan 2025 18:26:49 -0500 Message-ID: <20250102232649.473667474@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:14 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 05/16] scripts/sorttable: Make compare_extable() into two functions References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt Instead of having the compare_extable() part of the sorttable.h header where it get's defined twice, since it is a very simple function, just define it twice in sorttable.c, and then it can use the proper read functions for the word size and endianess and the Elf_Addr macro can be removed from sorttable.h. Also add a micro optimization. Instead of: if (a < b) return -1; if (a > b) return 1; return 0; That can be shorten to: if (a < b) return -1; return a > b; Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 20 ++++++++++++++++++++ scripts/sorttable.h | 14 -------------- 2 files changed, 20 insertions(+), 14 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 4dcdbf7a5e26..3e2c17e91485 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -173,6 +173,26 @@ static inline unsigned int get_secindex(unsigned int shndx, return r(&symtab_shndx_start[sym_offs]); } +static int compare_extable_32(const void *a, const void *b) +{ + Elf32_Addr av = r(a); + Elf32_Addr bv = r(b); + + if (av < bv) + return -1; + return av > bv; +} + +static int compare_extable_64(const void *a, const void *b) +{ + Elf64_Addr av = r8(a); + Elf64_Addr bv = r8(b); + + if (av < bv) + return -1; + return av > bv; +} + /* 32 bit and 64 bit are very similar */ #include "sorttable.h" #define SORTTABLE_64 diff --git a/scripts/sorttable.h b/scripts/sorttable.h index 7c06a754e31a..58e9cebe8362 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -23,7 +23,6 @@ #undef sort_mcount_loc #undef elf_mcount_loc #undef do_sort -#undef Elf_Addr #undef Elf_Ehdr #undef Elf_Shdr #undef Elf_Sym @@ -38,7 +37,6 @@ # define sort_mcount_loc sort_mcount_loc_64 # define elf_mcount_loc elf_mcount_loc_64 # define do_sort do_sort_64 -# define Elf_Addr Elf64_Addr # define Elf_Ehdr Elf64_Ehdr # define Elf_Shdr Elf64_Shdr # define Elf_Sym Elf64_Sym @@ -52,7 +50,6 @@ # define sort_mcount_loc sort_mcount_loc_32 # define elf_mcount_loc elf_mcount_loc_32 # define do_sort do_sort_32 -# define Elf_Addr Elf32_Addr # define Elf_Ehdr Elf32_Ehdr # define Elf_Shdr Elf32_Shdr # define Elf_Sym Elf32_Sym @@ -157,17 +154,6 @@ static void *sort_orctable(void *arg) } #endif -static int compare_extable(const void *a, const void *b) -{ - Elf_Addr av = _r(a); - Elf_Addr bv = _r(b); - - if (av < bv) - return -1; - if (av > bv) - return 1; - return 0; -} #ifdef MCOUNT_SORT_ENABLED pthread_t mcount_sort_thread; From patchwork Thu Jan 2 23:26:15 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925008 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CF0241BEF8F; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=NFnlMhXqS2nJxy/UYpqws23UjIz3hhiJ7F/egbouKYv2eBdiWfOmU3rSUoXM+NXed9lL7fQ9bEjgOd2KbAFvfqq4TRIqOmR+PF1Pe3hjpGCDlasHIBakkKjMOpcttevhAAE+8x4fdi6WYBKMVWA+u+KZ8iSEwBAKAY6IP8W+mB4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=JIh6w+rJfbF3hMQPwOZmL0LJXaj43J+6TttiH8ZjL0Q=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=BYW0IR84U9pGjLruZZ6EcW4i1Hi7WPzba+VbPMiaX8XrqLpdgpI2ci+DLIe8yXGN3vm9GCw6qhexs+FAJNr0MFJaSiZcmfVco8ulIRyuQR11FQX8NNwgUPuqJ0vYMKdkSEkUdeb2o9rZZu2cOmgdh/+MHpJ9byFiRjcl2U8eWUM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 77034C4CEE5; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaX-00000005Ytl-3K2J; Thu, 02 Jan 2025 18:26:49 -0500 Message-ID: <20250102232649.645426337@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:15 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 06/16] scripts/sorttable: Convert Elf_Ehdr to union References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In order to remove the double #include of sorttable.h for 64 and 32 bit to create duplicate functions for both, replace the Elf_Ehdr macro with a union that defines both Elf64_Ehdr and Elf32_Ehdr, with field e64 for the 64bit version, and e32 for the 32bit version. Then a macro etype can be used instead to get to the proper value. This will eventually be replaced with just single functions that can handle both 32bit and 64bit ELF parsing. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 36 ++++++++++++++++++++---------------- scripts/sorttable.h | 12 ++++++------ 2 files changed, 26 insertions(+), 22 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 3e2c17e91485..67cbbfc8214d 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -64,6 +64,11 @@ #define EM_LOONGARCH 258 #endif +typedef union { + Elf32_Ehdr e32; + Elf64_Ehdr e64; +} Elf_Ehdr; + static uint32_t (*r)(const uint32_t *); static uint16_t (*r2)(const uint16_t *); static uint64_t (*r8)(const uint64_t *); @@ -266,10 +271,10 @@ static void sort_relative_table_with_data(char *extab_image, int image_size) static int do_file(char const *const fname, void *addr) { int rc = -1; - Elf32_Ehdr *ehdr = addr; + Elf_Ehdr *ehdr = addr; table_sort_t custom_sort = NULL; - switch (ehdr->e_ident[EI_DATA]) { + switch (ehdr->e32.e_ident[EI_DATA]) { case ELFDATA2LSB: r = rle; r2 = r2le; @@ -284,18 +289,18 @@ static int do_file(char const *const fname, void *addr) break; default: fprintf(stderr, "unrecognized ELF data encoding %d: %s\n", - ehdr->e_ident[EI_DATA], fname); + ehdr->e32.e_ident[EI_DATA], fname); return -1; } - if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0 || - (r2(&ehdr->e_type) != ET_EXEC && r2(&ehdr->e_type) != ET_DYN) || - ehdr->e_ident[EI_VERSION] != EV_CURRENT) { + if (memcmp(ELFMAG, ehdr->e32.e_ident, SELFMAG) != 0 || + (r2(&ehdr->e32.e_type) != ET_EXEC && r2(&ehdr->e32.e_type) != ET_DYN) || + ehdr->e32.e_ident[EI_VERSION] != EV_CURRENT) { fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file %s\n", fname); return -1; } - switch (r2(&ehdr->e_machine)) { + switch (r2(&ehdr->e32.e_machine)) { case EM_386: case EM_AARCH64: case EM_LOONGARCH: @@ -318,14 +323,14 @@ static int do_file(char const *const fname, void *addr) break; default: fprintf(stderr, "unrecognized e_machine %d %s\n", - r2(&ehdr->e_machine), fname); + r2(&ehdr->e32.e_machine), fname); return -1; } - switch (ehdr->e_ident[EI_CLASS]) { + switch (ehdr->e32.e_ident[EI_CLASS]) { case ELFCLASS32: - if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) || - r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) { + if (r2(&ehdr->e32.e_ehsize) != sizeof(Elf32_Ehdr) || + r2(&ehdr->e32.e_shentsize) != sizeof(Elf32_Shdr)) { fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file: %s\n", fname); break; @@ -334,20 +339,19 @@ static int do_file(char const *const fname, void *addr) break; case ELFCLASS64: { - Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr; - if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) || - r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) { + if (r2(&ehdr->e64.e_ehsize) != sizeof(Elf64_Ehdr) || + r2(&ehdr->e64.e_shentsize) != sizeof(Elf64_Shdr)) { fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file: %s\n", fname); break; } - rc = do_sort_64(ghdr, fname, custom_sort); + rc = do_sort_64(ehdr, fname, custom_sort); } break; default: fprintf(stderr, "unrecognized ELF class %d %s\n", - ehdr->e_ident[EI_CLASS], fname); + ehdr->e32.e_ident[EI_CLASS], fname); break; } diff --git a/scripts/sorttable.h b/scripts/sorttable.h index 58e9cebe8362..eff204958ffc 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -23,12 +23,12 @@ #undef sort_mcount_loc #undef elf_mcount_loc #undef do_sort -#undef Elf_Ehdr #undef Elf_Shdr #undef Elf_Sym #undef ELF_ST_TYPE #undef uint_t #undef _r +#undef etype #ifdef SORTTABLE_64 # define extable_ent_size 16 @@ -37,12 +37,12 @@ # define sort_mcount_loc sort_mcount_loc_64 # define elf_mcount_loc elf_mcount_loc_64 # define do_sort do_sort_64 -# define Elf_Ehdr Elf64_Ehdr # define Elf_Shdr Elf64_Shdr # define Elf_Sym Elf64_Sym # define ELF_ST_TYPE ELF64_ST_TYPE # define uint_t uint64_t # define _r r8 +# define etype e64 #else # define extable_ent_size 8 # define compare_extable compare_extable_32 @@ -50,12 +50,12 @@ # define sort_mcount_loc sort_mcount_loc_32 # define elf_mcount_loc elf_mcount_loc_32 # define do_sort do_sort_32 -# define Elf_Ehdr Elf32_Ehdr # define Elf_Shdr Elf32_Shdr # define Elf_Sym Elf32_Sym # define ELF_ST_TYPE ELF32_ST_TYPE # define uint_t uint32_t # define _r r +# define etype e32 #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) @@ -219,7 +219,7 @@ static int do_sort(Elf_Ehdr *ehdr, table_sort_t custom_sort) { int rc = -1; - Elf_Shdr *s, *shdr = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->e_shoff)); + Elf_Shdr *s, *shdr = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->etype.e_shoff)); Elf_Shdr *strtab_sec = NULL; Elf_Shdr *symtab_sec = NULL; Elf_Shdr *extab_sec = NULL; @@ -246,12 +246,12 @@ static int do_sort(Elf_Ehdr *ehdr, unsigned int orc_num_entries = 0; #endif - shstrndx = r2(&ehdr->e_shstrndx); + shstrndx = r2(&ehdr->etype.e_shstrndx); if (shstrndx == SHN_XINDEX) shstrndx = r(&shdr[0].sh_link); secstrings = (const char *)ehdr + _r(&shdr[shstrndx].sh_offset); - shnum = r2(&ehdr->e_shnum); + shnum = r2(&ehdr->etype.e_shnum); if (shnum == SHN_UNDEF) shnum = _r(&shdr[0].sh_size); From patchwork Thu Jan 2 23:26:16 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925007 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D15FD1BEF91; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; cv=none; b=sdJOc7EJtQC/eWdZCdTs1dhAW7U0LJxsgHB1GfK3FbCq9W1URV0iv5kPsOBvPtOutx1DEwE0W3yHKlsMJOTr5Brz8YgoyR2Q+u9El25JfzVpwltcQ0V0PEjKNHRlJ+gmvq3WaE6UpX9t9865TcMcO/eiBRFNbWK6etgpqLwxzqU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860332; c=relaxed/simple; bh=1yEG7vRRi2cp/iNoVx6PzUagLZ0jLIeg+CMhBl1LmIA=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=V18QJAJ12Ze1u4lVmDkXLYufg5hRAL1orYzxrC6aT/UtQ0EWl65sCgTTA5UIlaZmaCqkM3e90XohvWCwgW7dJgGUW4haPtVxcRzgbrYnrMvstyOyJxANTfuxtncPzMrlENIGy5L/nFzxuSfZ9LWbLaTXpMx8KYbGf/+4av6nxqU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id A9513C4CEDD; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaX-00000005YuG-425P; Thu, 02 Jan 2025 18:26:49 -0500 Message-ID: <20250102232649.814083058@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:16 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 07/16] scripts/sorttable: Replace Elf_Shdr Macro with a union References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In order to remove the double #include of sorttable.h for 64 and 32 bit to create duplicate functions for both, replace the Elf_Shdr macro with a union that defines both Elf64_Shdr and Elf32_Shdr, with field e64 for the 64bit version, and e32 for the 32bit version. It can then use the macro etype to get the proper value. This will eventually be replaced with just single functions that can handle both 32bit and 64bit ELF parsing. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 10 ++++++ scripts/sorttable.h | 74 +++++++++++++++++++++++++-------------------- 2 files changed, 51 insertions(+), 33 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 67cbbfc8214d..94497b8ab04c 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -69,6 +69,11 @@ typedef union { Elf64_Ehdr e64; } Elf_Ehdr; +typedef union { + Elf32_Shdr e32; + Elf64_Shdr e64; +} Elf_Shdr; + static uint32_t (*r)(const uint32_t *); static uint16_t (*r2)(const uint16_t *); static uint64_t (*r8)(const uint64_t *); @@ -198,6 +203,11 @@ static int compare_extable_64(const void *a, const void *b) return av > bv; } +static inline void *get_index(void *start, int entsize, int index) +{ + return start + (entsize * index); +} + /* 32 bit and 64 bit are very similar */ #include "sorttable.h" #define SORTTABLE_64 diff --git a/scripts/sorttable.h b/scripts/sorttable.h index eff204958ffc..034ce8560dad 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -23,7 +23,6 @@ #undef sort_mcount_loc #undef elf_mcount_loc #undef do_sort -#undef Elf_Shdr #undef Elf_Sym #undef ELF_ST_TYPE #undef uint_t @@ -37,7 +36,6 @@ # define sort_mcount_loc sort_mcount_loc_64 # define elf_mcount_loc elf_mcount_loc_64 # define do_sort do_sort_64 -# define Elf_Shdr Elf64_Shdr # define Elf_Sym Elf64_Sym # define ELF_ST_TYPE ELF64_ST_TYPE # define uint_t uint64_t @@ -50,7 +48,6 @@ # define sort_mcount_loc sort_mcount_loc_32 # define elf_mcount_loc elf_mcount_loc_32 # define do_sort do_sort_32 -# define Elf_Shdr Elf32_Shdr # define Elf_Sym Elf32_Sym # define ELF_ST_TYPE ELF32_ST_TYPE # define uint_t uint32_t @@ -168,8 +165,8 @@ struct elf_mcount_loc { static void *sort_mcount_loc(void *arg) { struct elf_mcount_loc *emloc = (struct elf_mcount_loc *)arg; - uint_t offset = emloc->start_mcount_loc - _r(&(emloc->init_data_sec)->sh_addr) - + _r(&(emloc->init_data_sec)->sh_offset); + uint_t offset = emloc->start_mcount_loc - _r(&(emloc->init_data_sec)->etype.sh_addr) + + _r(&(emloc->init_data_sec)->etype.sh_offset); uint_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; unsigned char *start_loc = (void *)emloc->ehdr + offset; @@ -219,10 +216,11 @@ static int do_sort(Elf_Ehdr *ehdr, table_sort_t custom_sort) { int rc = -1; - Elf_Shdr *s, *shdr = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->etype.e_shoff)); + Elf_Shdr *shdr_start; Elf_Shdr *strtab_sec = NULL; Elf_Shdr *symtab_sec = NULL; Elf_Shdr *extab_sec = NULL; + Elf_Shdr *string_sec; Elf_Sym *sym; const Elf_Sym *symtab; Elf32_Word *symtab_shndx = NULL; @@ -232,7 +230,10 @@ static int do_sort(Elf_Ehdr *ehdr, const char *secstrings; const char *strtab; char *extab_image; + int sort_need_index; + int shentsize; int idx; + int i; unsigned int shnum; unsigned int shstrndx; #ifdef MCOUNT_SORT_ENABLED @@ -246,34 +247,40 @@ static int do_sort(Elf_Ehdr *ehdr, unsigned int orc_num_entries = 0; #endif + shdr_start = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->etype.e_shoff)); + shentsize = r2(&ehdr->etype.e_shentsize); + shstrndx = r2(&ehdr->etype.e_shstrndx); if (shstrndx == SHN_XINDEX) - shstrndx = r(&shdr[0].sh_link); - secstrings = (const char *)ehdr + _r(&shdr[shstrndx].sh_offset); + shstrndx = r(&shdr_start->etype.sh_link); + string_sec = get_index(shdr_start, shentsize, shstrndx); + secstrings = (const char *)ehdr + _r(&string_sec->etype.sh_offset); shnum = r2(&ehdr->etype.e_shnum); if (shnum == SHN_UNDEF) - shnum = _r(&shdr[0].sh_size); + shnum = _r(&shdr_start->etype.sh_size); + + for (i = 0; i < shnum; i++) { + Elf_Shdr *shdr = get_index(shdr_start, shentsize, i); - for (s = shdr; s < shdr + shnum; s++) { - idx = r(&s->sh_name); + idx = r(&shdr->etype.sh_name); if (!strcmp(secstrings + idx, "__ex_table")) - extab_sec = s; + extab_sec = shdr; if (!strcmp(secstrings + idx, ".symtab")) - symtab_sec = s; + symtab_sec = shdr; if (!strcmp(secstrings + idx, ".strtab")) - strtab_sec = s; + strtab_sec = shdr; - if (r(&s->sh_type) == SHT_SYMTAB_SHNDX) + if (r(&shdr->etype.sh_type) == SHT_SYMTAB_SHNDX) symtab_shndx = (Elf32_Word *)((const char *)ehdr + - _r(&s->sh_offset)); + _r(&shdr->etype.sh_offset)); #ifdef MCOUNT_SORT_ENABLED /* locate the .init.data section in vmlinux */ if (!strcmp(secstrings + idx, ".init.data")) { get_mcount_loc(&_start_mcount_loc, &_stop_mcount_loc); mstruct.ehdr = ehdr; - mstruct.init_data_sec = s; + mstruct.init_data_sec = shdr; mstruct.start_mcount_loc = _start_mcount_loc; mstruct.stop_mcount_loc = _stop_mcount_loc; } @@ -282,14 +289,14 @@ static int do_sort(Elf_Ehdr *ehdr, #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) /* locate the ORC unwind tables */ if (!strcmp(secstrings + idx, ".orc_unwind_ip")) { - orc_ip_size = _r(&s->sh_size); + orc_ip_size = _r(&shdr->etype.sh_size); g_orc_ip_table = (int *)((void *)ehdr + - _r(&s->sh_offset)); + _r(&shdr->etype.sh_offset)); } if (!strcmp(secstrings + idx, ".orc_unwind")) { - orc_size = _r(&s->sh_size); + orc_size = _r(&shdr->etype.sh_size); g_orc_table = (struct orc_entry *)((void *)ehdr + - _r(&s->sh_offset)); + _r(&shdr->etype.sh_offset)); } #endif } /* for loop */ @@ -352,22 +359,22 @@ static int do_sort(Elf_Ehdr *ehdr, goto out; } - extab_image = (void *)ehdr + _r(&extab_sec->sh_offset); - strtab = (const char *)ehdr + _r(&strtab_sec->sh_offset); + extab_image = (void *)ehdr + _r(&extab_sec->etype.sh_offset); + strtab = (const char *)ehdr + _r(&strtab_sec->etype.sh_offset); symtab = (const Elf_Sym *)((const char *)ehdr + - _r(&symtab_sec->sh_offset)); + _r(&symtab_sec->etype.sh_offset)); if (custom_sort) { - custom_sort(extab_image, _r(&extab_sec->sh_size)); + custom_sort(extab_image, _r(&extab_sec->etype.sh_size)); } else { - int num_entries = _r(&extab_sec->sh_size) / extable_ent_size; + int num_entries = _r(&extab_sec->etype.sh_size) / extable_ent_size; qsort(extab_image, num_entries, extable_ent_size, compare_extable); } /* find the flag main_extable_sort_needed */ - for (sym = (void *)ehdr + _r(&symtab_sec->sh_offset); - sym < sym + _r(&symtab_sec->sh_size) / sizeof(Elf_Sym); + for (sym = (void *)ehdr + _r(&symtab_sec->etype.sh_offset); + sym < sym + _r(&symtab_sec->etype.sh_size) / sizeof(Elf_Sym); sym++) { if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT) continue; @@ -385,13 +392,14 @@ static int do_sort(Elf_Ehdr *ehdr, goto out; } - sort_needed_sec = &shdr[get_secindex(r2(&sym->st_shndx), - sort_needed_sym - symtab, - symtab_shndx)]; + sort_need_index = get_secindex(r2(&sym->st_shndx), + sort_needed_sym - symtab, + symtab_shndx); + sort_needed_sec = get_index(shdr_start, shentsize, sort_need_index); sort_needed_loc = (void *)ehdr + - _r(&sort_needed_sec->sh_offset) + + _r(&sort_needed_sec->etype.sh_offset) + _r(&sort_needed_sym->st_value) - - _r(&sort_needed_sec->sh_addr); + _r(&sort_needed_sec->etype.sh_addr); /* extable has been sorted, clear the flag */ w(0, sort_needed_loc); From patchwork Thu Jan 2 23:26:17 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925009 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EFBA61BEF9F; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; cv=none; b=hdnCBRc1NdulQAkOlQLZ/MuI3JroMnJot3IC/sLJffQpe+2zX56UnXMFQAAw6F6hhn4rZt47edJVSRfOzj/J1xwyK+70F+UiSZKX4t6sRYohOj3dJfssUSbwX0k8gi8Uea1fG3Xp8KWqV9YT7Byal2N9krxasR6PzY1jRX94W7E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; c=relaxed/simple; bh=rpDkiZolJ8Aw8FySmRQR6P9UH1zV54Fcd5p2oSzjU24=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=qlR6+JS/bSHBmyNCQj/JROCb5dAM7KsNWcgOPpaLgA5pxsywOlcroCAEvBQEqwLUm+cw5XlgZ5CDf+pnPx3dmLhWm7yBQ/ry6fLSNN1I2ar78oxDiPYrVUmYf4xo+0cTaiaiyB/sb4/12LcOibpLxUOzWsbhK0wcOwT8BA3a01Q= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id D1E78C4CEEB; Thu, 2 Jan 2025 23:25:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaY-00000005Yun-0XmB; Thu, 02 Jan 2025 18:26:50 -0500 Message-ID: <20250102232649.981589934@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:17 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 08/16] scripts/sorttable: Convert Elf_Sym MACRO over to a union References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In order to remove the double #include of sorttable.h for 64 and 32 bit to create duplicate functions for both, replace the Elf_Sym macro with a union that defines both Elf64_Sym and Elf32_Sym, with field e64 for the 64bit version, and e32 for the 32bit version. It can then use the macro etype to get the proper value. This will eventually be replaced with just single functions that can handle both 32bit and 64bit ELF parsing. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 5 +++++ scripts/sorttable.h | 25 ++++++++++++++----------- 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 94497b8ab04c..57792cf2aa89 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -74,6 +74,11 @@ typedef union { Elf64_Shdr e64; } Elf_Shdr; +typedef union { + Elf32_Sym e32; + Elf64_Sym e64; +} Elf_Sym; + static uint32_t (*r)(const uint32_t *); static uint16_t (*r2)(const uint16_t *); static uint64_t (*r8)(const uint64_t *); diff --git a/scripts/sorttable.h b/scripts/sorttable.h index 034ce8560dad..a365a8bc405a 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -23,7 +23,6 @@ #undef sort_mcount_loc #undef elf_mcount_loc #undef do_sort -#undef Elf_Sym #undef ELF_ST_TYPE #undef uint_t #undef _r @@ -36,7 +35,6 @@ # define sort_mcount_loc sort_mcount_loc_64 # define elf_mcount_loc elf_mcount_loc_64 # define do_sort do_sort_64 -# define Elf_Sym Elf64_Sym # define ELF_ST_TYPE ELF64_ST_TYPE # define uint_t uint64_t # define _r r8 @@ -48,7 +46,6 @@ # define sort_mcount_loc sort_mcount_loc_32 # define elf_mcount_loc elf_mcount_loc_32 # define do_sort do_sort_32 -# define Elf_Sym Elf32_Sym # define ELF_ST_TYPE ELF32_ST_TYPE # define uint_t uint32_t # define _r r @@ -227,10 +224,13 @@ static int do_sort(Elf_Ehdr *ehdr, Elf_Sym *sort_needed_sym = NULL; Elf_Shdr *sort_needed_sec; uint32_t *sort_needed_loc; + void *sym_start; + void *sym_end; const char *secstrings; const char *strtab; char *extab_image; int sort_need_index; + int symentsize; int shentsize; int idx; int i; @@ -373,12 +373,15 @@ static int do_sort(Elf_Ehdr *ehdr, } /* find the flag main_extable_sort_needed */ - for (sym = (void *)ehdr + _r(&symtab_sec->etype.sh_offset); - sym < sym + _r(&symtab_sec->etype.sh_size) / sizeof(Elf_Sym); - sym++) { - if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT) + sym_start = (void *)ehdr + _r(&symtab_sec->etype.sh_offset); + sym_end = sym_start + _r(&symtab_sec->etype.sh_size); + symentsize = _r(&symtab_sec->etype.sh_entsize); + + for (sym = sym_start; (void *)sym + symentsize < sym_end; + sym = (void *)sym + symentsize) { + if (ELF_ST_TYPE(sym->etype.st_info) != STT_OBJECT) continue; - if (!strcmp(strtab + r(&sym->st_name), + if (!strcmp(strtab + r(&sym->etype.st_name), "main_extable_sort_needed")) { sort_needed_sym = sym; break; @@ -392,13 +395,13 @@ static int do_sort(Elf_Ehdr *ehdr, goto out; } - sort_need_index = get_secindex(r2(&sym->st_shndx), - sort_needed_sym - symtab, + sort_need_index = get_secindex(r2(&sym->etype.st_shndx), + ((void *)sort_needed_sym - (void *)symtab) / symentsize, symtab_shndx); sort_needed_sec = get_index(shdr_start, shentsize, sort_need_index); sort_needed_loc = (void *)ehdr + _r(&sort_needed_sec->etype.sh_offset) + - _r(&sort_needed_sym->st_value) - + _r(&sort_needed_sym->etype.st_value) - _r(&sort_needed_sec->etype.sh_addr); /* extable has been sorted, clear the flag */ From patchwork Thu Jan 2 23:26:18 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925010 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1C7941C07C4; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; cv=none; b=Z6gIYBQb0gpv6EUawKoRWVgOU0sAHCN+LHBfXVROefRhzYdJmjr0rMZHsoQwmp0QspYNMB7XqE8uNS6JQt8wCEaEpj8qpY6pOGVdA+AJaVbJGf5TayWU0GnKPHJfBjvgH4kCKdq1ccEGmLbiGVQ5Z64ta5Z1apbr0rBGxMrfoww= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; c=relaxed/simple; bh=CVOrvydFGYl67HKGAtv+3Ybs5IokbsMeYixlh2//VD4=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=aLHOtwIo4oqkwOjuWrJ5pPYZPU/3ck3q3hVuglOwLP8IFzYpRRnQ/mQAvx9PvqUMmmgG/d8Squ59qO481jGbiC/px5VA3P3rstEamWxODDOfhxuQTzZvxvyiRQGfCiGqDmSxwzLuD9Di9EIpwlazYntHFr7EJ8XR3d29qwdt8xs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 034B1C4CEDD; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaY-00000005YvJ-1Gl6; Thu, 02 Jan 2025 18:26:50 -0500 Message-ID: <20250102232650.151821171@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:18 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 09/16] scripts/sorttable: Add helper functions for Elf_Ehdr References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In order to remove the double #include of sorttable.h for 64 and 32 bit to create duplicate functions, add helper functions for Elf_Ehdr. This will create a function pointer for each helper that will get assigned to the appropriate function to handle either the 64bit or 32bit version. This also moves the _r()/r() wrappers for the Elf_Ehdr references that handle endian and size differences between the different architectures, into the helper function and out of the open code which is more error prone. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 25 +++++++++++++++++++++++++ scripts/sorttable.h | 20 ++++++++++++++++---- 2 files changed, 41 insertions(+), 4 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 57792cf2aa89..5dfa734eff09 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -85,6 +85,31 @@ static uint64_t (*r8)(const uint64_t *); static void (*w)(uint32_t, uint32_t *); typedef void (*table_sort_t)(char *, int); +static uint64_t ehdr64_shoff(Elf_Ehdr *ehdr) +{ + return r8(&ehdr->e64.e_shoff); +} + +static uint64_t ehdr32_shoff(Elf_Ehdr *ehdr) +{ + return r(&ehdr->e32.e_shoff); +} + +#define EHDR_HALF(fn_name) \ +static uint16_t ehdr64_##fn_name(Elf_Ehdr *ehdr) \ +{ \ + return r2(&ehdr->e64.e_##fn_name); \ +} \ + \ +static uint16_t ehdr32_##fn_name(Elf_Ehdr *ehdr) \ +{ \ + return r2(&ehdr->e32.e_##fn_name); \ +} + +EHDR_HALF(shentsize) +EHDR_HALF(shstrndx) +EHDR_HALF(shnum) + /* * Get the whole file as a programming convenience in order to avoid * malloc+lseek+read+free of many pieces. If successful, then mmap diff --git a/scripts/sorttable.h b/scripts/sorttable.h index a365a8bc405a..3855f2ad0e73 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -27,6 +27,10 @@ #undef uint_t #undef _r #undef etype +#undef ehdr_shoff +#undef ehdr_shentsize +#undef ehdr_shstrndx +#undef ehdr_shnum #ifdef SORTTABLE_64 # define extable_ent_size 16 @@ -39,6 +43,10 @@ # define uint_t uint64_t # define _r r8 # define etype e64 +# define ehdr_shoff ehdr64_shoff +# define ehdr_shentsize ehdr64_shentsize +# define ehdr_shstrndx ehdr64_shstrndx +# define ehdr_shnum ehdr64_shnum #else # define extable_ent_size 8 # define compare_extable compare_extable_32 @@ -50,6 +58,10 @@ # define uint_t uint32_t # define _r r # define etype e32 +# define ehdr_shoff ehdr32_shoff +# define ehdr_shentsize ehdr32_shentsize +# define ehdr_shstrndx ehdr32_shstrndx +# define ehdr_shnum ehdr32_shnum #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) @@ -247,16 +259,16 @@ static int do_sort(Elf_Ehdr *ehdr, unsigned int orc_num_entries = 0; #endif - shdr_start = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->etype.e_shoff)); - shentsize = r2(&ehdr->etype.e_shentsize); + shdr_start = (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr)); + shentsize = ehdr_shentsize(ehdr); - shstrndx = r2(&ehdr->etype.e_shstrndx); + shstrndx = ehdr_shstrndx(ehdr); if (shstrndx == SHN_XINDEX) shstrndx = r(&shdr_start->etype.sh_link); string_sec = get_index(shdr_start, shentsize, shstrndx); secstrings = (const char *)ehdr + _r(&string_sec->etype.sh_offset); - shnum = r2(&ehdr->etype.e_shnum); + shnum = ehdr_shnum(ehdr); if (shnum == SHN_UNDEF) shnum = _r(&shdr_start->etype.sh_size); From patchwork Thu Jan 2 23:26:19 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925012 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A7ED71C1AB4; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; cv=none; b=mihSCs3pUfCyzPImb51f2B0FJv8SX0pF8yeKJFVoYhUmJp0ZxX4Uxm+CVJxOFwAZ+W+E5XSUAdUUZ5vqGmIczX42j9rvddlyw39lEMuYCO5VjXe2c1fbBVewFU8yy4LGHN64XHNnnRoTN64ksO4mbRm9qG0xM1nGgo+epBtj3oA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; c=relaxed/simple; bh=ClP2j970xV7E8BGbbxPw4iYrRTf09dl7B9rXPmaBzNk=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=G+9+WVDgO5MnskQXQs2a29m68IYg8zmdBt5V+8McJqZXgUz3sTW5Ug1JajhHO1bdC7drYXw5+rLhCRJpM+tC7iuMX/9EfpfFy1ztnmMUrEsRS1utn+3ZS9O6tGz48zjBLB+dJhKWSZSmian/+GdCaKIOhktO2aIn8VuCr7j/zxE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3B963C4CEE1; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaY-00000005Yvo-1yV3; Thu, 02 Jan 2025 18:26:50 -0500 Message-ID: <20250102232650.323158112@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:19 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 10/16] scripts/sorttable: Add helper functions for Elf_Shdr References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In order to remove the double #include of sorttable.h for 64 and 32 bit to create duplicate functions, add helper functions for Elf_Shdr. This will create a function pointer for each helper that will get assigned to the appropriate function to handle either the 64bit or 32bit version. This also moves the _r()/r() wrappers for the Elf_Shdr references that handle endian and size differences between the different architectures, into the helper function and out of the open code which is more error prone. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 42 +++++++++++++++++++++++++++++ scripts/sorttable.h | 66 +++++++++++++++++++++++++++++---------------- 2 files changed, 85 insertions(+), 23 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 5dfa734eff09..b2b96ff261d6 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -110,6 +110,48 @@ EHDR_HALF(shentsize) EHDR_HALF(shstrndx) EHDR_HALF(shnum) +#define SHDR_WORD(fn_name) \ +static uint32_t shdr64_##fn_name(Elf_Shdr *shdr) \ +{ \ + return r(&shdr->e64.sh_##fn_name); \ +} \ + \ +static uint32_t shdr32_##fn_name(Elf_Shdr *shdr) \ +{ \ + return r(&shdr->e32.sh_##fn_name); \ +} + +#define SHDR_ADDR(fn_name) \ +static uint64_t shdr64_##fn_name(Elf_Shdr *shdr) \ +{ \ + return r8(&shdr->e64.sh_##fn_name); \ +} \ + \ +static uint64_t shdr32_##fn_name(Elf_Shdr *shdr) \ +{ \ + return r(&shdr->e32.sh_##fn_name); \ +} + +#define SHDR_WORD(fn_name) \ +static uint32_t shdr64_##fn_name(Elf_Shdr *shdr) \ +{ \ + return r(&shdr->e64.sh_##fn_name); \ +} \ + \ +static uint32_t shdr32_##fn_name(Elf_Shdr *shdr) \ +{ \ + return r(&shdr->e32.sh_##fn_name); \ +} + +SHDR_ADDR(addr) +SHDR_ADDR(offset) +SHDR_ADDR(size) +SHDR_ADDR(entsize) + +SHDR_WORD(link) +SHDR_WORD(name) +SHDR_WORD(type) + /* * Get the whole file as a programming convenience in order to avoid * malloc+lseek+read+free of many pieces. If successful, then mmap diff --git a/scripts/sorttable.h b/scripts/sorttable.h index 3855f2ad0e73..a391757aaff0 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -31,6 +31,13 @@ #undef ehdr_shentsize #undef ehdr_shstrndx #undef ehdr_shnum +#undef shdr_addr +#undef shdr_offset +#undef shdr_link +#undef shdr_size +#undef shdr_name +#undef shdr_type +#undef shdr_entsize #ifdef SORTTABLE_64 # define extable_ent_size 16 @@ -47,6 +54,13 @@ # define ehdr_shentsize ehdr64_shentsize # define ehdr_shstrndx ehdr64_shstrndx # define ehdr_shnum ehdr64_shnum +# define shdr_addr shdr64_addr +# define shdr_offset shdr64_offset +# define shdr_link shdr64_link +# define shdr_size shdr64_size +# define shdr_name shdr64_name +# define shdr_type shdr64_type +# define shdr_entsize shdr64_entsize #else # define extable_ent_size 8 # define compare_extable compare_extable_32 @@ -62,6 +76,13 @@ # define ehdr_shentsize ehdr32_shentsize # define ehdr_shstrndx ehdr32_shstrndx # define ehdr_shnum ehdr32_shnum +# define shdr_addr shdr32_addr +# define shdr_offset shdr32_offset +# define shdr_link shdr32_link +# define shdr_size shdr32_size +# define shdr_name shdr32_name +# define shdr_type shdr32_type +# define shdr_entsize shdr32_entsize #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) @@ -174,8 +195,8 @@ struct elf_mcount_loc { static void *sort_mcount_loc(void *arg) { struct elf_mcount_loc *emloc = (struct elf_mcount_loc *)arg; - uint_t offset = emloc->start_mcount_loc - _r(&(emloc->init_data_sec)->etype.sh_addr) - + _r(&(emloc->init_data_sec)->etype.sh_offset); + uint_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec) + + shdr_offset(emloc->init_data_sec); uint_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; unsigned char *start_loc = (void *)emloc->ehdr + offset; @@ -264,18 +285,18 @@ static int do_sort(Elf_Ehdr *ehdr, shstrndx = ehdr_shstrndx(ehdr); if (shstrndx == SHN_XINDEX) - shstrndx = r(&shdr_start->etype.sh_link); + shstrndx = shdr_link(shdr_start); string_sec = get_index(shdr_start, shentsize, shstrndx); - secstrings = (const char *)ehdr + _r(&string_sec->etype.sh_offset); + secstrings = (const char *)ehdr + shdr_offset(string_sec); shnum = ehdr_shnum(ehdr); if (shnum == SHN_UNDEF) - shnum = _r(&shdr_start->etype.sh_size); + shnum = shdr_size(shdr_start); for (i = 0; i < shnum; i++) { Elf_Shdr *shdr = get_index(shdr_start, shentsize, i); - idx = r(&shdr->etype.sh_name); + idx = shdr_name(shdr); if (!strcmp(secstrings + idx, "__ex_table")) extab_sec = shdr; if (!strcmp(secstrings + idx, ".symtab")) @@ -283,9 +304,9 @@ static int do_sort(Elf_Ehdr *ehdr, if (!strcmp(secstrings + idx, ".strtab")) strtab_sec = shdr; - if (r(&shdr->etype.sh_type) == SHT_SYMTAB_SHNDX) + if (shdr_type(shdr) == SHT_SYMTAB_SHNDX) symtab_shndx = (Elf32_Word *)((const char *)ehdr + - _r(&shdr->etype.sh_offset)); + shdr_offset(shdr)); #ifdef MCOUNT_SORT_ENABLED /* locate the .init.data section in vmlinux */ @@ -301,14 +322,14 @@ static int do_sort(Elf_Ehdr *ehdr, #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) /* locate the ORC unwind tables */ if (!strcmp(secstrings + idx, ".orc_unwind_ip")) { - orc_ip_size = _r(&shdr->etype.sh_size); + orc_ip_size = shdr_size(shdr); g_orc_ip_table = (int *)((void *)ehdr + - _r(&shdr->etype.sh_offset)); + shdr_offset(shdr)); } if (!strcmp(secstrings + idx, ".orc_unwind")) { - orc_size = _r(&shdr->etype.sh_size); + orc_size = shdr_size(shdr); g_orc_table = (struct orc_entry *)((void *)ehdr + - _r(&shdr->etype.sh_offset)); + shdr_offset(shdr)); } #endif } /* for loop */ @@ -371,23 +392,22 @@ static int do_sort(Elf_Ehdr *ehdr, goto out; } - extab_image = (void *)ehdr + _r(&extab_sec->etype.sh_offset); - strtab = (const char *)ehdr + _r(&strtab_sec->etype.sh_offset); - symtab = (const Elf_Sym *)((const char *)ehdr + - _r(&symtab_sec->etype.sh_offset)); + extab_image = (void *)ehdr + shdr_offset(extab_sec); + strtab = (const char *)ehdr + shdr_offset(strtab_sec); + symtab = (const Elf_Sym *)((const char *)ehdr + shdr_offset(symtab_sec)); if (custom_sort) { - custom_sort(extab_image, _r(&extab_sec->etype.sh_size)); + custom_sort(extab_image, shdr_size(extab_sec)); } else { - int num_entries = _r(&extab_sec->etype.sh_size) / extable_ent_size; + int num_entries = shdr_size(extab_sec) / extable_ent_size; qsort(extab_image, num_entries, extable_ent_size, compare_extable); } /* find the flag main_extable_sort_needed */ - sym_start = (void *)ehdr + _r(&symtab_sec->etype.sh_offset); - sym_end = sym_start + _r(&symtab_sec->etype.sh_size); - symentsize = _r(&symtab_sec->etype.sh_entsize); + sym_start = (void *)ehdr + shdr_offset(symtab_sec); + sym_end = sym_start + shdr_size(symtab_sec); + symentsize = shdr_entsize(symtab_sec); for (sym = sym_start; (void *)sym + symentsize < sym_end; sym = (void *)sym + symentsize) { @@ -412,9 +432,9 @@ static int do_sort(Elf_Ehdr *ehdr, symtab_shndx); sort_needed_sec = get_index(shdr_start, shentsize, sort_need_index); sort_needed_loc = (void *)ehdr + - _r(&sort_needed_sec->etype.sh_offset) + + shdr_offset(sort_needed_sec) + _r(&sort_needed_sym->etype.st_value) - - _r(&sort_needed_sec->etype.sh_addr); + shdr_addr(sort_needed_sec); /* extable has been sorted, clear the flag */ w(0, sort_needed_loc); From patchwork Thu Jan 2 23:26:20 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925011 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A7F381C1AB6; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; cv=none; b=doFn+hrzmL7dPUXADjtUa1zeXGlNUfYA13oe0B95DBYy0y1Fz4HNnoMAO6g/2LwR8993ylKVj/fC95ctSurUyQQts6UZBh7LVXhF1o7YKR7GS0kHHTt1BXntXCpuc47X9t+YeSL6opFR5M8fgqRxItX8EQvmWatIaf487ssiOvQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; c=relaxed/simple; bh=agh6dznuHbLGn9kHb90P3Cnz6nybGAllPizve0i6QR4=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=Fb8TVDzHrab1afyHGh4gfMncjICfymS2MsP7YUbfVdB5cqgl3PVJLpNjnP/vM4vGsDkvLCE5GZPaqQ7Bcy6eox3BZF0XJ7OXEhCM7N/53ZW7Y61fU3I2Lm21o66OoIeEUXeRjWEJTQBQyNVjP0rnMiF4vW8ilhfiFr81pwGNUlk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 53723C4CEDD; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaY-00000005YwJ-2ggr; Thu, 02 Jan 2025 18:26:50 -0500 Message-ID: <20250102232650.489772500@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:20 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 11/16] scripts/sorttable: Add helper functions for Elf_Sym References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In order to remove the double #include of sorttable.h for 64 and 32 bit to create duplicate functions, add helper functions for Elf_Sym. This will create a function pointer for each helper that will get assigned to the appropriate function to handle either the 64bit or 32bit version. This also removes the last references of etype and _r() macros from the sorttable.h file as their references are now just defined in the appropriate architecture version of the helper functions. All read functions now exist in the helper functions which makes it easier to maintain, as the helper functions define the necessary architecture sizes. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 47 +++++++++++++++++++++++++++++++++++++++++++++ scripts/sorttable.h | 30 +++++++++++++++-------------- 2 files changed, 63 insertions(+), 14 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index b2b96ff261d6..20615de18276 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -152,6 +152,53 @@ SHDR_WORD(link) SHDR_WORD(name) SHDR_WORD(type) +#define SYM_ADDR(fn_name) \ +static uint64_t sym64_##fn_name(Elf_Sym *sym) \ +{ \ + return r8(&sym->e64.st_##fn_name); \ +} \ + \ +static uint64_t sym32_##fn_name(Elf_Sym *sym) \ +{ \ + return r(&sym->e32.st_##fn_name); \ +} + +#define SYM_WORD(fn_name) \ +static uint32_t sym64_##fn_name(Elf_Sym *sym) \ +{ \ + return r(&sym->e64.st_##fn_name); \ +} \ + \ +static uint32_t sym32_##fn_name(Elf_Sym *sym) \ +{ \ + return r(&sym->e32.st_##fn_name); \ +} + +#define SYM_HALF(fn_name) \ +static uint16_t sym64_##fn_name(Elf_Sym *sym) \ +{ \ + return r2(&sym->e64.st_##fn_name); \ +} \ + \ +static uint16_t sym32_##fn_name(Elf_Sym *sym) \ +{ \ + return r2(&sym->e32.st_##fn_name); \ +} + +static uint8_t sym64_type(Elf_Sym *sym) +{ + return ELF64_ST_TYPE(sym->e64.st_info); +} + +static uint8_t sym32_type(Elf_Sym *sym) +{ + return ELF32_ST_TYPE(sym->e32.st_info); +} + +SYM_ADDR(value) +SYM_WORD(name) +SYM_HALF(shndx) + /* * Get the whole file as a programming convenience in order to avoid * malloc+lseek+read+free of many pieces. If successful, then mmap diff --git a/scripts/sorttable.h b/scripts/sorttable.h index a391757aaff0..a1c9bdd6b5dd 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -23,10 +23,7 @@ #undef sort_mcount_loc #undef elf_mcount_loc #undef do_sort -#undef ELF_ST_TYPE #undef uint_t -#undef _r -#undef etype #undef ehdr_shoff #undef ehdr_shentsize #undef ehdr_shstrndx @@ -38,6 +35,10 @@ #undef shdr_name #undef shdr_type #undef shdr_entsize +#undef sym_type +#undef sym_name +#undef sym_value +#undef sym_shndx #ifdef SORTTABLE_64 # define extable_ent_size 16 @@ -46,10 +47,7 @@ # define sort_mcount_loc sort_mcount_loc_64 # define elf_mcount_loc elf_mcount_loc_64 # define do_sort do_sort_64 -# define ELF_ST_TYPE ELF64_ST_TYPE # define uint_t uint64_t -# define _r r8 -# define etype e64 # define ehdr_shoff ehdr64_shoff # define ehdr_shentsize ehdr64_shentsize # define ehdr_shstrndx ehdr64_shstrndx @@ -61,6 +59,10 @@ # define shdr_name shdr64_name # define shdr_type shdr64_type # define shdr_entsize shdr64_entsize +# define sym_type sym64_type +# define sym_name sym64_name +# define sym_value sym64_value +# define sym_shndx sym64_shndx #else # define extable_ent_size 8 # define compare_extable compare_extable_32 @@ -68,10 +70,7 @@ # define sort_mcount_loc sort_mcount_loc_32 # define elf_mcount_loc elf_mcount_loc_32 # define do_sort do_sort_32 -# define ELF_ST_TYPE ELF32_ST_TYPE # define uint_t uint32_t -# define _r r -# define etype e32 # define ehdr_shoff ehdr32_shoff # define ehdr_shentsize ehdr32_shentsize # define ehdr_shstrndx ehdr32_shstrndx @@ -83,6 +82,10 @@ # define shdr_name shdr32_name # define shdr_type shdr32_type # define shdr_entsize shdr32_entsize +# define sym_type sym32_type +# define sym_name sym32_name +# define sym_value sym32_value +# define sym_shndx sym32_shndx #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) @@ -411,9 +414,9 @@ static int do_sort(Elf_Ehdr *ehdr, for (sym = sym_start; (void *)sym + symentsize < sym_end; sym = (void *)sym + symentsize) { - if (ELF_ST_TYPE(sym->etype.st_info) != STT_OBJECT) + if (sym_type(sym) != STT_OBJECT) continue; - if (!strcmp(strtab + r(&sym->etype.st_name), + if (!strcmp(strtab + sym_name(sym), "main_extable_sort_needed")) { sort_needed_sym = sym; break; @@ -427,14 +430,13 @@ static int do_sort(Elf_Ehdr *ehdr, goto out; } - sort_need_index = get_secindex(r2(&sym->etype.st_shndx), + sort_need_index = get_secindex(sym_shndx(sym), ((void *)sort_needed_sym - (void *)symtab) / symentsize, symtab_shndx); sort_needed_sec = get_index(shdr_start, shentsize, sort_need_index); sort_needed_loc = (void *)ehdr + shdr_offset(sort_needed_sec) + - _r(&sort_needed_sym->etype.st_value) - - shdr_addr(sort_needed_sec); + sym_value(sort_needed_sym) - shdr_addr(sort_needed_sec); /* extable has been sorted, clear the flag */ w(0, sort_needed_loc); From patchwork Thu Jan 2 23:26:21 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925013 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D3C471C1F20; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; cv=none; b=jvv2tYohM1pJoxrMla3WQMug3k3QQiLuFwkiAWtdtMfvNSb/HlRQdv7TrnhRbDmLCiiGom/y1cRPkc50g3YRZZVez5/oQdHAw5cHkz9yIFRKTTE3ESi2A9jjiodNI5lKObfmnedsWq5MJaBXPyn6rm5XcQopt/OdrBhoVbmivCI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860333; c=relaxed/simple; bh=/4azsqDLsrbB/1qJH9CZHFoMzOGofhz0TORgNxsoWJE=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=jseDhG5QMDgOfhrW7+RrHccvSNkILZuW+PFH6LMrFsbFkURT4BmRh+znYeUnpPTXfl9NgNb6hi9vJH73930g/kfzTv219KI9bH1aTpwANos2u/XVGmt065K0CoU8qU9q0RUTC2AhjyJeWVQhCn4rzfmnt9zNd1kAOUCHyryAOBg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 85758C4CEDE; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaY-00000005Ywp-3PZt; Thu, 02 Jan 2025 18:26:50 -0500 Message-ID: <20250102232650.662023463@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:21 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 12/16] scripts/sorttable: Use uint64_t for mcount sorting References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt The mcount sorting defines uint_t to uint64_t on 64bit architectures and uint32_t on 32bit architectures. It can work with just using uint64_t as that will hold the values of both, and they are not used to point into the ELF file. sizeof(uint_t) is used for defining the size of the mcount_loc section. Instead of using a type, define long_size and use that instead. This will allow the header code to be moved into the C file as generic functions and not need to include sorttable.h twice, once for 64bit and once for 32bit. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.h | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/scripts/sorttable.h b/scripts/sorttable.h index a1c9bdd6b5dd..b9c0716ee72c 100644 --- a/scripts/sorttable.h +++ b/scripts/sorttable.h @@ -23,7 +23,6 @@ #undef sort_mcount_loc #undef elf_mcount_loc #undef do_sort -#undef uint_t #undef ehdr_shoff #undef ehdr_shentsize #undef ehdr_shstrndx @@ -39,6 +38,7 @@ #undef sym_name #undef sym_value #undef sym_shndx +#undef long_size #ifdef SORTTABLE_64 # define extable_ent_size 16 @@ -47,7 +47,6 @@ # define sort_mcount_loc sort_mcount_loc_64 # define elf_mcount_loc elf_mcount_loc_64 # define do_sort do_sort_64 -# define uint_t uint64_t # define ehdr_shoff ehdr64_shoff # define ehdr_shentsize ehdr64_shentsize # define ehdr_shstrndx ehdr64_shstrndx @@ -63,6 +62,7 @@ # define sym_name sym64_name # define sym_value sym64_value # define sym_shndx sym64_shndx +# define long_size 8 #else # define extable_ent_size 8 # define compare_extable compare_extable_32 @@ -70,7 +70,6 @@ # define sort_mcount_loc sort_mcount_loc_32 # define elf_mcount_loc elf_mcount_loc_32 # define do_sort do_sort_32 -# define uint_t uint32_t # define ehdr_shoff ehdr32_shoff # define ehdr_shentsize ehdr32_shentsize # define ehdr_shstrndx ehdr32_shstrndx @@ -86,6 +85,7 @@ # define sym_name sym32_name # define sym_value sym32_value # define sym_shndx sym32_shndx +# define long_size 4 #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) @@ -190,25 +190,25 @@ pthread_t mcount_sort_thread; struct elf_mcount_loc { Elf_Ehdr *ehdr; Elf_Shdr *init_data_sec; - uint_t start_mcount_loc; - uint_t stop_mcount_loc; + uint64_t start_mcount_loc; + uint64_t stop_mcount_loc; }; /* Sort the addresses stored between __start_mcount_loc to __stop_mcount_loc in vmlinux */ static void *sort_mcount_loc(void *arg) { struct elf_mcount_loc *emloc = (struct elf_mcount_loc *)arg; - uint_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec) + uint64_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec) + shdr_offset(emloc->init_data_sec); - uint_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; + uint64_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; unsigned char *start_loc = (void *)emloc->ehdr + offset; - qsort(start_loc, count/sizeof(uint_t), sizeof(uint_t), compare_extable); + qsort(start_loc, count/long_size, long_size, compare_extable); return NULL; } /* Get the address of __start_mcount_loc and __stop_mcount_loc in System.map */ -static void get_mcount_loc(uint_t *_start, uint_t *_stop) +static void get_mcount_loc(uint64_t *_start, uint64_t *_stop) { FILE *file_start, *file_stop; char start_buff[20]; @@ -274,8 +274,8 @@ static int do_sort(Elf_Ehdr *ehdr, unsigned int shstrndx; #ifdef MCOUNT_SORT_ENABLED struct elf_mcount_loc mstruct = {0}; - uint_t _start_mcount_loc = 0; - uint_t _stop_mcount_loc = 0; + uint64_t _start_mcount_loc = 0; + uint64_t _stop_mcount_loc = 0; #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) unsigned int orc_ip_size = 0; From patchwork Thu Jan 2 23:26:22 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925015 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EF1A71C1F2C; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; cv=none; b=uGbmd5DXNlt9LkE8IWBhPQGOOfaamFOFPwocqzHnzJvNDAYkX3Eaa4jTrFky648It4bc2FjkCTUi03eDWCvkte+lBJUxtv6lUT+A7kOOT7rrZk6nbOGW6Lrd1X/RxFW/bGGhaAuLtvTTCgUkx0bj8Gn48T3r9JSuQTO8qyBWRFA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; c=relaxed/simple; bh=Z1ifu5d2WFSuCvXmWv8QD9Mr0b9/K+neWrODXtL1TJ4=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=K4hlIQg0pBvy7VEcLgaLOtgB+pjLE9jjf1CPcZLS5dI7p2Yc23hGVjKoilSSRfvKP5y1yD866mpLBt/YyXZgzy0RUK102Kad+El2YE9O1kaWHhSGQ9RdkKUvn48y/jiGlHiQXkX432nyg3ztEcDc+mkMDR28WfwGhUqE6vVw9A8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id ABED7C4CEE7; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaY-00000005YxK-47r6; Thu, 02 Jan 2025 18:26:50 -0500 Message-ID: <20250102232650.834242633@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:22 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 13/16] scripts/sorttable: Move code from sorttable.h into sorttable.c References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt Instead of having the main code live in a header file and included twice with MACROs that define the Elf structures for 64 bit or 32 bit, move the code in the C file now that the Elf structures are defined in a union that has both. All accesses to the Elf structure fields are done through helper function pointers. If the file being parsed if for a 64 bit architecture, all the helper functions point to the 64 bit versions to retrieve the Elf fields. The same is true if the architecture is 32 bit, where the function pointers will point to the 32 bit helper functions. Note, when the value of a field can be either 32 bit or 64 bit, a 64 bit is always returned, as it works for the 32 bit code as well. This makes the code easier to read and maintain, and it now all exists in sorttable.c and sorttable.h may be removed. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 470 ++++++++++++++++++++++++++++++++++++++++-- scripts/sorttable.h | 482 -------------------------------------------- 2 files changed, 457 insertions(+), 495 deletions(-) delete mode 100644 scripts/sorttable.h diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 20615de18276..da9e1a82e886 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -327,10 +327,420 @@ static inline void *get_index(void *start, int entsize, int index) return start + (entsize * index); } -/* 32 bit and 64 bit are very similar */ -#include "sorttable.h" -#define SORTTABLE_64 -#include "sorttable.h" + +static int (*compare_extable)(const void *a, const void *b); +static uint64_t (*ehdr_shoff)(Elf_Ehdr *ehdr); +static uint16_t (*ehdr_shstrndx)(Elf_Ehdr *ehdr); +static uint16_t (*ehdr_shentsize)(Elf_Ehdr *ehdr); +static uint16_t (*ehdr_shnum)(Elf_Ehdr *ehdr); +static uint64_t (*shdr_addr)(Elf_Shdr *shdr); +static uint64_t (*shdr_offset)(Elf_Shdr *shdr); +static uint64_t (*shdr_size)(Elf_Shdr *shdr); +static uint64_t (*shdr_entsize)(Elf_Shdr *shdr); +static uint32_t (*shdr_link)(Elf_Shdr *shdr); +static uint32_t (*shdr_name)(Elf_Shdr *shdr); +static uint32_t (*shdr_type)(Elf_Shdr *shdr); +static uint8_t (*sym_type)(Elf_Sym *sym); +static uint32_t (*sym_name)(Elf_Sym *sym); +static uint64_t (*sym_value)(Elf_Sym *sym); +static uint16_t (*sym_shndx)(Elf_Sym *sym); + +static int extable_ent_size; +static int long_size; + + +#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) +/* ORC unwinder only support X86_64 */ +#include + +#define ERRSTR_MAXSZ 256 + +static char g_err[ERRSTR_MAXSZ]; +static int *g_orc_ip_table; +static struct orc_entry *g_orc_table; + +static pthread_t orc_sort_thread; + +static inline unsigned long orc_ip(const int *ip) +{ + return (unsigned long)ip + *ip; +} + +static int orc_sort_cmp(const void *_a, const void *_b) +{ + struct orc_entry *orc_a; + const int *a = g_orc_ip_table + *(int *)_a; + const int *b = g_orc_ip_table + *(int *)_b; + unsigned long a_val = orc_ip(a); + unsigned long b_val = orc_ip(b); + + if (a_val > b_val) + return 1; + if (a_val < b_val) + return -1; + + /* + * The "weak" section terminator entries need to always be on the left + * to ensure the lookup code skips them in favor of real entries. + * These terminator entries exist to handle any gaps created by + * whitelisted .o files which didn't get objtool generation. + */ + orc_a = g_orc_table + (a - g_orc_ip_table); + return orc_a->type == ORC_TYPE_UNDEFINED ? -1 : 1; +} + +static void *sort_orctable(void *arg) +{ + int i; + int *idxs = NULL; + int *tmp_orc_ip_table = NULL; + struct orc_entry *tmp_orc_table = NULL; + unsigned int *orc_ip_size = (unsigned int *)arg; + unsigned int num_entries = *orc_ip_size / sizeof(int); + unsigned int orc_size = num_entries * sizeof(struct orc_entry); + + idxs = (int *)malloc(*orc_ip_size); + if (!idxs) { + snprintf(g_err, ERRSTR_MAXSZ, "malloc idxs: %s", + strerror(errno)); + pthread_exit(g_err); + } + + tmp_orc_ip_table = (int *)malloc(*orc_ip_size); + if (!tmp_orc_ip_table) { + snprintf(g_err, ERRSTR_MAXSZ, "malloc tmp_orc_ip_table: %s", + strerror(errno)); + pthread_exit(g_err); + } + + tmp_orc_table = (struct orc_entry *)malloc(orc_size); + if (!tmp_orc_table) { + snprintf(g_err, ERRSTR_MAXSZ, "malloc tmp_orc_table: %s", + strerror(errno)); + pthread_exit(g_err); + } + + /* initialize indices array, convert ip_table to absolute address */ + for (i = 0; i < num_entries; i++) { + idxs[i] = i; + tmp_orc_ip_table[i] = g_orc_ip_table[i] + i * sizeof(int); + } + memcpy(tmp_orc_table, g_orc_table, orc_size); + + qsort(idxs, num_entries, sizeof(int), orc_sort_cmp); + + for (i = 0; i < num_entries; i++) { + if (idxs[i] == i) + continue; + + /* convert back to relative address */ + g_orc_ip_table[i] = tmp_orc_ip_table[idxs[i]] - i * sizeof(int); + g_orc_table[i] = tmp_orc_table[idxs[i]]; + } + + free(idxs); + free(tmp_orc_ip_table); + free(tmp_orc_table); + pthread_exit(NULL); +} +#endif + +#ifdef MCOUNT_SORT_ENABLED +static pthread_t mcount_sort_thread; + +struct elf_mcount_loc { + Elf_Ehdr *ehdr; + Elf_Shdr *init_data_sec; + uint64_t start_mcount_loc; + uint64_t stop_mcount_loc; +}; + +/* Sort the addresses stored between __start_mcount_loc to __stop_mcount_loc in vmlinux */ +static void *sort_mcount_loc(void *arg) +{ + struct elf_mcount_loc *emloc = (struct elf_mcount_loc *)arg; + uint64_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec) + + shdr_offset(emloc->init_data_sec); + uint64_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; + unsigned char *start_loc = (void *)emloc->ehdr + offset; + + qsort(start_loc, count/long_size, long_size, compare_extable); + return NULL; +} + +/* Get the address of __start_mcount_loc and __stop_mcount_loc in System.map */ +static void get_mcount_loc(uint64_t *_start, uint64_t *_stop) +{ + FILE *file_start, *file_stop; + char start_buff[20]; + char stop_buff[20]; + int len = 0; + + file_start = popen(" grep start_mcount System.map | awk '{print $1}' ", "r"); + if (!file_start) { + fprintf(stderr, "get start_mcount_loc error!"); + return; + } + + file_stop = popen(" grep stop_mcount System.map | awk '{print $1}' ", "r"); + if (!file_stop) { + fprintf(stderr, "get stop_mcount_loc error!"); + pclose(file_start); + return; + } + + while (fgets(start_buff, sizeof(start_buff), file_start) != NULL) { + len = strlen(start_buff); + start_buff[len - 1] = '\0'; + } + *_start = strtoul(start_buff, NULL, 16); + + while (fgets(stop_buff, sizeof(stop_buff), file_stop) != NULL) { + len = strlen(stop_buff); + stop_buff[len - 1] = '\0'; + } + *_stop = strtoul(stop_buff, NULL, 16); + + pclose(file_start); + pclose(file_stop); +} +#endif +static int do_sort(Elf_Ehdr *ehdr, + char const *const fname, + table_sort_t custom_sort) +{ + int rc = -1; + Elf_Shdr *shdr_start; + Elf_Shdr *strtab_sec = NULL; + Elf_Shdr *symtab_sec = NULL; + Elf_Shdr *extab_sec = NULL; + Elf_Shdr *string_sec; + Elf_Sym *sym; + const Elf_Sym *symtab; + Elf32_Word *symtab_shndx = NULL; + Elf_Sym *sort_needed_sym = NULL; + Elf_Shdr *sort_needed_sec; + uint32_t *sort_needed_loc; + void *sym_start; + void *sym_end; + const char *secstrings; + const char *strtab; + char *extab_image; + int sort_need_index; + int symentsize; + int shentsize; + int idx; + int i; + unsigned int shnum; + unsigned int shstrndx; +#ifdef MCOUNT_SORT_ENABLED + struct elf_mcount_loc mstruct = {0}; + uint64_t _start_mcount_loc = 0; + uint64_t _stop_mcount_loc = 0; +#endif +#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) + unsigned int orc_ip_size = 0; + unsigned int orc_size = 0; + unsigned int orc_num_entries = 0; +#endif + + shdr_start = (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr)); + shentsize = ehdr_shentsize(ehdr); + + shstrndx = ehdr_shstrndx(ehdr); + if (shstrndx == SHN_XINDEX) + shstrndx = shdr_link(shdr_start); + string_sec = get_index(shdr_start, shentsize, shstrndx); + secstrings = (const char *)ehdr + shdr_offset(string_sec); + + shnum = ehdr_shnum(ehdr); + if (shnum == SHN_UNDEF) + shnum = shdr_size(shdr_start); + + for (i = 0; i < shnum; i++) { + Elf_Shdr *shdr = get_index(shdr_start, shentsize, i); + + idx = shdr_name(shdr); + if (!strcmp(secstrings + idx, "__ex_table")) + extab_sec = shdr; + if (!strcmp(secstrings + idx, ".symtab")) + symtab_sec = shdr; + if (!strcmp(secstrings + idx, ".strtab")) + strtab_sec = shdr; + + if (shdr_type(shdr) == SHT_SYMTAB_SHNDX) + symtab_shndx = (Elf32_Word *)((const char *)ehdr + + shdr_offset(shdr)); + +#ifdef MCOUNT_SORT_ENABLED + /* locate the .init.data section in vmlinux */ + if (!strcmp(secstrings + idx, ".init.data")) { + get_mcount_loc(&_start_mcount_loc, &_stop_mcount_loc); + mstruct.ehdr = ehdr; + mstruct.init_data_sec = shdr; + mstruct.start_mcount_loc = _start_mcount_loc; + mstruct.stop_mcount_loc = _stop_mcount_loc; + } +#endif + +#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) + /* locate the ORC unwind tables */ + if (!strcmp(secstrings + idx, ".orc_unwind_ip")) { + orc_ip_size = shdr_size(shdr); + g_orc_ip_table = (int *)((void *)ehdr + + shdr_offset(shdr)); + } + if (!strcmp(secstrings + idx, ".orc_unwind")) { + orc_size = shdr_size(shdr); + g_orc_table = (struct orc_entry *)((void *)ehdr + + shdr_offset(shdr)); + } +#endif + } /* for loop */ + +#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) + if (!g_orc_ip_table || !g_orc_table) { + fprintf(stderr, + "incomplete ORC unwind tables in file: %s\n", fname); + goto out; + } + + orc_num_entries = orc_ip_size / sizeof(int); + if (orc_ip_size % sizeof(int) != 0 || + orc_size % sizeof(struct orc_entry) != 0 || + orc_num_entries != orc_size / sizeof(struct orc_entry)) { + fprintf(stderr, + "inconsistent ORC unwind table entries in file: %s\n", + fname); + goto out; + } + + /* create thread to sort ORC unwind tables concurrently */ + if (pthread_create(&orc_sort_thread, NULL, + sort_orctable, &orc_ip_size)) { + fprintf(stderr, + "pthread_create orc_sort_thread failed '%s': %s\n", + strerror(errno), fname); + goto out; + } +#endif + +#ifdef MCOUNT_SORT_ENABLED + if (!mstruct.init_data_sec || !_start_mcount_loc || !_stop_mcount_loc) { + fprintf(stderr, + "incomplete mcount's sort in file: %s\n", + fname); + goto out; + } + + /* create thread to sort mcount_loc concurrently */ + if (pthread_create(&mcount_sort_thread, NULL, &sort_mcount_loc, &mstruct)) { + fprintf(stderr, + "pthread_create mcount_sort_thread failed '%s': %s\n", + strerror(errno), fname); + goto out; + } +#endif + if (!extab_sec) { + fprintf(stderr, "no __ex_table in file: %s\n", fname); + goto out; + } + + if (!symtab_sec) { + fprintf(stderr, "no .symtab in file: %s\n", fname); + goto out; + } + + if (!strtab_sec) { + fprintf(stderr, "no .strtab in file: %s\n", fname); + goto out; + } + + extab_image = (void *)ehdr + shdr_offset(extab_sec); + strtab = (const char *)ehdr + shdr_offset(strtab_sec); + symtab = (const Elf_Sym *)((const char *)ehdr + shdr_offset(symtab_sec)); + + if (custom_sort) { + custom_sort(extab_image, shdr_size(extab_sec)); + } else { + int num_entries = shdr_size(extab_sec) / extable_ent_size; + qsort(extab_image, num_entries, + extable_ent_size, compare_extable); + } + + /* find the flag main_extable_sort_needed */ + sym_start = (void *)ehdr + shdr_offset(symtab_sec); + sym_end = sym_start + shdr_size(symtab_sec); + symentsize = shdr_entsize(symtab_sec); + + for (sym = sym_start; (void *)sym + symentsize < sym_end; + sym = (void *)sym + symentsize) { + if (sym_type(sym) != STT_OBJECT) + continue; + if (!strcmp(strtab + sym_name(sym), + "main_extable_sort_needed")) { + sort_needed_sym = sym; + break; + } + } + + if (!sort_needed_sym) { + fprintf(stderr, + "no main_extable_sort_needed symbol in file: %s\n", + fname); + goto out; + } + + sort_need_index = get_secindex(sym_shndx(sym), + ((void *)sort_needed_sym - (void *)symtab) / symentsize, + symtab_shndx); + sort_needed_sec = get_index(shdr_start, shentsize, sort_need_index); + sort_needed_loc = (void *)ehdr + + shdr_offset(sort_needed_sec) + + sym_value(sort_needed_sym) - shdr_addr(sort_needed_sec); + + /* extable has been sorted, clear the flag */ + w(0, sort_needed_loc); + rc = 0; + +out: +#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) + if (orc_sort_thread) { + void *retval = NULL; + /* wait for ORC tables sort done */ + rc = pthread_join(orc_sort_thread, &retval); + if (rc) { + fprintf(stderr, + "pthread_join failed '%s': %s\n", + strerror(errno), fname); + } else if (retval) { + rc = -1; + fprintf(stderr, + "failed to sort ORC tables '%s': %s\n", + (char *)retval, fname); + } + } +#endif + +#ifdef MCOUNT_SORT_ENABLED + if (mcount_sort_thread) { + void *retval = NULL; + /* wait for mcount sort done */ + rc = pthread_join(mcount_sort_thread, &retval); + if (rc) { + fprintf(stderr, + "pthread_join failed '%s': %s\n", + strerror(errno), fname); + } else if (retval) { + rc = -1; + fprintf(stderr, + "failed to sort mcount '%s': %s\n", + (char *)retval, fname); + } + } +#endif + return rc; +} static int compare_relative_table(const void *a, const void *b) { @@ -399,7 +809,6 @@ static void sort_relative_table_with_data(char *extab_image, int image_size) static int do_file(char const *const fname, void *addr) { - int rc = -1; Elf_Ehdr *ehdr = addr; table_sort_t custom_sort = NULL; @@ -462,29 +871,64 @@ static int do_file(char const *const fname, void *addr) r2(&ehdr->e32.e_shentsize) != sizeof(Elf32_Shdr)) { fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file: %s\n", fname); - break; + return -1; } - rc = do_sort_32(ehdr, fname, custom_sort); + + compare_extable = compare_extable_32; + ehdr_shoff = ehdr32_shoff; + ehdr_shentsize = ehdr32_shentsize; + ehdr_shstrndx = ehdr32_shstrndx; + ehdr_shnum = ehdr32_shnum; + shdr_addr = shdr32_addr; + shdr_offset = shdr32_offset; + shdr_link = shdr32_link; + shdr_size = shdr32_size; + shdr_name = shdr32_name; + shdr_type = shdr32_type; + shdr_entsize = shdr32_entsize; + sym_type = sym32_type; + sym_name = sym32_name; + sym_value = sym32_value; + sym_shndx = sym32_shndx; + long_size = 4; + extable_ent_size = 8; break; case ELFCLASS64: - { if (r2(&ehdr->e64.e_ehsize) != sizeof(Elf64_Ehdr) || r2(&ehdr->e64.e_shentsize) != sizeof(Elf64_Shdr)) { fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file: %s\n", fname); - break; - } - rc = do_sort_64(ehdr, fname, custom_sort); + return -1; } + + compare_extable = compare_extable_64; + ehdr_shoff = ehdr64_shoff; + ehdr_shentsize = ehdr64_shentsize; + ehdr_shstrndx = ehdr64_shstrndx; + ehdr_shnum = ehdr64_shnum; + shdr_addr = shdr64_addr; + shdr_offset = shdr64_offset; + shdr_link = shdr64_link; + shdr_size = shdr64_size; + shdr_name = shdr64_name; + shdr_type = shdr64_type; + shdr_entsize = shdr64_entsize; + sym_type = sym64_type; + sym_name = sym64_name; + sym_value = sym64_value; + sym_shndx = sym64_shndx; + long_size = 8; + extable_ent_size = 16; + break; default: fprintf(stderr, "unrecognized ELF class %d %s\n", ehdr->e32.e_ident[EI_CLASS], fname); - break; + return -1; } - return rc; + return do_sort(ehdr, fname, custom_sort); } int main(int argc, char *argv[]) diff --git a/scripts/sorttable.h b/scripts/sorttable.h deleted file mode 100644 index b9c0716ee72c..000000000000 --- a/scripts/sorttable.h +++ /dev/null @@ -1,482 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * sorttable.h - * - * Added ORC unwind tables sort support and other updates: - * Copyright (C) 1999-2019 Alibaba Group Holding Limited. by: - * Shile Zhang - * - * Copyright 2011 - 2012 Cavium, Inc. - * - * Some of code was taken out of arch/x86/kernel/unwind_orc.c, written by: - * Copyright (C) 2017 Josh Poimboeuf - * - * Some of this code was taken out of recordmcount.h written by: - * - * Copyright 2009 John F. Reiser . All rights reserved. - * Copyright 2010 Steven Rostedt , Red Hat Inc. - */ - -#undef extable_ent_size -#undef compare_extable -#undef get_mcount_loc -#undef sort_mcount_loc -#undef elf_mcount_loc -#undef do_sort -#undef ehdr_shoff -#undef ehdr_shentsize -#undef ehdr_shstrndx -#undef ehdr_shnum -#undef shdr_addr -#undef shdr_offset -#undef shdr_link -#undef shdr_size -#undef shdr_name -#undef shdr_type -#undef shdr_entsize -#undef sym_type -#undef sym_name -#undef sym_value -#undef sym_shndx -#undef long_size - -#ifdef SORTTABLE_64 -# define extable_ent_size 16 -# define compare_extable compare_extable_64 -# define get_mcount_loc get_mcount_loc_64 -# define sort_mcount_loc sort_mcount_loc_64 -# define elf_mcount_loc elf_mcount_loc_64 -# define do_sort do_sort_64 -# define ehdr_shoff ehdr64_shoff -# define ehdr_shentsize ehdr64_shentsize -# define ehdr_shstrndx ehdr64_shstrndx -# define ehdr_shnum ehdr64_shnum -# define shdr_addr shdr64_addr -# define shdr_offset shdr64_offset -# define shdr_link shdr64_link -# define shdr_size shdr64_size -# define shdr_name shdr64_name -# define shdr_type shdr64_type -# define shdr_entsize shdr64_entsize -# define sym_type sym64_type -# define sym_name sym64_name -# define sym_value sym64_value -# define sym_shndx sym64_shndx -# define long_size 8 -#else -# define extable_ent_size 8 -# define compare_extable compare_extable_32 -# define get_mcount_loc get_mcount_loc_32 -# define sort_mcount_loc sort_mcount_loc_32 -# define elf_mcount_loc elf_mcount_loc_32 -# define do_sort do_sort_32 -# define ehdr_shoff ehdr32_shoff -# define ehdr_shentsize ehdr32_shentsize -# define ehdr_shstrndx ehdr32_shstrndx -# define ehdr_shnum ehdr32_shnum -# define shdr_addr shdr32_addr -# define shdr_offset shdr32_offset -# define shdr_link shdr32_link -# define shdr_size shdr32_size -# define shdr_name shdr32_name -# define shdr_type shdr32_type -# define shdr_entsize shdr32_entsize -# define sym_type sym32_type -# define sym_name sym32_name -# define sym_value sym32_value -# define sym_shndx sym32_shndx -# define long_size 4 -#endif - -#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) -/* ORC unwinder only support X86_64 */ -#include - -#define ERRSTR_MAXSZ 256 - -char g_err[ERRSTR_MAXSZ]; -int *g_orc_ip_table; -struct orc_entry *g_orc_table; - -pthread_t orc_sort_thread; - -static inline unsigned long orc_ip(const int *ip) -{ - return (unsigned long)ip + *ip; -} - -static int orc_sort_cmp(const void *_a, const void *_b) -{ - struct orc_entry *orc_a; - const int *a = g_orc_ip_table + *(int *)_a; - const int *b = g_orc_ip_table + *(int *)_b; - unsigned long a_val = orc_ip(a); - unsigned long b_val = orc_ip(b); - - if (a_val > b_val) - return 1; - if (a_val < b_val) - return -1; - - /* - * The "weak" section terminator entries need to always be on the left - * to ensure the lookup code skips them in favor of real entries. - * These terminator entries exist to handle any gaps created by - * whitelisted .o files which didn't get objtool generation. - */ - orc_a = g_orc_table + (a - g_orc_ip_table); - return orc_a->type == ORC_TYPE_UNDEFINED ? -1 : 1; -} - -static void *sort_orctable(void *arg) -{ - int i; - int *idxs = NULL; - int *tmp_orc_ip_table = NULL; - struct orc_entry *tmp_orc_table = NULL; - unsigned int *orc_ip_size = (unsigned int *)arg; - unsigned int num_entries = *orc_ip_size / sizeof(int); - unsigned int orc_size = num_entries * sizeof(struct orc_entry); - - idxs = (int *)malloc(*orc_ip_size); - if (!idxs) { - snprintf(g_err, ERRSTR_MAXSZ, "malloc idxs: %s", - strerror(errno)); - pthread_exit(g_err); - } - - tmp_orc_ip_table = (int *)malloc(*orc_ip_size); - if (!tmp_orc_ip_table) { - snprintf(g_err, ERRSTR_MAXSZ, "malloc tmp_orc_ip_table: %s", - strerror(errno)); - pthread_exit(g_err); - } - - tmp_orc_table = (struct orc_entry *)malloc(orc_size); - if (!tmp_orc_table) { - snprintf(g_err, ERRSTR_MAXSZ, "malloc tmp_orc_table: %s", - strerror(errno)); - pthread_exit(g_err); - } - - /* initialize indices array, convert ip_table to absolute address */ - for (i = 0; i < num_entries; i++) { - idxs[i] = i; - tmp_orc_ip_table[i] = g_orc_ip_table[i] + i * sizeof(int); - } - memcpy(tmp_orc_table, g_orc_table, orc_size); - - qsort(idxs, num_entries, sizeof(int), orc_sort_cmp); - - for (i = 0; i < num_entries; i++) { - if (idxs[i] == i) - continue; - - /* convert back to relative address */ - g_orc_ip_table[i] = tmp_orc_ip_table[idxs[i]] - i * sizeof(int); - g_orc_table[i] = tmp_orc_table[idxs[i]]; - } - - free(idxs); - free(tmp_orc_ip_table); - free(tmp_orc_table); - pthread_exit(NULL); -} -#endif - -#ifdef MCOUNT_SORT_ENABLED -pthread_t mcount_sort_thread; - -struct elf_mcount_loc { - Elf_Ehdr *ehdr; - Elf_Shdr *init_data_sec; - uint64_t start_mcount_loc; - uint64_t stop_mcount_loc; -}; - -/* Sort the addresses stored between __start_mcount_loc to __stop_mcount_loc in vmlinux */ -static void *sort_mcount_loc(void *arg) -{ - struct elf_mcount_loc *emloc = (struct elf_mcount_loc *)arg; - uint64_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec) - + shdr_offset(emloc->init_data_sec); - uint64_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; - unsigned char *start_loc = (void *)emloc->ehdr + offset; - - qsort(start_loc, count/long_size, long_size, compare_extable); - return NULL; -} - -/* Get the address of __start_mcount_loc and __stop_mcount_loc in System.map */ -static void get_mcount_loc(uint64_t *_start, uint64_t *_stop) -{ - FILE *file_start, *file_stop; - char start_buff[20]; - char stop_buff[20]; - int len = 0; - - file_start = popen(" grep start_mcount System.map | awk '{print $1}' ", "r"); - if (!file_start) { - fprintf(stderr, "get start_mcount_loc error!"); - return; - } - - file_stop = popen(" grep stop_mcount System.map | awk '{print $1}' ", "r"); - if (!file_stop) { - fprintf(stderr, "get stop_mcount_loc error!"); - pclose(file_start); - return; - } - - while (fgets(start_buff, sizeof(start_buff), file_start) != NULL) { - len = strlen(start_buff); - start_buff[len - 1] = '\0'; - } - *_start = strtoul(start_buff, NULL, 16); - - while (fgets(stop_buff, sizeof(stop_buff), file_stop) != NULL) { - len = strlen(stop_buff); - stop_buff[len - 1] = '\0'; - } - *_stop = strtoul(stop_buff, NULL, 16); - - pclose(file_start); - pclose(file_stop); -} -#endif -static int do_sort(Elf_Ehdr *ehdr, - char const *const fname, - table_sort_t custom_sort) -{ - int rc = -1; - Elf_Shdr *shdr_start; - Elf_Shdr *strtab_sec = NULL; - Elf_Shdr *symtab_sec = NULL; - Elf_Shdr *extab_sec = NULL; - Elf_Shdr *string_sec; - Elf_Sym *sym; - const Elf_Sym *symtab; - Elf32_Word *symtab_shndx = NULL; - Elf_Sym *sort_needed_sym = NULL; - Elf_Shdr *sort_needed_sec; - uint32_t *sort_needed_loc; - void *sym_start; - void *sym_end; - const char *secstrings; - const char *strtab; - char *extab_image; - int sort_need_index; - int symentsize; - int shentsize; - int idx; - int i; - unsigned int shnum; - unsigned int shstrndx; -#ifdef MCOUNT_SORT_ENABLED - struct elf_mcount_loc mstruct = {0}; - uint64_t _start_mcount_loc = 0; - uint64_t _stop_mcount_loc = 0; -#endif -#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) - unsigned int orc_ip_size = 0; - unsigned int orc_size = 0; - unsigned int orc_num_entries = 0; -#endif - - shdr_start = (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr)); - shentsize = ehdr_shentsize(ehdr); - - shstrndx = ehdr_shstrndx(ehdr); - if (shstrndx == SHN_XINDEX) - shstrndx = shdr_link(shdr_start); - string_sec = get_index(shdr_start, shentsize, shstrndx); - secstrings = (const char *)ehdr + shdr_offset(string_sec); - - shnum = ehdr_shnum(ehdr); - if (shnum == SHN_UNDEF) - shnum = shdr_size(shdr_start); - - for (i = 0; i < shnum; i++) { - Elf_Shdr *shdr = get_index(shdr_start, shentsize, i); - - idx = shdr_name(shdr); - if (!strcmp(secstrings + idx, "__ex_table")) - extab_sec = shdr; - if (!strcmp(secstrings + idx, ".symtab")) - symtab_sec = shdr; - if (!strcmp(secstrings + idx, ".strtab")) - strtab_sec = shdr; - - if (shdr_type(shdr) == SHT_SYMTAB_SHNDX) - symtab_shndx = (Elf32_Word *)((const char *)ehdr + - shdr_offset(shdr)); - -#ifdef MCOUNT_SORT_ENABLED - /* locate the .init.data section in vmlinux */ - if (!strcmp(secstrings + idx, ".init.data")) { - get_mcount_loc(&_start_mcount_loc, &_stop_mcount_loc); - mstruct.ehdr = ehdr; - mstruct.init_data_sec = shdr; - mstruct.start_mcount_loc = _start_mcount_loc; - mstruct.stop_mcount_loc = _stop_mcount_loc; - } -#endif - -#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) - /* locate the ORC unwind tables */ - if (!strcmp(secstrings + idx, ".orc_unwind_ip")) { - orc_ip_size = shdr_size(shdr); - g_orc_ip_table = (int *)((void *)ehdr + - shdr_offset(shdr)); - } - if (!strcmp(secstrings + idx, ".orc_unwind")) { - orc_size = shdr_size(shdr); - g_orc_table = (struct orc_entry *)((void *)ehdr + - shdr_offset(shdr)); - } -#endif - } /* for loop */ - -#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) - if (!g_orc_ip_table || !g_orc_table) { - fprintf(stderr, - "incomplete ORC unwind tables in file: %s\n", fname); - goto out; - } - - orc_num_entries = orc_ip_size / sizeof(int); - if (orc_ip_size % sizeof(int) != 0 || - orc_size % sizeof(struct orc_entry) != 0 || - orc_num_entries != orc_size / sizeof(struct orc_entry)) { - fprintf(stderr, - "inconsistent ORC unwind table entries in file: %s\n", - fname); - goto out; - } - - /* create thread to sort ORC unwind tables concurrently */ - if (pthread_create(&orc_sort_thread, NULL, - sort_orctable, &orc_ip_size)) { - fprintf(stderr, - "pthread_create orc_sort_thread failed '%s': %s\n", - strerror(errno), fname); - goto out; - } -#endif - -#ifdef MCOUNT_SORT_ENABLED - if (!mstruct.init_data_sec || !_start_mcount_loc || !_stop_mcount_loc) { - fprintf(stderr, - "incomplete mcount's sort in file: %s\n", - fname); - goto out; - } - - /* create thread to sort mcount_loc concurrently */ - if (pthread_create(&mcount_sort_thread, NULL, &sort_mcount_loc, &mstruct)) { - fprintf(stderr, - "pthread_create mcount_sort_thread failed '%s': %s\n", - strerror(errno), fname); - goto out; - } -#endif - if (!extab_sec) { - fprintf(stderr, "no __ex_table in file: %s\n", fname); - goto out; - } - - if (!symtab_sec) { - fprintf(stderr, "no .symtab in file: %s\n", fname); - goto out; - } - - if (!strtab_sec) { - fprintf(stderr, "no .strtab in file: %s\n", fname); - goto out; - } - - extab_image = (void *)ehdr + shdr_offset(extab_sec); - strtab = (const char *)ehdr + shdr_offset(strtab_sec); - symtab = (const Elf_Sym *)((const char *)ehdr + shdr_offset(symtab_sec)); - - if (custom_sort) { - custom_sort(extab_image, shdr_size(extab_sec)); - } else { - int num_entries = shdr_size(extab_sec) / extable_ent_size; - qsort(extab_image, num_entries, - extable_ent_size, compare_extable); - } - - /* find the flag main_extable_sort_needed */ - sym_start = (void *)ehdr + shdr_offset(symtab_sec); - sym_end = sym_start + shdr_size(symtab_sec); - symentsize = shdr_entsize(symtab_sec); - - for (sym = sym_start; (void *)sym + symentsize < sym_end; - sym = (void *)sym + symentsize) { - if (sym_type(sym) != STT_OBJECT) - continue; - if (!strcmp(strtab + sym_name(sym), - "main_extable_sort_needed")) { - sort_needed_sym = sym; - break; - } - } - - if (!sort_needed_sym) { - fprintf(stderr, - "no main_extable_sort_needed symbol in file: %s\n", - fname); - goto out; - } - - sort_need_index = get_secindex(sym_shndx(sym), - ((void *)sort_needed_sym - (void *)symtab) / symentsize, - symtab_shndx); - sort_needed_sec = get_index(shdr_start, shentsize, sort_need_index); - sort_needed_loc = (void *)ehdr + - shdr_offset(sort_needed_sec) + - sym_value(sort_needed_sym) - shdr_addr(sort_needed_sec); - - /* extable has been sorted, clear the flag */ - w(0, sort_needed_loc); - rc = 0; - -out: -#if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) - if (orc_sort_thread) { - void *retval = NULL; - /* wait for ORC tables sort done */ - rc = pthread_join(orc_sort_thread, &retval); - if (rc) { - fprintf(stderr, - "pthread_join failed '%s': %s\n", - strerror(errno), fname); - } else if (retval) { - rc = -1; - fprintf(stderr, - "failed to sort ORC tables '%s': %s\n", - (char *)retval, fname); - } - } -#endif - -#ifdef MCOUNT_SORT_ENABLED - if (mcount_sort_thread) { - void *retval = NULL; - /* wait for mcount sort done */ - rc = pthread_join(mcount_sort_thread, &retval); - if (rc) { - fprintf(stderr, - "pthread_join failed '%s': %s\n", - strerror(errno), fname); - } else if (retval) { - rc = -1; - fprintf(stderr, - "failed to sort mcount '%s': %s\n", - (char *)retval, fname); - } - } -#endif - return rc; -} From patchwork Thu Jan 2 23:26:23 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925014 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E8A0D1C1F29; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; cv=none; b=dKsvxWzL6Ed5M2oDtrfDJyh9JPbbPW8AC/ex1qQtHOAPO3H+sV8qebhaub8EWJKBJuQE2Ag1wgn6XLt0w/jRBrdAdacuoTahZxq8k37Zn7FEnZ/lz9AoF7knKfelG9J9Q/VFfBGZ6u60SpfBB5UhtXnzLkFzCxHw+NlyquUGSm0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; c=relaxed/simple; bh=ZJOFh8xy6UlAFyVl4JN2AflWGfx7zZzuhkOtpnS3D+0=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=lvj9GoPXGoWitX96xobUNYla8kkO7YWVcIUJLZ/FvjMMJP5qOlDvuZdxdtPC9ybgTl01C42xk2QXaMbDZNaVt6RpTo/D9QAGwcgkGscBL99vfpWordveFbF6xaRLeWEmxgswRBe+7MvZcb1x4SzCzGVo2x5crGdDLxfjkePYDXI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id D541BC4CEDD; Thu, 2 Jan 2025 23:25:33 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaZ-00000005Yxq-0deb; Thu, 02 Jan 2025 18:26:51 -0500 Message-ID: <20250102232651.004515726@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:23 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 14/16] scripts/sorttable: Get start/stop_mcount_loc from ELF file directly References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt The get_mcount_loc() does a cheesy trick to find the start_mcount_loc and stop_mcount_loc values. That trick is: file_start = popen(" grep start_mcount System.map | awk '{print $1}' ", "r"); and file_stop = popen(" grep stop_mcount System.map | awk '{print $1}' ", "r"); Those values are stored in the Elf symbol table. Use that to capture those values. Using the symbol table is more efficient and more robust. The above could fail if another variable had "start_mcount" or "stop_mcount" as part of its name. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 96 +++++++++++++++++++++------------------------ 1 file changed, 45 insertions(+), 51 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index da9e1a82e886..c26e71e6ec6b 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -469,42 +469,41 @@ static void *sort_mcount_loc(void *arg) } /* Get the address of __start_mcount_loc and __stop_mcount_loc in System.map */ -static void get_mcount_loc(uint64_t *_start, uint64_t *_stop) +static void get_mcount_loc(struct elf_mcount_loc *emloc, Elf_Shdr *symtab_sec, + const char *strtab) { - FILE *file_start, *file_stop; - char start_buff[20]; - char stop_buff[20]; - int len = 0; + Elf_Sym *sym, *end_sym; + int symentsize = shdr_entsize(symtab_sec); + int found = 0; + + sym = (void *)emloc->ehdr + shdr_offset(symtab_sec); + end_sym = (void *)sym + shdr_size(symtab_sec); + + while (sym < end_sym) { + if (!strcmp(strtab + sym_name(sym), "__start_mcount_loc")) { + emloc->start_mcount_loc = sym_value(sym); + if (++found == 2) + break; + } else if (!strcmp(strtab + sym_name(sym), "__stop_mcount_loc")) { + emloc->stop_mcount_loc = sym_value(sym); + if (++found == 2) + break; + } + sym = (void *)sym + symentsize; + } - file_start = popen(" grep start_mcount System.map | awk '{print $1}' ", "r"); - if (!file_start) { + if (!emloc->start_mcount_loc) { fprintf(stderr, "get start_mcount_loc error!"); return; } - file_stop = popen(" grep stop_mcount System.map | awk '{print $1}' ", "r"); - if (!file_stop) { + if (!emloc->stop_mcount_loc) { fprintf(stderr, "get stop_mcount_loc error!"); - pclose(file_start); return; } - - while (fgets(start_buff, sizeof(start_buff), file_start) != NULL) { - len = strlen(start_buff); - start_buff[len - 1] = '\0'; - } - *_start = strtoul(start_buff, NULL, 16); - - while (fgets(stop_buff, sizeof(stop_buff), file_stop) != NULL) { - len = strlen(stop_buff); - stop_buff[len - 1] = '\0'; - } - *_stop = strtoul(stop_buff, NULL, 16); - - pclose(file_start); - pclose(file_stop); } #endif + static int do_sort(Elf_Ehdr *ehdr, char const *const fname, table_sort_t custom_sort) @@ -535,8 +534,6 @@ static int do_sort(Elf_Ehdr *ehdr, unsigned int shstrndx; #ifdef MCOUNT_SORT_ENABLED struct elf_mcount_loc mstruct = {0}; - uint64_t _start_mcount_loc = 0; - uint64_t _stop_mcount_loc = 0; #endif #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) unsigned int orc_ip_size = 0; @@ -574,15 +571,9 @@ static int do_sort(Elf_Ehdr *ehdr, #ifdef MCOUNT_SORT_ENABLED /* locate the .init.data section in vmlinux */ - if (!strcmp(secstrings + idx, ".init.data")) { - get_mcount_loc(&_start_mcount_loc, &_stop_mcount_loc); - mstruct.ehdr = ehdr; + if (!strcmp(secstrings + idx, ".init.data")) mstruct.init_data_sec = shdr; - mstruct.start_mcount_loc = _start_mcount_loc; - mstruct.stop_mcount_loc = _stop_mcount_loc; - } #endif - #if defined(SORTTABLE_64) && defined(UNWINDER_ORC_ENABLED) /* locate the ORC unwind tables */ if (!strcmp(secstrings + idx, ".orc_unwind_ip")) { @@ -624,23 +615,6 @@ static int do_sort(Elf_Ehdr *ehdr, goto out; } #endif - -#ifdef MCOUNT_SORT_ENABLED - if (!mstruct.init_data_sec || !_start_mcount_loc || !_stop_mcount_loc) { - fprintf(stderr, - "incomplete mcount's sort in file: %s\n", - fname); - goto out; - } - - /* create thread to sort mcount_loc concurrently */ - if (pthread_create(&mcount_sort_thread, NULL, &sort_mcount_loc, &mstruct)) { - fprintf(stderr, - "pthread_create mcount_sort_thread failed '%s': %s\n", - strerror(errno), fname); - goto out; - } -#endif if (!extab_sec) { fprintf(stderr, "no __ex_table in file: %s\n", fname); goto out; @@ -660,6 +634,26 @@ static int do_sort(Elf_Ehdr *ehdr, strtab = (const char *)ehdr + shdr_offset(strtab_sec); symtab = (const Elf_Sym *)((const char *)ehdr + shdr_offset(symtab_sec)); +#ifdef MCOUNT_SORT_ENABLED + mstruct.ehdr = ehdr; + get_mcount_loc(&mstruct, symtab_sec, strtab); + + if (!mstruct.init_data_sec || !mstruct.start_mcount_loc || !mstruct.stop_mcount_loc) { + fprintf(stderr, + "incomplete mcount's sort in file: %s\n", + fname); + goto out; + } + + /* create thread to sort mcount_loc concurrently */ + if (pthread_create(&mcount_sort_thread, NULL, &sort_mcount_loc, &mstruct)) { + fprintf(stderr, + "pthread_create mcount_sort_thread failed '%s': %s\n", + strerror(errno), fname); + goto out; + } +#endif + if (custom_sort) { custom_sort(extab_image, shdr_size(extab_sec)); } else { From patchwork Thu Jan 2 23:26:24 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925016 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1C61C1C2335; Thu, 2 Jan 2025 23:25:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; cv=none; b=mvkimj42Vx/b2WaqVxwm5FFF1kyq4qUD6JGZ5GYdoMtygDbOvHqI1c1S67V1gQflpjHOd5xgNldmVl2B7oNbAhiFVFSmYYVh5HzHetD6y68Z5d4tuwjBDJ7fviCBnRQ80iLr/3GoI9dzAzKsPRnzWJciJCZS2ioElEpp2BdCTps= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; c=relaxed/simple; bh=BDb0Sreoy9rBRdj+OjLgmVqqmdKxyy8n159KbqO39WA=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=FWJIR2GN+lM21QcvEGMYAZ+EMTXIxnbN69/jqKs0zD7rsajrOvd188pqusK2rAI04W44ohWeYoAd/3+wjLrYXrwZ2gq9lFf7y4WY+BZZuCPgzix82hlzRNYYA5rHZHIQXygVD1NyiK4Y9GB6ZAlsUd1QmYdIY49D4L75TmkYeG8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 05E7EC4CEE3; Thu, 2 Jan 2025 23:25:34 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaZ-00000005YyL-1Mxe; Thu, 02 Jan 2025 18:26:51 -0500 Message-ID: <20250102232651.173687711@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:24 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 15/16] scripts/sorttable: Zero out weak functions in mcount_loc table References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt In preparation for removing weak functions from available_filter_functions, have the sorttable.c code that sorts the mcount regions during the build modified to take a "nm -S vmlinux" as input, sort it, and any function listed in the mcount_loc section that is not within a boundary of the function list given by nm is considered a weak function and is zeroed out. This will move them all to the beginning of the mcount_loc section. This will allow for the ftrace code to be able to skip them in one go. Signed-off-by: Steven Rostedt (Google) --- scripts/link-vmlinux.sh | 4 +- scripts/sorttable.c | 129 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 130 insertions(+), 3 deletions(-) diff --git a/scripts/link-vmlinux.sh b/scripts/link-vmlinux.sh index d853ddb3b28c..976808c46665 100755 --- a/scripts/link-vmlinux.sh +++ b/scripts/link-vmlinux.sh @@ -177,12 +177,14 @@ mksysmap() sorttable() { - ${objtree}/scripts/sorttable ${1} + ${NM} -S ${1} > .tmp_vmlinux.nm-sort + ${objtree}/scripts/sorttable -s .tmp_vmlinux.nm-sort ${1} } cleanup() { rm -f .btf.* + rm -f .tmp_vmlinux.nm-sort rm -f System.map rm -f vmlinux rm -f vmlinux.map diff --git a/scripts/sorttable.c b/scripts/sorttable.c index c26e71e6ec6b..1a2b420a4929 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -446,6 +446,98 @@ static void *sort_orctable(void *arg) #endif #ifdef MCOUNT_SORT_ENABLED +struct func_info { + uint64_t addr; + uint64_t size; +}; + +/* List of functions created by: nm -S vmlinux */ +static struct func_info *function_list; +static int function_list_size; + +/* Allocate functions in 1k blocks */ +#define FUNC_BLK_SIZE 1024 +#define FUNC_BLK_MASK (FUNC_BLK_SIZE - 1) + +static int add_field(uint64_t addr, uint64_t size) +{ + struct func_info *fi; + int fsize = function_list_size; + + if (!(fsize & FUNC_BLK_MASK)) { + fsize += FUNC_BLK_SIZE; + fi = realloc(function_list, fsize * sizeof(struct func_info)); + if (!fi) + return -1; + function_list = fi; + } + fi = &function_list[function_list_size++]; + fi->addr = addr; + fi->size = size; + return 0; +} + +/* Only return match if the address lies inside the function size */ +static int cmp_func_addr(const void *K, const void *A) +{ + uint64_t key = *(const uint64_t *)K; + const struct func_info *a = A; + + if (key < a->addr) + return -1; + return key >= a->addr + a->size; +} + +/* Find the function in function list that is bounded by the function size */ +static int find_func(uint64_t key) +{ + return bsearch(&key, function_list, function_list_size, + sizeof(struct func_info), cmp_func_addr) != NULL; +} + +static int cmp_funcs(const void *A, const void *B) +{ + const struct func_info *a = A; + const struct func_info *b = B; + + if (a->addr < b->addr) + return -1; + return a->addr > b->addr; +} + +static int parse_symbols(const char *fname) +{ + FILE *fp; + char addr_str[20]; /* Only need 17, but round up to next int size */ + char size_str[20]; + char type; + + fp = fopen(fname, "r"); + if (!fp) { + perror(fname); + return -1; + } + + while (fscanf(fp, "%16s %16s %c %*s\n", addr_str, size_str, &type) == 3) { + uint64_t addr; + uint64_t size; + + /* Only care about functions */ + if (type != 't' && type != 'T') + continue; + + addr = strtoull(addr_str, NULL, 16); + size = strtoull(size_str, NULL, 16); + if (add_field(addr, size) < 0) + return -1; + } + fclose(fp); + + qsort(function_list, function_list_size, sizeof(struct func_info), cmp_funcs); + + return 0; +} + static pthread_t mcount_sort_thread; struct elf_mcount_loc { @@ -463,6 +555,22 @@ static void *sort_mcount_loc(void *arg) + shdr_offset(emloc->init_data_sec); uint64_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; unsigned char *start_loc = (void *)emloc->ehdr + offset; + void *end_loc = start_loc + count; + + /* zero out any locations not found by function list */ + if (function_list_size) { + for (void *ptr = start_loc; ptr < end_loc; ptr += long_size) { + uint64_t key; + + key = long_size == 4 ? r((uint32_t *)ptr) : r8((uint64_t *)ptr); + if (!find_func(key)) { + if (long_size == 4) + *(uint32_t *)ptr = 0; + else + *(uint64_t *)ptr = 0; + } + } + } qsort(start_loc, count/long_size, long_size, compare_extable); return NULL; @@ -502,6 +610,8 @@ static void get_mcount_loc(struct elf_mcount_loc *emloc, Elf_Shdr *symtab_sec, return; } } +#else /* MCOUNT_SORT_ENABLED */ +static inline int parse_symbols(const char *fname) { return 0; } #endif static int do_sort(Elf_Ehdr *ehdr, @@ -930,14 +1040,29 @@ int main(int argc, char *argv[]) int i, n_error = 0; /* gcc-4.3.0 false positive complaint */ size_t size = 0; void *addr = NULL; + int c; + + while ((c = getopt(argc, argv, "s:")) >= 0) { + switch (c) { + case 's': + if (parse_symbols(optarg) < 0) { + fprintf(stderr, "Could not parse %s\n", optarg); + return -1; + } + break; + default: + fprintf(stderr, "usage: sorttable [-s nm-file] vmlinux...\n"); + return 0; + } + } - if (argc < 2) { + if ((argc - optind) < 1) { fprintf(stderr, "usage: sorttable vmlinux...\n"); return 0; } /* Process each file in turn, allowing deep failure. */ - for (i = 1; i < argc; i++) { + for (i = optind; i < argc; i++) { addr = mmap_file(argv[i], &size); if (!addr) { ++n_error; From patchwork Thu Jan 2 23:26:25 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 13925017 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B56E71C3C10; Thu, 2 Jan 2025 23:25:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; cv=none; b=bqXuyIxFq5Eritcpw33Kd+jIJsCJt6WorQYvyjAaBFDaVj33FZZtdPF9yzJSDL89fehE3A3O6T7hf+sLKTL2SbXQrmG1goUW64ktlWsbTl4IiVecDxS4NQ2z2d68Q1rVv3JIG3R2Ra9wpJlPRaJ7N5AUxwj2V0u5j3+SK0X0uvE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1735860334; c=relaxed/simple; bh=uLAkQ1iCsJrNH+pf6IhLKO9FnRJigtIjVOdVkksLxas=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=Ovgux5+JTuelkbiWHwpLoHknCiux4WkEOUHzJD7RJrGHfh+EUaqppnMqArPGCR6e/TrBWhOV4Ha9MKm0C7lrmy/GPMARVulkrqGCOxHxvgKiN9fypAwp+XxS6FvkyxKH8wp29F+83zDyXieJ/EVAhL0AkmP3YrlBs76aGB0hxH4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 32DBAC4CED0; Thu, 2 Jan 2025 23:25:34 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98) (envelope-from ) id 1tTUaZ-00000005Yyp-25r6; Thu, 02 Jan 2025 18:26:51 -0500 Message-ID: <20250102232651.347490863@goodmis.org> User-Agent: quilt/0.68 Date: Thu, 02 Jan 2025 18:26:25 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, bpf Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Linus Torvalds , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Zheng Yejian , Martin Kelly , Christophe Leroy , Josh Poimboeuf Subject: [PATCH v2 16/16] scripts/sorttable: ftrace: Do not add weak functions to available_filter_functions References: <20250102232609.529842248@goodmis.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Steven Rostedt When a function is annotated as "weak" and is overridden, the code is not removed. If it is traced, the fentry/mcount location in the weak function will be referenced by the "__mcount_loc" section. This will then be added to the available_filter_functions list. Since only the address of the functions are listed, to find the name to show, a search of kallsyms is used. Since kallsyms will return the function by simply finding the function that the address is after but before the next function, an address of a weak function will show up as the function before it. This is because kallsyms does not save names of weak functions. This has caused issues in the past, as now the traced weak function will be listed in available_filter_functions with the name of the function before it. At best, this will cause the previous function's name to be listed twice. At worse, if the previous function was marked notrace, it will now show up as a function that can be traced. Note that it only shows up that it can be traced but will not be if enabled, which causes confusion. https://lore.kernel.org/all/20220412094923.0abe90955e5db486b7bca279@kernel.org/ The commit b39181f7c6907 ("ftrace: Add FTRACE_MCOUNT_MAX_OFFSET to avoid adding weak function") was a workaround to this by checking the function address before printing its name. If the address was too far from the function given by the name then instead of printing the name it would print: __ftrace_invalid_address___ The real issue is that these invalid addresses are listed in the ftrace table look up which available_filter_functions is derived from. A place holder must be listed in that file because set_ftrace_filter may take a series of indexes into that file instead of names to be able to do O(1) lookups to enable filtering (many tools use this method). Even if kallsyms saved the size of the function, it does not remove the need of having these place holders. The real solution is to not add a weak function into the ftrace table in the first place. To solve this, the sorttable.c code that sorts the mcount regions during the build is modified to take a "nm -S vmlinux" input, sort it, and any function listed in the mcount_loc section that is not within a boundary of the function list given by nm is considered a weak function and is zeroed out. Note, this does not mean they will remain zero when booting as KASLR will still shift those addresses. A new initdata variable is added: ftrace_mcount_skip The sorttable will update that to the number of functions at the start of the mcount_loc section that should be skipped. As it zeros out the weak functions before sorting, they end up all at the start of the section. This variable states how many of them to skip over. On boot up, when the ftrace table is created from the mcount_loc section, it will start at the start_mcount_loc + ftrace_mcount_skip. This stops the weak functions from ever being added to the ftrace table and also keeps from needing place holders in available_filter_functions. Before: ~# grep __ftrace_invalid_address___ /sys/kernel/tracing/available_filter_functions | wc -l 556 After: ~# grep __ftrace_invalid_address___ /sys/kernel/tracing/available_filter_functions | wc -l 0 Signed-off-by: Steven Rostedt (Google) --- kernel/trace/ftrace.c | 16 +++++++++++++--- scripts/sorttable.c | 36 ++++++++++++++++++++++++++++++++++-- 2 files changed, 47 insertions(+), 5 deletions(-) diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c index 9b17efb1a87d..1b8cb4ebd285 100644 --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c @@ -7747,10 +7747,14 @@ int __init __weak ftrace_dyn_arch_init(void) return 0; } +/* This is set in scripts/sorttable.c */ +int ftrace_mcount_skip __initdata; + void __init ftrace_init(void) { extern unsigned long __start_mcount_loc[]; extern unsigned long __stop_mcount_loc[]; + unsigned long *start_addr = __start_mcount_loc; unsigned long count, flags; int ret; @@ -7761,6 +7765,14 @@ void __init ftrace_init(void) goto failed; count = __stop_mcount_loc - __start_mcount_loc; + + /* + * scripts/sorttable.c will set ftrace_mcount_skip to state + * how many functions to skip in the __mcount_loc section. + * These would have been weak functions. + */ + count -= ftrace_mcount_skip; + start_addr += ftrace_mcount_skip; if (!count) { pr_info("ftrace: No functions to be traced?\n"); goto failed; @@ -7769,9 +7781,7 @@ void __init ftrace_init(void) pr_info("ftrace: allocating %ld entries in %ld pages\n", count, DIV_ROUND_UP(count, ENTRIES_PER_PAGE)); - ret = ftrace_process_locs(NULL, - __start_mcount_loc, - __stop_mcount_loc); + ret = ftrace_process_locs(NULL, start_addr, __stop_mcount_loc); if (ret) { pr_warn("ftrace: failed to allocate entries for functions\n"); goto failed; diff --git a/scripts/sorttable.c b/scripts/sorttable.c index 1a2b420a4929..506172898fd8 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -543,6 +543,7 @@ static pthread_t mcount_sort_thread; struct elf_mcount_loc { Elf_Ehdr *ehdr; Elf_Shdr *init_data_sec; + Elf_Sym *ftrace_skip_sym; uint64_t start_mcount_loc; uint64_t stop_mcount_loc; }; @@ -554,9 +555,17 @@ static void *sort_mcount_loc(void *arg) uint64_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec) + shdr_offset(emloc->init_data_sec); uint64_t count = emloc->stop_mcount_loc - emloc->start_mcount_loc; + uint32_t *skip_addr = NULL; unsigned char *start_loc = (void *)emloc->ehdr + offset; void *end_loc = start_loc + count; + if (emloc->ftrace_skip_sym) { + offset = sym_value(emloc->ftrace_skip_sym) - + shdr_addr(emloc->init_data_sec) + + shdr_offset(emloc->init_data_sec); + skip_addr = (void *)emloc->ehdr + offset; + } + /* zero out any locations not found by function list */ if (function_list_size) { for (void *ptr = start_loc; ptr < end_loc; ptr += long_size) { @@ -573,6 +582,25 @@ static void *sort_mcount_loc(void *arg) } qsort(start_loc, count/long_size, long_size, compare_extable); + + /* Now set how many functions need to be skipped */ + for (void *ptr = start_loc; skip_addr && ptr < end_loc; ptr += long_size) { + uint64_t val; + + if (long_size == 4) + val = *(uint32_t *)ptr; + else + val = *(uint64_t *)ptr; + if (val) { + uint32_t skip; + + /* Update the ftrace_mcount_skip to skip these functions */ + val = ptr - (void *)start_loc; + skip = val / long_size; + w(r(&skip), skip_addr); + break; + } + } return NULL; } @@ -590,11 +618,15 @@ static void get_mcount_loc(struct elf_mcount_loc *emloc, Elf_Shdr *symtab_sec, while (sym < end_sym) { if (!strcmp(strtab + sym_name(sym), "__start_mcount_loc")) { emloc->start_mcount_loc = sym_value(sym); - if (++found == 2) + if (++found == 3) break; } else if (!strcmp(strtab + sym_name(sym), "__stop_mcount_loc")) { emloc->stop_mcount_loc = sym_value(sym); - if (++found == 2) + if (++found == 3) + break; + } else if (!strcmp(strtab + sym_name(sym), "ftrace_mcount_skip")) { + emloc->ftrace_skip_sym = sym; + if (++found == 3) break; } sym = (void *)sym + symentsize;