Commit 9c7dc1dd authored by Josh Poimboeuf's avatar Josh Poimboeuf Committed by Ingo Molnar
Browse files

objtool: Warn on functions with ambiguous -ffunction-sections section names 



When compiled with -ffunction-sections, a function named startup() will
be placed in .text.startup.  However, .text.startup is also used by the
compiler for functions with __attribute__((constructor)).

That creates an ambiguity for the vmlinux linker script, which needs to
differentiate those two cases.

Similar naming conflicts exist for functions named exit(), split(),
unlikely(), hot() and unknown().

One potential solution would be to use '#ifdef CC_USING_FUNCTION_SECTIONS'
to create two distinct implementations of the TEXT_MAIN macro.  However,
-ffunction-sections can be (and is) enabled or disabled on a per-object
basis (for example via ccflags-y or AUTOFDO_PROFILE).

So the recently unified TEXT_MAIN macro (commit 1ba9f897
("vmlinux.lds: Unify TEXT_MAIN, DATA_MAIN, and related macros")) is
necessary.  This means there's no way for the linker script to
disambiguate things.

Instead, use objtool to warn on any function names whose resulting
section names might create ambiguity when the kernel is compiled (in
whole or in part) with -ffunction-sections.

Signed-off-by: default avatarJosh Poimboeuf <jpoimboe@kernel.org>
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: live-patching@vger.kernel.org
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: https://patch.msgid.link/65fedea974fe14be487c8867a0b8d0e4a294ce1e.1762991150.git.jpoimboe@kernel.org
parent 0330b7fb

include/asm-generic/vmlinux.lds.h

+15 −0
Original line number Diff line number Diff line
@@ -97,6 +97,21 @@ 
 * Other .text.* sections that are typically grouped separately, such as

 * .text.unlikely or .text.hot, must be matched explicitly before using

 * TEXT_MAIN.

 *

 * NOTE: builds *with* and *without* -ffunction-sections are both supported by

 * this single macro.  Even with -ffunction-sections, there may be some objects

 * NOT compiled with the flag due to the use of a specific Makefile override

 * like cflags-y or AUTOFDO_PROFILE_foo.o.  So this single catchall rule is

 * needed to support mixed object builds.

 *

 * One implication is that functions named startup(), exit(), split(),

 * unlikely(), hot(), and unknown() are not allowed in the kernel due to the

 * ambiguity of their section names with -ffunction-sections.  For example,

 * .text.startup could be __attribute__((constructor)) code in a *non*

 * ffunction-sections object, which should be placed in .init.text; or it could

 * be an actual function named startup() in an ffunction-sections object, which

 * should be placed in .text.  Objtool will detect and complain about any such

 * ambiguously named functions.

 */

#define TEXT_MAIN							\

	.text								\

tools/objtool/Documentation/objtool.txt

+7 −0
Original line number Diff line number Diff line
@@ -456,6 +456,13 @@ the objtool maintainers. 
    these special names and does not use module_init() / module_exit()

    macros to create them.



13. file.o: warning: func() function name creates ambiguity with -ffunctions-sections



    Functions named startup(), exit(), split(), unlikely(), hot(), and

    unknown() are not allowed due to the ambiguity of their section

    names when compiled with -ffunction-sections.  For more information,

    see the comment above TEXT_MAIN in include/asm-generic/vmlinux.lds.h.





If the error doesn't seem to make sense, it could be a bug in objtool.

Feel free to ask objtool maintainers for help.

tools/objtool/check.c

+33 −0
Original line number Diff line number Diff line
@@ -2663,6 +2663,37 @@ static int decode_sections(struct objtool_file *file) 
	return 0;

}



/*

 * Certain function names are disallowed due to section name ambiguities

 * introduced by -ffunction-sections.

 *

 * See the comment above TEXT_MAIN in include/asm-generic/vmlinux.lds.h.

 */

static int validate_function_names(struct objtool_file *file)

{

	struct symbol *func;

	int warnings = 0;



	for_each_sym(file->elf, func) {

		if (!is_func_sym(func))

			continue;



		if (!strcmp(func->name, "startup")	|| strstarts(func->name, "startup.")	||

		    !strcmp(func->name, "exit")		|| strstarts(func->name, "exit.")	||

		    !strcmp(func->name, "split")	|| strstarts(func->name, "split.")	||

		    !strcmp(func->name, "unlikely")	|| strstarts(func->name, "unlikely.")	||

		    !strcmp(func->name, "hot")		|| strstarts(func->name, "hot.")	||

		    !strcmp(func->name, "unknown")	|| strstarts(func->name, "unknown.")) {



			WARN("%s() function name creates ambiguity with -ffunction-sections",

			     func->name);

			warnings++;

		}

	}



	return warnings;

}



static bool is_special_call(struct instruction *insn)

{

	if (insn->type == INSN_CALL) {
@@ -4932,6 +4963,8 @@ int check(struct objtool_file *file) 
	if (!nr_insns)

		goto out;



	warnings += validate_function_names(file);



	if (opts.retpoline)

		warnings += validate_retpoline(file);