// SPDX-License-Identifier: GPL-2.0-or-later

#define _GNU_SOURCE /* memmem() */

#include <subcmd/parse-options.h>

#include <stdlib.h>

#include <string.h>

#include <libgen.h>

#include <stdio.h>

#include <ctype.h>

#include <objtool/objtool.h>

#include <objtool/warn.h>

#include <objtool/arch.h>

#include <objtool/klp.h>

#include <objtool/util.h>

#include <arch/special.h>

#include <linux/objtool_types.h>

#include <linux/livepatch_external.h>

#include <linux/stringify.h>

#include <linux/string.h>

#include <linux/jhash.h>

#define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))

struct elfs {

struct elf *orig, *patched, *out;

const char *modname;

};

struct export {

struct hlist_node hash;

char *mod, *sym;

};

static const char * const klp_diff_usage[] = {

"objtool klp diff [<options>] <in1.o> <in2.o> <out.o>",

NULL,

};

static const struct option klp_diff_options[] = {

OPT_GROUP("Options:"),

OPT_BOOLEAN('d', "debug", &debug, "enable debug output"),

OPT_END(),

};

static DEFINE_HASHTABLE(exports, 15);

static inline u32 str_hash(const char *str)

{

return jhash(str, strlen(str), 0);

}

static char *escape_str(const char *orig)

{

size_t len = 0;

const char *a;

char *b, *new;

for (a = orig; *a; a++) {

switch (*a) {

case '\001': len += 5; break;

case '\n':

case '\t': len += 2; break;

default: len++;

}

}

new = malloc(len + 1);

if (!new)

return NULL;

for (a = orig, b = new; *a; a++) {

switch (*a) {

case '\001': memcpy(b, "<SOH>", 5); b += 5; break;

case '\n': *b++ = '\\'; *b++ = 'n'; break;

case '\t': *b++ = '\\'; *b++ = 't'; break;

default: *b++ = *a;

}

}

*b = '\0';

return new;

}

static int read_exports(void)

{

const char *symvers = "Module.symvers";

char line[1024], *path = NULL;

unsigned int line_num = 1;

FILE *file;

file = fopen(symvers, "r");

if (!file) {

path = top_level_dir(symvers);

if (!path) {

ERROR("can't open '%s', \"objtool diff\" should be run from the kernel tree", symvers);

return -1;

}

file = fopen(path, "r");

if (!file) {

ERROR_GLIBC("fopen");

return -1;

}

}

while (fgets(line, 1024, file)) {

char *sym, *mod, *type;

struct export *export;

sym = strchr(line, '\t');

if (!sym) {

ERROR("malformed Module.symvers (sym) at line %d", line_num);

return -1;

}

*sym++ = '\0';

mod = strchr(sym, '\t');

if (!mod) {

ERROR("malformed Module.symvers (mod) at line %d", line_num);

return -1;

}

*mod++ = '\0';

type = strchr(mod, '\t');

if (!type) {

ERROR("malformed Module.symvers (type) at line %d", line_num);

return -1;

}

*type++ = '\0';

if (*sym == '\0' || *mod == '\0') {

ERROR("malformed Module.symvers at line %d", line_num);

return -1;

}

export = calloc(1, sizeof(*export));

if (!export) {

ERROR_GLIBC("calloc");

return -1;

}

export->mod = strdup(mod);

if (!export->mod) {

ERROR_GLIBC("strdup");

return -1;

}

export->sym = strdup(sym);

if (!export->sym) {

ERROR_GLIBC("strdup");

return -1;

}

hash_add(exports, &export->hash, str_hash(sym));

}

free(path);

fclose(file);

return 0;

}

static int read_sym_checksums(struct elf *elf)

