mirror of
https://github.com/torvalds/linux
synced 2024-09-06 09:51:23 +00:00
![Ard Biesheuvel](/assets/img/avatar_default.png)
Weak references are references that are permitted to remain unsatisfied in the final link. This means they cannot be implemented using place relative relocations, resulting in GOT entries when using position independent code generation. The notes section should always exist, so the weak annotations can be omitted. Acked-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: Ard Biesheuvel <ardb@kernel.org> Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
192 lines
5 KiB
C
192 lines
5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/buildid.h>
|
|
#include <linux/cache.h>
|
|
#include <linux/elf.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/pagemap.h>
|
|
|
|
#define BUILD_ID 3
|
|
|
|
/*
|
|
* Parse build id from the note segment. This logic can be shared between
|
|
* 32-bit and 64-bit system, because Elf32_Nhdr and Elf64_Nhdr are
|
|
* identical.
|
|
*/
|
|
static int parse_build_id_buf(unsigned char *build_id,
|
|
__u32 *size,
|
|
const void *note_start,
|
|
Elf32_Word note_size)
|
|
{
|
|
Elf32_Word note_offs = 0, new_offs;
|
|
|
|
while (note_offs + sizeof(Elf32_Nhdr) < note_size) {
|
|
Elf32_Nhdr *nhdr = (Elf32_Nhdr *)(note_start + note_offs);
|
|
|
|
if (nhdr->n_type == BUILD_ID &&
|
|
nhdr->n_namesz == sizeof("GNU") &&
|
|
!strcmp((char *)(nhdr + 1), "GNU") &&
|
|
nhdr->n_descsz > 0 &&
|
|
nhdr->n_descsz <= BUILD_ID_SIZE_MAX) {
|
|
memcpy(build_id,
|
|
note_start + note_offs +
|
|
ALIGN(sizeof("GNU"), 4) + sizeof(Elf32_Nhdr),
|
|
nhdr->n_descsz);
|
|
memset(build_id + nhdr->n_descsz, 0,
|
|
BUILD_ID_SIZE_MAX - nhdr->n_descsz);
|
|
if (size)
|
|
*size = nhdr->n_descsz;
|
|
return 0;
|
|
}
|
|
new_offs = note_offs + sizeof(Elf32_Nhdr) +
|
|
ALIGN(nhdr->n_namesz, 4) + ALIGN(nhdr->n_descsz, 4);
|
|
if (new_offs <= note_offs) /* overflow */
|
|
break;
|
|
note_offs = new_offs;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static inline int parse_build_id(const void *page_addr,
|
|
unsigned char *build_id,
|
|
__u32 *size,
|
|
const void *note_start,
|
|
Elf32_Word note_size)
|
|
{
|
|
/* check for overflow */
|
|
if (note_start < page_addr || note_start + note_size < note_start)
|
|
return -EINVAL;
|
|
|
|
/* only supports note that fits in the first page */
|
|
if (note_start + note_size > page_addr + PAGE_SIZE)
|
|
return -EINVAL;
|
|
|
|
return parse_build_id_buf(build_id, size, note_start, note_size);
|
|
}
|
|
|
|
/* Parse build ID from 32-bit ELF */
|
|
static int get_build_id_32(const void *page_addr, unsigned char *build_id,
|
|
__u32 *size)
|
|
{
|
|
Elf32_Ehdr *ehdr = (Elf32_Ehdr *)page_addr;
|
|
Elf32_Phdr *phdr;
|
|
int i;
|
|
|
|
/* only supports phdr that fits in one page */
|
|
if (ehdr->e_phnum >
|
|
(PAGE_SIZE - sizeof(Elf32_Ehdr)) / sizeof(Elf32_Phdr))
|
|
return -EINVAL;
|
|
|
|
phdr = (Elf32_Phdr *)(page_addr + sizeof(Elf32_Ehdr));
|
|
|
|
for (i = 0; i < ehdr->e_phnum; ++i) {
|
|
if (phdr[i].p_type == PT_NOTE &&
|
|
!parse_build_id(page_addr, build_id, size,
|
|
page_addr + phdr[i].p_offset,
|
|
phdr[i].p_filesz))
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Parse build ID from 64-bit ELF */
|
|
static int get_build_id_64(const void *page_addr, unsigned char *build_id,
|
|
__u32 *size)
|
|
{
|
|
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)page_addr;
|
|
Elf64_Phdr *phdr;
|
|
int i;
|
|
|
|
/* only supports phdr that fits in one page */
|
|
if (ehdr->e_phnum >
|
|
(PAGE_SIZE - sizeof(Elf64_Ehdr)) / sizeof(Elf64_Phdr))
|
|
return -EINVAL;
|
|
|
|
phdr = (Elf64_Phdr *)(page_addr + sizeof(Elf64_Ehdr));
|
|
|
|
for (i = 0; i < ehdr->e_phnum; ++i) {
|
|
if (phdr[i].p_type == PT_NOTE &&
|
|
!parse_build_id(page_addr, build_id, size,
|
|
page_addr + phdr[i].p_offset,
|
|
phdr[i].p_filesz))
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* Parse build ID of ELF file mapped to vma
|
|
* @vma: vma object
|
|
* @build_id: buffer to store build id, at least BUILD_ID_SIZE long
|
|
* @size: returns actual build id size in case of success
|
|
*
|
|
* Return: 0 on success, -EINVAL otherwise
|
|
*/
|
|
int build_id_parse(struct vm_area_struct *vma, unsigned char *build_id,
|
|
__u32 *size)
|
|
{
|
|
Elf32_Ehdr *ehdr;
|
|
struct page *page;
|
|
void *page_addr;
|
|
int ret;
|
|
|
|
/* only works for page backed storage */
|
|
if (!vma->vm_file)
|
|
return -EINVAL;
|
|
|
|
page = find_get_page(vma->vm_file->f_mapping, 0);
|
|
if (!page)
|
|
return -EFAULT; /* page not mapped */
|
|
|
|
ret = -EINVAL;
|
|
page_addr = kmap_local_page(page);
|
|
ehdr = (Elf32_Ehdr *)page_addr;
|
|
|
|
/* compare magic x7f "ELF" */
|
|
if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0)
|
|
goto out;
|
|
|
|
/* only support executable file and shared object file */
|
|
if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
|
|
goto out;
|
|
|
|
if (ehdr->e_ident[EI_CLASS] == ELFCLASS32)
|
|
ret = get_build_id_32(page_addr, build_id, size);
|
|
else if (ehdr->e_ident[EI_CLASS] == ELFCLASS64)
|
|
ret = get_build_id_64(page_addr, build_id, size);
|
|
out:
|
|
kunmap_local(page_addr);
|
|
put_page(page);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* build_id_parse_buf - Get build ID from a buffer
|
|
* @buf: ELF note section(s) to parse
|
|
* @buf_size: Size of @buf in bytes
|
|
* @build_id: Build ID parsed from @buf, at least BUILD_ID_SIZE_MAX long
|
|
*
|
|
* Return: 0 on success, -EINVAL otherwise
|
|
*/
|
|
int build_id_parse_buf(const void *buf, unsigned char *build_id, u32 buf_size)
|
|
{
|
|
return parse_build_id_buf(build_id, NULL, buf, buf_size);
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID) || IS_ENABLED(CONFIG_VMCORE_INFO)
|
|
unsigned char vmlinux_build_id[BUILD_ID_SIZE_MAX] __ro_after_init;
|
|
|
|
/**
|
|
* init_vmlinux_build_id - Compute and stash the running kernel's build ID
|
|
*/
|
|
void __init init_vmlinux_build_id(void)
|
|
{
|
|
extern const void __start_notes;
|
|
extern const void __stop_notes;
|
|
unsigned int size = &__stop_notes - &__start_notes;
|
|
|
|
build_id_parse_buf(&__start_notes, vmlinux_build_id, size);
|
|
}
|
|
#endif
|