| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Alex Smith | 1162 | 91.28% | 1 | 14.29% |
| Peng Fan | 50 | 3.93% | 1 | 14.29% |
| Guoyun Sun | 45 | 3.53% | 2 | 28.57% |
| Linus Torvalds (pre-git) | 8 | 0.63% | 1 | 14.29% |
| David Daney | 6 | 0.47% | 1 | 14.29% |
| Thomas Gleixner | 2 | 0.16% | 1 | 14.29% |
| Total | 1273 | 7 |
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2015 Imagination Technologies * Author: Alex Smith <alex.smith@imgtec.com> */ /* * This tool is used to generate the real VDSO images from the raw image. It * first patches up the MIPS ABI flags and GNU attributes sections defined in * elf.S to have the correct name and type. It then generates a C source file * to be compiled into the kernel containing the VDSO image data and a * mips_vdso_image struct for it, including symbol offsets extracted from the * image. * * We need to be passed both a stripped and unstripped VDSO image. The stripped * image is compiled into the kernel, but we must also patch up the unstripped * image's ABI flags sections so that it can be installed and used for * debugging. */ #include <sys/mman.h> #include <sys/stat.h> #include <sys/types.h> #include <byteswap.h> #include <elf.h> #include <errno.h> #include <fcntl.h> #include <inttypes.h> #include <stdarg.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> /* Define these in case the system elf.h is not new enough to have them. */ #ifndef SHT_GNU_ATTRIBUTES # define SHT_GNU_ATTRIBUTES 0x6ffffff5 #endif #ifndef SHT_MIPS_ABIFLAGS # define SHT_MIPS_ABIFLAGS 0x7000002a #endif enum { ABI_O32 = (1 << 0), ABI_N32 = (1 << 1), ABI_N64 = (1 << 2), ABI_ALL = ABI_O32 | ABI_N32 | ABI_N64, }; /* Symbols the kernel requires offsets for. */ static struct { const char *name; const char *offset_name; unsigned int abis; } vdso_symbols[] = { { "__vdso_sigreturn", "off_sigreturn", ABI_O32 }, { "__vdso_rt_sigreturn", "off_rt_sigreturn", ABI_ALL }, {} }; static const char *program_name; static const char *vdso_name; static unsigned char elf_class; static unsigned int elf_abi; static bool need_swap; static FILE *out_file; #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ # define HOST_ORDER ELFDATA2LSB #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ # define HOST_ORDER ELFDATA2MSB #endif #define BUILD_SWAP(bits) \ static uint##bits##_t swap_uint##bits(uint##bits##_t val) \ { \ return need_swap ? bswap_##bits(val) : val; \ } BUILD_SWAP(16) BUILD_SWAP(32) BUILD_SWAP(64) #define __FUNC(name, bits) name##bits #define _FUNC(name, bits) __FUNC(name, bits) #define FUNC(name) _FUNC(name, ELF_BITS) #define __ELF(x, bits) Elf##bits##_##x #define _ELF(x, bits) __ELF(x, bits) #define ELF(x) _ELF(x, ELF_BITS) /* * Include genvdso.h twice with ELF_BITS defined differently to get functions * for both ELF32 and ELF64. */ #define ELF_BITS 64 #include "genvdso.h" #undef ELF_BITS #define ELF_BITS 32 #include "genvdso.h" #undef ELF_BITS static void *map_vdso(const char *path, size_t *_size) { int fd; struct stat stat; void *addr; const Elf32_Ehdr *ehdr; fd = open(path, O_RDWR); if (fd < 0) { fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name, path, strerror(errno)); return NULL; } if (fstat(fd, &stat) != 0) { fprintf(stderr, "%s: Failed to stat '%s': %s\n", program_name, path, strerror(errno)); close(fd); return NULL; } addr = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (addr == MAP_FAILED) { fprintf(stderr, "%s: Failed to map '%s': %s\n", program_name, path, strerror(errno)); close(fd); return NULL; } /* ELF32/64 header formats are the same for the bits we're checking. */ ehdr = addr; if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0) { fprintf(stderr, "%s: '%s' is not an ELF file\n", program_name, path); close(fd); return NULL; } elf_class = ehdr->e_ident[EI_CLASS]; switch (elf_class) { case ELFCLASS32: case ELFCLASS64: break; default: fprintf(stderr, "%s: '%s' has invalid ELF class\n", program_name, path); close(fd); return NULL; } switch (ehdr->e_ident[EI_DATA]) { case ELFDATA2LSB: case ELFDATA2MSB: need_swap = ehdr->e_ident[EI_DATA] != HOST_ORDER; break; default: fprintf(stderr, "%s: '%s' has invalid ELF data order\n", program_name, path); close(fd); return NULL; } if (swap_uint16(ehdr->e_machine) != EM_MIPS) { fprintf(stderr, "%s: '%s' has invalid ELF machine (expected EM_MIPS)\n", program_name, path); close(fd); return NULL; } else if (swap_uint16(ehdr->e_type) != ET_DYN) { fprintf(stderr, "%s: '%s' has invalid ELF type (expected ET_DYN)\n", program_name, path); close(fd); return NULL; } *_size = stat.st_size; close(fd); return addr; } static bool patch_vdso(const char *path, void *vdso) { if (elf_class == ELFCLASS64) return patch_vdso64(path, vdso); else return patch_vdso32(path, vdso); } static bool get_symbols(const char *path, void *vdso) { if (elf_class == ELFCLASS64) return get_symbols64(path, vdso); else return get_symbols32(path, vdso); } int main(int argc, char **argv) { const char *dbg_vdso_path, *vdso_path, *out_path; void *dbg_vdso, *vdso; size_t dbg_vdso_size, vdso_size, i; program_name = argv[0]; if (argc < 4 || argc > 5) { fprintf(stderr, "Usage: %s <debug VDSO> <stripped VDSO> <output file> [<name>]\n", program_name); return EXIT_FAILURE; } dbg_vdso_path = argv[1]; vdso_path = argv[2]; out_path = argv[3]; vdso_name = (argc > 4) ? argv[4] : ""; dbg_vdso = map_vdso(dbg_vdso_path, &dbg_vdso_size); if (!dbg_vdso) return EXIT_FAILURE; vdso = map_vdso(vdso_path, &vdso_size); if (!vdso) return EXIT_FAILURE; /* Patch both the VDSOs' ABI flags sections. */ if (!patch_vdso(dbg_vdso_path, dbg_vdso)) return EXIT_FAILURE; if (!patch_vdso(vdso_path, vdso)) return EXIT_FAILURE; if (msync(dbg_vdso, dbg_vdso_size, MS_SYNC) != 0) { fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name, dbg_vdso_path, strerror(errno)); return EXIT_FAILURE; } else if (msync(vdso, vdso_size, MS_SYNC) != 0) { fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name, vdso_path, strerror(errno)); return EXIT_FAILURE; } out_file = fopen(out_path, "w"); if (!out_file) { fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name, out_path, strerror(errno)); return EXIT_FAILURE; } fprintf(out_file, "/* Automatically generated - do not edit */\n"); fprintf(out_file, "#include <linux/linkage.h>\n"); fprintf(out_file, "#include <linux/mm.h>\n"); fprintf(out_file, "#include <asm/vdso.h>\n"); fprintf(out_file, "static int vdso_mremap(\n"); fprintf(out_file, " const struct vm_special_mapping *sm,\n"); fprintf(out_file, " struct vm_area_struct *new_vma)\n"); fprintf(out_file, "{\n"); fprintf(out_file, " current->mm->context.vdso =\n"); fprintf(out_file, " (void *)(new_vma->vm_start);\n"); fprintf(out_file, " return 0;\n"); fprintf(out_file, "}\n"); /* Write out the stripped VDSO data. */ fprintf(out_file, "static unsigned char vdso_data[PAGE_ALIGN(%zu)] __page_aligned_data = {\n\t", vdso_size); for (i = 0; i < vdso_size; i++) { if (!(i % 10)) fprintf(out_file, "\n\t"); fprintf(out_file, "0x%02x, ", ((unsigned char *)vdso)[i]); } fprintf(out_file, "\n};\n"); /* Preallocate a page array. */ fprintf(out_file, "static struct page *vdso_pages[PAGE_ALIGN(%zu) / PAGE_SIZE];\n", vdso_size); fprintf(out_file, "struct mips_vdso_image vdso_image%s%s = {\n", (vdso_name[0]) ? "_" : "", vdso_name); fprintf(out_file, "\t.data = vdso_data,\n"); fprintf(out_file, "\t.size = PAGE_ALIGN(%zu),\n", vdso_size); fprintf(out_file, "\t.mapping = {\n"); fprintf(out_file, "\t\t.name = \"[vdso]\",\n"); fprintf(out_file, "\t\t.pages = vdso_pages,\n"); fprintf(out_file, "\t\t.mremap = vdso_mremap,\n"); fprintf(out_file, "\t},\n"); /* Calculate and write symbol offsets to <output file> */ if (!get_symbols(dbg_vdso_path, dbg_vdso)) { unlink(out_path); fclose(out_file); return EXIT_FAILURE; } fprintf(out_file, "};\n"); fclose(out_file); return EXIT_SUCCESS; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1