Merge branch 'tip/perf/core-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace into perf/core

4 files changed, 261 insertions, 91 deletions

diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index d5f925abe4d2..fdca952f6a40 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -244,13 +244,16 @@ endif
 
 ifdef CONFIG_FTRACE_MCOUNT_RECORD
 ifdef BUILD_C_RECORDMCOUNT
+ifeq ("$(origin RECORDMCOUNT_WARN)", "command line")
+  RECORDMCOUNT_FLAGS = -w
+endif
 # 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.
 sub_cmd_record_mcount =                                 \
         if [ $(@) != "scripts/mod/empty.o" ]; then      \
-                $(objtree)/scripts/recordmcount "$(@)"; \
+                $(objtree)/scripts/recordmcount $(RECORDMCOUNT_FLAGS) "$(@)";   \
         fi;
 else
 sub_cmd_record_mcount = set -e ; perl $(srctree)/scripts/recordmcount.pl "$(ARCH)" \
diff --git a/scripts/recordmcount.c b/scripts/recordmcount.c
index f9f6f52db772..ee52cb8e17ad 100644
--- a/scripts/recordmcount.c
+++ b/scripts/recordmcount.c
@@ -24,6 +24,7 @@
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+#include <getopt.h>
 #include <elf.h>
 #include <fcntl.h>
 #include <setjmp.h>
@@ -39,6 +40,7 @@ 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 */
 static const char *altmcount;   /* alternate mcount symbol name */