{

struct section *sec;

sec = find_section_by_name(elf, ".discard.sym_checksum");

if (!sec) {

ERROR("'%s' missing .discard.sym_checksum section, file not processed by 'objtool --checksum'?",

elf->name);

return -1;

}

if (!sec->rsec) {

ERROR("missing reloc section for .discard.sym_checksum");

return -1;

}

if (sec_size(sec) % sizeof(struct sym_checksum)) {

ERROR("struct sym_checksum size mismatch");

return -1;

}

for (int i = 0; i < sec_size(sec) / sizeof(struct sym_checksum); i++) {

struct sym_checksum *sym_checksum;

struct reloc *reloc;

struct symbol *sym;

sym_checksum = (struct sym_checksum *)sec->data->d_buf + i;

reloc = find_reloc_by_dest(elf, sec, i * sizeof(*sym_checksum));

if (!reloc) {

ERROR("can't find reloc for sym_checksum[%d]", i);

return -1;

}

sym = reloc->sym;

if (is_sec_sym(sym)) {

ERROR("not sure how to handle section %s", sym->name);

return -1;

}

if (is_func_sym(sym))

sym->csum.checksum = sym_checksum->checksum;

}

return 0;

}

static struct symbol *first_file_symbol(struct elf *elf)

{

struct symbol *sym;

for_each_sym(elf, sym) {

if (is_file_sym(sym))

return sym;

}

return NULL;

}

static struct symbol *next_file_symbol(struct elf *elf, struct symbol *sym)

{

for_each_sym_continue(elf, sym) {

if (is_file_sym(sym))

return sym;

}

return NULL;

}

/*

* Certain static local variables should never be correlated. They will be

* used in place rather than referencing the originals.

*/

static bool is_uncorrelated_static_local(struct symbol *sym)

{

static const char * const vars[] = {

"__already_done.",

"__func__.",

"__key.",

"__warned.",

"_entry.",

"_entry_ptr.",

"_rs.",

"descriptor.",

"CSWTCH.",

};

if (!is_object_sym(sym) || !is_local_sym(sym))

return false;

if (!strcmp(sym->sec->name, ".data.once"))

return true;

for (int i = 0; i < ARRAY_SIZE(vars); i++) {

if (strstarts(sym->name, vars[i]))

return true;

}

return false;

}

/*

* Clang emits several useless .Ltmp_* code labels.

*/

static bool is_clang_tmp_label(struct symbol *sym)

{

return sym->type == STT_NOTYPE &&

is_text_sec(sym->sec) &&

strstarts(sym->name, ".Ltmp") &&

isdigit(sym->name[5]);

}

static bool is_special_section(struct section *sec)

{

static const char * const specials[] = {

".altinstructions",

".smp_locks",

"__bug_table",

"__ex_table",

"__jump_table",

"__mcount_loc",

/*

* Extract .static_call_sites here to inherit non-module

* preferential treatment. The later static call processing

* during klp module build will be skipped when it sees this

* section already exists.

*/

".static_call_sites",

};

static const char * const non_special_discards[] = {

".discard.addressable",

".discard.sym_checksum",

};

if (is_text_sec(sec))

return false;

for (int i = 0; i < ARRAY_SIZE(specials); i++) {

if (!strcmp(sec->name, specials[i]))

return true;

}

/* Most .discard data sections are special */

for (int i = 0; i < ARRAY_SIZE(non_special_discards); i++) {

if (!strcmp(sec->name, non_special_discards[i]))

return false;

}

return strstarts(sec->name, ".discard.");

}

/*

* These sections are referenced by special sections but aren't considered

* special sections themselves.

*/

static bool is_special_section_aux(struct section *sec)

{

static const char * const specials_aux[] = {

".altinstr_replacement",

".altinstr_aux",

};

for (int i = 0; i < ARRAY_SIZE(specials_aux); i++) {

if (!strcmp(sec->name, specials_aux[i]))

return true;

}

return false;

}

/*

* These symbols should never be correlated, so their local patched versions

* are used instead of linking to the originals.

*/

static bool dont_correlate(struct symbol *sym)

{

return is_file_sym(sym) ||

is_null_sym(sym) ||

is_sec_sym(sym) ||

is_prefix_func(sym) ||

is_uncorrelated_static_local(sym) ||

is_clang_tmp_label(sym) ||

is_string_sec(sym->sec) ||

is_special_section(sym->sec) ||

is_special_section_aux(sym->sec) ||

strstarts(sym->name, "__initcall__");

}

/*

* For each symbol in the original kernel, find its corresponding "twin" in the

* patched kernel.

*/

static int correlate_symbols(struct elfs *e)

