kprobes: improve kretprobe scalability with hashed locking

[karo-tx-linux.git] / arch / powerpc / kernel / vmlinux.lds.S

diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S
index 0afb9e31d2a008a79f1b5a4d2ff70d8dc798a458..a914411bced5defb4179628c9b0049d68a360ab0 100644 (file)
--- a/arch/powerpc/kernel/vmlinux.lds.S
+++ b/arch/powerpc/kernel/vmlinux.lds.S
@@ -1,16 +1,33 @@
 #ifdef CONFIG_PPC64
-#include <asm/page.h>
 #define PROVIDE32(x)   PROVIDE(__unused__##x)
 #else
-#define PAGE_SIZE      4096
-#define KERNELBASE     CONFIG_KERNEL_START
 #define PROVIDE32(x)   PROVIDE(x)
 #endif
+#include <asm/page.h>
 #include <asm-generic/vmlinux.lds.h>
 #include <asm/cache.h>
 
 ENTRY(_stext)
 
+PHDRS {
+       kernel PT_LOAD FLAGS(7); /* RWX */
+       notes PT_NOTE FLAGS(0);
+       dummy PT_NOTE FLAGS(0);
+
+       /* binutils < 2.18 has a bug that makes it misbehave when taking an
+          ELF file with all segments at load address 0 as input.  This
+          happens when running "strip" on vmlinux, because of the AT() magic
+          in this linker script.  People using GCC >= 4.2 won't run into
+          this problem, because the "build-id" support will put some data
+          into the "notes" segment (at a non-zero load address).
+
+          To work around this, we force some data into both the "dummy"
+          segment and the kernel segment, so the dummy segment will get a
+          non-zero load address.  It's not enough to always create the
+          "notes" segment, since if nothing gets assigned to it, its load
+          address will be zero.  */
+}
+
 #ifdef CONFIG_PPC64
 OUTPUT_ARCH(powerpc:common64)
 jiffies = jiffies_64;
@@ -33,11 +50,11 @@ SECTIONS
  */
 
        /* Text and gots */
-       .text : {
+       .text : AT(ADDR(.text) - LOAD_OFFSET) {
                ALIGN_FUNCTION();
                *(.text.head)
                _text = .;
-               *(.text .fixup .text.init.refok .exit.text.refok)
+               *(.text .fixup .text.init.refok .exit.text.refok __ftr_alt_*)
                SCHED_TEXT
                LOCK_TEXT
                KPROBES_TEXT
@@ -52,21 +69,25 @@ SECTIONS
                . = ALIGN(PAGE_SIZE);
                _etext = .;
                PROVIDE32 (etext = .);
-       }
+       } :kernel
 
        /* Read-only data */
        RODATA
 
        /* Exception & bug tables */
-       __ex_table : {
+       __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
                __start___ex_table = .;
                *(__ex_table)
                __stop___ex_table = .;
        }
 
-       NOTES
+       NOTES :kernel :notes
 
-       BUG_TABLE
+       /* The dummy segment contents for the bug workaround mentioned above
+          near PHDRS.  */
+       .dummy : {
+               LONG(0xf177)
+       } :kernel :dummy
 
 /*
  * Init sections discarded at runtime
@@ -74,20 +95,20 @@ SECTIONS
        . = ALIGN(PAGE_SIZE);
        __init_begin = .;
 
-       .init.text : {
+       .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
                _sinittext = .;
                INIT_TEXT
                _einittext = .;
-       }
+       } :kernel
 
        /* .exit.text is discarded at runtime, not link time,
         * to deal with references from __bug_table
         */
-       .exit.text : {
+       .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
                EXIT_TEXT
        }
 
-       .init.data : {
+       .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
                INIT_DATA
                __vtop_table_begin = .;
                *(.vtop_fixup);
@@ -103,19 +124,19 @@ SECTIONS
        }
 
        . = ALIGN(16);
-       .init.setup : {
+       .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
                __setup_start = .;
                *(.init.setup)
                __setup_end = .;
        }
 
-       .initcall.init : {
+       .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
                __initcall_start = .;
                INITCALLS
                __initcall_end = .;
                }
 
-       .con_initcall.init : {
+       .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
                __con_initcall_start = .;
                *(.con_initcall.init)
                __con_initcall_end = .;
@@ -124,14 +145,20 @@ SECTIONS
        SECURITY_INIT
 
        . = ALIGN(8);
-       __ftr_fixup : {
+       __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
                __start___ftr_fixup = .;
                *(__ftr_fixup)
                __stop___ftr_fixup = .;
        }
+       . = ALIGN(8);
+       __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
+               __start___lwsync_fixup = .;
+               *(__lwsync_fixup)
+               __stop___lwsync_fixup = .;
+       }
 #ifdef CONFIG_PPC64
        . = ALIGN(8);
-       __fw_ftr_fixup : {
+       __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
                __start___fw_ftr_fixup = .;
                *(__fw_ftr_fixup)
                __stop___fw_ftr_fixup = .;
@@ -139,14 +166,14 @@ SECTIONS
 #endif
 #ifdef CONFIG_BLK_DEV_INITRD
        . = ALIGN(PAGE_SIZE);
-       .init.ramfs : {
+       .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
                __initramfs_start = .;
                *(.init.ramfs)
                __initramfs_end = .;
        }
 #endif
        . = ALIGN(PAGE_SIZE);
-       .data.percpu : {
+       .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) {
                __per_cpu_start = .;
                *(.data.percpu)
                *(.data.percpu.shared_aligned)
@@ -154,7 +181,7 @@ SECTIONS
        }
 
        . = ALIGN(8);
-       .machine.desc : {
+       .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
                __machine_desc_start = . ;
                *(.machine.desc)
                __machine_desc_end = . ;
@@ -172,25 +199,24 @@ SECTIONS
        _sdata = .;
 
 #ifdef CONFIG_PPC32
-       .data    :
-       {
+       .data : AT(ADDR(.data) - LOAD_OFFSET) {
                DATA_DATA
                *(.sdata)
                *(.got.plt) *(.got)
        }
 #else
-       .data : {
+       .data : AT(ADDR(.data) - LOAD_OFFSET) {
                DATA_DATA
                *(.data.rel*)
                *(.toc1)
                *(.branch_lt)
        }
 
-       .opd : {
+       .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
                *(.opd)
        }
 
-       .got : {
+       .got : AT(ADDR(.got) - LOAD_OFFSET) {
                __toc_start = .;
                *(.got)
                *(.toc)
@@ -207,26 +233,26 @@ SECTIONS
 #else
        . = ALIGN(16384);
 #endif
-       .data.init_task : {
+       .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
                *(.data.init_task)
        }
 
        . = ALIGN(PAGE_SIZE);
-       .data.page_aligned : {
+       .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
                *(.data.page_aligned)
        }
 
-       .data.cacheline_aligned : {
+       .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
                *(.data.cacheline_aligned)
        }
 
        . = ALIGN(L1_CACHE_BYTES);
-       .data.read_mostly : {
+       .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
                *(.data.read_mostly)
        }
 
        . = ALIGN(PAGE_SIZE);
-       __data_nosave : {
+       .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
                __nosave_begin = .;
                *(.data.nosave)
                . = ALIGN(PAGE_SIZE);
@@ -237,7 +263,7 @@ SECTIONS
  * And finally the bss
  */
 
-       .bss : {
+       .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
                __bss_start = .;
                *(.sbss) *(.scommon)
                *(.dynbss)