+static int warn_on_notrace_sect; /* warn when section has mcount not being recorded */
 
 /* setjmp() return values */
 enum {
@@ -78,7 +80,7 @@ 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) {
+        if (w == (off_t)-1) {
                 perror("lseek");
                 fail_file();
         }
@@ -111,13 +113,41 @@ static void *
 umalloc(size_t size)
 {
         void *const addr = malloc(size);
-        if (0 == addr) {
+        if (addr == 0) {
                 fprintf(stderr, "malloc failed: %zu bytes\n", size);
                 fail_file();
         }
         return addr;
 }
 
+static unsigned char ideal_nop5_x86_64[5] = { 0x0f, 0x1f, 0x44, 0x00, 0x00 };
+static unsigned char ideal_nop5_x86_32[5] = { 0x3e, 0x8d, 0x74, 0x26, 0x00 };
+static unsigned char *ideal_nop;
+
+static char rel_type_nop;
+
+static int (*make_nop)(void *map, size_t const offset);
+
+static int make_nop_x86(void *map, size_t const offset)
+{
+        uint32_t *ptr;
+        unsigned char *op;
+
+        /* Confirm we have 0xe8 0x0 0x0 0x0 0x0 */
+        ptr = map + offset;
+        if (*ptr != 0)
+                return -1;
+
+        op = map + offset - 1;
+        if (*op != 0xe8)
+                return -1;
+
+        /* convert to nop */
+        ulseek(fd_map, offset - 1, SEEK_SET);
+        uwrite(fd_map, ideal_nop, 5);
+        return 0;
+}
+
 /*
  * Get the whole file as a programming convenience in order to avoid
  * malloc+lseek+read+free of many pieces.  If successful, then mmap
@@ -136,7 +166,7 @@ static void *mmap_file(char const *fname)
         void *addr;
 
         fd_map = open(fname, O_RDWR);
-        if (0 > fd_map || 0 > fstat(fd_map, &sb)) {
+        if (fd_map < 0 || fstat(fd_map, &sb) < 0) {
                 perror(fname);
                 fail_file();
         }
@@ -147,7 +177,7 @@ static void *mmap_file(char const *fname)
         addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE,
                     fd_map, 0);
         mmap_failed = 0;
-        if (MAP_FAILED == addr) {
+        if (addr == MAP_FAILED) {
                 mmap_failed = 1;
                 addr = umalloc(sb.st_size);
                 uread(fd_map, addr, sb.st_size);
@@ -206,12 +236,13 @@ static uint32_t (*w2)(uint16_t);
 static int
 is_mcounted_section_name(char const *const txtname)
 {
-        return 0 == strcmp(".text",           txtname) ||
-                0 == strcmp(".ref.text",      txtname) ||
-                0 == strcmp(".sched.text",    txtname) ||
-                0 == strcmp(".spinlock.text", txtname) ||
-                0 == strcmp(".irqentry.text", txtname) ||
-                0 == strcmp(".text.unlikely", txtname);
+        return strcmp(".text",           txtname) == 0 ||
+                strcmp(".ref.text",      txtname) == 0 ||
+                strcmp(".sched.text",    txtname) == 0 ||
+                strcmp(".spinlock.text", txtname) == 0 ||
+                strcmp(".irqentry.text", txtname) == 0 ||
+                strcmp(".kprobes.text", txtname) == 0 ||
+                strcmp(".text.unlikely", txtname) == 0;
 }
 
 /* 32 bit and 64 bit are very similar */
@@ -264,43 +295,48 @@ do_file(char const *const fname)
         w8 = w8nat;
         switch (ehdr->e_ident[EI_DATA]) {
                 static unsigned int const endian = 1;
-        default: {
+        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) {
+                break;
+        case ELFDATA2LSB:
+                if (*(unsigned char const *)&endian != 1) {
                         /* main() is big endian, file.o is little endian. */
                         w = w4rev;
                         w2 = w2rev;
                         w8 = w8rev;
                 }
-        } break;
-        case ELFDATA2MSB: {
-                if (0 != *(unsigned char const *)&endian) {
+                break;
+        case ELFDATA2MSB:
+                if (*(unsigned char const *)&endian != 0) {
                         /* main() is little endian, file.o is big endian. */
                         w = w4rev;
                         w2 = w2rev;
                         w8 = w8rev;
                 }
-        } break;
+                break;
         }  /* end switch */
-        if (0 != memcmp(ELFMAG, ehdr->e_ident, SELFMAG)
-        ||  ET_REL != w2(ehdr->e_type)
-        ||  EV_CURRENT != ehdr->e_ident[EI_VERSION]) {
+        if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
+        ||  w2(ehdr->e_type) != ET_REL
+        ||  ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
                 fprintf(stderr, "unrecognized ET_REL file %s\n", fname);
                 fail_file();
         }
 
         gpfx = 0;
         switch (w2(ehdr->e_machine)) {
-        default: {
+        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;
+                break;
+        case EM_386:
+                reltype = R_386_32;
+                make_nop = make_nop_x86;
+                ideal_nop = ideal_nop5_x86_32;
+                mcount_adjust_32 = -1;
+                break;
         case EM_ARM:     reltype = R_ARM_ABS32;
                          altmcount = "__gnu_mcount_nc";
                          break;
@@ -311,67 +347,91 @@ do_file(char const *const fname)
         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;
+        case EM_X86_64:
+                make_nop = make_nop_x86;
+                ideal_nop = ideal_nop5_x86_64;
+                reltype = R_X86_64_64;
+                mcount_adjust_64 = -1;
+                break;
         }  /* end switch */
 
         switch (ehdr->e_ident[EI_CLASS]) {
-        default: {
+        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)) {
+                break;
+        case ELFCLASS32:
+                if (w2(ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
+                ||  w2(ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
                         fprintf(stderr,
                                 "unrecognized ET_REL file: %s\n", fname);
                         fail_file();
                 }
-                if (EM_S390 == w2(ehdr->e_machine))
+                if (w2(ehdr->e_machine) == EM_S390) {
                         reltype = R_390_32;
-                if (EM_MIPS == w2(ehdr->e_machine)) {
+                        mcount_adjust_32 = -4;
+                }
+                if (w2(ehdr->e_machine) == EM_MIPS) {
                         reltype = R_MIPS_32;
                         is_fake_mcount32 = MIPS32_is_fake_mcount;
                 }
                 do32(ehdr, fname, reltype);
-        } break;
+                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)) {
+                if (w2(ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
+                ||  w2(ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
                         fprintf(stderr,
                                 "unrecognized ET_REL file: %s\n", fname);
                         fail_file();
                 }
-                if (EM_S390 == w2(ghdr->e_machine))
+                if (w2(ghdr->e_machine) == EM_S390) {
                         reltype = R_390_64;
-                if (EM_MIPS == w2(ghdr->e_machine)) {
+                        mcount_adjust_64 = -8;
+                }
+                if (w2(ghdr->e_machine) == EM_MIPS) {
                         reltype = R_MIPS_64;
                         Elf64_r_sym = MIPS64_r_sym;
                         Elf64_r_info = MIPS64_r_info;
                         is_fake_mcount64 = MIPS64_is_fake_mcount;
                 }
                 do64(ghdr, fname, reltype);
-        } break;
+                break;
+        }
         }  /* end switch */
 
         cleanup();
 }
 
 int
-main(int argc, char const *argv[])
+main(int argc, char *argv[])
 {
         const char ftrace[] = "/ftrace.o";
         int ftrace_size = sizeof(ftrace) - 1;
         int n_error = 0;  /* gcc-4.3.0 false positive complaint */
+        int c;
+        int i;
+
+        while ((c = getopt(argc, argv, "w")) >= 0) {
+                switch (c) {
+                case 'w':
+                        warn_on_notrace_sect = 1;
+                        break;
+                default:
+                        fprintf(stderr, "usage: recordmcount [-w] file.o...\n");
+                        return 0;
+                }
+        }
 
-        if (argc <= 1) {
-                fprintf(stderr, "usage: recordmcount file.o...\n");
+        if ((argc - optind) < 1) {
+                fprintf(stderr, "usage: recordmcount [-w] file.o...\n");
                 return 0;
         }
 
         /* Process each file in turn, allowing deep failure. */
-        for (--argc, ++argv; 0 < argc; --argc, ++argv) {
+        for (i = optind; i < argc; i++) {
+                char *file = argv[i];
                 int const sjval = setjmp(jmpenv);
                 int len;
 
@@ -380,29 +440,29 @@ main(int argc, char const *argv[])
                  * function but does not call it. Since ftrace.o should
                  * not be traced anyway, we just skip it.
                  */
-                len = strlen(argv[0]);
+                len = strlen(file);
                 if (len >= ftrace_size &&
-                    strcmp(argv[0] + (len - ftrace_size), ftrace) == 0)
+                    strcmp(file + (len - ftrace_size), ftrace) == 0)
                         continue;
 
                 switch (sjval) {
-                default: {
-                        fprintf(stderr, "internal error: %s\n", argv[0]);
+                default:
+                        fprintf(stderr, "internal error: %s\n", file);
                         exit(1);
-                } break;
-                case SJ_SETJMP: {  /* normal sequence */
+                        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 */
+                        do_file(file);
+                        break;
+                case SJ_FAIL:    /* error in do_file or below */
                         ++n_error;
-                } break;
-                case SJ_SUCCEED: {  /* premature success */
+                        break;
+                case SJ_SUCCEED:    /* premature success */
                         /* do nothing */
-                } break;
+                        break;
                 }  /* end switch */
         }
         return !!n_error;
diff --git a/scripts/recordmcount.h b/scripts/recordmcount.h
index baf187bee983..4be60364a405 100644
--- a/scripts/recordmcount.h
+++ b/scripts/recordmcount.h
@@ -22,11 +22,15 @@
 #undef is_fake_mcount
 #undef fn_is_fake_mcount
 #undef MIPS_is_fake_mcount
+#undef mcount_adjust
 #undef sift_rel_mcount
+#undef nop_mcount
 #undef find_secsym_ndx
 #undef __has_rel_mcount
 #undef has_rel_mcount
 #undef tot_relsize
+#undef get_mcountsym
+#undef get_sym_str_and_relp
 #undef do_func
 #undef Elf_Addr
 #undef Elf_Ehdr
@@ -49,14 +53,18 @@
 #ifdef RECORD_MCOUNT_64
 # define append_func            append64
 # define sift_rel_mcount        sift64_rel_mcount
+# define nop_mcount             nop_mcount_64
 # 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 get_sym_str_and_relp   get_sym_str_and_relp_64
 # define do_func                do64
+# define get_mcountsym          get_mcountsym_64
 # define is_fake_mcount         is_fake_mcount64
 # define fn_is_fake_mcount      fn_is_fake_mcount64
 # define MIPS_is_fake_mcount    MIPS64_is_fake_mcount
+# define mcount_adjust          mcount_adjust_64
 # define Elf_Addr               Elf64_Addr
 # define Elf_Ehdr               Elf64_Ehdr
 # define Elf_Shdr               Elf64_Shdr
@@ -77,14 +85,18 @@
 #else
 # define append_func            append32
 # define sift_rel_mcount        sift32_rel_mcount
+# define nop_mcount             nop_mcount_32
 # 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 get_sym_str_and_relp   get_sym_str_and_relp_32
 # define do_func                do32
+# define get_mcountsym          get_mcountsym_32
 # define is_fake_mcount         is_fake_mcount32
 # define fn_is_fake_mcount      fn_is_fake_mcount32
 # define MIPS_is_fake_mcount    MIPS32_is_fake_mcount
+# define mcount_adjust          mcount_adjust_32
 # define Elf_Addr               Elf32_Addr
 # define Elf_Ehdr               Elf32_Ehdr
 # define Elf_Shdr               Elf32_Shdr
@@ -123,6 +135,8 @@ static void fn_ELF_R_INFO(Elf_Rel *const rp, unsigned sym, unsigned type)
 }
 static void (*Elf_r_info)(Elf_Rel *const rp, unsigned sym, unsigned type) = fn_ELF_R_INFO;
 
+static int mcount_adjust = 0;
+
 /*
  * MIPS mcount long call has 2 _mcount symbols, only the position of the 1st
  * _mcount symbol is needed for dynamic function tracer, with it, to disable
@@ -234,6 +248,49 @@ static void append_func(Elf_Ehdr *const ehdr,
         uwrite(fd_map, ehdr, sizeof(*ehdr));
 }
 
+static unsigned get_mcountsym(Elf_Sym const *const sym0,
+                              Elf_Rel const *relp,
+                              char const *const str0)
+{
+        unsigned mcountsym = 0;
+
+        Elf_Sym const *const symp =
+                &sym0[Elf_r_sym(relp)];
+        char const *symname = &str0[w(symp->st_name)];
+        char const *mcount = gpfx == '_' ? "_mcount" : "mcount";
+
+        if (symname[0] == '.')
+                ++symname;  /* ppc64 hack */
+        if (strcmp(mcount, symname) == 0 ||
+            (altmcount && strcmp(altmcount, symname) == 0))
+                mcountsym = Elf_r_sym(relp);
+
+        return mcountsym;
+}
+
+static void get_sym_str_and_relp(Elf_Shdr const *const relhdr,
+                                 Elf_Ehdr const *const ehdr,
+                                 Elf_Sym const **sym0,
+                                 char const **str0,
+                                 Elf_Rel const **relp)
+{
+        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_Shdr const *const strsec = &shdr0[w(symsec->sh_link)];
+        Elf_Rel const *const rel0 = (Elf_Rel const *)(_w(relhdr->sh_offset)
+                + (void *)ehdr);
+
+        *sym0 = (Elf_Sym const *)(_w(symsec->sh_offset)
+                                  + (void *)ehdr);
+
+        *str0 = (char const *)(_w(strsec->sh_offset)
+                               + (void *)ehdr);
+
+        *relp = rel0;
+}
+
 /*
  * Look at the relocations in order to find the calls to mcount.
  * Accumulate the section offsets that are found, and their relocation info,
@@ -250,47 +307,27 @@ static uint_t *sift_rel_mcount(uint_t *mlocp,
 {
         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);
+        Elf_Sym const *sym0;
+        char const *str0;
+        Elf_Rel const *relp;
         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;
 
+        get_sym_str_and_relp(relhdr, ehdr, &sym0, &str0, &relp);
+
         for (t = nrel; t; --t) {
-                if (!mcountsym) {
-                        Elf_Sym const *const symp =
-                                &sym0[Elf_r_sym(relp)];
-                        char const *symname = &str0[w(symp->st_name)];
-                        char const *mcount = '_' == gpfx ? "_mcount" : "mcount";
-
-                        if ('.' == symname[0])
-                                ++symname;  /* ppc64 hack */
-                        if (0 == strcmp(mcount, symname) ||
-                            (altmcount && 0 == strcmp(altmcount, symname)))
-                                mcountsym = Elf_r_sym(relp);
-                }
+                if (!mcountsym)
+                        mcountsym = get_mcountsym(sym0, relp, str0);
 
                 if (mcountsym == Elf_r_sym(relp) && !is_fake_mcount(relp)) {
-                        uint_t const addend = _w(_w(relp->r_offset) - recval);
-
+                        uint_t const addend =
+                                _w(_w(relp->r_offset) - recval + mcount_adjust);
                         mrelp->r_offset = _w(offbase
                                 + ((void *)mlocp - (void *)mloc0));
                         Elf_r_info(mrelp, recsym, reltype);
-                        if (sizeof(Elf_Rela) == rel_entsize) {
+                        if (rel_entsize == sizeof(Elf_Rela)) {
                                 ((Elf_Rela *)mrelp)->r_addend = addend;
                                 *mlocp++ = 0;
                         } else
@@ -304,6 +341,63 @@ static uint_t *sift_rel_mcount(uint_t *mlocp,
         return mlocp;
 }
 
+/*
+ * Read the relocation table again, but this time its called on sections
+ * that are not going to be traced. The mcount calls here will be converted
+ * into nops.
+ */
+static void nop_mcount(Elf_Shdr const *const relhdr,
+                       Elf_Ehdr const *const ehdr,
+                       const char *const txtname)
+{
+        Elf_Shdr *const shdr0 = (Elf_Shdr *)(_w(ehdr->e_shoff)
+                + (void *)ehdr);
+        Elf_Sym const *sym0;
+        char const *str0;
+        Elf_Rel const *relp;
+        Elf_Shdr const *const shdr = &shdr0[w(relhdr->sh_info)];
+        unsigned rel_entsize = _w(relhdr->sh_entsize);
+        unsigned const nrel = _w(relhdr->sh_size) / rel_entsize;
+        unsigned mcountsym = 0;
+        unsigned t;
+        int once = 0;
+
+        get_sym_str_and_relp(relhdr, ehdr, &sym0, &str0, &relp);
+
+        for (t = nrel; t; --t) {
+                int ret = -1;
+
+                if (!mcountsym)
+                        mcountsym = get_mcountsym(sym0, relp, str0);
+
+                if (mcountsym == Elf_r_sym(relp) && !is_fake_mcount(relp)) {
+                        if (make_nop)
+                                ret = make_nop((void *)ehdr, shdr->sh_offset + relp->r_offset);
+                        if (warn_on_notrace_sect && !once) {
+                                printf("Section %s has mcount callers being ignored\n",
+                                       txtname);
+                                once = 1;
+                                /* just warn? */
+                                if (!make_nop)
+                                        return;
+                        }
+                }
+
+                /*
+                 * If we successfully removed the mcount, mark the relocation
+                 * as a nop (don't do anything with it).
+                 */
+                if (!ret) {
+                        Elf_Rel rel;
+                        rel = *(Elf_Rel *)relp;
+                        Elf_r_info(&rel, Elf_r_sym(relp), rel_type_nop);
+                        ulseek(fd_map, (void *)relp - (void *)ehdr, SEEK_SET);
+                        uwrite(fd_map, &rel, sizeof(rel));
+                }
+                relp = (Elf_Rel const *)(rel_entsize + (void *)relp);
+        }
+}
+
 
 /*
  * Find a symbol in the given section, to be used as the base for relocating
@@ -354,13 +448,13 @@ __has_rel_mcount(Elf_Shdr const *const relhdr,  /* is SHT_REL or SHT_RELA */
         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)) {
+        if (strcmp("__mcount_loc", txtname) == 0) {
                 fprintf(stderr, "warning: __mcount_loc already exists: %s\n",
                         fname);
                 succeed_file();
         }
-        if (SHT_PROGBITS != w(txthdr->sh_type) ||
-            !is_mcounted_section_name(txtname))
+        if (w(txthdr->sh_type) != SHT_PROGBITS ||
+            !(w(txthdr->sh_flags) & SHF_EXECINSTR))
                 return NULL;
         return txtname;
 }
@@ -370,7 +464,7 @@ static char const *has_rel_mcount(Elf_Shdr const *const relhdr,
                                   char const *const shstrtab,
                                   char const *const fname)
 {
-        if (SHT_REL  != w(relhdr->sh_type) && SHT_RELA != w(relhdr->sh_type))
+        if (w(relhdr->sh_type) != SHT_REL && w(relhdr->sh_type) != SHT_RELA)
                 return NULL;
         return __has_rel_mcount(relhdr, shdr0, shstrtab, fname);
 }
@@ -383,9 +477,11 @@ static unsigned tot_relsize(Elf_Shdr const *const shdr0,
 {
         unsigned totrelsz = 0;
         Elf_Shdr const *shdrp = shdr0;
+        char const *txtname;
 
         for (; nhdr; --nhdr, ++shdrp) {
-                if (has_rel_mcount(shdrp, shdr0, shstrtab, fname))
+                txtname = has_rel_mcount(shdrp, shdr0, shstrtab, fname);
+                if (txtname && is_mcounted_section_name(txtname))
                         totrelsz += _w(shdrp->sh_size);
         }
         return totrelsz;
@@ -421,7 +517,7 @@ do_func(Elf_Ehdr *const ehdr, char const *const fname, unsigned const reltype)
         for (relhdr = shdr0, k = nhdr; k; --k, ++relhdr) {
                 char const *const txtname = has_rel_mcount(relhdr, shdr0,
                         shstrtab, fname);
-                if (txtname) {
+                if (txtname && is_mcounted_section_name(txtname)) {
                         uint_t recval = 0;
                         unsigned const recsym = find_secsym_ndx(
                                 w(relhdr->sh_info), txtname, &recval,
@@ -432,6 +528,12 @@ do_func(Elf_Ehdr *const ehdr, char const *const fname, unsigned const reltype)
                         mlocp = sift_rel_mcount(mlocp,
                                 (void *)mlocp - (void *)mloc0, &mrelp,
                                 relhdr, ehdr, recsym, recval, reltype);
+                } else if (txtname && (warn_on_notrace_sect || make_nop)) {
+                        /*
+                         * This section is ignored by ftrace, but still
+                         * has mcount calls. Convert them to nops now.
+                         */
+                        nop_mcount(relhdr, ehdr, txtname);
                 }
         }
         if (mloc0 != mlocp) {
diff --git a/scripts/recordmcount.pl b/scripts/recordmcount.pl
index 4be0deea71ca..858966ab019c 100755
--- a/scripts/recordmcount.pl
+++ b/scripts/recordmcount.pl
@@ -134,6 +134,7 @@ my %text_sections = (
      ".sched.text" => 1,
      ".spinlock.text" => 1,
      ".irqentry.text" => 1,
+     ".kprobes.text" => 1,
      ".text.unlikely" => 1,
 );
 
@@ -222,6 +223,7 @@ if ($arch eq "x86_64") {
     $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount([+-]0x[0-9a-zA-Z]+)?\$";
     $type = ".quad";
     $alignment = 8;
+    $mcount_adjust = -1;
 
     # force flags for this arch
     $ld .= " -m elf_x86_64";
@@ -231,6 +233,7 @@ if ($arch eq "x86_64") {
 
 } elsif ($arch eq "i386") {
     $alignment = 4;
+    $mcount_adjust = -1;
 
     # force flags for this arch
     $ld .= " -m elf_i386";
@@ -240,12 +243,14 @@ if ($arch eq "x86_64") {
 
 } elsif ($arch eq "s390" && $bits == 32) {
     $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_32\\s+_mcount\$";
+    $mcount_adjust = -4;
     $alignment = 4;
     $ld .= " -m elf_s390";
     $cc .= " -m31";
 
 } elsif ($arch eq "s390" && $bits == 64) {
     $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_(PC|PLT)32DBL\\s+_mcount\\+0x2\$";
+    $mcount_adjust = -8;
     $alignment = 8;
     $type = ".quad";
     $ld .= " -m elf64_s390";