{

struct symbol *file1_sym, *file2_sym;

struct symbol *sym1, *sym2;

file1_sym = first_file_symbol(e->orig);

file2_sym = first_file_symbol(e->patched);

/*

* Correlate any locals before the first FILE symbol. This has been

* seen when LTO inexplicably strips the initramfs_data.o FILE symbol

* due to the file only containing data and no code.

*/

for_each_sym(e->orig, sym1) {

if (sym1 == file1_sym || !is_local_sym(sym1))

break;

if (dont_correlate(sym1))

continue;

for_each_sym(e->patched, sym2) {

if (sym2 == file2_sym || !is_local_sym(sym2))

break;

if (sym2->twin || dont_correlate(sym2))

continue;

if (strcmp(sym1->demangled_name, sym2->demangled_name))

continue;

sym1->twin = sym2;

sym2->twin = sym1;

break;

}

}

/* Correlate locals after the first FILE symbol */

for (; ; file1_sym = next_file_symbol(e->orig, file1_sym),

file2_sym = next_file_symbol(e->patched, file2_sym)) {

if (!file1_sym && file2_sym) {

ERROR("FILE symbol mismatch: NULL != %s", file2_sym->name);

return -1;

}

if (file1_sym && !file2_sym) {

ERROR("FILE symbol mismatch: %s != NULL", file1_sym->name);

return -1;

}

if (!file1_sym)

break;

if (strcmp(file1_sym->name, file2_sym->name)) {

ERROR("FILE symbol mismatch: %s != %s", file1_sym->name, file2_sym->name);

return -1;

}

file1_sym->twin = file2_sym;

file2_sym->twin = file1_sym;

sym1 = file1_sym;

for_each_sym_continue(e->orig, sym1) {

if (is_file_sym(sym1) || !is_local_sym(sym1))

break;

if (dont_correlate(sym1))

continue;

sym2 = file2_sym;

for_each_sym_continue(e->patched, sym2) {

if (is_file_sym(sym2) || !is_local_sym(sym2))

break;

if (sym2->twin || dont_correlate(sym2))

continue;

if (strcmp(sym1->demangled_name, sym2->demangled_name))

continue;

sym1->twin = sym2;

sym2->twin = sym1;

break;

}

}

}

/* Correlate globals */

for_each_sym(e->orig, sym1) {

if (sym1->bind == STB_LOCAL)

continue;

sym2 = find_global_symbol_by_name(e->patched, sym1->name);

if (sym2 && !sym2->twin && !strcmp(sym1->name, sym2->name)) {

sym1->twin = sym2;

sym2->twin = sym1;

}

}

for_each_sym(e->orig, sym1) {

if (sym1->twin || dont_correlate(sym1))

continue;

WARN("no correlation: %s", sym1->name);

}

return 0;

}

/* "sympos" is used by livepatch to disambiguate duplicate symbol names */

static unsigned long find_sympos(struct elf *elf, struct symbol *sym)

{

bool vmlinux = str_ends_with(objname, "vmlinux.o");

unsigned long sympos = 0, nr_matches = 0;

bool has_dup = false;

struct symbol *s;

if (sym->bind != STB_LOCAL)

return 0;

if (vmlinux && sym->type == STT_FUNC) {

/*

* HACK: Unfortunately, symbol ordering can differ between

* vmlinux.o and vmlinux due to the linker script emitting

* .text.unlikely* before .text*. Count .text.unlikely* first.

*

* TODO: Disambiguate symbols more reliably (checksums?)

*/

for_each_sym(elf, s) {

if (strstarts(s->sec->name, ".text.unlikely") &&

!strcmp(s->name, sym->name)) {

nr_matches++;

if (s == sym)

sympos = nr_matches;

else

has_dup = true;

}

}

for_each_sym(elf, s) {

if (!strstarts(s->sec->name, ".text.unlikely") &&

!strcmp(s->name, sym->name)) {

nr_matches++;

if (s == sym)

sympos = nr_matches;

else

has_dup = true;

}

}

} else {

for_each_sym(elf, s) {

if (!strcmp(s->name, sym->name)) {

nr_matches++;

if (s == sym)

sympos = nr_matches;

else

has_dup = true;

}

}

}

if (!sympos) {

ERROR("can't find sympos for %s", sym->name);

return ULONG_MAX;

}

return has_dup ? sympos : 0;

}

