2019-05-31 08:09:38 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2010-10-13 23:06:14 +00:00
|
|
|
/*
|
|
|
|
|
* recordmcount.h
|
|
|
|
|
*
|
|
|
|
|
* This code was taken out of recordmcount.c written by
|
|
|
|
|
* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. 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 <srostedt@redhat.com>, Red Hat Inc.
|
|
|
|
|
*/
|
|
|
|
|
#undef append_func
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
#undef is_fake_mcount
|
|
|
|
|
#undef fn_is_fake_mcount
|
|
|
|
|
#undef MIPS_is_fake_mcount
|
2011-05-10 08:10:40 +00:00
|
|
|
#undef mcount_adjust
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef sift_rel_mcount
|
2011-04-08 07:58:48 +00:00
|
|
|
#undef nop_mcount
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef find_secsym_ndx
|
|
|
|
|
#undef __has_rel_mcount
|
|
|
|
|
#undef has_rel_mcount
|
|
|
|
|
#undef tot_relsize
|
2011-04-21 00:47:34 +00:00
|
|
|
#undef get_mcountsym
|
2020-04-24 19:30:46 +00:00
|
|
|
#undef find_symtab
|
|
|
|
|
#undef get_shnum
|
|
|
|
|
#undef set_shnum
|
|
|
|
|
#undef get_shstrndx
|
|
|
|
|
#undef get_symindex
|
2011-04-21 01:13:06 +00:00
|
|
|
#undef get_sym_str_and_relp
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef do_func
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
#undef Elf_Addr
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef Elf_Ehdr
|
|
|
|
|
#undef Elf_Shdr
|
|
|
|
|
#undef Elf_Rel
|
|
|
|
|
#undef Elf_Rela
|
|
|
|
|
#undef Elf_Sym
|
|
|
|
|
#undef ELF_R_SYM
|
2010-10-27 10:59:07 +00:00
|
|
|
#undef Elf_r_sym
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef ELF_R_INFO
|
2010-10-27 10:59:07 +00:00
|
|
|
#undef Elf_r_info
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef ELF_ST_BIND
|
2011-05-11 17:23:51 +00:00
|
|
|
#undef ELF_ST_TYPE
|
2010-10-27 10:59:07 +00:00
|
|
|
#undef fn_ELF_R_SYM
|
|
|
|
|
#undef fn_ELF_R_INFO
|
2010-10-13 23:06:14 +00:00
|
|
|
#undef uint_t
|
|
|
|
|
#undef _w
|
|
|
|
|
#undef _align
|
|
|
|
|
#undef _size
|
|
|
|
|
|
|
|
|
|
#ifdef RECORD_MCOUNT_64
|
|
|
|
|
# define append_func append64
|
|
|
|
|
# define sift_rel_mcount sift64_rel_mcount
|
2011-04-08 07:58:48 +00:00
|
|
|
# define nop_mcount nop_mcount_64
|
2010-10-13 23:06:14 +00:00
|
|
|
# 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
|
2020-04-24 19:30:46 +00:00
|
|
|
# define find_symtab find_symtab64
|
|
|
|
|
# define get_shnum get_shnum64
|
|
|
|
|
# define set_shnum set_shnum64
|
|
|
|
|
# define get_shstrndx get_shstrndx64
|
|
|
|
|
# define get_symindex get_symindex64
|
2011-04-21 01:13:06 +00:00
|
|
|
# define get_sym_str_and_relp get_sym_str_and_relp_64
|
2010-10-13 23:06:14 +00:00
|
|
|
# define do_func do64
|
2011-04-21 00:47:34 +00:00
|
|
|
# define get_mcountsym get_mcountsym_64
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
# 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
|
2011-05-10 08:10:40 +00:00
|
|
|
# define mcount_adjust mcount_adjust_64
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
# define Elf_Addr Elf64_Addr
|
2010-10-13 23:06:14 +00:00
|
|
|
# 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
|
2010-10-27 10:59:07 +00:00
|
|
|
# define Elf_r_sym Elf64_r_sym
|
2010-10-13 23:06:14 +00:00
|
|
|
# define ELF_R_INFO ELF64_R_INFO
|
2010-10-27 10:59:07 +00:00
|
|
|
# define Elf_r_info Elf64_r_info
|
2010-10-13 23:06:14 +00:00
|
|
|
# define ELF_ST_BIND ELF64_ST_BIND
|
2011-05-11 17:23:51 +00:00
|
|
|
# define ELF_ST_TYPE ELF64_ST_TYPE
|
2010-10-27 10:59:07 +00:00
|
|
|
# define fn_ELF_R_SYM fn_ELF64_R_SYM
|
|
|
|
|
# define fn_ELF_R_INFO fn_ELF64_R_INFO
|
2010-10-13 23:06:14 +00:00
|
|
|
# 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
|
2011-04-08 07:58:48 +00:00
|
|
|
# define nop_mcount nop_mcount_32
|
2010-10-13 23:06:14 +00:00
|
|
|
# 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
|
2020-04-24 19:30:46 +00:00
|
|
|
# define find_symtab find_symtab32
|
|
|
|
|
# define get_shnum get_shnum32
|
|
|
|
|
# define set_shnum set_shnum32
|
|
|
|
|
# define get_shstrndx get_shstrndx32
|
|
|
|
|
# define get_symindex get_symindex32
|
2011-04-21 01:13:06 +00:00
|
|
|
# define get_sym_str_and_relp get_sym_str_and_relp_32
|
2010-10-13 23:06:14 +00:00
|
|
|
# define do_func do32
|
2011-04-21 00:47:34 +00:00
|
|
|
# define get_mcountsym get_mcountsym_32
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
# 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
|
2011-05-10 08:10:40 +00:00
|
|
|
# define mcount_adjust mcount_adjust_32
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
# define Elf_Addr Elf32_Addr
|
2010-10-13 23:06:14 +00:00
|
|
|
# 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
|
2010-10-27 10:59:07 +00:00
|
|
|
# define Elf_r_sym Elf32_r_sym
|
2010-10-13 23:06:14 +00:00
|
|
|
# define ELF_R_INFO ELF32_R_INFO
|
2010-10-27 10:59:07 +00:00
|
|
|
# define Elf_r_info Elf32_r_info
|
2010-10-13 23:06:14 +00:00
|
|
|
# define ELF_ST_BIND ELF32_ST_BIND
|
2011-05-11 17:23:51 +00:00
|
|
|
# define ELF_ST_TYPE ELF32_ST_TYPE
|
2010-10-27 10:59:07 +00:00
|
|
|
# define fn_ELF_R_SYM fn_ELF32_R_SYM
|
|
|
|
|
# define fn_ELF_R_INFO fn_ELF32_R_INFO
|
2010-10-13 23:06:14 +00:00
|
|
|
# define uint_t uint32_t
|
|
|
|
|
# define _w w
|
|
|
|
|
# define _align 3u
|
|
|
|
|
# define _size 4
|
|
|
|
|
#endif
|
|
|
|
|
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
/* Functions and pointers that do_file() may override for specific e_machine. */
|
|
|
|
|
static int fn_is_fake_mcount(Elf_Rel const *rp)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
static int (*is_fake_mcount)(Elf_Rel const *rp) = fn_is_fake_mcount;
|
|
|
|
|
|
2010-10-27 10:59:07 +00:00
|
|
|
static uint_t fn_ELF_R_SYM(Elf_Rel const *rp)
|
|
|
|
|
{
|
|
|
|
|
return ELF_R_SYM(_w(rp->r_info));
|
|
|
|
|
}
|
|
|
|
|
static uint_t (*Elf_r_sym)(Elf_Rel const *rp) = fn_ELF_R_SYM;
|
|
|
|
|
|
|
|
|
|
static void fn_ELF_R_INFO(Elf_Rel *const rp, unsigned sym, unsigned type)
|
|
|
|
|
{
|
2010-11-23 03:41:44 +00:00
|
|
|
rp->r_info = _w(ELF_R_INFO(sym, type));
|
2010-10-27 10:59:07 +00:00
|
|
|
}
|
|
|
|
|
static void (*Elf_r_info)(Elf_Rel *const rp, unsigned sym, unsigned type) = fn_ELF_R_INFO;
|
|
|
|
|
|
2011-05-10 08:10:40 +00:00
|
|
|
static int mcount_adjust = 0;
|
|
|
|
|
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
* tracing(ftrace_make_nop), the instruction in the position is replaced with
|
|
|
|
|
* the "b label" instruction, to enable tracing(ftrace_make_call), replace the
|
|
|
|
|
* instruction back. So, here, we set the 2nd one as fake and filter it.
|
|
|
|
|
*
|
|
|
|
|
* c: 3c030000 lui v1,0x0 <--> b label
|
|
|
|
|
* c: R_MIPS_HI16 _mcount
|
|
|
|
|
* c: R_MIPS_NONE *ABS*
|
|
|
|
|
* c: R_MIPS_NONE *ABS*
|
|
|
|
|
* 10: 64630000 daddiu v1,v1,0
|
|
|
|
|
* 10: R_MIPS_LO16 _mcount
|
|
|
|
|
* 10: R_MIPS_NONE *ABS*
|
|
|
|
|
* 10: R_MIPS_NONE *ABS*
|
|
|
|
|
* 14: 03e0082d move at,ra
|
|
|
|
|
* 18: 0060f809 jalr v1
|
|
|
|
|
* label:
|
|
|
|
|
*/
|
|
|
|
|
#define MIPS_FAKEMCOUNT_OFFSET 4
|
|
|
|
|
|
|
|
|
|
static int MIPS_is_fake_mcount(Elf_Rel const *rp)
|
|
|
|
|
{
|
2014-06-17 09:39:53 +00:00
|
|
|
static Elf_Addr old_r_offset = ~(Elf_Addr)0;
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
Elf_Addr current_r_offset = _w(rp->r_offset);
|
|
|
|
|
int is_fake;
|
|
|
|
|
|
2014-06-17 09:39:53 +00:00
|
|
|
is_fake = (old_r_offset != ~(Elf_Addr)0) &&
|
ftrace/MIPS: Add module support for C version of recordmcount
Since MIPS modules' address space differs from the core kernel space, to access
the _mcount in the core kernel, the kernel functions in modules must use long
call (-mlong-calls): load the _mcount address into one register and jump to the
address stored by the register:
c: 3c030000 lui v1,0x0 <--------> b label
c: R_MIPS_HI16 _mcount
c: R_MIPS_NONE *ABS*
c: R_MIPS_NONE *ABS*
10: 64630000 daddiu v1,v1,0
10: R_MIPS_LO16 _mcount
10: R_MIPS_NONE *ABS*
10: R_MIPS_NONE *ABS*
14: 03e0082d move at,ra
18: 0060f809 jalr v1
label:
In the old Perl version of recordmcount, we only need to record the position of
the 1st R_MIPS_HI16 type of _mcount, and later, in ftrace_make_nop(), replace
the instruction in this position by a "b label" and in ftrace_make_call(),
replace it back.
But, the default C version of recordmcount records all of the _mcount symbols,
so, we must filter the 2nd _mcount like the Perl version of recordmcount does.
The C version of recordmcount copes with the symbols before they are linked, So
It doesn't know the type of the symbols and therefore can not filter the
symbols as the Perl version of recordmcount does. But as we can see above, the
2nd _mcount symbols of the long call alawys follows the 1st _mcount symbol of
the same long call, which means the offset from the 1st to the 2nd is fixed, it
is 0x10-0xc = 4 here, 4 is the length of the 1st load instruciton, for MIPS has
fixed length of instructions, this offset is always 4.
And as we know, the _mcount is inserted into the entry of every kernel
function, the offset between the other _mcount's is expected to be always
bigger than 4. So, to filter the 2ns _mcount symbol of the long call, we can
simply check the offset between two _mcount symbols, If it is 4, then, filter
the 2nd _mcount symbol.
To avoid touching too much code, an 'empty' function fn_is_fake_mcount() is
added for all of the archs, and the specific archs can override it via chaning
the function pointer: is_fake_mcount in do_file() with the e_machine. e.g. This
patch adds MIPS_is_fake_mcount() to override the default fn_is_fake_mcount()
pointed by is_fake_mcount.
This fn_is_fake_mcount() checks if the _mcount symbol is fake, e.g. the 2nd
_mcount symbol of the long call is fake, for there are 2 _mcount symbols mapped
to one real mcount call, so, one of them is fake and must be filtered.
This fn_is_fake_mcount() is called in sift_rel_mcount() after finding the
_mcount symbols and before adding the _mcount symbol into mrelp, so, it can
prevent the fake mcount symbol going into the last __mcount_loc table.
Signed-off-by: Wu Zhangjin <wuzhangjin@gmail.com>
LKML-Reference: <b866f0138224340a132d31861fa3f9300dee30ac.1288176026.git.wuzhangjin@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2010-10-27 10:59:08 +00:00
|
|
|
(current_r_offset - old_r_offset == MIPS_FAKEMCOUNT_OFFSET);
|
|
|
|
|
old_r_offset = current_r_offset;
|
|
|
|
|
|
|
|
|
|
return is_fake;
|
|
|
|
|
}
|
2010-10-27 10:59:07 +00:00
|
|
|
|
2020-04-24 19:30:46 +00:00
|
|
|
static unsigned int get_symindex(Elf_Sym const *sym, Elf32_Word const *symtab,
|
|
|
|
|
Elf32_Word const *symtab_shndx)
|
|
|
|
|
{
|
|
|
|
|
unsigned long offset;
|
2021-06-16 15:41:26 +00:00
|
|
|
unsigned short shndx = w2(sym->st_shndx);
|
2020-04-24 19:30:46 +00:00
|
|
|
int index;
|
|
|
|
|
|
2021-06-16 15:41:26 +00:00
|
|
|
if (shndx > SHN_UNDEF && shndx < SHN_LORESERVE)
|
|
|
|
|
return shndx;
|
2020-04-24 19:30:46 +00:00
|
|
|
|
2021-06-16 15:41:26 +00:00
|
|
|
if (shndx == SHN_XINDEX) {
|
|
|
|
|
offset = (unsigned long)sym - (unsigned long)symtab;
|
|
|
|
|
index = offset / sizeof(*sym);
|
2020-04-24 19:30:46 +00:00
|
|
|
|
2021-06-16 15:41:26 +00:00
|
|
|
return w(symtab_shndx[index]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
2020-04-24 19:30:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned int get_shnum(Elf_Ehdr const *ehdr, Elf_Shdr const *shdr0)
|
|
|
|
|
{
|
|
|
|
|
if (shdr0 && !ehdr->e_shnum)
|
|
|
|
|
return w(shdr0->sh_size);
|
|
|
|
|
|
|
|
|
|
return w2(ehdr->e_shnum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_shnum(Elf_Ehdr *ehdr, Elf_Shdr *shdr0, unsigned int new_shnum)
|
|
|
|
|
{
|
|
|
|
|
if (new_shnum >= SHN_LORESERVE) {
|
|
|
|
|
ehdr->e_shnum = 0;
|
|
|
|
|
shdr0->sh_size = w(new_shnum);
|
|
|
|
|
} else
|
|
|
|
|
ehdr->e_shnum = w2(new_shnum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int get_shstrndx(Elf_Ehdr const *ehdr, Elf_Shdr const *shdr0)
|
|
|
|
|
{
|
|
|
|
|
if (ehdr->e_shstrndx != SHN_XINDEX)
|
|
|
|
|
return w2(ehdr->e_shstrndx);
|
|
|
|
|
|
|
|
|
|
return w(shdr0->sh_link);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void find_symtab(Elf_Ehdr *const ehdr, Elf_Shdr const *shdr0,
|
|
|
|
|
unsigned const nhdr, Elf32_Word **symtab,
|
|
|
|
|
Elf32_Word **symtab_shndx)
|
|
|
|
|
{
|
|
|
|
|
Elf_Shdr const *relhdr;
|
|
|
|
|
unsigned k;
|
|
|
|
|
|
|
|
|
|
*symtab = NULL;
|
|
|
|
|
*symtab_shndx = NULL;
|
|
|
|
|
|
|
|
|
|
for (relhdr = shdr0, k = nhdr; k; --k, ++relhdr) {
|
|
|
|
|
if (relhdr->sh_type == SHT_SYMTAB)
|
|
|
|
|
*symtab = (void *)ehdr + relhdr->sh_offset;
|
|
|
|
|
else if (relhdr->sh_type == SHT_SYMTAB_SHNDX)
|
|
|
|
|
*symtab_shndx = (void *)ehdr + relhdr->sh_offset;
|
|
|
|
|
|
|
|
|
|
if (*symtab && *symtab_shndx)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
/* Append the new shstrtab, Elf_Shdr[], __mcount_loc and its relocations. */
|
2019-07-31 18:24:12 +00:00
|
|
|
static int append_func(Elf_Ehdr *const ehdr,
|
2010-10-13 23:06:14 +00:00
|
|
|
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";
|
|
|
|
|
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);
|
2020-04-24 19:30:46 +00:00
|
|
|
Elf_Shdr *const shdr0 = (Elf_Shdr *)(old_shoff + (void *)ehdr);
|
|
|
|
|
unsigned int const old_shnum = get_shnum(ehdr, shdr0);
|
|
|
|
|
unsigned int const new_shnum = 2 + old_shnum; /* {.rel,}__mcount_loc */
|
2010-10-13 23:06:14 +00:00
|
|
|
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;
|
|
|
|
|
|
2020-04-24 19:30:46 +00:00
|
|
|
set_shnum(ehdr, shdr0, new_shnum);
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
/* body for new shstrtab */
|
2019-07-31 18:24:12 +00:00
|
|
|
if (ulseek(sb.st_size, SEEK_SET) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (uwrite(old_shstr_sh_offset + (void *)ehdr, old_shstr_sh_size) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (uwrite(mc_name, 1 + strlen(mc_name)) < 0)
|
|
|
|
|
return -1;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
/* old(modified) Elf_Shdr table, word-byte aligned */
|
2019-07-31 18:24:12 +00:00
|
|
|
if (ulseek(t, SEEK_SET) < 0)
|
|
|
|
|
return -1;
|
2010-10-13 23:06:14 +00:00
|
|
|
t += sizeof(Elf_Shdr) * old_shnum;
|
2019-07-31 18:24:12 +00:00
|
|
|
if (uwrite(old_shoff + (void *)ehdr,
|
|
|
|
|
sizeof(Elf_Shdr) * old_shnum) < 0)
|
|
|
|
|
return -1;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
/* 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);
|
2019-07-31 18:24:12 +00:00
|
|
|
if (uwrite(&mcsec, sizeof(mcsec)) < 0)
|
|
|
|
|
return -1;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
2019-07-31 18:24:12 +00:00
|
|
|
if (uwrite(&mcsec, sizeof(mcsec)) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (uwrite(mloc0, (void *)mlocp - (void *)mloc0) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (uwrite(mrel0, (void *)mrelp - (void *)mrel0) < 0)
|
|
|
|
|
return -1;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
ehdr->e_shoff = _w(new_e_shoff);
|
2019-07-31 18:24:12 +00:00
|
|
|
if (ulseek(0, SEEK_SET) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (uwrite(ehdr, sizeof(*ehdr)) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
2010-10-13 23:06:14 +00:00
|
|
|
}
|
|
|
|
|
|
2011-04-21 00:47:34 +00:00
|
|
|
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";
|
2011-02-09 18:13:23 +00:00
|
|
|
char const *fentry = "__fentry__";
|
2011-04-21 00:47:34 +00:00
|
|
|
|
|
|
|
|
if (symname[0] == '.')
|
|
|
|
|
++symname; /* ppc64 hack */
|
|
|
|
|
if (strcmp(mcount, symname) == 0 ||
|
2011-02-09 18:13:23 +00:00
|
|
|
(altmcount && strcmp(altmcount, symname) == 0) ||
|
|
|
|
|
(strcmp(fentry, symname) == 0))
|
2011-04-21 00:47:34 +00:00
|
|
|
mcountsym = Elf_r_sym(relp);
|
|
|
|
|
|
|
|
|
|
return mcountsym;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-21 01:13:06 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
/*
|
|
|
|
|
* 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;
|
2011-04-21 01:13:06 +00:00
|
|
|
Elf_Sym const *sym0;
|
|
|
|
|
char const *str0;
|
|
|
|
|
Elf_Rel const *relp;
|
2010-10-13 23:06:14 +00:00
|
|
|
unsigned rel_entsize = _w(relhdr->sh_entsize);
|
|
|
|
|
unsigned const nrel = _w(relhdr->sh_size) / rel_entsize;
|
|
|
|
|
unsigned mcountsym = 0;
|
|
|
|
|
unsigned t;
|
|
|
|
|
|
2011-04-21 01:13:06 +00:00
|
|
|
get_sym_str_and_relp(relhdr, ehdr, &sym0, &str0, &relp);
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
for (t = nrel; t; --t) {
|
2011-04-21 00:47:34 +00:00
|
|
|
if (!mcountsym)
|
|
|
|
|
mcountsym = get_mcountsym(sym0, relp, str0);
|
2010-10-13 23:06:14 +00:00
|
|
|
|
recordmcount: Fix spurious mcount entries on powerpc
An impending change to enable HAVE_C_RECORDMCOUNT on powerpc leads to
warnings such as the following:
# modprobe kprobe_example
ftrace-powerpc: Not expected bl: opcode is 3c4c0001
WARNING: CPU: 0 PID: 227 at kernel/trace/ftrace.c:2001 ftrace_bug+0x90/0x318
Modules linked in:
CPU: 0 PID: 227 Comm: modprobe Not tainted 5.2.0-rc6-00678-g1c329100b942 #2
NIP: c000000000264318 LR: c00000000025d694 CTR: c000000000f5cd30
REGS: c000000001f2b7b0 TRAP: 0700 Not tainted (5.2.0-rc6-00678-g1c329100b942)
MSR: 900000010282b033 <SF,HV,VEC,VSX,EE,FP,ME,IR,DR,RI,LE,TM[E]> CR: 28228222 XER: 00000000
CFAR: c0000000002642fc IRQMASK: 0
<snip>
NIP [c000000000264318] ftrace_bug+0x90/0x318
LR [c00000000025d694] ftrace_process_locs+0x4f4/0x5e0
Call Trace:
[c000000001f2ba40] [0000000000000004] 0x4 (unreliable)
[c000000001f2bad0] [c00000000025d694] ftrace_process_locs+0x4f4/0x5e0
[c000000001f2bb90] [c00000000020ff10] load_module+0x25b0/0x30c0
[c000000001f2bd00] [c000000000210cb0] sys_finit_module+0xc0/0x130
[c000000001f2be20] [c00000000000bda4] system_call+0x5c/0x70
Instruction dump:
419e0018 2f83ffff 419e00bc 2f83ffea 409e00cc 4800001c 0fe00000 3c62ff96
39000001 39400000 386386d0 480000c4 <0fe00000> 3ce20003 39000001 3c62ff96
---[ end trace 4c438d5cebf78381 ]---
ftrace failed to modify
[<c0080000012a0008>] 0xc0080000012a0008
actual: 01:00:4c:3c
Initializing ftrace call sites
ftrace record flags: 2000000
(0)
expected tramp: c00000000006af4c
Looking at the relocation records in __mcount_loc shows a few spurious
entries:
RELOCATION RECORDS FOR [__mcount_loc]:
OFFSET TYPE VALUE
0000000000000000 R_PPC64_ADDR64 .text.unlikely+0x0000000000000008
0000000000000008 R_PPC64_ADDR64 .text.unlikely+0x0000000000000014
0000000000000010 R_PPC64_ADDR64 .text.unlikely+0x0000000000000060
0000000000000018 R_PPC64_ADDR64 .text.unlikely+0x00000000000000b4
0000000000000020 R_PPC64_ADDR64 .init.text+0x0000000000000008
0000000000000028 R_PPC64_ADDR64 .init.text+0x0000000000000014
The first entry in each section is incorrect. Looking at the
relocation records, the spurious entries correspond to the
R_PPC64_ENTRY records:
RELOCATION RECORDS FOR [.text.unlikely]:
OFFSET TYPE VALUE
0000000000000000 R_PPC64_REL64 .TOC.-0x0000000000000008
0000000000000008 R_PPC64_ENTRY *ABS*
0000000000000014 R_PPC64_REL24 _mcount
<snip>
The problem is that we are not validating the return value from
get_mcountsym() in sift_rel_mcount(). With this entry, mcountsym is 0,
but Elf_r_sym(relp) also ends up being 0. Fix this by ensuring
mcountsym is valid before processing the entry.
Signed-off-by: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Acked-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
Tested-by: Satheesh Rajendran <sathnaga@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-06-26 18:38:01 +00:00
|
|
|
if (mcountsym && mcountsym == Elf_r_sym(relp) &&
|
|
|
|
|
!is_fake_mcount(relp)) {
|
2011-05-10 08:10:40 +00:00
|
|
|
uint_t const addend =
|
|
|
|
|
_w(_w(relp->r_offset) - recval + mcount_adjust);
|
2010-10-13 23:06:14 +00:00
|
|
|
mrelp->r_offset = _w(offbase
|
|
|
|
|
+ ((void *)mlocp - (void *)mloc0));
|
2010-10-27 10:59:07 +00:00
|
|
|
Elf_r_info(mrelp, recsym, reltype);
|
2011-04-06 17:21:17 +00:00
|
|
|
if (rel_entsize == sizeof(Elf_Rela)) {
|
2010-10-13 23:06:14 +00:00
|
|
|
((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;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-08 07:58:48 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2019-07-31 18:24:12 +00:00
|
|
|
static int nop_mcount(Elf_Shdr const *const relhdr,
|
|
|
|
|
Elf_Ehdr const *const ehdr,
|
|
|
|
|
const char *const txtname)
|
2011-04-08 07:58:48 +00:00
|
|
|
{
|
|
|
|
|
Elf_Shdr *const shdr0 = (Elf_Shdr *)(_w(ehdr->e_shoff)
|
|
|
|
|
+ (void *)ehdr);
|
2011-04-21 01:13:06 +00:00
|
|
|
Elf_Sym const *sym0;
|
|
|
|
|
char const *str0;
|
|
|
|
|
Elf_Rel const *relp;
|
|
|
|
|
Elf_Shdr const *const shdr = &shdr0[w(relhdr->sh_info)];
|
2011-04-08 07:58:48 +00:00
|
|
|
unsigned rel_entsize = _w(relhdr->sh_entsize);
|
|
|
|
|
unsigned const nrel = _w(relhdr->sh_size) / rel_entsize;
|
|
|
|
|
unsigned mcountsym = 0;
|
|
|
|
|
unsigned t;
|
2011-04-12 22:53:25 +00:00
|
|
|
int once = 0;
|
2011-04-08 07:58:48 +00:00
|
|
|
|
2011-04-21 01:13:06 +00:00
|
|
|
get_sym_str_and_relp(relhdr, ehdr, &sym0, &str0, &relp);
|
|
|
|
|
|
2011-04-08 07:58:48 +00:00
|
|
|
for (t = nrel; t; --t) {
|
|
|
|
|
int ret = -1;
|
|
|
|
|
|
2011-04-21 00:47:34 +00:00
|
|
|
if (!mcountsym)
|
|
|
|
|
mcountsym = get_mcountsym(sym0, relp, str0);
|
2011-04-08 07:58:48 +00:00
|
|
|
|
2011-04-12 22:53:25 +00:00
|
|
|
if (mcountsym == Elf_r_sym(relp) && !is_fake_mcount(relp)) {
|
2019-10-09 15:05:38 +00:00
|
|
|
if (make_nop)
|
2015-11-03 00:58:47 +00:00
|
|
|
ret = make_nop((void *)ehdr, _w(shdr->sh_offset) + _w(relp->r_offset));
|
2011-04-12 22:53:25 +00:00
|
|
|
if (warn_on_notrace_sect && !once) {
|
|
|
|
|
printf("Section %s has mcount callers being ignored\n",
|
|
|
|
|
txtname);
|
|
|
|
|
once = 1;
|
|
|
|
|
/* just warn? */
|
|
|
|
|
if (!make_nop)
|
2019-07-31 18:24:12 +00:00
|
|
|
return 0;
|
2011-04-12 22:53:25 +00:00
|
|
|
}
|
|
|
|
|
}
|
2011-04-08 07:58:48 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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);
|
2019-07-31 18:24:12 +00:00
|
|
|
if (ulseek((void *)relp - (void *)ehdr, SEEK_SET) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (uwrite(&rel, sizeof(rel)) < 0)
|
|
|
|
|
return -1;
|
2011-04-08 07:58:48 +00:00
|
|
|
}
|
|
|
|
|
relp = (Elf_Rel const *)(rel_entsize + (void *)relp);
|
|
|
|
|
}
|
2019-07-31 18:24:12 +00:00
|
|
|
return 0;
|
2011-04-08 07:58:48 +00:00
|
|
|
}
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
*/
|
2019-07-31 18:24:12 +00:00
|
|
|
static int find_secsym_ndx(unsigned const txtndx,
|
2010-10-13 23:06:14 +00:00
|
|
|
char const *const txtname,
|
|
|
|
|
uint_t *const recvalp,
|
2019-07-31 18:24:12 +00:00
|
|
|
unsigned int *sym_index,
|
2010-10-13 23:06:14 +00:00
|
|
|
Elf_Shdr const *const symhdr,
|
2020-04-24 19:30:46 +00:00
|
|
|
Elf32_Word const *symtab,
|
|
|
|
|
Elf32_Word const *symtab_shndx,
|
2010-10-13 23:06:14 +00:00
|
|
|
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);
|
|
|
|
|
|
2020-04-24 19:30:46 +00:00
|
|
|
if (txtndx == get_symindex(symp, symtab, symtab_shndx)
|
2010-10-13 23:06:14 +00:00
|
|
|
/* avoid STB_WEAK */
|
|
|
|
|
&& (STB_LOCAL == st_bind || STB_GLOBAL == st_bind)) {
|
2011-05-11 17:23:51 +00:00
|
|
|
/* function symbols on ARM have quirks, avoid them */
|
|
|
|
|
if (w2(ehdr->e_machine) == EM_ARM
|
|
|
|
|
&& ELF_ST_TYPE(symp->st_info) == STT_FUNC)
|
|
|
|
|
continue;
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
*recvalp = _w(symp->st_value);
|
2019-07-31 18:24:12 +00:00
|
|
|
*sym_index = symp - sym0;
|
|
|
|
|
return 0;
|
2010-10-13 23:06:14 +00:00
|
|
|
}
|
|
|
|
|
}
|
2018-05-24 03:16:12 +00:00
|
|
|
fprintf(stderr, "Cannot find symbol for section %u: %s.\n",
|
2010-10-13 23:06:14 +00:00
|
|
|
txtndx, txtname);
|
2019-07-31 18:24:12 +00:00
|
|
|
return -1;
|
2010-10-13 23:06:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Evade ISO C restriction: no declaration after statement in has_rel_mcount. */
|
2019-07-31 18:24:13 +00:00
|
|
|
static char const * __has_rel_mcount(Elf_Shdr const *const relhdr, /* reltype */
|
|
|
|
|
Elf_Shdr const *const shdr0,
|
|
|
|
|
char const *const shstrtab,
|
|
|
|
|
char const *const fname)
|
2010-10-13 23:06:14 +00:00
|
|
|
{
|
|
|
|
|
/* .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)];
|
|
|
|
|
|
2011-04-06 17:21:17 +00:00
|
|
|
if (strcmp("__mcount_loc", txtname) == 0) {
|
2010-10-13 23:06:14 +00:00
|
|
|
fprintf(stderr, "warning: __mcount_loc already exists: %s\n",
|
|
|
|
|
fname);
|
2019-07-31 18:24:12 +00:00
|
|
|
return already_has_rel_mcount;
|
2010-10-13 23:06:14 +00:00
|
|
|
}
|
2011-04-06 17:21:17 +00:00
|
|
|
if (w(txthdr->sh_type) != SHT_PROGBITS ||
|
2011-12-20 01:42:42 +00:00
|
|
|
!(_w(txthdr->sh_flags) & SHF_EXECINSTR))
|
2010-10-13 23:06:14 +00:00
|
|
|
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)
|
|
|
|
|
{
|
2011-04-06 17:21:17 +00:00
|
|
|
if (w(relhdr->sh_type) != SHT_REL && w(relhdr->sh_type) != SHT_RELA)
|
2010-10-13 23:06:14 +00:00
|
|
|
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;
|
2011-04-08 07:58:48 +00:00
|
|
|
char const *txtname;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
for (; nhdr; --nhdr, ++shdrp) {
|
2011-04-08 07:58:48 +00:00
|
|
|
txtname = has_rel_mcount(shdrp, shdr0, shstrtab, fname);
|
2019-07-31 18:24:12 +00:00
|
|
|
if (txtname == already_has_rel_mcount) {
|
|
|
|
|
totrelsz = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2011-04-08 07:58:48 +00:00
|
|
|
if (txtname && is_mcounted_section_name(txtname))
|
2010-10-13 23:06:14 +00:00
|
|
|
totrelsz += _w(shdrp->sh_size);
|
|
|
|
|
}
|
|
|
|
|
return totrelsz;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Overall supervision for Elf32 ET_REL file. */
|
2019-07-31 18:24:13 +00:00
|
|
|
static int do_func(Elf_Ehdr *const ehdr, char const *const fname,
|
|
|
|
|
unsigned const reltype)
|
2010-10-13 23:06:14 +00:00
|
|
|
{
|
|
|
|
|
Elf_Shdr *const shdr0 = (Elf_Shdr *)(_w(ehdr->e_shoff)
|
|
|
|
|
+ (void *)ehdr);
|
2020-04-24 19:30:46 +00:00
|
|
|
unsigned const nhdr = get_shnum(ehdr, shdr0);
|
|
|
|
|
Elf_Shdr *const shstr = &shdr0[get_shstrndx(ehdr, shdr0)];
|
2010-10-13 23:06:14 +00:00
|
|
|
char const *const shstrtab = (char const *)(_w(shstr->sh_offset)
|
|
|
|
|
+ (void *)ehdr);
|
|
|
|
|
|
|
|
|
|
Elf_Shdr const *relhdr;
|
|
|
|
|
unsigned k;
|
|
|
|
|
|
2020-04-24 19:30:46 +00:00
|
|
|
Elf32_Word *symtab;
|
|
|
|
|
Elf32_Word *symtab_shndx;
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
/* Upper bound on space: assume all relevant relocs are for mcount. */
|
2019-07-31 18:24:12 +00:00
|
|
|
unsigned totrelsz;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
2019-07-31 18:24:12 +00:00
|
|
|
Elf_Rel * mrel0;
|
|
|
|
|
Elf_Rel * mrelp;
|
|
|
|
|
|
|
|
|
|
uint_t * mloc0;
|
|
|
|
|
uint_t * mlocp;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
unsigned rel_entsize = 0;
|
|
|
|
|
unsigned symsec_sh_link = 0;
|
|
|
|
|
|
2019-07-31 18:24:12 +00:00
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
|
|
totrelsz = tot_relsize(shdr0, nhdr, shstrtab, fname);
|
|
|
|
|
if (totrelsz == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
mrel0 = umalloc(totrelsz);
|
|
|
|
|
mrelp = mrel0;
|
|
|
|
|
if (!mrel0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* 2*sizeof(address) <= sizeof(Elf_Rel) */
|
|
|
|
|
mloc0 = umalloc(totrelsz>>1);
|
|
|
|
|
mlocp = mloc0;
|
|
|
|
|
if (!mloc0) {
|
|
|
|
|
free(mrel0);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-24 19:30:46 +00:00
|
|
|
find_symtab(ehdr, shdr0, nhdr, &symtab, &symtab_shndx);
|
|
|
|
|
|
2010-10-13 23:06:14 +00:00
|
|
|
for (relhdr = shdr0, k = nhdr; k; --k, ++relhdr) {
|
|
|
|
|
char const *const txtname = has_rel_mcount(relhdr, shdr0,
|
|
|
|
|
shstrtab, fname);
|
2019-07-31 18:24:12 +00:00
|
|
|
if (txtname == already_has_rel_mcount) {
|
|
|
|
|
result = 0;
|
|
|
|
|
file_updated = 0;
|
|
|
|
|
goto out; /* Nothing to be done; don't append! */
|
|
|
|
|
}
|
2011-04-08 07:58:48 +00:00
|
|
|
if (txtname && is_mcounted_section_name(txtname)) {
|
2019-07-31 18:24:12 +00:00
|
|
|
unsigned int recsym;
|
2010-10-13 23:06:14 +00:00
|
|
|
uint_t recval = 0;
|
2019-07-31 18:24:12 +00:00
|
|
|
|
|
|
|
|
symsec_sh_link = w(relhdr->sh_link);
|
|
|
|
|
result = find_secsym_ndx(w(relhdr->sh_info), txtname,
|
|
|
|
|
&recval, &recsym,
|
|
|
|
|
&shdr0[symsec_sh_link],
|
2020-04-24 19:30:46 +00:00
|
|
|
symtab, symtab_shndx,
|
2019-07-31 18:24:12 +00:00
|
|
|
ehdr);
|
|
|
|
|
if (result)
|
|
|
|
|
goto out;
|
2010-10-13 23:06:14 +00:00
|
|
|
|
|
|
|
|
rel_entsize = _w(relhdr->sh_entsize);
|
|
|
|
|
mlocp = sift_rel_mcount(mlocp,
|
|
|
|
|
(void *)mlocp - (void *)mloc0, &mrelp,
|
|
|
|
|
relhdr, ehdr, recsym, recval, reltype);
|
2011-04-12 22:53:25 +00:00
|
|
|
} else if (txtname && (warn_on_notrace_sect || make_nop)) {
|
2011-04-08 07:58:48 +00:00
|
|
|
/*
|
|
|
|
|
* This section is ignored by ftrace, but still
|
|
|
|
|
* has mcount calls. Convert them to nops now.
|
|
|
|
|
*/
|
2019-07-31 18:24:12 +00:00
|
|
|
if (nop_mcount(relhdr, ehdr, txtname) < 0) {
|
|
|
|
|
result = -1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2010-10-13 23:06:14 +00:00
|
|
|
}
|
|
|
|
|
}
|
2019-07-31 18:24:12 +00:00
|
|
|
if (!result && mloc0 != mlocp)
|
|
|
|
|
result = append_func(ehdr, shstr, mloc0, mlocp, mrel0, mrelp,
|
|
|
|
|
rel_entsize, symsec_sh_link);
|
|
|
|
|
out:
|
2010-10-13 23:06:14 +00:00
|
|
|
free(mrel0);
|
|
|
|
|
free(mloc0);
|
2019-07-31 18:24:12 +00:00
|
|
|
return result;
|
2010-10-13 23:06:14 +00:00
|
|
|
}
|
