From bf5438fca2950b03c21ad868090cc1a8fcd49536 Mon Sep 17 00:00:00 2001 From: Jason Baron Date: Fri, 17 Sep 2010 11:09:00 -0400 Subject: jump label: Base patch for jump label base patch to implement 'jump labeling'. Based on a new 'asm goto' inline assembly gcc mechanism, we can now branch to labels from an 'asm goto' statment. This allows us to create a 'no-op' fastpath, which can subsequently be patched with a jump to the slowpath code. This is useful for code which might be rarely used, but which we'd like to be able to call, if needed. Tracepoints are the current usecase that these are being implemented for. Acked-by: David S. Miller Signed-off-by: Jason Baron LKML-Reference: [ cleaned up some formating ] Signed-off-by: Steven Rostedt --- scripts/gcc-goto.sh | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 scripts/gcc-goto.sh (limited to 'scripts') diff --git a/scripts/gcc-goto.sh b/scripts/gcc-goto.sh new file mode 100644 index 0000000..8e82424 --- /dev/null +++ b/scripts/gcc-goto.sh @@ -0,0 +1,5 @@ +#!/bin/sh +# Test for gcc 'asm goto' suport +# Copyright (C) 2010, Jason Baron + +echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $1 -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y" -- cgit v1.1 From 52159d98be6f26c48f5e02c7ab3c9848a85979b5 Mon Sep 17 00:00:00 2001 From: Jason Baron Date: Fri, 17 Sep 2010 11:09:17 -0400 Subject: jump label: Convert dynamic debug to use jump labels Convert the 'dynamic debug' infrastructure to use jump labels. Signed-off-by: Jason Baron LKML-Reference: Signed-off-by: Steven Rostedt --- scripts/Makefile.lib | 11 +-------- scripts/basic/Makefile | 2 +- scripts/basic/hash.c | 64 -------------------------------------------------- 3 files changed, 2 insertions(+), 75 deletions(-) delete mode 100644 scripts/basic/hash.c (limited to 'scripts') diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib index 54fd1b7..7bfcf1a 100644 --- a/scripts/Makefile.lib +++ b/scripts/Makefile.lib @@ -101,14 +101,6 @@ basename_flags = -D"KBUILD_BASENAME=KBUILD_STR($(call name-fix,$(basetarget)))" modname_flags = $(if $(filter 1,$(words $(modname))),\ -D"KBUILD_MODNAME=KBUILD_STR($(call name-fix,$(modname)))") -#hash values -ifdef CONFIG_DYNAMIC_DEBUG -debug_flags = -D"DEBUG_HASH=$(shell ./scripts/basic/hash djb2 $(@D)$(modname))"\ - -D"DEBUG_HASH2=$(shell ./scripts/basic/hash r5 $(@D)$(modname))" -else -debug_flags = -endif - orig_c_flags = $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(KBUILD_SUBDIR_CCFLAGS) \ $(ccflags-y) $(CFLAGS_$(basetarget).o) _c_flags = $(filter-out $(CFLAGS_REMOVE_$(basetarget).o), $(orig_c_flags)) @@ -152,8 +144,7 @@ endif c_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(__c_flags) $(modkern_cflags) \ - -D"KBUILD_STR(s)=\#s" $(basename_flags) $(modname_flags) \ - $(debug_flags) + -D"KBUILD_STR(s)=\#s" $(basename_flags) $(modname_flags) a_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(__a_flags) $(modkern_aflags) diff --git a/scripts/basic/Makefile b/scripts/basic/Makefile index 0955995..4c324a1 100644 --- a/scripts/basic/Makefile +++ b/scripts/basic/Makefile @@ -9,7 +9,7 @@ # fixdep: Used to generate dependency information during build process # docproc: Used in Documentation/DocBook -hostprogs-y := fixdep docproc hash +hostprogs-y := fixdep docproc always := $(hostprogs-y) # fixdep is needed to compile other host programs diff --git a/scripts/basic/hash.c b/scripts/basic/hash.c deleted file mode 100644 index 2ef5d3f..0000000 --- a/scripts/basic/hash.c +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (C) 2008 Red Hat, Inc., Jason Baron - * - */ - -#include -#include -#include - -#define DYNAMIC_DEBUG_HASH_BITS 6 - -static const char *program; - -static void usage(void) -{ - printf("Usage: %s \n", program); - exit(1); -} - -/* djb2 hashing algorithm by Dan Bernstein. From: - * http://www.cse.yorku.ca/~oz/hash.html - */ - -static unsigned int djb2_hash(char *str) -{ - unsigned long hash = 5381; - int c; - - c = *str; - while (c) { - hash = ((hash << 5) + hash) + c; - c = *++str; - } - return (unsigned int)(hash & ((1 << DYNAMIC_DEBUG_HASH_BITS) - 1)); -} - -static unsigned int r5_hash(char *str) -{ - unsigned long hash = 0; - int c; - - c = *str; - while (c) { - hash = (hash + (c << 4) + (c >> 4)) * 11; - c = *++str; - } - return (unsigned int)(hash & ((1 << DYNAMIC_DEBUG_HASH_BITS) - 1)); -} - -int main(int argc, char *argv[]) -{ - program = argv[0]; - - if (argc != 3) - usage(); - if (!strcmp(argv[1], "djb2")) - printf("%d\n", djb2_hash(argv[2])); - else if (!strcmp(argv[1], "r5")) - printf("%d\n", r5_hash(argv[2])); - else - usage(); - exit(0); -} - -- cgit v1.1 From d6dad199a10423ce37b8bfec1f055c380dc4a3d5 Mon Sep 17 00:00:00 2001 From: Ingo Molnar Date: Fri, 24 Sep 2010 09:12:25 +0200 Subject: jump label: Fix GCC feature check when distcc is used The following build bug occurs on distcc builds: CC arch/x86/kernel/asm-offsets.s In file included from include/linux/module.h:24, from include/linux/crypto.h:22, from arch/x86/kernel/asm-offsets_64.c:9, from arch/x86/kernel/asm-offsets.c:5: include/trace/events/module.h: In function 'trace_module_load': include/trace/events/module.h:18: error: expected '(' before 'goto' include/trace/events/module.h:18: error: expected identifier or '*' before '(' token It triggers because distcc is invoked by turning $CC into "distcc gcc", but gcc-goto.sh check script was using $1 not $@ to expand parameters. Cc: Jason Baron Cc: Steven Rostedt LKML-Reference: <20100923034910.867858597@goodmis.org> Signed-off-by: Ingo Molnar --- scripts/gcc-goto.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'scripts') diff --git a/scripts/gcc-goto.sh b/scripts/gcc-goto.sh index 8e82424..520d16b 100644 --- a/scripts/gcc-goto.sh +++ b/scripts/gcc-goto.sh @@ -2,4 +2,4 @@ # Test for gcc 'asm goto' suport # Copyright (C) 2010, Jason Baron -echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $1 -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y" +echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y" -- cgit v1.1 From 81d3858d3131a589cade0d8b57f95cc1fc699b89 Mon Sep 17 00:00:00 2001 From: John Reiser Date: Wed, 13 Oct 2010 15:12:54 -0400 Subject: ftrace: Add C version of recordmcount compile time code Currently, the mcount callers are found with a perl script that does an objdump on every file in the kernel. This is a C version of that same code which should increase the performance time of compiling the kernel with dynamic ftrace enabled. Signed-off-by: John Reiser [ Updated the code to include .text.unlikely section as well as changing the format to follow Linux coding style. ] Signed-off-by: Steven Rostedt --- scripts/recordmcount.c | 885 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 885 insertions(+) create mode 100644 scripts/recordmcount.c (limited to 'scripts') diff --git a/scripts/recordmcount.c b/scripts/recordmcount.c new file mode 100644 index 0000000..34f32be --- /dev/null +++ b/scripts/recordmcount.c @@ -0,0 +1,885 @@ +/* + * recordmcount.c: construct a table of the locations of calls to 'mcount' + * so that ftrace can find them quickly. + * Copyright 2009 John F. Reiser . All rights reserved. + * Licensed under the GNU General Public License, version 2 (GPLv2). + * + * Restructured to fit Linux format, as well as other updates: + * Copyright 2010 Steven Rostedt , Red Hat Inc. + */ + +/* + * Strategy: alter the .o file in-place. + * + * Append a new STRTAB that has the new section names, followed by a new array + * ElfXX_Shdr[] that has the new section headers, followed by the section + * contents for __mcount_loc and its relocations. The old shstrtab strings, + * and the old ElfXX_Shdr[] array, remain as "garbage" (commonly, a couple + * kilobytes.) Subsequent processing by /bin/ld (or the kernel module loader) + * will ignore the garbage regions, because they are not designated by the + * new .e_shoff nor the new ElfXX_Shdr[]. [In order to remove the garbage, + * then use "ld -r" to create a new file that omits the garbage.] + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int fd_map; /* File descriptor for file being modified. */ +static int mmap_failed; /* Boolean flag. */ +static void *ehdr_curr; /* current ElfXX_Ehdr * for resource cleanup */ +static char gpfx; /* prefix for global symbol name (sometimes '_') */ +static struct stat sb; /* Remember .st_size, etc. */ +static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */ + +/* setjmp() return values */ +enum { + SJ_SETJMP = 0, /* hardwired first return */ + SJ_FAIL, + SJ_SUCCEED +}; + +/* Per-file resource cleanup when multiple files. */ +static void +cleanup(void) +{ + if (!mmap_failed) + munmap(ehdr_curr, sb.st_size); + else + free(ehdr_curr); + close(fd_map); +} + +static void __attribute__((noreturn)) +fail_file(void) +{ + cleanup(); + longjmp(jmpenv, SJ_FAIL); +} + +static void __attribute__((noreturn)) +succeed_file(void) +{ + cleanup(); + longjmp(jmpenv, SJ_SUCCEED); +} + +/* ulseek, uread, ...: Check return value for errors. */ + +static off_t +ulseek(int const fd, off_t const offset, int const whence) +{ + off_t const w = lseek(fd, offset, whence); + if ((off_t)-1 == w) { + perror("lseek"); + fail_file(); + } + return w; +} + +static size_t +uread(int const fd, void *const buf, size_t const count) +{ + size_t const n = read(fd, buf, count); + if (n != count) { + perror("read"); + fail_file(); + } + return n; +} + +static size_t +uwrite(int const fd, void const *const buf, size_t const count) +{ + size_t const n = write(fd, buf, count); + if (n != count) { + perror("write"); + fail_file(); + } + return n; +} + +static void * +umalloc(size_t size) +{ + void *const addr = malloc(size); + if (0 == addr) { + fprintf(stderr, "malloc failed: %zu bytes\n", size); + fail_file(); + } + return addr; +} + +/* + * Get the whole file as a programming convenience in order to avoid + * malloc+lseek+read+free of many pieces. If successful, then mmap + * avoids copying unused pieces; else just read the whole file. + * Open for both read and write; new info will be appended to the file. + * Use MAP_PRIVATE so that a few changes to the in-memory ElfXX_Ehdr + * do not propagate to the file until an explicit overwrite at the last. + * This preserves most aspects of consistency (all except .st_size) + * for simultaneous readers of the file while we are appending to it. + * However, multiple writers still are bad. We choose not to use + * locking because it is expensive and the use case of kernel build + * makes multiple writers unlikely. + */ +static void *mmap_file(char const *fname) +{ + void *addr; + + fd_map = open(fname, O_RDWR); + if (0 > fd_map || 0 > fstat(fd_map, &sb)) { + perror(fname); + fail_file(); + } + if (!S_ISREG(sb.st_mode)) { + fprintf(stderr, "not a regular file: %s\n", fname); + fail_file(); + } + addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, + fd_map, 0); + mmap_failed = 0; + if (MAP_FAILED == addr) { + mmap_failed = 1; + addr = umalloc(sb.st_size); + uread(fd_map, addr, sb.st_size); + } + return addr; +} + +/* w8rev, w8nat, ...: Handle endianness. */ + +static uint64_t w8rev(uint64_t const x) +{ + return ((0xff & (x >> (0 * 8))) << (7 * 8)) + | ((0xff & (x >> (1 * 8))) << (6 * 8)) + | ((0xff & (x >> (2 * 8))) << (5 * 8)) + | ((0xff & (x >> (3 * 8))) << (4 * 8)) + | ((0xff & (x >> (4 * 8))) << (3 * 8)) + | ((0xff & (x >> (5 * 8))) << (2 * 8)) + | ((0xff & (x >> (6 * 8))) << (1 * 8)) + | ((0xff & (x >> (7 * 8))) << (0 * 8)); +} + +static uint32_t w4rev(uint32_t const x) +{ + return ((0xff & (x >> (0 * 8))) << (3 * 8)) + | ((0xff & (x >> (1 * 8))) << (2 * 8)) + | ((0xff & (x >> (2 * 8))) << (1 * 8)) + | ((0xff & (x >> (3 * 8))) << (0 * 8)); +} + +static uint32_t w2rev(uint16_t const x) +{ + return ((0xff & (x >> (0 * 8))) << (1 * 8)) + | ((0xff & (x >> (1 * 8))) << (0 * 8)); +} + +static uint64_t w8nat(uint64_t const x) +{ + return x; +} + +static uint32_t w4nat(uint32_t const x) +{ + return x; +} + +static uint32_t w2nat(uint16_t const x) +{ + return x; +} + +static uint64_t (*w8)(uint64_t); +static uint32_t (*w)(uint32_t); +static uint32_t (*w2)(uint16_t); + +/* Names of the sections that could contain calls to mcount. */ +static int +is_mcounted_section_name(char const *const txtname) +{ + return 0 == strcmp(".text", txtname) || + 0 == strcmp(".sched.text", txtname) || + 0 == strcmp(".spinlock.text", txtname) || + 0 == strcmp(".irqentry.text", txtname) || + 0 == strcmp(".text.unlikely", txtname); +} + +/* Append the new shstrtab, Elf32_Shdr[], __mcount_loc and its relocations. */ +static void append32(Elf32_Ehdr *const ehdr, + Elf32_Shdr *const shstr, + uint32_t const *const mloc0, + uint32_t const *const mlocp, + Elf32_Rel const *const mrel0, + Elf32_Rel const *const mrelp, + unsigned int const rel_entsize, + unsigned int const symsec_sh_link) +{ + /* Begin constructing output file */ + Elf32_Shdr mcsec; + char const *mc_name = (sizeof(Elf32_Rela) == rel_entsize) + ? ".rela__mcount_loc" + : ".rel__mcount_loc"; + unsigned const old_shnum = w2(ehdr->e_shnum); + uint32_t const old_shoff = w(ehdr->e_shoff); + uint32_t const old_shstr_sh_size = w(shstr->sh_size); + uint32_t const old_shstr_sh_offset = w(shstr->sh_offset); + uint32_t t = 1 + strlen(mc_name) + w(shstr->sh_size); + uint32_t new_e_shoff; + + shstr->sh_size = w(t); + shstr->sh_offset = w(sb.st_size); + t += sb.st_size; + t += (3u & -t); /* 4-byte align */ + new_e_shoff = t; + + /* body for new shstrtab */ + ulseek(fd_map, sb.st_size, SEEK_SET); + uwrite(fd_map, old_shstr_sh_offset + (void *)ehdr, old_shstr_sh_size); + uwrite(fd_map, mc_name, 1 + strlen(mc_name)); + + /* old(modified) Elf32_Shdr table, 4-byte aligned */ + ulseek(fd_map, t, SEEK_SET); + t += sizeof(Elf32_Shdr) * old_shnum; + uwrite(fd_map, old_shoff + (void *)ehdr, + sizeof(Elf32_Shdr) * old_shnum); + + /* new sections __mcount_loc and .rel__mcount_loc */ + t += 2*sizeof(mcsec); + mcsec.sh_name = w((sizeof(Elf32_Rela) == rel_entsize) + strlen(".rel") + + old_shstr_sh_size); + mcsec.sh_type = w(SHT_PROGBITS); + mcsec.sh_flags = w(SHF_ALLOC); + mcsec.sh_addr = 0; + mcsec.sh_offset = w(t); + mcsec.sh_size = w((void *)mlocp - (void *)mloc0); + mcsec.sh_link = 0; + mcsec.sh_info = 0; + mcsec.sh_addralign = w(4); + mcsec.sh_entsize = w(4); + uwrite(fd_map, &mcsec, sizeof(mcsec)); + + mcsec.sh_name = w(old_shstr_sh_size); + mcsec.sh_type = (sizeof(Elf32_Rela) == rel_entsize) + ? w(SHT_RELA) + : w(SHT_REL); + mcsec.sh_flags = 0; + mcsec.sh_addr = 0; + mcsec.sh_offset = w((void *)mlocp - (void *)mloc0 + t); + mcsec.sh_size = w((void *)mrelp - (void *)mrel0); + mcsec.sh_link = w(symsec_sh_link); + mcsec.sh_info = w(old_shnum); + mcsec.sh_addralign = w(4); + mcsec.sh_entsize = w(rel_entsize); + uwrite(fd_map, &mcsec, sizeof(mcsec)); + + uwrite(fd_map, mloc0, (void *)mlocp - (void *)mloc0); + uwrite(fd_map, mrel0, (void *)mrelp - (void *)mrel0); + + ehdr->e_shoff = w(new_e_shoff); + ehdr->e_shnum = w2(2 + w2(ehdr->e_shnum)); /* {.rel,}__mcount_loc */ + ulseek(fd_map, 0, SEEK_SET); + uwrite(fd_map, ehdr, sizeof(*ehdr)); +} + +/* + * append64 and append32 (and other analogous pairs) could be templated + * using C++, but the complexity is high. (For an example, look at p_elf.h + * in the source for UPX, http://upx.sourceforge.net) So: remember to make + * the corresponding change in the routine for the other size. + */ +static void append64(Elf64_Ehdr *const ehdr, + Elf64_Shdr *const shstr, + uint64_t const *const mloc0, + uint64_t const *const mlocp, + Elf64_Rel const *const mrel0, + Elf64_Rel const *const mrelp, + unsigned int const rel_entsize, + unsigned int const symsec_sh_link) +{ + /* Begin constructing output file */ + Elf64_Shdr mcsec; + char const *mc_name = (sizeof(Elf64_Rela) == rel_entsize) + ? ".rela__mcount_loc" + : ".rel__mcount_loc"; + unsigned const old_shnum = w2(ehdr->e_shnum); + uint64_t const old_shoff = w8(ehdr->e_shoff); + uint64_t const old_shstr_sh_size = w8(shstr->sh_size); + uint64_t const old_shstr_sh_offset = w8(shstr->sh_offset); + uint64_t t = 1 + strlen(mc_name) + w8(shstr->sh_size); + uint64_t new_e_shoff; + + shstr->sh_size = w8(t); + shstr->sh_offset = w8(sb.st_size); + t += sb.st_size; + t += (7u & -t); /* 8-byte align */ + new_e_shoff = t; + + /* body for new shstrtab */ + ulseek(fd_map, sb.st_size, SEEK_SET); + uwrite(fd_map, old_shstr_sh_offset + (void *)ehdr, old_shstr_sh_size); + uwrite(fd_map, mc_name, 1 + strlen(mc_name)); + + /* old(modified) Elf64_Shdr table, 8-byte aligned */ + ulseek(fd_map, t, SEEK_SET); + t += sizeof(Elf64_Shdr) * old_shnum; + uwrite(fd_map, old_shoff + (void *)ehdr, + sizeof(Elf64_Shdr) * old_shnum); + + /* new sections __mcount_loc and .rel__mcount_loc */ + t += 2*sizeof(mcsec); + mcsec.sh_name = w((sizeof(Elf64_Rela) == rel_entsize) + strlen(".rel") + + old_shstr_sh_size); + mcsec.sh_type = w(SHT_PROGBITS); + mcsec.sh_flags = w8(SHF_ALLOC); + mcsec.sh_addr = 0; + mcsec.sh_offset = w8(t); + mcsec.sh_size = w8((void *)mlocp - (void *)mloc0); + mcsec.sh_link = 0; + mcsec.sh_info = 0; + mcsec.sh_addralign = w8(8); + mcsec.sh_entsize = w8(8); + uwrite(fd_map, &mcsec, sizeof(mcsec)); + + mcsec.sh_name = w(old_shstr_sh_size); + mcsec.sh_type = (sizeof(Elf64_Rela) == rel_entsize) + ? w(SHT_RELA) + : w(SHT_REL); + mcsec.sh_flags = 0; + mcsec.sh_addr = 0; + mcsec.sh_offset = w8((void *)mlocp - (void *)mloc0 + t); + mcsec.sh_size = w8((void *)mrelp - (void *)mrel0); + mcsec.sh_link = w(symsec_sh_link); + mcsec.sh_info = w(old_shnum); + mcsec.sh_addralign = w8(8); + mcsec.sh_entsize = w8(rel_entsize); + uwrite(fd_map, &mcsec, sizeof(mcsec)); + + uwrite(fd_map, mloc0, (void *)mlocp - (void *)mloc0); + uwrite(fd_map, mrel0, (void *)mrelp - (void *)mrel0); + + ehdr->e_shoff = w8(new_e_shoff); + ehdr->e_shnum = w2(2 + w2(ehdr->e_shnum)); /* {.rel,}__mcount_loc */ + ulseek(fd_map, 0, SEEK_SET); + uwrite(fd_map, ehdr, sizeof(*ehdr)); +} + +/* + * Look at the relocations in order to find the calls to mcount. + * Accumulate the section offsets that are found, and their relocation info, + * onto the end of the existing arrays. + */ +static uint32_t *sift32_rel_mcount(uint32_t *mlocp, + unsigned const offbase, + Elf32_Rel **const mrelpp, + Elf32_Shdr const *const relhdr, + Elf32_Ehdr const *const ehdr, + unsigned const recsym, + uint32_t const recval, + unsigned const reltype) +{ + uint32_t *const mloc0 = mlocp; + Elf32_Rel *mrelp = *mrelpp; + Elf32_Shdr *const shdr0 = (Elf32_Shdr *)(w(ehdr->e_shoff) + + (void *)ehdr); + unsigned const symsec_sh_link = w(relhdr->sh_link); + Elf32_Shdr const *const symsec = &shdr0[symsec_sh_link]; + Elf32_Sym const *const sym0 = (Elf32_Sym const *)(w(symsec->sh_offset) + + (void *)ehdr); + + Elf32_Shdr const *const strsec = &shdr0[w(symsec->sh_link)]; + char const *const str0 = (char const *)(w(strsec->sh_offset) + + (void *)ehdr); + + Elf32_Rel const *const rel0 = (Elf32_Rel const *)(w(relhdr->sh_offset) + + (void *)ehdr); + unsigned rel_entsize = w(relhdr->sh_entsize); + unsigned const nrel = w(relhdr->sh_size) / rel_entsize; + Elf32_Rel const *relp = rel0; + + unsigned mcountsym = 0; + unsigned t; + + for (t = nrel; t; --t) { + if (!mcountsym) { + Elf32_Sym const *const symp = + &sym0[ELF32_R_SYM(w(relp->r_info))]; + + if (0 == strcmp((('_' == gpfx) ? "_mcount" : "mcount"), + &str0[w(symp->st_name)])) + mcountsym = ELF32_R_SYM(w(relp->r_info)); + } + if (mcountsym == ELF32_R_SYM(w(relp->r_info))) { + uint32_t const addend = w(w(relp->r_offset) - recval); + mrelp->r_offset = w(offbase + + ((void *)mlocp - (void *)mloc0)); + mrelp->r_info = w(ELF32_R_INFO(recsym, reltype)); + if (sizeof(Elf32_Rela) == rel_entsize) { + ((Elf32_Rela *)mrelp)->r_addend = addend; + *mlocp++ = 0; + } else + *mlocp++ = addend; + + mrelp = (Elf32_Rel *)(rel_entsize + (void *)mrelp); + } + relp = (Elf32_Rel const *)(rel_entsize + (void *)relp); + } + *mrelpp = mrelp; + return mlocp; +} + +static uint64_t *sift64_rel_mcount(uint64_t *mlocp, + unsigned const offbase, + Elf64_Rel **const mrelpp, + Elf64_Shdr const *const relhdr, + Elf64_Ehdr const *const ehdr, + unsigned const recsym, + uint64_t const recval, + unsigned const reltype) +{ + uint64_t *const mloc0 = mlocp; + Elf64_Rel *mrelp = *mrelpp; + Elf64_Shdr *const shdr0 = (Elf64_Shdr *)(w8(ehdr->e_shoff) + + (void *)ehdr); + unsigned const symsec_sh_link = w(relhdr->sh_link); + Elf64_Shdr const *const symsec = &shdr0[symsec_sh_link]; + Elf64_Sym const *const sym0 = (Elf64_Sym const *)(w8(symsec->sh_offset) + + (void *)ehdr); + + Elf64_Shdr const *const strsec = &shdr0[w(symsec->sh_link)]; + char const *const str0 = (char const *)(w8(strsec->sh_offset) + + (void *)ehdr); + + Elf64_Rel const *const rel0 = (Elf64_Rel const *)(w8(relhdr->sh_offset) + + (void *)ehdr); + unsigned rel_entsize = w8(relhdr->sh_entsize); + unsigned const nrel = w8(relhdr->sh_size) / rel_entsize; + Elf64_Rel const *relp = rel0; + + unsigned mcountsym = 0; + unsigned t; + + for (t = nrel; 0 != t; --t) { + if (!mcountsym) { + Elf64_Sym const *const symp = + &sym0[ELF64_R_SYM(w8(relp->r_info))]; + char const *symname = &str0[w(symp->st_name)]; + + if ('.' == symname[0]) + ++symname; /* ppc64 hack */ + if (0 == strcmp((('_' == gpfx) ? "_mcount" : "mcount"), + symname)) + mcountsym = ELF64_R_SYM(w8(relp->r_info)); + } + + if (mcountsym == ELF64_R_SYM(w8(relp->r_info))) { + uint64_t const addend = w8(w8(relp->r_offset) - recval); + + mrelp->r_offset = w8(offbase + + ((void *)mlocp - (void *)mloc0)); + mrelp->r_info = w8(ELF64_R_INFO(recsym, reltype)); + if (sizeof(Elf64_Rela) == rel_entsize) { + ((Elf64_Rela *)mrelp)->r_addend = addend; + *mlocp++ = 0; + } else + *mlocp++ = addend; + + mrelp = (Elf64_Rel *)(rel_entsize + (void *)mrelp); + } + relp = (Elf64_Rel const *)(rel_entsize + (void *)relp); + } + *mrelpp = mrelp; + + return mlocp; +} + +/* + * Find a symbol in the given section, to be used as the base for relocating + * the table of offsets of calls to mcount. A local or global symbol suffices, + * but avoid a Weak symbol because it may be overridden; the change in value + * would invalidate the relocations of the offsets of the calls to mcount. + * Often the found symbol will be the unnamed local symbol generated by + * GNU 'as' for the start of each section. For example: + * Num: Value Size Type Bind Vis Ndx Name + * 2: 00000000 0 SECTION LOCAL DEFAULT 1 + */ +static unsigned find32_secsym_ndx(unsigned const txtndx, + char const *const txtname, + uint32_t *const recvalp, + Elf32_Shdr const *const symhdr, + Elf32_Ehdr const *const ehdr) +{ + Elf32_Sym const *const sym0 = (Elf32_Sym const *)(w(symhdr->sh_offset) + + (void *)ehdr); + unsigned const nsym = w(symhdr->sh_size) / w(symhdr->sh_entsize); + Elf32_Sym const *symp; + unsigned t; + + for (symp = sym0, t = nsym; t; --t, ++symp) { + unsigned int const st_bind = ELF32_ST_BIND(symp->st_info); + + if (txtndx == w2(symp->st_shndx) + /* avoid STB_WEAK */ + && (STB_LOCAL == st_bind || STB_GLOBAL == st_bind)) { + *recvalp = w(symp->st_value); + return symp - sym0; + } + } + fprintf(stderr, "Cannot find symbol for section %d: %s.\n", + txtndx, txtname); + fail_file(); +} + +static unsigned find64_secsym_ndx(unsigned const txtndx, + char const *const txtname, + uint64_t *const recvalp, + Elf64_Shdr const *const symhdr, + Elf64_Ehdr const *const ehdr) +{ + Elf64_Sym const *const sym0 = (Elf64_Sym const *)(w8(symhdr->sh_offset) + + (void *)ehdr); + unsigned const nsym = w8(symhdr->sh_size) / w8(symhdr->sh_entsize); + Elf64_Sym const *symp; + unsigned t; + + for (symp = sym0, t = nsym; t; --t, ++symp) { + unsigned int const st_bind = ELF64_ST_BIND(symp->st_info); + + if (txtndx == w2(symp->st_shndx) + /* avoid STB_WEAK */ + && (STB_LOCAL == st_bind || STB_GLOBAL == st_bind)) { + *recvalp = w8(symp->st_value); + return symp - sym0; + } + } + fprintf(stderr, "Cannot find symbol for section %d: %s.\n", + txtndx, txtname); + fail_file(); +} + +/* + * Evade ISO C restriction: no declaration after statement in + * has32_rel_mcount. + */ +static char const * +__has32_rel_mcount(Elf32_Shdr const *const relhdr, /* is SHT_REL or SHT_RELA */ + Elf32_Shdr const *const shdr0, + char const *const shstrtab, + char const *const fname) +{ + /* .sh_info depends on .sh_type == SHT_REL[,A] */ + Elf32_Shdr const *const txthdr = &shdr0[w(relhdr->sh_info)]; + char const *const txtname = &shstrtab[w(txthdr->sh_name)]; + + if (0 == strcmp("__mcount_loc", txtname)) { + fprintf(stderr, "warning: __mcount_loc already exists: %s\n", + fname); + succeed_file(); + } + if (SHT_PROGBITS != w(txthdr->sh_type) || + !is_mcounted_section_name(txtname)) + return NULL; + return txtname; +} + +static char const *has32_rel_mcount(Elf32_Shdr const *const relhdr, + Elf32_Shdr const *const shdr0, + char const *const shstrtab, + char const *const fname) +{ + if (SHT_REL != w(relhdr->sh_type) && SHT_RELA != w(relhdr->sh_type)) + return NULL; + return __has32_rel_mcount(relhdr, shdr0, shstrtab, fname); +} + +static char const *__has64_rel_mcount(Elf64_Shdr const *const relhdr, + Elf64_Shdr const *const shdr0, + char const *const shstrtab, + char const *const fname) +{ + /* .sh_info depends on .sh_type == SHT_REL[,A] */ + Elf64_Shdr const *const txthdr = &shdr0[w(relhdr->sh_info)]; + char const *const txtname = &shstrtab[w(txthdr->sh_name)]; + + if (0 == strcmp("__mcount_loc", txtname)) { + fprintf(stderr, "warning: __mcount_loc already exists: %s\n", + fname); + succeed_file(); + } + if (SHT_PROGBITS != w(txthdr->sh_type) || + !is_mcounted_section_name(txtname)) + return NULL; + return txtname; +} + +static char const *has64_rel_mcount(Elf64_Shdr const *const relhdr, + Elf64_Shdr const *const shdr0, + char const *const shstrtab, + char const *const fname) +{ + if (SHT_REL != w(relhdr->sh_type) && SHT_RELA != w(relhdr->sh_type)) + return NULL; + return __has64_rel_mcount(relhdr, shdr0, shstrtab, fname); +} + +static unsigned tot32_relsize(Elf32_Shdr const *const shdr0, + unsigned nhdr, + const char *const shstrtab, + const char *const fname) +{ + unsigned totrelsz = 0; + Elf32_Shdr const *shdrp = shdr0; + for (; 0 != nhdr; --nhdr, ++shdrp) { + if (has32_rel_mcount(shdrp, shdr0, shstrtab, fname)) + totrelsz += w(shdrp->sh_size); + } + return totrelsz; +} + +static unsigned tot64_relsize(Elf64_Shdr const *const shdr0, + unsigned nhdr, + const char *const shstrtab, + const char *const fname) +{ + unsigned totrelsz = 0; + Elf64_Shdr const *shdrp = shdr0; + + for (; nhdr; --nhdr, ++shdrp) { + if (has64_rel_mcount(shdrp, shdr0, shstrtab, fname)) + totrelsz += w8(shdrp->sh_size); + } + return totrelsz; +} + +/* Overall supervision for Elf32 ET_REL file. */ +static void +do32(Elf32_Ehdr *const ehdr, char const *const fname, unsigned const reltype) +{ + Elf32_Shdr *const shdr0 = (Elf32_Shdr *)(w(ehdr->e_shoff) + + (void *)ehdr); + unsigned const nhdr = w2(ehdr->e_shnum); + Elf32_Shdr *const shstr = &shdr0[w2(ehdr->e_shstrndx)]; + char const *const shstrtab = (char const *)(w(shstr->sh_offset) + + (void *)ehdr); + + Elf32_Shdr const *relhdr; + unsigned k; + + /* Upper bound on space: assume all relevant relocs are for mcount. */ + unsigned const totrelsz = tot32_relsize(shdr0, nhdr, shstrtab, fname); + Elf32_Rel *const mrel0 = umalloc(totrelsz); + Elf32_Rel * mrelp = mrel0; + + /* 2*sizeof(address) <= sizeof(Elf32_Rel) */ + uint32_t *const mloc0 = umalloc(totrelsz>>1); + uint32_t * mlocp = mloc0; + + unsigned rel_entsize = 0; + unsigned symsec_sh_link = 0; + + for (relhdr = shdr0, k = nhdr; k; --k, ++relhdr) { + char const *const txtname = has32_rel_mcount(relhdr, shdr0, + shstrtab, fname); + if (txtname) { + uint32_t recval = 0; + unsigned const recsym = find32_secsym_ndx( + w(relhdr->sh_info), txtname, &recval, + &shdr0[symsec_sh_link = w(relhdr->sh_link)], + ehdr); + + rel_entsize = w(relhdr->sh_entsize); + mlocp = sift32_rel_mcount(mlocp, + (void *)mlocp - (void *)mloc0, &mrelp, + relhdr, ehdr, recsym, recval, reltype); + } + } + if (mloc0 != mlocp) { + append32(ehdr, shstr, mloc0, mlocp, mrel0, mrelp, + rel_entsize, symsec_sh_link); + } + free(mrel0); + free(mloc0); +} + +static void +do64(Elf64_Ehdr *const ehdr, char const *const fname, unsigned const reltype) +{ + Elf64_Shdr *const shdr0 = (Elf64_Shdr *)(w8(ehdr->e_shoff) + + (void *)ehdr); + unsigned const nhdr = w2(ehdr->e_shnum); + Elf64_Shdr *const shstr = &shdr0[w2(ehdr->e_shstrndx)]; + char const *const shstrtab = (char const *)(w8(shstr->sh_offset) + + (void *)ehdr); + + Elf64_Shdr const *relhdr; + unsigned k; + + /* Upper bound on space: assume all relevant relocs are for mcount. */ + unsigned const totrelsz = tot64_relsize(shdr0, nhdr, shstrtab, fname); + Elf64_Rel *const mrel0 = umalloc(totrelsz); + Elf64_Rel * mrelp = mrel0; + + /* 2*sizeof(address) <= sizeof(Elf64_Rel) */ + uint64_t *const mloc0 = umalloc(totrelsz>>1); + uint64_t * mlocp = mloc0; + + unsigned rel_entsize = 0; + unsigned symsec_sh_link = 0; + + for ((relhdr = shdr0), k = nhdr; k; --k, ++relhdr) { + char const *const txtname = has64_rel_mcount(relhdr, shdr0, + shstrtab, fname); + if (txtname) { + uint64_t recval = 0; + unsigned const recsym = find64_secsym_ndx( + w(relhdr->sh_info), txtname, &recval, + &shdr0[symsec_sh_link = w(relhdr->sh_link)], + ehdr); + + rel_entsize = w8(relhdr->sh_entsize); + mlocp = sift64_rel_mcount(mlocp, + (void *)mlocp - (void *)mloc0, &mrelp, + relhdr, ehdr, recsym, recval, reltype); + } + } + if (mloc0 != mlocp) { + append64(ehdr, shstr, mloc0, mlocp, mrel0, mrelp, + rel_entsize, symsec_sh_link); + } + free(mrel0); + free(mloc0); +} + +static void +do_file(char const *const fname) +{ + Elf32_Ehdr *const ehdr = mmap_file(fname); + unsigned int reltype = 0; + + ehdr_curr = ehdr; + w = w4nat; + w2 = w2nat; + w8 = w8nat; + switch (ehdr->e_ident[EI_DATA]) { + static unsigned int const endian = 1; + default: { + fprintf(stderr, "unrecognized ELF data encoding %d: %s\n", + ehdr->e_ident[EI_DATA], fname); + fail_file(); + } break; + case ELFDATA2LSB: { + if (1 != *(unsigned char const *)&endian) { + /* main() is big endian, file.o is little endian. */ + w = w4rev; + w2 = w2rev; + w8 = w8rev; + } + } break; + case ELFDATA2MSB: { + if (0 != *(unsigned char const *)&endian) { + /* main() is little endian, file.o is big endian. */ + w = w4rev; + w2 = w2rev; + w8 = w8rev; + } + } break; + } /* end switch */ + if (0 != memcmp(ELFMAG, ehdr->e_ident, SELFMAG) + || ET_REL != w2(ehdr->e_type) + || EV_CURRENT != ehdr->e_ident[EI_VERSION]) { + fprintf(stderr, "unrecognized ET_REL file %s\n", fname); + fail_file(); + } + + gpfx = 0; + switch (w2(ehdr->e_machine)) { + default: { + fprintf(stderr, "unrecognized e_machine %d %s\n", + w2(ehdr->e_machine), fname); + fail_file(); + } break; + case EM_386: reltype = R_386_32; break; + case EM_ARM: reltype = R_ARM_ABS32; break; + case EM_IA_64: reltype = R_IA64_IMM64; gpfx = '_'; break; + case EM_PPC: reltype = R_PPC_ADDR32; gpfx = '_'; break; + case EM_PPC64: reltype = R_PPC64_ADDR64; gpfx = '_'; break; + case EM_S390: /* reltype: e_class */ gpfx = '_'; break; + case EM_SH: reltype = R_SH_DIR32; break; + case EM_SPARCV9: reltype = R_SPARC_64; gpfx = '_'; break; + case EM_X86_64: reltype = R_X86_64_64; break; + } /* end switch */ + + switch (ehdr->e_ident[EI_CLASS]) { + default: { + fprintf(stderr, "unrecognized ELF class %d %s\n", + ehdr->e_ident[EI_CLASS], fname); + fail_file(); + } break; + case ELFCLASS32: { + if (sizeof(Elf32_Ehdr) != w2(ehdr->e_ehsize) + || sizeof(Elf32_Shdr) != w2(ehdr->e_shentsize)) { + fprintf(stderr, + "unrecognized ET_REL file: %s\n", fname); + fail_file(); + } + if (EM_S390 == w2(ehdr->e_machine)) + reltype = R_390_32; + do32(ehdr, fname, reltype); + } break; + case ELFCLASS64: { + Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr; + if (sizeof(Elf64_Ehdr) != w2(ghdr->e_ehsize) + || sizeof(Elf64_Shdr) != w2(ghdr->e_shentsize)) { + fprintf(stderr, + "unrecognized ET_REL file: %s\n", fname); + fail_file(); + } + if (EM_S390 == w2(ghdr->e_machine)) + reltype = R_390_64; + do64(ghdr, fname, reltype); + } break; + } /* end switch */ + + cleanup(); +} + +int +main(int argc, char const *argv[]) +{ + int n_error = 0; /* gcc-4.3.0 false positive complaint */ + if (argc <= 1) + fprintf(stderr, "usage: recordmcount file.o...\n"); + else /* Process each file in turn, allowing deep failure. */ + for (--argc, ++argv; 0 < argc; --argc, ++argv) { + int const sjval = setjmp(jmpenv); + switch (sjval) { + default: { + fprintf(stderr, "internal error: %s\n", argv[0]); + exit(1); + } break; + case SJ_SETJMP: { /* normal sequence */ + /* Avoid problems if early cleanup() */ + fd_map = -1; + ehdr_curr = NULL; + mmap_failed = 1; + do_file(argv[0]); + } break; + case SJ_FAIL: { /* error in do_file or below */ + ++n_error; + } break; + case SJ_SUCCEED: { /* premature success */ + /* do nothing */ + } break; + } /* end switch */ + } + return !!n_error; +} + + -- cgit v1.1 From 72441cb1fd77d092f09ddfac748955703884c9a7 Mon Sep 17 00:00:00 2001 From: Steven Rostedt Date: Wed, 13 Oct 2010 17:12:30 -0400 Subject: ftrace/x86: Add support for C version of recordmcount This patch adds the support for the C version of recordmcount and compile times show ~ 12% improvement. After verifying this works, other archs can add: HAVE_C_MCOUNT_RECORD in its Kconfig and it will use the C version of recordmcount instead of the perl version. Cc: Cc: Michal Marek Cc: linux-kbuild@vger.kernel.org Cc: John Reiser Signed-off-by: Steven Rostedt --- scripts/Makefile | 1 + scripts/Makefile.build | 4 ++++ 2 files changed, 5 insertions(+) (limited to 'scripts') diff --git a/scripts/Makefile b/scripts/Makefile index 842dbc2..2e08810 100644 --- a/scripts/Makefile +++ b/scripts/Makefile @@ -11,6 +11,7 @@ hostprogs-$(CONFIG_KALLSYMS) += kallsyms hostprogs-$(CONFIG_LOGO) += pnmtologo hostprogs-$(CONFIG_VT) += conmakehash hostprogs-$(CONFIG_IKCONFIG) += bin2c +hostprogs-$(BUILD_C_RECORDMCOUNT) += recordmcount always := $(hostprogs-y) $(hostprogs-m) diff --git a/scripts/Makefile.build b/scripts/Makefile.build index a1a5cf9..4d03a7ef 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -209,12 +209,16 @@ cmd_modversions = \ endif ifdef CONFIG_FTRACE_MCOUNT_RECORD +ifdef BUILD_C_RECORDMCOUNT +cmd_record_mcount = $(srctree)/scripts/recordmcount "$(@)"; +else cmd_record_mcount = set -e ; perl $(srctree)/scripts/recordmcount.pl "$(ARCH)" \ "$(if $(CONFIG_CPU_BIG_ENDIAN),big,little)" \ "$(if $(CONFIG_64BIT),64,32)" \ "$(OBJDUMP)" "$(OBJCOPY)" "$(CC)" "$(LD)" "$(NM)" "$(RM)" "$(MV)" \ "$(if $(part-of-module),1,0)" "$(@)"; endif +endif define rule_cc_o_c $(call echo-cmd,checksrc) $(cmd_checksrc) \ -- cgit v1.1 From c28d5077f8d79bfce1e3f88db2e261cf2b6473dc Mon Sep 17 00:00:00 2001 From: Steven Rostedt Date: Wed, 13 Oct 2010 19:06:14 -0400 Subject: ftrace: Remove duplicate code for 64 and 32 bit in recordmcount.c The elf reader for recordmcount.c had duplicate functions for both 32 bit and 64 bit elf handling. This was due to the need of using the 32 and 64 bit elf structures. This patch consolidates the two by using macros to define the 32 and 64 bit names in a recordmcount.h file, and then by just defining a RECORD_MCOUNT_64 macro and including recordmcount.h twice we create the funtions for both the 32 bit version as well as the 64 bit version using one code source. Cc: John Reiser Signed-off-by: Steven Rostedt --- scripts/recordmcount.c | 548 +------------------------------------------------ scripts/recordmcount.h | 366 +++++++++++++++++++++++++++++++++ 2 files changed, 370 insertions(+), 544 deletions(-) create mode 100644 scripts/recordmcount.h (limited to 'scripts') diff --git a/scripts/recordmcount.c b/scripts/recordmcount.c index 34f32be..7f7f718 100644 --- a/scripts/recordmcount.c +++ b/scripts/recordmcount.c @@ -212,550 +212,10 @@ is_mcounted_section_name(char const *const txtname) 0 == strcmp(".text.unlikely", txtname); } -/* Append the new shstrtab, Elf32_Shdr[], __mcount_loc and its relocations. */ -static void append32(Elf32_Ehdr *const ehdr, - Elf32_Shdr *const shstr, - uint32_t const *const mloc0, - uint32_t const *const mlocp, - Elf32_Rel const *const mrel0, - Elf32_Rel const *const mrelp, - unsigned int const rel_entsize, - unsigned int const symsec_sh_link) -{ - /* Begin constructing output file */ - Elf32_Shdr mcsec; - char const *mc_name = (sizeof(Elf32_Rela) == rel_entsize) - ? ".rela__mcount_loc" - : ".rel__mcount_loc"; - unsigned const old_shnum = w2(ehdr->e_shnum); - uint32_t const old_shoff = w(ehdr->e_shoff); - uint32_t const old_shstr_sh_size = w(shstr->sh_size); - uint32_t const old_shstr_sh_offset = w(shstr->sh_offset); - uint32_t t = 1 + strlen(mc_name) + w(shstr->sh_size); - uint32_t new_e_shoff; - - shstr->sh_size = w(t); - shstr->sh_offset = w(sb.st_size); - t += sb.st_size; - t += (3u & -t); /* 4-byte align */ - new_e_shoff = t; - - /* body for new shstrtab */ - ulseek(fd_map, sb.st_size, SEEK_SET); - uwrite(fd_map, old_shstr_sh_offset + (void *)ehdr, old_shstr_sh_size); - uwrite(fd_map, mc_name, 1 + strlen(mc_name)); - - /* old(modified) Elf32_Shdr table, 4-byte aligned */ - ulseek(fd_map, t, SEEK_SET); - t += sizeof(Elf32_Shdr) * old_shnum; - uwrite(fd_map, old_shoff + (void *)ehdr, - sizeof(Elf32_Shdr) * old_shnum); - - /* new sections __mcount_loc and .rel__mcount_loc */ - t += 2*sizeof(mcsec); - mcsec.sh_name = w((sizeof(Elf32_Rela) == rel_entsize) + strlen(".rel") - + old_shstr_sh_size); - mcsec.sh_type = w(SHT_PROGBITS); - mcsec.sh_flags = w(SHF_ALLOC); - mcsec.sh_addr = 0; - mcsec.sh_offset = w(t); - mcsec.sh_size = w((void *)mlocp - (void *)mloc0); - mcsec.sh_link = 0; - mcsec.sh_info = 0; - mcsec.sh_addralign = w(4); - mcsec.sh_entsize = w(4); - uwrite(fd_map, &mcsec, sizeof(mcsec)); - - mcsec.sh_name = w(old_shstr_sh_size); - mcsec.sh_type = (sizeof(Elf32_Rela) == rel_entsize) - ? w(SHT_RELA) - : w(SHT_REL); - mcsec.sh_flags = 0; - mcsec.sh_addr = 0; - mcsec.sh_offset = w((void *)mlocp - (void *)mloc0 + t); - mcsec.sh_size = w((void *)mrelp - (void *)mrel0); - mcsec.sh_link = w(symsec_sh_link); - mcsec.sh_info = w(old_shnum); - mcsec.sh_addralign = w(4); - mcsec.sh_entsize = w(rel_entsize); - uwrite(fd_map, &mcsec, sizeof(mcsec)); - - uwrite(fd_map, mloc0, (void *)mlocp - (void *)mloc0); - uwrite(fd_map, mrel0, (void *)mrelp - (void *)mrel0); - - ehdr->e_shoff = w(new_e_shoff); - ehdr->e_shnum = w2(2 + w2(ehdr->e_shnum)); /* {.rel,}__mcount_loc */ - ulseek(fd_map, 0, SEEK_SET); - uwrite(fd_map, ehdr, sizeof(*ehdr)); -} - -/* - * append64 and append32 (and other analogous pairs) could be templated - * using C++, but the complexity is high. (For an example, look at p_elf.h - * in the source for UPX, http://upx.sourceforge.net) So: remember to make - * the corresponding change in the routine for the other size. - */ -static void append64(Elf64_Ehdr *const ehdr, - Elf64_Shdr *const shstr, - uint64_t const *const mloc0, - uint64_t const *const mlocp, - Elf64_Rel const *const mrel0, - Elf64_Rel const *const mrelp, - unsigned int const rel_entsize, - unsigned int const symsec_sh_link) -{ - /* Begin constructing output file */ - Elf64_Shdr mcsec; - char const *mc_name = (sizeof(Elf64_Rela) == rel_entsize) - ? ".rela__mcount_loc" - : ".rel__mcount_loc"; - unsigned const old_shnum = w2(ehdr->e_shnum); - uint64_t const old_shoff = w8(ehdr->e_shoff); - uint64_t const old_shstr_sh_size = w8(shstr->sh_size); - uint64_t const old_shstr_sh_offset = w8(shstr->sh_offset); - uint64_t t = 1 + strlen(mc_name) + w8(shstr->sh_size); - uint64_t new_e_shoff; - - shstr->sh_size = w8(t); - shstr->sh_offset = w8(sb.st_size); - t += sb.st_size; - t += (7u & -t); /* 8-byte align */ - new_e_shoff = t; - - /* body for new shstrtab */ - ulseek(fd_map, sb.st_size, SEEK_SET); - uwrite(fd_map, old_shstr_sh_offset + (void *)ehdr, old_shstr_sh_size); - uwrite(fd_map, mc_name, 1 + strlen(mc_name)); - - /* old(modified) Elf64_Shdr table, 8-byte aligned */ - ulseek(fd_map, t, SEEK_SET); - t += sizeof(Elf64_Shdr) * old_shnum; - uwrite(fd_map, old_shoff + (void *)ehdr, - sizeof(Elf64_Shdr) * old_shnum); - - /* new sections __mcount_loc and .rel__mcount_loc */ - t += 2*sizeof(mcsec); - mcsec.sh_name = w((sizeof(Elf64_Rela) == rel_entsize) + strlen(".rel") - + old_shstr_sh_size); - mcsec.sh_type = w(SHT_PROGBITS); - mcsec.sh_flags = w8(SHF_ALLOC); - mcsec.sh_addr = 0; - mcsec.sh_offset = w8(t); - mcsec.sh_size = w8((void *)mlocp - (void *)mloc0); - mcsec.sh_link = 0; - mcsec.sh_info = 0; - mcsec.sh_addralign = w8(8); - mcsec.sh_entsize = w8(8); - uwrite(fd_map, &mcsec, sizeof(mcsec)); - - mcsec.sh_name = w(old_shstr_sh_size); - mcsec.sh_type = (sizeof(Elf64_Rela) == rel_entsize) - ? w(SHT_RELA) - : w(SHT_REL); - mcsec.sh_flags = 0; - mcsec.sh_addr = 0; - mcsec.sh_offset = w8((void *)mlocp - (void *)mloc0 + t); - mcsec.sh_size = w8((void *)mrelp - (void *)mrel0); - mcsec.sh_link = w(symsec_sh_link); - mcsec.sh_info = w(old_shnum); - mcsec.sh_addralign = w8(8); - mcsec.sh_entsize = w8(rel_entsize); - uwrite(fd_map, &mcsec, sizeof(mcsec)); - - uwrite(fd_map, mloc0, (void *)mlocp - (void *)mloc0); - uwrite(fd_map, mrel0, (void *)mrelp - (void *)mrel0); - - ehdr->e_shoff = w8(new_e_shoff); - ehdr->e_shnum = w2(2 + w2(ehdr->e_shnum)); /* {.rel,}__mcount_loc */ - ulseek(fd_map, 0, SEEK_SET); - uwrite(fd_map, ehdr, sizeof(*ehdr)); -} - -/* - * Look at the relocations in order to find the calls to mcount. - * Accumulate the section offsets that are found, and their relocation info, - * onto the end of the existing arrays. - */ -static uint32_t *sift32_rel_mcount(uint32_t *mlocp, - unsigned const offbase, - Elf32_Rel **const mrelpp, - Elf32_Shdr const *const relhdr, - Elf32_Ehdr const *const ehdr, - unsigned const recsym, - uint32_t const recval, - unsigned const reltype) -{ - uint32_t *const mloc0 = mlocp; - Elf32_Rel *mrelp = *mrelpp; - Elf32_Shdr *const shdr0 = (Elf32_Shdr *)(w(ehdr->e_shoff) - + (void *)ehdr); - unsigned const symsec_sh_link = w(relhdr->sh_link); - Elf32_Shdr const *const symsec = &shdr0[symsec_sh_link]; - Elf32_Sym const *const sym0 = (Elf32_Sym const *)(w(symsec->sh_offset) - + (void *)ehdr); - - Elf32_Shdr const *const strsec = &shdr0[w(symsec->sh_link)]; - char const *const str0 = (char const *)(w(strsec->sh_offset) - + (void *)ehdr); - - Elf32_Rel const *const rel0 = (Elf32_Rel const *)(w(relhdr->sh_offset) - + (void *)ehdr); - unsigned rel_entsize = w(relhdr->sh_entsize); - unsigned const nrel = w(relhdr->sh_size) / rel_entsize; - Elf32_Rel const *relp = rel0; - - unsigned mcountsym = 0; - unsigned t; - - for (t = nrel; t; --t) { - if (!mcountsym) { - Elf32_Sym const *const symp = - &sym0[ELF32_R_SYM(w(relp->r_info))]; - - if (0 == strcmp((('_' == gpfx) ? "_mcount" : "mcount"), - &str0[w(symp->st_name)])) - mcountsym = ELF32_R_SYM(w(relp->r_info)); - } - if (mcountsym == ELF32_R_SYM(w(relp->r_info))) { - uint32_t const addend = w(w(relp->r_offset) - recval); - mrelp->r_offset = w(offbase - + ((void *)mlocp - (void *)mloc0)); - mrelp->r_info = w(ELF32_R_INFO(recsym, reltype)); - if (sizeof(Elf32_Rela) == rel_entsize) { - ((Elf32_Rela *)mrelp)->r_addend = addend; - *mlocp++ = 0; - } else - *mlocp++ = addend; - - mrelp = (Elf32_Rel *)(rel_entsize + (void *)mrelp); - } - relp = (Elf32_Rel const *)(rel_entsize + (void *)relp); - } - *mrelpp = mrelp; - return mlocp; -} - -static uint64_t *sift64_rel_mcount(uint64_t *mlocp, - unsigned const offbase, - Elf64_Rel **const mrelpp, - Elf64_Shdr const *const relhdr, - Elf64_Ehdr const *const ehdr, - unsigned const recsym, - uint64_t const recval, - unsigned const reltype) -{ - uint64_t *const mloc0 = mlocp; - Elf64_Rel *mrelp = *mrelpp; - Elf64_Shdr *const shdr0 = (Elf64_Shdr *)(w8(ehdr->e_shoff) - + (void *)ehdr); - unsigned const symsec_sh_link = w(relhdr->sh_link); - Elf64_Shdr const *const symsec = &shdr0[symsec_sh_link]; - Elf64_Sym const *const sym0 = (Elf64_Sym const *)(w8(symsec->sh_offset) - + (void *)ehdr); - - Elf64_Shdr const *const strsec = &shdr0[w(symsec->sh_link)]; - char const *const str0 = (char const *)(w8(strsec->sh_offset) - + (void *)ehdr); - - Elf64_Rel const *const rel0 = (Elf64_Rel const *)(w8(relhdr->sh_offset) - + (void *)ehdr); - unsigned rel_entsize = w8(relhdr->sh_entsize); - unsigned const nrel = w8(relhdr->sh_size) / rel_entsize; - Elf64_Rel const *relp = rel0; - - unsigned mcountsym = 0; - unsigned t; - - for (t = nrel; 0 != t; --t) { - if (!mcountsym) { - Elf64_Sym const *const symp = - &sym0[ELF64_R_SYM(w8(relp->r_info))]; - char const *symname = &str0[w(symp->st_name)]; - - if ('.' == symname[0]) - ++symname; /* ppc64 hack */ - if (0 == strcmp((('_' == gpfx) ? "_mcount" : "mcount"), - symname)) - mcountsym = ELF64_R_SYM(w8(relp->r_info)); - } - - if (mcountsym == ELF64_R_SYM(w8(relp->r_info))) { - uint64_t const addend = w8(w8(relp->r_offset) - recval); - - mrelp->r_offset = w8(offbase - + ((void *)mlocp - (void *)mloc0)); - mrelp->r_info = w8(ELF64_R_INFO(recsym, reltype)); - if (sizeof(Elf64_Rela) == rel_entsize) { - ((Elf64_Rela *)mrelp)->r_addend = addend; - *mlocp++ = 0; - } else - *mlocp++ = addend; - - mrelp = (Elf64_Rel *)(rel_entsize + (void *)mrelp); - } - relp = (Elf64_Rel const *)(rel_entsize + (void *)relp); - } - *mrelpp = mrelp; - - return mlocp; -} - -/* - * Find a symbol in the given section, to be used as the base for relocating - * the table of offsets of calls to mcount. A local or global symbol suffices, - * but avoid a Weak symbol because it may be overridden; the change in value - * would invalidate the relocations of the offsets of the calls to mcount. - * Often the found symbol will be the unnamed local symbol generated by - * GNU 'as' for the start of each section. For example: - * Num: Value Size Type Bind Vis Ndx Name - * 2: 00000000 0 SECTION LOCAL DEFAULT 1 - */ -static unsigned find32_secsym_ndx(unsigned const txtndx, - char const *const txtname, - uint32_t *const recvalp, - Elf32_Shdr const *const symhdr, - Elf32_Ehdr const *const ehdr) -{ - Elf32_Sym const *const sym0 = (Elf32_Sym const *)(w(symhdr->sh_offset) - + (void *)ehdr); - unsigned const nsym = w(symhdr->sh_size) / w(symhdr->sh_entsize); - Elf32_Sym const *symp; - unsigned t; - - for (symp = sym0, t = nsym; t; --t, ++symp) { - unsigned int const st_bind = ELF32_ST_BIND(symp->st_info); - - if (txtndx == w2(symp->st_shndx) - /* avoid STB_WEAK */ - && (STB_LOCAL == st_bind || STB_GLOBAL == st_bind)) { - *recvalp = w(symp->st_value); - return symp - sym0; - } - } - fprintf(stderr, "Cannot find symbol for section %d: %s.\n", - txtndx, txtname); - fail_file(); -} - -static unsigned find64_secsym_ndx(unsigned const txtndx, - char const *const txtname, - uint64_t *const recvalp, - Elf64_Shdr const *const symhdr, - Elf64_Ehdr const *const ehdr) -{ - Elf64_Sym const *const sym0 = (Elf64_Sym const *)(w8(symhdr->sh_offset) - + (void *)ehdr); - unsigned const nsym = w8(symhdr->sh_size) / w8(symhdr->sh_entsize); - Elf64_Sym const *symp; - unsigned t; - - for (symp = sym0, t = nsym; t; --t, ++symp) { - unsigned int const st_bind = ELF64_ST_BIND(symp->st_info); - - if (txtndx == w2(symp->st_shndx) - /* avoid STB_WEAK */ - && (STB_LOCAL == st_bind || STB_GLOBAL == st_bind)) { - *recvalp = w8(symp->st_value); - return symp - sym0; - } - } - fprintf(stderr, "Cannot find symbol for section %d: %s.\n", - txtndx, txtname); - fail_file(); -} - -/* - * Evade ISO C restriction: no declaration after statement in - * has32_rel_mcount. - */ -static char const * -__has32_rel_mcount(Elf32_Shdr const *const relhdr, /* is SHT_REL or SHT_RELA */ - Elf32_Shdr const *const shdr0, - char const *const shstrtab, - char const *const fname) -{ - /* .sh_info depends on .sh_type == SHT_REL[,A] */ - Elf32_Shdr const *const txthdr = &shdr0[w(relhdr->sh_info)]; - char const *const txtname = &shstrtab[w(txthdr->sh_name)]; - - if (0 == strcmp("__mcount_loc", txtname)) { - fprintf(stderr, "warning: __mcount_loc already exists: %s\n", - fname); - succeed_file(); - } - if (SHT_PROGBITS != w(txthdr->sh_type) || - !is_mcounted_section_name(txtname)) - return NULL; - return txtname; -} - -static char const *has32_rel_mcount(Elf32_Shdr const *const relhdr, - Elf32_Shdr const *const shdr0, - char const *const shstrtab, - char const *const fname) -{ - if (SHT_REL != w(relhdr->sh_type) && SHT_RELA != w(relhdr->sh_type)) - return NULL; - return __has32_rel_mcount(relhdr, shdr0, shstrtab, fname); -} - -static char const *__has64_rel_mcount(Elf64_Shdr const *const relhdr, - Elf64_Shdr const *const shdr0, - char const *const shstrtab, - char const *const fname) -{ - /* .sh_info depends on .sh_type == SHT_REL[,A] */ - Elf64_Shdr const *const txthdr = &shdr0[w(relhdr->sh_info)]; - char const *const txtname = &shstrtab[w(txthdr->sh_name)]; - - if (0 == strcmp("__mcount_loc", txtname)) { - fprintf(stderr, "warning: __mcount_loc already exists: %s\n", - fname); - succeed_file(); - } - if (SHT_PROGBITS != w(txthdr->sh_type) || - !is_mcounted_section_name(txtname)) - return NULL; - return txtname; -} - -static char const *has64_rel_mcount(Elf64_Shdr const *const relhdr, - Elf64_Shdr const *const shdr0, - char const *const shstrtab, - char const *const fname) -{ - if (SHT_REL != w(relhdr->sh_type) && SHT_RELA != w(relhdr->sh_type)) - return NULL; - return __has64_rel_mcount(relhdr, shdr0, shstrtab, fname); -} - -static unsigned tot32_relsize(Elf32_Shdr const *const shdr0, - unsigned nhdr, - const char *const shstrtab, - const char *const fname) -{ - unsigned totrelsz = 0; - Elf32_Shdr const *shdrp = shdr0; - for (; 0 != nhdr; --nhdr, ++shdrp) { - if (has32_rel_mcount(shdrp, shdr0, shstrtab, fname)) - totrelsz += w(shdrp->sh_size); - } - return totrelsz; -} - -static unsigned tot64_relsize(Elf64_Shdr const *const shdr0, - unsigned nhdr, - const char *const shstrtab, - const char *const fname) -{ - unsigned totrelsz = 0; - Elf64_Shdr const *shdrp = shdr0; - - for (; nhdr; --nhdr, ++shdrp) { - if (has64_rel_mcount(shdrp, shdr0, shstrtab, fname)) - totrelsz += w8(shdrp->sh_size); - } - return totrelsz; -} - -/* Overall supervision for Elf32 ET_REL file. */ -static void -do32(Elf32_Ehdr *const ehdr, char const *const fname, unsigned const reltype) -{ - Elf32_Shdr *const shdr0 = (Elf32_Shdr *)(w(ehdr->e_shoff) - + (void *)ehdr); - unsigned const nhdr = w2(ehdr->e_shnum); - Elf32_Shdr *const shstr = &shdr0[w2(ehdr->e_shstrndx)]; - char const *const shstrtab = (char const *)(w(shstr->sh_offset) - + (void *)ehdr); - - Elf32_Shdr const *relhdr; - unsigned k; - - /* Upper bound on space: assume all relevant relocs are for mcount. */ - unsigned const totrelsz = tot32_relsize(shdr0, nhdr, shstrtab, fname); - Elf32_Rel *const mrel0 = umalloc(totrelsz); - Elf32_Rel * mrelp = mrel0; - - /* 2*sizeof(address) <= sizeof(Elf32_Rel) */ - uint32_t *const mloc0 = umalloc(totrelsz>>1); - uint32_t * mlocp = mloc0; - - unsigned rel_entsize = 0; - unsigned symsec_sh_link = 0; - - for (relhdr = shdr0, k = nhdr; k; --k, ++relhdr) { - char const *const txtname = has32_rel_mcount(relhdr, shdr0, - shstrtab, fname); - if (txtname) { - uint32_t recval = 0; - unsigned const recsym = find32_secsym_ndx( - w(relhdr->sh_info), txtname, &recval, - &shdr0[symsec_sh_link = w(relhdr->sh_link)], - ehdr); - - rel_entsize = w(relhdr->sh_entsize); - mlocp = sift32_rel_mcount(mlocp, - (void *)mlocp - (void *)mloc0, &mrelp, - relhdr, ehdr, recsym, recval, reltype); - } - } - if (mloc0 != mlocp) { - append32(ehdr, shstr, mloc0, mlocp, mrel0, mrelp, - rel_entsize, symsec_sh_link); - } - free(mrel0); - free(mloc0); -} - -static void -do64(Elf64_Ehdr *const ehdr, char const *const fname, unsigned const reltype) -{ - Elf64_Shdr *const shdr0 = (Elf64_Shdr *)(w8(ehdr->e_shoff) - + (void *)ehdr); - unsigned const nhdr = w2(ehdr->e_shnum); - Elf64_Shdr *const shstr = &shdr0[w2(ehdr->e_shstrndx)]; - char const *const shstrtab = (char const *)(w8(shstr->sh_offset) - + (void *)ehdr); - - Elf64_Shdr const *relhdr; - unsigned k; - - /* Upper bound on space: assume all relevant relocs are for mcount. */ - unsigned const totrelsz = tot64_relsize(shdr0, nhdr, shstrtab, fname); - Elf64_Rel *const mrel0 = umalloc(totrelsz); - Elf64_Rel * mrelp = mrel0; - - /* 2*sizeof(address) <= sizeof(Elf64_Rel) */ - uint64_t *const mloc0 = umalloc(totrelsz>>1); - uint64_t * mlocp = mloc0; - - unsigned rel_entsize = 0; - unsigned symsec_sh_link = 0; - - for ((relhdr = shdr0), k = nhdr; k; --k, ++relhdr) { - char const *const txtname = has64_rel_mcount(relhdr, shdr0, - shstrtab, fname); - if (txtname) { - uint64_t recval = 0; - unsigned const recsym = find64_secsym_ndx( - w(relhdr->sh_info), txtname, &recval, - &shdr0[symsec_sh_link = w(relhdr->sh_link)], - ehdr); - - rel_entsize = w8(relhdr->sh_entsize); - mlocp = sift64_rel_mcount(mlocp, - (void *)mlocp - (void *)mloc0, &mrelp, - relhdr, ehdr, recsym, recval, reltype); - } - } - if (mloc0 != mlocp) { - append64(ehdr, shstr, mloc0, mlocp, mrel0, mrelp, - rel_entsize, symsec_sh_link); - } - free(mrel0); - free(mloc0); -} +/* 32 bit and 64 bit are very similar */ +#include "recordmcount.h" +#define RECORD_MCOUNT_64 +#include "recordmcount.h" static void do_file(char const *const fname) diff --git a/scripts/recordmcount.h b/scripts/recordmcount.h new file mode 100644 index 0000000..7f39d09 --- /dev/null +++ b/scripts/recordmcount.h @@ -0,0 +1,366 @@ +/* + * recordmcount.h + * + * This code was taken out of recordmcount.c written by + * Copyright 2009 John F. Reiser . All rights reserved. + * + * The original code had the same algorithms for both 32bit + * and 64bit ELF files, but the code was duplicated to support + * the difference in structures that were used. This + * file creates a macro of everything that is different between + * the 64 and 32 bit code, such that by including this header + * twice we can create both sets of functions by including this + * header once with RECORD_MCOUNT_64 undefined, and again with + * it defined. + * + * This conversion to macros was done by: + * Copyright 2010 Steven Rostedt , Red Hat Inc. + * + * Licensed under the GNU General Public License, version 2 (GPLv2). + */ +#undef append_func +#undef sift_rel_mcount +#undef find_secsym_ndx +#undef __has_rel_mcount +#undef has_rel_mcount +#undef tot_relsize +#undef do_func +#undef Elf_Ehdr +#undef Elf_Shdr +#undef Elf_Rel +#undef Elf_Rela +#undef Elf_Sym +#undef ELF_R_SYM +#undef ELF_R_INFO +#undef ELF_ST_BIND +#undef uint_t +#undef _w +#undef _align +#undef _size + +#ifdef RECORD_MCOUNT_64 +# define append_func append64 +# define sift_rel_mcount sift64_rel_mcount +# define find_secsym_ndx find64_secsym_ndx +# define __has_rel_mcount __has64_rel_mcount +# define has_rel_mcount has64_rel_mcount +# define tot_relsize tot64_relsize +# define do_func do64 +# 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_INFO ELF64_R_INFO +# define ELF_ST_BIND ELF64_ST_BIND +# define uint_t uint64_t +# define _w w8 +# define _align 7u +# define _size 8 +#else +# define append_func append32 +# define sift_rel_mcount sift32_rel_mcount +# define find_secsym_ndx find32_secsym_ndx +# define __has_rel_mcount __has32_rel_mcount +# define has_rel_mcount has32_rel_mcount +# define tot_relsize tot32_relsize +# define do_func do32 +# 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_INFO ELF32_R_INFO +# define ELF_ST_BIND ELF32_ST_BIND +# define uint_t uint32_t +# define _w w +# define _align 3u +# define _size 4 +#endif + +/* Append the new shstrtab, Elf_Shdr[], __mcount_loc and its relocations. */ +static void append_func(Elf_Ehdr *const ehdr, + Elf_Shdr *const shstr, + uint_t const *const mloc0, + uint_t const *const mlocp, + Elf_Rel const *const mrel0, + Elf_Rel const *const mrelp, + unsigned int const rel_entsize, + unsigned int const symsec_sh_link) +{ + /* Begin constructing output file */ + Elf_Shdr mcsec; + char const *mc_name = (sizeof(Elf_Rela) == rel_entsize) + ? ".rela__mcount_loc" + : ".rel__mcount_loc"; + unsigned const old_shnum = w2(ehdr->e_shnum); + uint_t const old_shoff = _w(ehdr->e_shoff); + uint_t const old_shstr_sh_size = _w(shstr->sh_size); + uint_t const old_shstr_sh_offset = _w(shstr->sh_offset); + uint_t t = 1 + strlen(mc_name) + _w(shstr->sh_size); + uint_t new_e_shoff; + + shstr->sh_size = _w(t); + shstr->sh_offset = _w(sb.st_size); + t += sb.st_size; + t += (_align & -t); /* word-byte align */ + new_e_shoff = t; + + /* body for new shstrtab */ + ulseek(fd_map, sb.st_size, SEEK_SET); + uwrite(fd_map, old_shstr_sh_offset + (void *)ehdr, old_shstr_sh_size); + uwrite(fd_map, mc_name, 1 + strlen(mc_name)); + + /* old(modified) Elf_Shdr table, word-byte aligned */ + ulseek(fd_map, t, SEEK_SET); + t += sizeof(Elf_Shdr) * old_shnum; + uwrite(fd_map, old_shoff + (void *)ehdr, + sizeof(Elf_Shdr) * old_shnum); + + /* new sections __mcount_loc and .rel__mcount_loc */ + t += 2*sizeof(mcsec); + mcsec.sh_name = w((sizeof(Elf_Rela) == rel_entsize) + strlen(".rel") + + old_shstr_sh_size); + mcsec.sh_type = w(SHT_PROGBITS); + mcsec.sh_flags = _w(SHF_ALLOC); + mcsec.sh_addr = 0; + mcsec.sh_offset = _w(t); + mcsec.sh_size = _w((void *)mlocp - (void *)mloc0); + mcsec.sh_link = 0; + mcsec.sh_info = 0; + mcsec.sh_addralign = _w(_size); + mcsec.sh_entsize = _w(_size); + uwrite(fd_map, &mcsec, sizeof(mcsec)); + + mcsec.sh_name = w(old_shstr_sh_size); + mcsec.sh_type = (sizeof(Elf_Rela) == rel_entsize) + ? w(SHT_RELA) + : w(SHT_REL); + mcsec.sh_flags = 0; + mcsec.sh_addr = 0; + mcsec.sh_offset = _w((void *)mlocp - (void *)mloc0 + t); + mcsec.sh_size = _w((void *)mrelp - (void *)mrel0); + mcsec.sh_link = w(symsec_sh_link); + mcsec.sh_info = w(old_shnum); + mcsec.sh_addralign = _w(_size); + mcsec.sh_entsize = _w(rel_entsize); + uwrite(fd_map, &mcsec, sizeof(mcsec)); + + uwrite(fd_map, mloc0, (void *)mlocp - (void *)mloc0); + uwrite(fd_map, mrel0, (void *)mrelp - (void *)mrel0); + + ehdr->e_shoff = _w(new_e_shoff); + ehdr->e_shnum = w2(2 + w2(ehdr->e_shnum)); /* {.rel,}__mcount_loc */ + ulseek(fd_map, 0, SEEK_SET); + uwrite(fd_map, ehdr, sizeof(*ehdr)); +} + + +/* + * Look at the relocations in order to find the calls to mcount. + * Accumulate the section offsets that are found, and their relocation info, + * onto the end of the existing arrays. + */ +static uint_t *sift_rel_mcount(uint_t *mlocp, + unsigned const offbase, + Elf_Rel **const mrelpp, + Elf_Shdr const *const relhdr, + Elf_Ehdr const *const ehdr, + unsigned const recsym, + uint_t const recval, + unsigned const reltype) +{ + uint_t *const mloc0 = mlocp; + Elf_Rel *mrelp = *mrelpp; + Elf_Shdr *const shdr0 = (Elf_Shdr *)(_w(ehdr->e_shoff) + + (void *)ehdr); + unsigned const symsec_sh_link = w(relhdr->sh_link); + Elf_Shdr const *const symsec = &shdr0[symsec_sh_link]; + Elf_Sym const *const sym0 = (Elf_Sym const *)(_w(symsec->sh_offset) + + (void *)ehdr); + + Elf_Shdr const *const strsec = &shdr0[w(symsec->sh_link)]; + char const *const str0 = (char const *)(_w(strsec->sh_offset) + + (void *)ehdr); + + Elf_Rel const *const rel0 = (Elf_Rel const *)(_w(relhdr->sh_offset) + + (void *)ehdr); + unsigned rel_entsize = _w(relhdr->sh_entsize); + unsigned const nrel = _w(relhdr->sh_size) / rel_entsize; + Elf_Rel const *relp = rel0; + + unsigned mcountsym = 0; + unsigned t; + + for (t = nrel; t; --t) { + if (!mcountsym) { + Elf_Sym const *const symp = + &sym0[ELF_R_SYM(_w(relp->r_info))]; + char const *symname = &str0[w(symp->st_name)]; + + if ('.' == symname[0]) + ++symname; /* ppc64 hack */ + if (0 == strcmp((('_' == gpfx) ? "_mcount" : "mcount"), + symname)) + mcountsym = ELF_R_SYM(_w(relp->r_info)); + } + + if (mcountsym == ELF_R_SYM(_w(relp->r_info))) { + uint_t const addend = _w(_w(relp->r_offset) - recval); + + mrelp->r_offset = _w(offbase + + ((void *)mlocp - (void *)mloc0)); + mrelp->r_info = _w(ELF_R_INFO(recsym, reltype)); + if (sizeof(Elf_Rela) == rel_entsize) { + ((Elf_Rela *)mrelp)->r_addend = addend; + *mlocp++ = 0; + } else + *mlocp++ = addend; + + mrelp = (Elf_Rel *)(rel_entsize + (void *)mrelp); + } + relp = (Elf_Rel const *)(rel_entsize + (void *)relp); + } + *mrelpp = mrelp; + return mlocp; +} + + +/* + * Find a symbol in the given section, to be used as the base for relocating + * the table of offsets of calls to mcount. A local or global symbol suffices, + * but avoid a Weak symbol because it may be overridden; the change in value + * would invalidate the relocations of the offsets of the calls to mcount. + * Often the found symbol will be the unnamed local symbol generated by + * GNU 'as' for the start of each section. For example: + * Num: Value Size Type Bind Vis Ndx Name + * 2: 00000000 0 SECTION LOCAL DEFAULT 1 + */ +static unsigned find_secsym_ndx(unsigned const txtndx, + char const *const txtname, + uint_t *const recvalp, + Elf_Shdr const *const symhdr, + Elf_Ehdr const *const ehdr) +{ + Elf_Sym const *const sym0 = (Elf_Sym const *)(_w(symhdr->sh_offset) + + (void *)ehdr); + unsigned const nsym = _w(symhdr->sh_size) / _w(symhdr->sh_entsize); + Elf_Sym const *symp; + unsigned t; + + for (symp = sym0, t = nsym; t; --t, ++symp) { + unsigned int const st_bind = ELF_ST_BIND(symp->st_info); + + if (txtndx == w2(symp->st_shndx) + /* avoid STB_WEAK */ + && (STB_LOCAL == st_bind || STB_GLOBAL == st_bind)) { + *recvalp = _w(symp->st_value); + return symp - sym0; + } + } + fprintf(stderr, "Cannot find symbol for section %d: %s.\n", + txtndx, txtname); + fail_file(); +} + + +/* Evade ISO C restriction: no declaration after statement in has_rel_mcount. */ +static char const * +__has_rel_mcount(Elf_Shdr const *const relhdr, /* is SHT_REL or SHT_RELA */ + Elf_Shdr const *const shdr0, + char const *const shstrtab, + char const *const fname) +{ + /* .sh_info depends on .sh_type == SHT_REL[,A] */ + Elf_Shdr const *const txthdr = &shdr0[w(relhdr->sh_info)]; + char const *const txtname = &shstrtab[w(txthdr->sh_name)]; + + if (0 == strcmp("__mcount_loc", txtname)) { + fprintf(stderr, "warning: __mcount_loc already exists: %s\n", + fname); + succeed_file(); + } + if (SHT_PROGBITS != w(txthdr->sh_type) || + !is_mcounted_section_name(txtname)) + return NULL; + return txtname; +} + +static char const *has_rel_mcount(Elf_Shdr const *const relhdr, + Elf_Shdr const *const shdr0, + char const *const shstrtab, + char const *const fname) +{ + if (SHT_REL != w(relhdr->sh_type) && SHT_RELA != w(relhdr->sh_type)) + return NULL; + return __has_rel_mcount(relhdr, shdr0, shstrtab, fname); +} + + +static unsigned tot_relsize(Elf_Shdr const *const shdr0, + unsigned nhdr, + const char *const shstrtab, + const char *const fname) +{ + unsigned totrelsz = 0; + Elf_Shdr const *shdrp = shdr0; + + for (; nhdr; --nhdr, ++shdrp) { + if (has_rel_mcount(shdrp, shdr0, shstrtab, fname)) + totrelsz += _w(shdrp->sh_size); + } + return totrelsz; +} + + +/* Overall supervision for Elf32 ET_REL file. */ +static void +do_func(Elf_Ehdr *const ehdr, char const *const fname, unsigned const reltype) +{ + Elf_Shdr *const shdr0 = (Elf_Shdr *)(_w(ehdr->e_shoff) + + (void *)ehdr); + unsigned const nhdr = w2(ehdr->e_shnum); + Elf_Shdr *const shstr = &shdr0[w2(ehdr->e_shstrndx)]; + char const *const shstrtab = (char const *)(_w(shstr->sh_offset) + + (void *)ehdr); + + Elf_Shdr const *relhdr; + unsigned k; + + /* Upper bound on space: assume all relevant relocs are for mcount. */ + unsigned const totrelsz = tot_relsize(shdr0, nhdr, shstrtab, fname); + Elf_Rel *const mrel0 = umalloc(totrelsz); + Elf_Rel * mrelp = mrel0; + + /* 2*sizeof(address) <= sizeof(Elf_Rel) */ + uint_t *const mloc0 = umalloc(totrelsz>>1); + uint_t * mlocp = mloc0; + + unsigned rel_entsize = 0; + unsigned symsec_sh_link = 0; + + for (relhdr = shdr0, k = nhdr; k; --k, ++relhdr) { + char const *const txtname = has_rel_mcount(relhdr, shdr0, + shstrtab, fname); + if (txtname) { + uint_t recval = 0; + unsigned const recsym = find_secsym_ndx( + w(relhdr->sh_info), txtname, &recval, + &shdr0[symsec_sh_link = w(relhdr->sh_link)], + ehdr); + + rel_entsize = _w(relhdr->sh_entsize); + mlocp = sift_rel_mcount(mlocp, + (void *)mlocp - (void *)mloc0, &mrelp, + relhdr, ehdr, recsym, recval, reltype); + } + } + if (mloc0 != mlocp) { + append_func(ehdr, shstr, mloc0, mlocp, mrel0, mrelp, + rel_entsize, symsec_sh_link); + } + free(mrel0); + free(mloc0); +} -- cgit v1.1 From 444758636439810f110f86a3042c2dfd3626a9e2 Mon Sep 17 00:00:00 2001 From: Steven Rostedt Date: Fri, 15 Oct 2010 11:49:47 -0400 Subject: ftrace: Do not process kernel/trace/ftrace.o with C recordmcount program The file kernel/trace/ftrace.c references the mcount() call to convert the mcount() callers to nops. But because it references mcount(), the mcount() address is placed in the relocation table. The C version of recordmcount reads the relocation table of all object files, and it will add all references to mcount to the __mcount_loc table that is used to find the places that call mcount() and change the call to a nop. When recordmcount finds the mcount reference in kernel/trace/ftrace.o, it saves that location even though the code is not a call, but references mcount as data. On boot up, when all calls are converted to nops, the code has a safety check to determine what op code it is actually replacing before it replaces it. If that op code at the address does not match, then a warning is printed and the function tracer is disabled. The reference to mcount in ftrace.c, causes this warning to trigger, since the reference is not a call to mcount(). The ftrace.c file is not compiled with the -pg flag, so no calls to mcount() should be expected. This patch simply makes recordmcount.c skip the kernel/trace/ftrace.c file. This was the same solution used by the perl version of recordmcount. Reported-by: Ingo Molnar Cc: John Reiser Signed-off-by: Steven Rostedt --- scripts/recordmcount.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) (limited to 'scripts') diff --git a/scripts/recordmcount.c b/scripts/recordmcount.c index 7f7f718..26e1271 100644 --- a/scripts/recordmcount.c +++ b/scripts/recordmcount.c @@ -313,12 +313,30 @@ do_file(char const *const fname) int main(int argc, char const *argv[]) { + const char ftrace[] = "kernel/trace/ftrace.o"; + int ftrace_size = sizeof(ftrace) - 1; int n_error = 0; /* gcc-4.3.0 false positive complaint */ - if (argc <= 1) + + if (argc <= 1) { fprintf(stderr, "usage: recordmcount file.o...\n"); - else /* Process each file in turn, allowing deep failure. */ + return 0; + } + + /* Process each file in turn, allowing deep failure. */ for (--argc, ++argv; 0 < argc; --argc, ++argv) { int const sjval = setjmp(jmpenv); + int len; + + /* + * The file kernel/trace/ftrace.o references the mcount + * function but does not call it. Since ftrace.o should + * not be traced anyway, we just skip it. + */ + len = strlen(argv[0]); + if (len >= ftrace_size && + strcmp(argv[0] + (len - ftrace_size), ftrace) == 0) + continue; + switch (sjval) { default: { fprintf(stderr, "internal error: %s\n", argv[0]); -- cgit v1.1 From 85caa993d7f218b7c2abcfcb28e212396b6a3313 Mon Sep 17 00:00:00 2001 From: Steven Rostedt Date: Fri, 15 Oct 2010 12:09:25 -0400 Subject: ftrace: Use objtree for C version of recordmcount The C version of recordmcount is compiled to a binary, which will end up located in the objtree. If the kernel is built with O=path, the srctree will not include the binary recordmcount caller. Cc: Michal Marek Cc: linux-kbuild@vger.kernel.org Signed-off-by: Steven Rostedt --- scripts/Makefile.build | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'scripts') diff --git a/scripts/Makefile.build b/scripts/Makefile.build index 4d03a7ef..4db60b2 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -210,7 +210,7 @@ endif ifdef CONFIG_FTRACE_MCOUNT_RECORD ifdef BUILD_C_RECORDMCOUNT -cmd_record_mcount = $(srctree)/scripts/recordmcount "$(@)"; +cmd_record_mcount = $(objtree)/scripts/recordmcount "$(@)"; else cmd_record_mcount = set -e ; perl $(srctree)/scripts/recordmcount.pl "$(ARCH)" \ "$(if $(CONFIG_CPU_BIG_ENDIAN),big,little)" \ -- cgit v1.1 From d7b4d6de57d414a6384376880f2caf7125a45494 Mon Sep 17 00:00:00 2001 From: Steven Rostedt Date: Mon, 18 Oct 2010 14:42:00 -0400 Subject: ftrace: Remove recursion between recordmcount and scripts/mod/empty When DYNAMIC_FTRACE is enabled and we use the C version of recordmcount, all objects are run through the recordmcount program to create a separate section that stores all the callers of mcount. The build process has a special file: scripts/mod/empty.o. This is built from empty.c which is literally an empty file (except for a single comment). This file is used to find information about the target elf format, like endianness and word size. The problem comes up when we need to build recordmcount. The build process requires that empty.o is built first. The build rules for empty.o will try to execute recordmcount on the empty.o file. We get an error that recordmcount does not exist. To avoid this recursion, the build file will skip running recordmcount if the file that it is building is script/mod/empty.o. [ extra comment Suggested-by: Sam Ravnborg ] Reported-by: Ingo Molnar Tested-by: Ingo Molnar Cc: Michal Marek Cc: linux-kbuild@vger.kernel.org Signed-off-by: Steven Rostedt --- scripts/Makefile.build | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'scripts') diff --git a/scripts/Makefile.build b/scripts/Makefile.build index 4db60b2..843bd4f 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -210,7 +210,13 @@ endif ifdef CONFIG_FTRACE_MCOUNT_RECORD ifdef BUILD_C_RECORDMCOUNT -cmd_record_mcount = $(objtree)/scripts/recordmcount "$(@)"; +# Due to recursion, we must skip empty.o. +# The empty.o file is created in the make process in order to determine +# the target endianness and word size. It is made before all other C +# files, including recordmcount. +cmd_record_mcount = if [ $(@) != "scripts/mod/empty.o" ]; then \ + $(objtree)/scripts/recordmcount "$(@)"; \ + fi; else cmd_record_mcount = set -e ; perl $(srctree)/scripts/recordmcount.pl "$(ARCH)" \ "$(if $(CONFIG_CPU_BIG_ENDIAN),big,little)" \ -- cgit v1.1