static int clone_sym_relocs(struct elfs *e, struct symbol *patched_sym);

static struct symbol *__clone_symbol(struct elf *elf, struct symbol *patched_sym,

bool data_too)

{

struct section *out_sec = NULL;

unsigned long offset = 0;

struct symbol *out_sym;

if (data_too && !is_undef_sym(patched_sym)) {

struct section *patched_sec = patched_sym->sec;

out_sec = find_section_by_name(elf, patched_sec->name);

if (!out_sec) {

out_sec = elf_create_section(elf, patched_sec->name, 0,

patched_sec->sh.sh_entsize,

patched_sec->sh.sh_type,

patched_sec->sh.sh_addralign,

patched_sec->sh.sh_flags);

if (!out_sec)

return NULL;

}

if (is_string_sec(patched_sym->sec)) {

out_sym = elf_create_section_symbol(elf, out_sec);

if (!out_sym)

return NULL;

goto sym_created;

}

if (!is_sec_sym(patched_sym))

offset = sec_size(out_sec);

if (patched_sym->len || is_sec_sym(patched_sym)) {

void *data = NULL;

size_t size;

/* bss doesn't have data */

if (patched_sym->sec->data->d_buf)

data = patched_sym->sec->data->d_buf + patched_sym->offset;

if (is_sec_sym(patched_sym))

size = sec_size(patched_sym->sec);

else

size = patched_sym->len;

if (!elf_add_data(elf, out_sec, data, size))

return NULL;

}

}

out_sym = elf_create_symbol(elf, patched_sym->name, out_sec,

patched_sym->bind, patched_sym->type,

offset, patched_sym->len);

if (!out_sym)

return NULL;

sym_created:

patched_sym->clone = out_sym;

out_sym->clone = patched_sym;

return out_sym;

}

static const char *sym_type(struct symbol *sym)

{

switch (sym->type) {

case STT_NOTYPE: return "NOTYPE";

case STT_OBJECT: return "OBJECT";

case STT_FUNC: return "FUNC";

case STT_SECTION: return "SECTION";

case STT_FILE: return "FILE";

default: return "UNKNOWN";

}

}

static const char *sym_bind(struct symbol *sym)

{

switch (sym->bind) {

case STB_LOCAL: return "LOCAL";

case STB_GLOBAL: return "GLOBAL";

case STB_WEAK: return "WEAK";

default: return "UNKNOWN";

}

}

/*

* Copy a symbol to the output object, optionally including its data and

* relocations.

*/

static struct symbol *clone_symbol(struct elfs *e, struct symbol *patched_sym,

bool data_too)

{

struct symbol *pfx;

if (patched_sym->clone)

return patched_sym->clone;

dbg_indent("%s%s", patched_sym->name, data_too ? " [+DATA]" : "");

/* Make sure the prefix gets cloned first */

if (is_func_sym(patched_sym) && data_too) {

pfx = get_func_prefix(patched_sym);

if (pfx)

clone_symbol(e, pfx, true);

}

if (!__clone_symbol(e->out, patched_sym, data_too))

return NULL;

if (data_too && clone_sym_relocs(e, patched_sym))

return NULL;

return patched_sym->clone;

}

static void mark_included_function(struct symbol *func)

{

struct symbol *pfx;

func->included = 1;

/* Include prefix function */

pfx = get_func_prefix(func);

if (pfx)

pfx->included = 1;

/* Make sure .cold parent+child always stay together */

if (func->cfunc && func->cfunc != func)

func->cfunc->included = 1;

if (func->pfunc && func->pfunc != func)

func->pfunc->included = 1;

}

/*

* Copy all changed functions (and their dependencies) from the patched object

* to the output object.

*/

static int mark_changed_functions(struct elfs *e)

