2007-07-21 15:10:01 +00:00
|
|
|
#
|
2008-01-30 12:30:42 +00:00
|
|
|
# Building vDSO images for x86.
|
2007-07-21 15:10:01 +00:00
|
|
|
#
|
|
|
|
|
|
2014-02-08 08:01:05 +00:00
|
|
|
KBUILD_CFLAGS += $(DISABLE_LTO)
|
2016-02-29 04:22:34 +00:00
|
|
|
KASAN_SANITIZE := n
|
|
|
|
|
UBSAN_SANITIZE := n
|
|
|
|
|
OBJECT_FILES_NON_STANDARD := y
|
2014-02-08 08:01:05 +00:00
|
|
|
|
kernel: add kcov code coverage
kcov provides code coverage collection for coverage-guided fuzzing
(randomized testing). Coverage-guided fuzzing is a testing technique
that uses coverage feedback to determine new interesting inputs to a
system. A notable user-space example is AFL
(http://lcamtuf.coredump.cx/afl/). However, this technique is not
widely used for kernel testing due to missing compiler and kernel
support.
kcov does not aim to collect as much coverage as possible. It aims to
collect more or less stable coverage that is function of syscall inputs.
To achieve this goal it does not collect coverage in soft/hard
interrupts and instrumentation of some inherently non-deterministic or
non-interesting parts of kernel is disbled (e.g. scheduler, locking).
Currently there is a single coverage collection mode (tracing), but the
API anticipates additional collection modes. Initially I also
implemented a second mode which exposes coverage in a fixed-size hash
table of counters (what Quentin used in his original patch). I've
dropped the second mode for simplicity.
This patch adds the necessary support on kernel side. The complimentary
compiler support was added in gcc revision 231296.
We've used this support to build syzkaller system call fuzzer, which has
found 90 kernel bugs in just 2 months:
https://github.com/google/syzkaller/wiki/Found-Bugs
We've also found 30+ bugs in our internal systems with syzkaller.
Another (yet unexplored) direction where kcov coverage would greatly
help is more traditional "blob mutation". For example, mounting a
random blob as a filesystem, or receiving a random blob over wire.
Why not gcov. Typical fuzzing loop looks as follows: (1) reset
coverage, (2) execute a bit of code, (3) collect coverage, repeat. A
typical coverage can be just a dozen of basic blocks (e.g. an invalid
input). In such context gcov becomes prohibitively expensive as
reset/collect coverage steps depend on total number of basic
blocks/edges in program (in case of kernel it is about 2M). Cost of
kcov depends only on number of executed basic blocks/edges. On top of
that, kernel requires per-thread coverage because there are always
background threads and unrelated processes that also produce coverage.
With inlined gcov instrumentation per-thread coverage is not possible.
kcov exposes kernel PCs and control flow to user-space which is
insecure. But debugfs should not be mapped as user accessible.
Based on a patch by Quentin Casasnovas.
[akpm@linux-foundation.org: make task_struct.kcov_mode have type `enum kcov_mode']
[akpm@linux-foundation.org: unbreak allmodconfig]
[akpm@linux-foundation.org: follow x86 Makefile layout standards]
Signed-off-by: Dmitry Vyukov <dvyukov@google.com>
Reviewed-by: Kees Cook <keescook@chromium.org>
Cc: syzkaller <syzkaller@googlegroups.com>
Cc: Vegard Nossum <vegard.nossum@oracle.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Tavis Ormandy <taviso@google.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Quentin Casasnovas <quentin.casasnovas@oracle.com>
Cc: Kostya Serebryany <kcc@google.com>
Cc: Eric Dumazet <edumazet@google.com>
Cc: Alexander Potapenko <glider@google.com>
Cc: Kees Cook <keescook@google.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: David Drysdale <drysdale@google.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Andrey Ryabinin <ryabinin.a.a@gmail.com>
Cc: Kirill A. Shutemov <kirill@shutemov.name>
Cc: Jiri Slaby <jslaby@suse.cz>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-22 21:27:30 +00:00
|
|
|
# Prevents link failures: __sanitizer_cov_trace_pc() is not linked in.
|
|
|
|
|
KCOV_INSTRUMENT := n
|
|
|
|
|
|
2008-01-30 12:30:42 +00:00
|
|
|
VDSO64-$(CONFIG_X86_64) := y
|
2012-02-19 19:38:06 +00:00
|
|
|
VDSOX32-$(CONFIG_X86_X32_ABI) := y
|
2008-01-30 12:30:42 +00:00
|
|
|
VDSO32-$(CONFIG_X86_32) := y
|
2015-06-22 11:55:15 +00:00
|
|
|
VDSO32-$(CONFIG_IA32_EMULATION) := y
|
2008-01-30 12:30:42 +00:00
|
|
|
|
2007-07-21 15:10:01 +00:00
|
|
|
# files to link into the vdso
|
2014-07-11 01:13:16 +00:00
|
|
|
vobjs-y := vdso-note.o vclock_gettime.o vgetcpu.o
|
2012-02-19 19:38:06 +00:00
|
|
|
|
2007-07-21 15:10:01 +00:00
|
|
|
# files to link into kernel
|
2014-03-17 22:22:08 +00:00
|
|
|
obj-y += vma.o
|
2016-02-29 04:22:34 +00:00
|
|
|
OBJECT_FILES_NON_STANDARD_vma.o := n
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
|
|
|
|
|
# vDSO images to build
|
|
|
|
|
vdso_img-$(VDSO64-y) += 64
|
|
|
|
|
vdso_img-$(VDSOX32-y) += x32
|
2015-10-06 00:47:56 +00:00
|
|
|
vdso_img-$(VDSO32-y) += 32
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
|
|
|
|
|
obj-$(VDSO32-y) += vdso32-setup.o
|
2007-07-21 15:10:01 +00:00
|
|
|
|
2014-06-13 00:53:12 +00:00
|
|
|
vobjs := $(foreach F,$(vobjs-y),$(obj)/$F)
|
2007-07-21 15:10:01 +00:00
|
|
|
|
|
|
|
|
$(obj)/vdso.o: $(obj)/vdso.so
|
|
|
|
|
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
targets += vdso.lds $(vobjs-y)
|
|
|
|
|
|
|
|
|
|
# Build the vDSO image C files and link them in.
|
|
|
|
|
vdso_img_objs := $(vdso_img-y:%=vdso-image-%.o)
|
|
|
|
|
vdso_img_cfiles := $(vdso_img-y:%=vdso-image-%.c)
|
|
|
|
|
vdso_img_sodbg := $(vdso_img-y:%=vdso%.so.dbg)
|
|
|
|
|
obj-y += $(vdso_img_objs)
|
|
|
|
|
targets += $(vdso_img_cfiles)
|
|
|
|
|
targets += $(vdso_img_sodbg)
|
2014-07-11 01:13:16 +00:00
|
|
|
.SECONDARY: $(vdso_img-y:%=$(obj)/vdso-image-%.c) \
|
|
|
|
|
$(vdso_img-y:%=$(obj)/vdso%.so)
|
2007-07-21 15:10:01 +00:00
|
|
|
|
2007-11-12 19:14:19 +00:00
|
|
|
export CPPFLAGS_vdso.lds += -P -C
|
2007-07-21 15:10:01 +00:00
|
|
|
|
2010-12-14 00:01:38 +00:00
|
|
|
VDSO_LDFLAGS_vdso.lds = -m64 -Wl,-soname=linux-vdso.so.1 \
|
2011-07-13 13:24:12 +00:00
|
|
|
-Wl,--no-undefined \
|
2014-02-08 08:01:05 +00:00
|
|
|
-Wl,-z,max-page-size=4096 -Wl,-z,common-page-size=4096 \
|
|
|
|
|
$(DISABLE_LTO)
|
2007-07-21 15:10:01 +00:00
|
|
|
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
$(obj)/vdso64.so.dbg: $(src)/vdso.lds $(vobjs) FORCE
|
2008-01-30 12:30:44 +00:00
|
|
|
$(call if_changed,vdso)
|
2007-07-21 15:10:01 +00:00
|
|
|
|
2015-05-11 08:15:50 +00:00
|
|
|
HOST_EXTRACFLAGS += -I$(srctree)/tools/include -I$(srctree)/include/uapi -I$(srctree)/arch/x86/include/uapi
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
hostprogs-y += vdso2c
|
|
|
|
|
|
|
|
|
|
quiet_cmd_vdso2c = VDSO2C $@
|
|
|
|
|
define cmd_vdso2c
|
2014-07-11 01:13:16 +00:00
|
|
|
$(obj)/vdso2c $< $(<:%.dbg=%) $@
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
endef
|
|
|
|
|
|
2014-07-11 01:13:16 +00:00
|
|
|
$(obj)/vdso-image-%.c: $(obj)/vdso%.so.dbg $(obj)/vdso%.so $(obj)/vdso2c FORCE
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
$(call if_changed,vdso2c)
|
2007-10-17 16:04:32 +00:00
|
|
|
|
2011-05-23 13:31:29 +00:00
|
|
|
#
|
|
|
|
|
# Don't omit frame pointers for ease of userspace debugging, but do
|
|
|
|
|
# optimize sibling calls.
|
|
|
|
|
#
|
2008-04-14 19:19:30 +00:00
|
|
|
CFL := $(PROFILING) -mcmodel=small -fPIC -O2 -fasynchronous-unwind-tables -m64 \
|
2011-05-23 13:31:29 +00:00
|
|
|
$(filter -g%,$(KBUILD_CFLAGS)) $(call cc-option, -fno-stack-protector) \
|
2014-06-24 20:46:52 +00:00
|
|
|
-fno-omit-frame-pointer -foptimize-sibling-calls \
|
2015-10-06 00:47:58 +00:00
|
|
|
-DDISABLE_BRANCH_PROFILING -DBUILD_VDSO
|
2007-07-21 15:10:01 +00:00
|
|
|
|
2008-03-19 17:25:53 +00:00
|
|
|
$(vobjs): KBUILD_CFLAGS += $(CFL)
|
2007-07-21 15:10:01 +00:00
|
|
|
|
2011-05-23 13:31:29 +00:00
|
|
|
#
|
|
|
|
|
# vDSO code runs in userspace and -pg doesn't help with profiling anyway.
|
|
|
|
|
#
|
|
|
|
|
CFLAGS_REMOVE_vdso-note.o = -pg
|
|
|
|
|
CFLAGS_REMOVE_vclock_gettime.o = -pg
|
|
|
|
|
CFLAGS_REMOVE_vgetcpu.o = -pg
|
|
|
|
|
CFLAGS_REMOVE_vvar.o = -pg
|
|
|
|
|
|
2012-02-19 19:38:06 +00:00
|
|
|
#
|
|
|
|
|
# X32 processes use x32 vDSO to access 64bit kernel data.
|
|
|
|
|
#
|
|
|
|
|
# Build x32 vDSO image:
|
|
|
|
|
# 1. Compile x32 vDSO as 64bit.
|
|
|
|
|
# 2. Convert object files to x32.
|
|
|
|
|
# 3. Build x32 VDSO image with x32 objects, which contains 64bit codes
|
|
|
|
|
# so that it can reach 64bit address space with 64bit pointers.
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
CPPFLAGS_vdsox32.lds = $(CPPFLAGS_vdso.lds)
|
|
|
|
|
VDSO_LDFLAGS_vdsox32.lds = -Wl,-m,elf32_x86_64 \
|
|
|
|
|
-Wl,-soname=linux-vdso.so.1 \
|
|
|
|
|
-Wl,-z,max-page-size=4096 \
|
|
|
|
|
-Wl,-z,common-page-size=4096
|
|
|
|
|
|
2014-06-13 00:53:12 +00:00
|
|
|
# 64-bit objects to re-brand as x32
|
|
|
|
|
vobjs64-for-x32 := $(filter-out $(vobjs-nox32),$(vobjs-y))
|
|
|
|
|
|
|
|
|
|
# x32-rebranded versions
|
|
|
|
|
vobjx32s-y := $(vobjs64-for-x32:.o=-x32.o)
|
|
|
|
|
|
|
|
|
|
# same thing, but in the output directory
|
2012-02-19 19:38:06 +00:00
|
|
|
vobjx32s := $(foreach F,$(vobjx32s-y),$(obj)/$F)
|
|
|
|
|
|
|
|
|
|
# Convert 64bit object file to x32 for x32 vDSO.
|
|
|
|
|
quiet_cmd_x32 = X32 $@
|
|
|
|
|
cmd_x32 = $(OBJCOPY) -O elf32-x86-64 $< $@
|
|
|
|
|
|
|
|
|
|
$(obj)/%-x32.o: $(obj)/%.o FORCE
|
|
|
|
|
$(call if_changed,x32)
|
|
|
|
|
|
x86, vdso: Reimplement vdso.so preparation in build-time C
Currently, vdso.so files are prepared and analyzed by a combination
of objcopy, nm, some linker script tricks, and some simple ELF
parsers in the kernel. Replace all of that with plain C code that
runs at build time.
All five vdso images now generate .c files that are compiled and
linked in to the kernel image.
This should cause only one userspace-visible change: the loaded vDSO
images are stripped more heavily than they used to be. Everything
outside the loadable segment is dropped. In particular, this causes
the section table and section name strings to be missing. This
should be fine: real dynamic loaders don't load or inspect these
tables anyway. The result is roughly equivalent to eu-strip's
--strip-sections option.
The purpose of this change is to enable the vvar and hpet mappings
to be moved to the page following the vDSO load segment. Currently,
it is possible for the section table to extend into the page after
the load segment, so, if we map it, it risks overlapping the vvar or
hpet page. This happens whenever the load segment is just under a
multiple of PAGE_SIZE.
The only real subtlety here is that the old code had a C file with
inline assembler that did 'call VDSO32_vsyscall' and a linker script
that defined 'VDSO32_vsyscall = __kernel_vsyscall'. This most
likely worked by accident: the linker script entry defines a symbol
associated with an address as opposed to an alias for the real
dynamic symbol __kernel_vsyscall. That caused ld to relocate the
reference at link time instead of leaving an interposable dynamic
relocation. Since the VDSO32_vsyscall hack is no longer needed, I
now use 'call __kernel_vsyscall', and I added -Bsymbolic to make it
work. vdso2c will generate an error and abort the build if the
resulting image contains any dynamic relocations, so we won't
silently generate bad vdso images.
(Dynamic relocations are a problem because nothing will even attempt
to relocate the vdso.)
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/2c4fcf45524162a34d87fdda1eb046b2a5cecee7.1399317206.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-05 19:19:34 +00:00
|
|
|
targets += vdsox32.lds $(vobjx32s-y)
|
2012-02-19 19:38:06 +00:00
|
|
|
|
2014-07-11 01:13:16 +00:00
|
|
|
$(obj)/%.so: OBJCOPYFLAGS := -S
|
|
|
|
|
$(obj)/%.so: $(obj)/%.so.dbg
|
|
|
|
|
$(call if_changed,objcopy)
|
|
|
|
|
|
2012-02-19 19:38:06 +00:00
|
|
|
$(obj)/vdsox32.so.dbg: $(src)/vdsox32.lds $(vobjx32s) FORCE
|
|
|
|
|
$(call if_changed,vdso)
|
|
|
|
|
|
2008-01-30 12:30:42 +00:00
|
|
|
CPPFLAGS_vdso32.lds = $(CPPFLAGS_vdso.lds)
|
2014-02-08 08:01:05 +00:00
|
|
|
VDSO_LDFLAGS_vdso32.lds = -m32 -Wl,-m,elf_i386 -Wl,-soname=linux-gate.so.1
|
2008-01-30 12:30:42 +00:00
|
|
|
|
|
|
|
|
# This makes sure the $(obj) subdirectory exists even though vdso32/
|
|
|
|
|
# is not a kbuild sub-make subdirectory.
|
|
|
|
|
override obj-dirs = $(dir $(obj)) $(obj)/vdso32/
|
|
|
|
|
|
|
|
|
|
targets += vdso32/vdso32.lds
|
2015-10-06 00:47:56 +00:00
|
|
|
targets += vdso32/note.o vdso32/vclock_gettime.o vdso32/system_call.o
|
2014-07-11 01:13:16 +00:00
|
|
|
targets += vdso32/vclock_gettime.o
|
2008-01-30 12:30:42 +00:00
|
|
|
|
2015-10-06 00:47:58 +00:00
|
|
|
KBUILD_AFLAGS_32 := $(filter-out -m64,$(KBUILD_AFLAGS)) -DBUILD_VDSO
|
2015-10-06 00:47:56 +00:00
|
|
|
$(obj)/vdso32.so.dbg: KBUILD_AFLAGS = $(KBUILD_AFLAGS_32)
|
|
|
|
|
$(obj)/vdso32.so.dbg: asflags-$(CONFIG_X86_64) += -m32
|
2008-01-30 12:30:42 +00:00
|
|
|
|
2014-03-17 22:22:09 +00:00
|
|
|
KBUILD_CFLAGS_32 := $(filter-out -m64,$(KBUILD_CFLAGS))
|
|
|
|
|
KBUILD_CFLAGS_32 := $(filter-out -mcmodel=kernel,$(KBUILD_CFLAGS_32))
|
|
|
|
|
KBUILD_CFLAGS_32 := $(filter-out -fno-pic,$(KBUILD_CFLAGS_32))
|
|
|
|
|
KBUILD_CFLAGS_32 := $(filter-out -mfentry,$(KBUILD_CFLAGS_32))
|
|
|
|
|
KBUILD_CFLAGS_32 += -m32 -msoft-float -mregparm=0 -fpic
|
2014-03-17 22:22:12 +00:00
|
|
|
KBUILD_CFLAGS_32 += $(call cc-option, -fno-stack-protector)
|
|
|
|
|
KBUILD_CFLAGS_32 += $(call cc-option, -foptimize-sibling-calls)
|
|
|
|
|
KBUILD_CFLAGS_32 += -fno-omit-frame-pointer
|
2014-06-24 20:46:52 +00:00
|
|
|
KBUILD_CFLAGS_32 += -DDISABLE_BRANCH_PROFILING
|
2015-10-06 00:47:56 +00:00
|
|
|
$(obj)/vdso32.so.dbg: KBUILD_CFLAGS = $(KBUILD_CFLAGS_32)
|
2014-03-17 22:22:09 +00:00
|
|
|
|
2015-10-06 00:47:56 +00:00
|
|
|
$(obj)/vdso32.so.dbg: FORCE \
|
|
|
|
|
$(obj)/vdso32/vdso32.lds \
|
|
|
|
|
$(obj)/vdso32/vclock_gettime.o \
|
|
|
|
|
$(obj)/vdso32/note.o \
|
|
|
|
|
$(obj)/vdso32/system_call.o
|
2008-01-30 12:30:42 +00:00
|
|
|
$(call if_changed,vdso)
|
|
|
|
|
|
|
|
|
|
#
|
|
|
|
|
# The DSO images are built using a special linker script.
|
|
|
|
|
#
|
|
|
|
|
quiet_cmd_vdso = VDSO $@
|
|
|
|
|
cmd_vdso = $(CC) -nostdlib -o $@ \
|
|
|
|
|
$(VDSO_LDFLAGS) $(VDSO_LDFLAGS_$(filter %.lds,$(^F))) \
|
2010-06-18 21:36:26 +00:00
|
|
|
-Wl,-T,$(filter %.lds,$^) $(filter %.o,$^) && \
|
|
|
|
|
sh $(srctree)/$(src)/checkundef.sh '$(NM)' '$@'
|
2008-01-30 12:30:42 +00:00
|
|
|
|
2015-08-06 21:45:45 +00:00
|
|
|
VDSO_LDFLAGS = -fPIC -shared $(call cc-ldoption, -Wl$(comma)--hash-style=both) \
|
2014-06-20 19:20:44 +00:00
|
|
|
$(call cc-ldoption, -Wl$(comma)--build-id) -Wl,-Bsymbolic $(LTO_CFLAGS)
|
2009-06-17 23:28:09 +00:00
|
|
|
GCOV_PROFILE := n
|
2008-01-30 12:30:42 +00:00
|
|
|
|
|
|
|
|
#
|
2014-06-20 19:20:44 +00:00
|
|
|
# Install the unstripped copies of vdso*.so. If our toolchain supports
|
|
|
|
|
# build-id, install .build-id links as well.
|
2008-01-30 12:30:42 +00:00
|
|
|
#
|
2014-06-12 15:28:10 +00:00
|
|
|
quiet_cmd_vdso_install = INSTALL $(@:install_%=%)
|
2014-06-20 19:20:44 +00:00
|
|
|
define cmd_vdso_install
|
|
|
|
|
cp $< "$(MODLIB)/vdso/$(@:install_%=%)"; \
|
|
|
|
|
if readelf -n $< |grep -q 'Build ID'; then \
|
|
|
|
|
buildid=`readelf -n $< |grep 'Build ID' |sed -e 's/^.*Build ID: \(.*\)$$/\1/'`; \
|
|
|
|
|
first=`echo $$buildid | cut -b-2`; \
|
|
|
|
|
last=`echo $$buildid | cut -b3-`; \
|
|
|
|
|
mkdir -p "$(MODLIB)/vdso/.build-id/$$first"; \
|
|
|
|
|
ln -sf "../../$(@:install_%=%)" "$(MODLIB)/vdso/.build-id/$$first/$$last.debug"; \
|
|
|
|
|
fi
|
|
|
|
|
endef
|
2014-06-12 15:28:10 +00:00
|
|
|
|
|
|
|
|
vdso_img_insttargets := $(vdso_img_sodbg:%.dbg=install_%)
|
|
|
|
|
|
|
|
|
|
$(MODLIB)/vdso: FORCE
|
2007-10-17 16:04:32 +00:00
|
|
|
@mkdir -p $(MODLIB)/vdso
|
2014-06-12 15:28:10 +00:00
|
|
|
|
2016-03-13 00:13:55 +00:00
|
|
|
$(vdso_img_insttargets): install_%: $(obj)/%.dbg $(MODLIB)/vdso
|
2007-10-17 16:04:32 +00:00
|
|
|
$(call cmd,vdso_install)
|
|
|
|
|
|
2014-06-12 15:28:10 +00:00
|
|
|
PHONY += vdso_install $(vdso_img_insttargets)
|
2016-03-13 00:13:55 +00:00
|
|
|
vdso_install: $(vdso_img_insttargets)
|
2008-01-30 12:32:27 +00:00
|
|
|
|
2015-10-06 00:47:56 +00:00
|
|
|
clean-files := vdso32.so vdso32.so.dbg vdso64* vdso-image-*.c vdsox32.so*
|