cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

vdsomunge.c (5151B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Copyright 2015 Mentor Graphics Corporation.
      4 *
      5 * vdsomunge - Host program which produces a shared object
      6 * architecturally specified to be usable by both soft- and hard-float
      7 * programs.
      8 *
      9 * The Procedure Call Standard for the ARM Architecture (ARM IHI
     10 * 0042E) says:
     11 *
     12 *	6.4.1 VFP and Base Standard Compatibility
     13 *
     14 *	Code compiled for the VFP calling standard is compatible with
     15 *	the base standard (and vice-versa) if no floating-point or
     16 *	containerized vector arguments or results are used.
     17 *
     18 * And ELF for the ARM Architecture (ARM IHI 0044E) (Table 4-2) says:
     19 *
     20 *	If both EF_ARM_ABI_FLOAT_XXXX bits are clear, conformance to the
     21 *	base procedure-call standard is implied.
     22 *
     23 * The VDSO is built with -msoft-float, as with the rest of the ARM
     24 * kernel, and uses no floating point arguments or results.  The build
     25 * process will produce a shared object that may or may not have the
     26 * EF_ARM_ABI_FLOAT_SOFT flag set (it seems to depend on the binutils
     27 * version; binutils starting with 2.24 appears to set it).  The
     28 * EF_ARM_ABI_FLOAT_HARD flag should definitely not be set, and this
     29 * program will error out if it is.
     30 *
     31 * If the soft-float flag is set, this program clears it.  That's all
     32 * it does.
     33 */
     34
     35#include <elf.h>
     36#include <errno.h>
     37#include <fcntl.h>
     38#include <stdarg.h>
     39#include <stdbool.h>
     40#include <stdio.h>
     41#include <stdlib.h>
     42#include <string.h>
     43#include <sys/mman.h>
     44#include <sys/stat.h>
     45#include <sys/types.h>
     46#include <unistd.h>
     47
     48#define swab16(x) \
     49	((((x) & 0x00ff) << 8) | \
     50	 (((x) & 0xff00) >> 8))
     51
     52#define swab32(x) \
     53	((((x) & 0x000000ff) << 24) | \
     54	 (((x) & 0x0000ff00) <<  8) | \
     55	 (((x) & 0x00ff0000) >>  8) | \
     56	 (((x) & 0xff000000) >> 24))
     57
     58#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
     59#define HOST_ORDER ELFDATA2LSB
     60#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     61#define HOST_ORDER ELFDATA2MSB
     62#endif
     63
     64/* Some of the ELF constants we'd like to use were added to <elf.h>
     65 * relatively recently.
     66 */
     67#ifndef EF_ARM_EABI_VER5
     68#define EF_ARM_EABI_VER5 0x05000000
     69#endif
     70
     71#ifndef EF_ARM_ABI_FLOAT_SOFT
     72#define EF_ARM_ABI_FLOAT_SOFT 0x200
     73#endif
     74
     75#ifndef EF_ARM_ABI_FLOAT_HARD
     76#define EF_ARM_ABI_FLOAT_HARD 0x400
     77#endif
     78
     79static int failed;
     80static const char *argv0;
     81static const char *outfile;
     82
     83static void fail(const char *fmt, ...)
     84{
     85	va_list ap;
     86
     87	failed = 1;
     88	fprintf(stderr, "%s: ", argv0);
     89	va_start(ap, fmt);
     90	vfprintf(stderr, fmt, ap);
     91	va_end(ap);
     92	exit(EXIT_FAILURE);
     93}
     94
     95static void cleanup(void)
     96{
     97	if (failed && outfile != NULL)
     98		unlink(outfile);
     99}
    100
    101static Elf32_Word read_elf_word(Elf32_Word word, bool swap)
    102{
    103	return swap ? swab32(word) : word;
    104}
    105
    106static Elf32_Half read_elf_half(Elf32_Half half, bool swap)
    107{
    108	return swap ? swab16(half) : half;
    109}
    110
    111static void write_elf_word(Elf32_Word val, Elf32_Word *dst, bool swap)
    112{
    113	*dst = swap ? swab32(val) : val;
    114}
    115
    116int main(int argc, char **argv)
    117{
    118	const Elf32_Ehdr *inhdr;
    119	bool clear_soft_float;
    120	const char *infile;
    121	Elf32_Word e_flags;
    122	const void *inbuf;
    123	struct stat stat;
    124	void *outbuf;
    125	bool swap;
    126	int outfd;
    127	int infd;
    128
    129	atexit(cleanup);
    130	argv0 = argv[0];
    131
    132	if (argc != 3)
    133		fail("Usage: %s [infile] [outfile]\n", argv[0]);
    134
    135	infile = argv[1];
    136	outfile = argv[2];
    137
    138	infd = open(infile, O_RDONLY);
    139	if (infd < 0)
    140		fail("Cannot open %s: %s\n", infile, strerror(errno));
    141
    142	if (fstat(infd, &stat) != 0)
    143		fail("Failed stat for %s: %s\n", infile, strerror(errno));
    144
    145	inbuf = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, infd, 0);
    146	if (inbuf == MAP_FAILED)
    147		fail("Failed to map %s: %s\n", infile, strerror(errno));
    148
    149	close(infd);
    150
    151	inhdr = inbuf;
    152
    153	if (memcmp(&inhdr->e_ident, ELFMAG, SELFMAG) != 0)
    154		fail("Not an ELF file\n");
    155
    156	if (inhdr->e_ident[EI_CLASS] != ELFCLASS32)
    157		fail("Unsupported ELF class\n");
    158
    159	swap = inhdr->e_ident[EI_DATA] != HOST_ORDER;
    160
    161	if (read_elf_half(inhdr->e_type, swap) != ET_DYN)
    162		fail("Not a shared object\n");
    163
    164	if (read_elf_half(inhdr->e_machine, swap) != EM_ARM)
    165		fail("Unsupported architecture %#x\n", inhdr->e_machine);
    166
    167	e_flags = read_elf_word(inhdr->e_flags, swap);
    168
    169	if (EF_ARM_EABI_VERSION(e_flags) != EF_ARM_EABI_VER5) {
    170		fail("Unsupported EABI version %#x\n",
    171		     EF_ARM_EABI_VERSION(e_flags));
    172	}
    173
    174	if (e_flags & EF_ARM_ABI_FLOAT_HARD)
    175		fail("Unexpected hard-float flag set in e_flags\n");
    176
    177	clear_soft_float = !!(e_flags & EF_ARM_ABI_FLOAT_SOFT);
    178
    179	outfd = open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    180	if (outfd < 0)
    181		fail("Cannot open %s: %s\n", outfile, strerror(errno));
    182
    183	if (ftruncate(outfd, stat.st_size) != 0)
    184		fail("Cannot truncate %s: %s\n", outfile, strerror(errno));
    185
    186	outbuf = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
    187		      outfd, 0);
    188	if (outbuf == MAP_FAILED)
    189		fail("Failed to map %s: %s\n", outfile, strerror(errno));
    190
    191	close(outfd);
    192
    193	memcpy(outbuf, inbuf, stat.st_size);
    194
    195	if (clear_soft_float) {
    196		Elf32_Ehdr *outhdr;
    197
    198		outhdr = outbuf;
    199		e_flags &= ~EF_ARM_ABI_FLOAT_SOFT;
    200		write_elf_word(e_flags, &outhdr->e_flags, swap);
    201	}
    202
    203	if (msync(outbuf, stat.st_size, MS_SYNC) != 0)
    204		fail("Failed to sync %s: %s\n", outfile, strerror(errno));
    205
    206	return EXIT_SUCCESS;
    207}