{

struct symbol *sym_orig, *patched_sym;

bool changed = false;

/* Find changed functions */

for_each_sym(e->orig, sym_orig) {

if (!is_func_sym(sym_orig) || is_prefix_func(sym_orig))

continue;

patched_sym = sym_orig->twin;

if (!patched_sym)

continue;

if (sym_orig->csum.checksum != patched_sym->csum.checksum) {

patched_sym->changed = 1;

mark_included_function(patched_sym);

changed = true;

}

}

/* Find added functions and print them */

for_each_sym(e->patched, patched_sym) {

if (!is_func_sym(patched_sym) || is_prefix_func(patched_sym))

continue;

if (!patched_sym->twin) {

printf("%s: new function: %s\n", objname, patched_sym->name);

mark_included_function(patched_sym);

changed = true;

}

}

/* Print changed functions */

for_each_sym(e->patched, patched_sym) {

if (patched_sym->changed)

printf("%s: changed function: %s\n", objname, patched_sym->name);

}

return !changed ? -1 : 0;

}

static int clone_included_functions(struct elfs *e)

{

struct symbol *patched_sym;

for_each_sym(e->patched, patched_sym) {

if (patched_sym->included) {

if (!clone_symbol(e, patched_sym, true))

return -1;

}

}

return 0;

}

/*

* Determine whether a relocation should reference the section rather than the

* underlying symbol.

*/

static bool section_reference_needed(struct section *sec)

{

/*

* String symbols are zero-length and uncorrelated. It's easier to

* deal with them as section symbols.

*/

if (is_string_sec(sec))

return true;

/*

* .rodata has mostly anonymous data so there's no way to determine the

* length of a needed reference. just copy the whole section if needed.

*/

if (strstarts(sec->name, ".rodata"))

return true;

/* UBSAN anonymous data */

if (strstarts(sec->name, ".data..Lubsan") || /* GCC */

strstarts(sec->name, ".data..L__unnamed_")) /* Clang */

return true;

return false;

}

static bool is_reloc_allowed(struct reloc *reloc)

{

return section_reference_needed(reloc->sym->sec) == is_sec_sym(reloc->sym);

}

static struct export *find_export(struct symbol *sym)

{

struct export *export;

hash_for_each_possible(exports, export, hash, str_hash(sym->name)) {

if (!strcmp(export->sym, sym->name))

return export;

}

return NULL;

}

static const char *__find_modname(struct elfs *e)

{

struct section *sec;

char *name;

sec = find_section_by_name(e->orig, ".modinfo");

if (!sec) {

ERROR("missing .modinfo section");

return NULL;

}

name = memmem(sec->data->d_buf, sec_size(sec), "\0name=", 6);

if (name)

return name + 6;

name = strdup(e->orig->name);

if (!name) {

ERROR_GLIBC("strdup");

return NULL;

}

for (char *c = name; *c; c++) {

if (*c == '/')

name = c + 1;

else if (*c == '-')

*c = '_';

else if (*c == '.') {

*c = '\0';

break;

}

}

return name;

}

/* Get the object's module name as defined by the kernel (and klp_object) */

static const char *find_modname(struct elfs *e)

{

const char *modname;

if (e->modname)

return e->modname;

modname = __find_modname(e);

e->modname = modname;

return modname;

}

/*

* Copying a function from its native compiled environment to a kernel module

* removes its natural access to local functions/variables and unexported

* globals. References to such symbols need to be converted to KLP relocs so

* the kernel arch relocation code knows to apply them and where to find the

* symbols. Particularly, duplicate static symbols need to be disambiguated.

*/

static bool klp_reloc_needed(struct reloc *patched_reloc)

{

struct symbol *patched_sym = patched_reloc->sym;

struct export *export;

/* no external symbol to reference */

if (dont_correlate(patched_sym))

return false;

/* For included functions, a regular reloc will do. */

if (patched_sym->included)

return false;

/*

* If exported by a module, it has to be a klp reloc. Thanks to the

* clusterfunk that is late module patching, the patch module is

* allowed to be loaded before any modules it depends on.

*

* If exported by vmlinux, a normal reloc will do.

*/

export = find_export(patched_sym);

if (export)

return strcmp(export->mod, "vmlinux");

if (!patched_sym->twin) {

/*

* Presumably the symbol and its reference were added by the

* patch. The symbol could be defined in this .o or in another

* .o in the patch module.

*

* This check needs to be *after* the export check due to the

* possibility of the patch adding a new UNDEF reference to an

* exported symbol.

*/

return false;

}

/* Unexported symbol which lives in the original vmlinux or module. */

return true;

}

static int convert_reloc_sym_to_secsym(struct elf *elf, struct reloc *reloc)

{

struct symbol *sym = reloc->sym;

struct section *sec = sym->sec;

if (!sec->sym && !elf_create_section_symbol(elf, sec))

return -1;

reloc->sym = sec->sym;

set_reloc_sym(elf, reloc, sym->idx);

set_reloc_addend(elf, reloc, sym->offset + reloc_addend(reloc));

return 0;

}

static int convert_reloc_secsym_to_sym(struct elf *elf, struct reloc *reloc)

{

struct symbol *sym = reloc->sym;

struct section *sec = sym->sec;

/* If the symbol has a dedicated section, it's easy to find */

sym = find_symbol_by_offset(sec, 0);

if (sym && sym->len == sec_size(sec))

goto found_sym;

/* No dedicated section; find the symbol manually */

sym = find_symbol_containing(sec, arch_adjusted_addend(reloc));

if (!sym) {

/*

* This can happen for special section references to weak code

* whose symbol has been stripped by the linker.

*/

return -1;

}

found_sym:

reloc->sym = sym;

set_reloc_sym(elf, reloc, sym->idx);

set_reloc_addend(elf, reloc, reloc_addend(reloc) - sym->offset);

return 0;

}

/*

* Convert a relocation symbol reference to the needed format: either a section

* symbol or the underlying symbol itself.

*/

static int convert_reloc_sym(struct elf *elf, struct reloc *reloc)

{

if (is_reloc_allowed(reloc))

return 0;

if (section_reference_needed(reloc->sym->sec))

return convert_reloc_sym_to_secsym(elf, reloc);

else

return convert_reloc_secsym_to_sym(elf, reloc);

}

/*

* Convert a regular relocation to a klp relocation (sort of).

*/

static int clone_reloc_klp(struct elfs *e, struct reloc *patched_reloc,

struct section *sec, unsigned long offset,

struct export *export)

{

struct symbol *patched_sym = patched_reloc->sym;

s64 addend = reloc_addend(patched_reloc);

const char *sym_modname, *sym_orig_name;

static struct section *klp_relocs;

struct symbol *sym, *klp_sym;

unsigned long klp_reloc_off;

char sym_name[SYM_NAME_LEN];

struct klp_reloc klp_reloc;

unsigned long sympos;

if (!patched_sym->twin) {

ERROR("unexpected klp reloc for new symbol %s", patched_sym->name);

return -1;

}

/*

* Keep the original reloc intact for now to avoid breaking objtool run

* which relies on proper relocations for many of its features. This

* will be disabled later by "objtool klp post-link".

*

* Convert it to UNDEF (and WEAK to avoid modpost warnings).

*/

sym = patched_sym->clone;

if (!sym) {

/* STB_WEAK: avoid modpost undefined symbol warnings */

sym = elf_create_symbol(e->out, patched_sym->name, NULL,

STB_WEAK, patched_sym->type, 0, 0);

if (!sym)

return -1;

patched_sym->clone = sym;

sym->clone = patched_sym;

}

if (!elf_create_reloc(e->out, sec, offset, sym, addend, reloc_type(patched_reloc)))

return -1;

/*

* Create the KLP symbol.

*/

if (export) {

sym_modname = export->mod;

sym_orig_name = export->sym;

sympos = 0;

} else {

sym_modname = find_modname(e);

if (!sym_modname)

return -1;

sym_orig_name = patched_sym->twin->name;

sympos = find_sympos(e->orig, patched_sym->twin);

if (sympos == ULONG_MAX)

return -1;

}

/* symbol format: .klp.sym.modname.sym_name,sympos */

if (snprintf_check(sym_name, SYM_NAME_LEN, KLP_SYM_PREFIX "%s.%s,%ld",

sym_modname, sym_orig_name, sympos))

return -1;

klp_sym = find_symbol_by_name(e->out, sym_name);

if (!klp_sym) {

__dbg_indent("%s", sym_name);

/* STB_WEAK: avoid modpost undefined symbol warnings */

klp_sym = elf_create_symbol(e->out, sym_name, NULL,

STB_WEAK, patched_sym->type, 0, 0);

if (!klp_sym)

return -1;