[thirdparty/linux.git] / scripts / recordmcount.c

/*
 * recordmcount.c: construct a table of the locations of calls to 'mcount'
 * so that ftrace can find them quickly.
 * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>.  All rights reserved.
 * Licensed under the GNU General Public License, version 2 (GPLv2).
 *
 * Restructured to fit Linux format, as well as other updates:
 *  Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
 */

/*
 * Strategy: alter the .o file in-place.
 *
 * Append a new STRTAB that has the new section names, followed by a new array
 * ElfXX_Shdr[] that has the new section headers, followed by the section
 * contents for __mcount_loc and its relocations.  The old shstrtab strings,
 * and the old ElfXX_Shdr[] array, remain as "garbage" (commonly, a couple
 * kilobytes.)  Subsequent processing by /bin/ld (or the kernel module loader)
 * will ignore the garbage regions, because they are not designated by the
 * new .e_shoff nor the new ElfXX_Shdr[].  [In order to remove the garbage,
 * then use "ld -r" to create a new file that omits the garbage.]
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <getopt.h>
#include <elf.h>
#include <fcntl.h>
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#ifndef EM_AARCH64
#define EM_AARCH64	183
#define R_AARCH64_NONE		0
#define R_AARCH64_ABS64	257
#endif

static int fd_map;	/* File descriptor for file being modified. */
static int mmap_failed; /* Boolean flag. */
static char gpfx;	/* prefix for global symbol name (sometimes '_') */
static struct stat sb;	/* Remember .st_size, etc. */
static jmp_buf jmpenv;	/* setjmp/longjmp per-file error escape */
static const char *altmcount;	/* alternate mcount symbol name */
static int warn_on_notrace_sect; /* warn when section has mcount not being recorded */
static void *file_map;	/* pointer of the mapped file */
static void *file_end;	/* pointer to the end of the mapped file */
static int file_updated; /* flag to state file was changed */
static void *file_ptr;	/* current file pointer location */
static void *file_append; /* added to the end of the file */
static size_t file_append_size; /* how much is added to end of file */

/* setjmp() return values */
enum {
	SJ_SETJMP = 0,  /* hardwired first return */
	SJ_FAIL,
	SJ_SUCCEED
};

/* Per-file resource cleanup when multiple files. */
static void
cleanup(void)
{
	if (!mmap_failed)
		munmap(file_map, sb.st_size);
	else
		free(file_map);
	file_map = NULL;
	free(file_append);
	file_append = NULL;
	file_append_size = 0;
	file_updated = 0;
}

static void __attribute__((noreturn))
fail_file(void)
{
	cleanup();
	longjmp(jmpenv, SJ_FAIL);
}

static void __attribute__((noreturn))
succeed_file(void)
{
	cleanup();
	longjmp(jmpenv, SJ_SUCCEED);
}

/* ulseek, uread, ...:  Check return value for errors. */

static off_t
ulseek(int const fd, off_t const offset, int const whence)
{
	switch (whence) {
	case SEEK_SET:
		file_ptr = file_map + offset;
		break;
	case SEEK_CUR:
		file_ptr += offset;
		break;
	case SEEK_END:
		file_ptr = file_map + (sb.st_size - offset);
		break;
	}
	if (file_ptr < file_map) {
		fprintf(stderr, "lseek: seek before file\n");
		fail_file();
	}
	return file_ptr - file_map;
}

static size_t
uread(int const fd, void *const buf, size_t const count)
{
	size_t const n = read(fd, buf, count);
	if (n != count) {
		perror("read");
		fail_file();
	}
	return n;
}

static size_t
uwrite(int const fd, void const *const buf, size_t const count)
{
	size_t cnt = count;
	off_t idx = 0;

	file_updated = 1;

	if (file_ptr + count >= file_end) {
		off_t aoffset = (file_ptr + count) - file_end;

		if (aoffset > file_append_size) {
			file_append = realloc(file_append, aoffset);
			file_append_size = aoffset;
		}
		if (!file_append) {
			perror("write");
			fail_file();
		}
		if (file_ptr < file_end) {
			cnt = file_end - file_ptr;
		} else {
			cnt = 0;
			idx = aoffset - count;
		}
	}

	if (cnt)
		memcpy(file_ptr, buf, cnt);

	if (cnt < count)
		memcpy(file_append + idx, buf + cnt, count - cnt);

	file_ptr += count;
	return count;
}

static void *
umalloc(size_t size)
{
	void *const addr = malloc(size);
	if (addr == 0) {
		fprintf(stderr, "malloc failed: %zu bytes\n", size);
		fail_file();
	}
	return addr;
}

static unsigned char ideal_nop5_x86_64[5] = { 0x0f, 0x1f, 0x44, 0x00, 0x00 };
static unsigned char ideal_nop5_x86_32[5] = { 0x3e, 0x8d, 0x74, 0x26, 0x00 };
static unsigned char *ideal_nop;

static char rel_type_nop;

static int (*make_nop)(void *map, size_t const offset);

static int make_nop_x86(void *map, size_t const offset)
{
	uint32_t *ptr;
	unsigned char *op;

	/* Confirm we have 0xe8 0x0 0x0 0x0 0x0 */
	ptr = map + offset;
	if (*ptr != 0)
		return -1;

	op = map + offset - 1;
	if (*op != 0xe8)
		return -1;

	/* convert to nop */
	ulseek(fd_map, offset - 1, SEEK_SET);
	uwrite(fd_map, ideal_nop, 5);
	return 0;
}

static unsigned char ideal_nop4_arm_le[4] = { 0x00, 0x00, 0xa0, 0xe1 }; /* mov r0, r0 */
static unsigned char ideal_nop4_arm_be[4] = { 0xe1, 0xa0, 0x00, 0x00 }; /* mov r0, r0 */
static unsigned char *ideal_nop4_arm;

static unsigned char bl_mcount_arm_le[4] = { 0xfe, 0xff, 0xff, 0xeb }; /* bl */
static unsigned char bl_mcount_arm_be[4] = { 0xeb, 0xff, 0xff, 0xfe }; /* bl */
static unsigned char *bl_mcount_arm;

static unsigned char push_arm_le[4] = { 0x04, 0xe0, 0x2d, 0xe5 }; /* push {lr} */
static unsigned char push_arm_be[4] = { 0xe5, 0x2d, 0xe0, 0x04 }; /* push {lr} */
static unsigned char *push_arm;

static unsigned char ideal_nop2_thumb_le[2] = { 0x00, 0xbf }; /* nop */
static unsigned char ideal_nop2_thumb_be[2] = { 0xbf, 0x00 }; /* nop */
static unsigned char *ideal_nop2_thumb;

static unsigned char push_bl_mcount_thumb_le[6] = { 0x00, 0xb5, 0xff, 0xf7, 0xfe, 0xff }; /* push {lr}, bl */
static unsigned char push_bl_mcount_thumb_be[6] = { 0xb5, 0x00, 0xf7, 0xff, 0xff, 0xfe }; /* push {lr}, bl */
static unsigned char *push_bl_mcount_thumb;

static int make_nop_arm(void *map, size_t const offset)
{
	char *ptr;
	int cnt = 1;
	int nop_size;
	size_t off = offset;

	ptr = map + offset;
	if (memcmp(ptr, bl_mcount_arm, 4) == 0) {
		if (memcmp(ptr - 4, push_arm, 4) == 0) {
			off -= 4;
			cnt = 2;
		}
		ideal_nop = ideal_nop4_arm;
		nop_size = 4;
	} else if (memcmp(ptr - 2, push_bl_mcount_thumb, 6) == 0) {
		cnt = 3;
		nop_size = 2;
		off -= 2;
		ideal_nop = ideal_nop2_thumb;
	} else
		return -1;

	/* Convert to nop */
	ulseek(fd_map, off, SEEK_SET);

	do {
		uwrite(fd_map, ideal_nop, nop_size);
	} while (--cnt > 0);

	return 0;
}

static unsigned char ideal_nop4_arm64[4] = {0x1f, 0x20, 0x03, 0xd5};
static int make_nop_arm64(void *map, size_t const offset)
{
	uint32_t *ptr;

	ptr = map + offset;
	/* bl <_mcount> is 0x94000000 before relocation */
	if (*ptr != 0x94000000)
		return -1;

	/* Convert to nop */
	ulseek(fd_map, offset, SEEK_SET);
	uwrite(fd_map, ideal_nop, 4);
	return 0;
}

/*
 * Get the whole file as a programming convenience in order to avoid
 * malloc+lseek+read+free of many pieces.  If successful, then mmap
 * avoids copying unused pieces; else just read the whole file.
 * Open for both read and write; new info will be appended to the file.
 * Use MAP_PRIVATE so that a few changes to the in-memory ElfXX_Ehdr
 * do not propagate to the file until an explicit overwrite at the last.
 * This preserves most aspects of consistency (all except .st_size)
 * for simultaneous readers of the file while we are appending to it.
 * However, multiple writers still are bad.  We choose not to use
 * locking because it is expensive and the use case of kernel build
 * makes multiple writers unlikely.
 */
static void *mmap_file(char const *fname)
{
	fd_map = open(fname, O_RDONLY);
	if (fd_map < 0 || fstat(fd_map, &sb) < 0) {
		perror(fname);
		fail_file();
	}
	if (!S_ISREG(sb.st_mode)) {
		fprintf(stderr, "not a regular file: %s\n", fname);
		fail_file();
	}
	file_map = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE,
			fd_map, 0);
	mmap_failed = 0;
	if (file_map == MAP_FAILED) {
		mmap_failed = 1;
		file_map = umalloc(sb.st_size);
		uread(fd_map, file_map, sb.st_size);
	}
	close(fd_map);

	file_end = file_map + sb.st_size;

	return file_map;
}

static void write_file(const char *fname)
{
	char tmp_file[strlen(fname) + 4];
	size_t n;

	if (!file_updated)
		return;

	sprintf(tmp_file, "%s.rc", fname);

	/*
	 * After reading the entire file into memory, delete it
	 * and write it back, to prevent weird side effects of modifying
	 * an object file in place.
	 */
	fd_map = open(tmp_file, O_WRONLY | O_TRUNC | O_CREAT, sb.st_mode);
	if (fd_map < 0) {
		perror(fname);
		fail_file();
	}
	n = write(fd_map, file_map, sb.st_size);
	if (n != sb.st_size) {
		perror("write");
		fail_file();
	}
	if (file_append_size) {
		n = write(fd_map, file_append, file_append_size);
		if (n != file_append_size) {
			perror("write");
			fail_file();
		}
	}
	close(fd_map);
	if (rename(tmp_file, fname) < 0) {
		perror(fname);
		fail_file();
	}
}

/* w8rev, w8nat, ...: Handle endianness. */

static uint64_t w8rev(uint64_t const x)
{
	return   ((0xff & (x >> (0 * 8))) << (7 * 8))
	       | ((0xff & (x >> (1 * 8))) << (6 * 8))
	       | ((0xff & (x >> (2 * 8))) << (5 * 8))
	       | ((0xff & (x >> (3 * 8))) << (4 * 8))
	       | ((0xff & (x >> (4 * 8))) << (3 * 8))
	       | ((0xff & (x >> (5 * 8))) << (2 * 8))
	       | ((0xff & (x >> (6 * 8))) << (1 * 8))
	       | ((0xff & (x >> (7 * 8))) << (0 * 8));
}

static uint32_t w4rev(uint32_t const x)
{
	return   ((0xff & (x >> (0 * 8))) << (3 * 8))
	       | ((0xff & (x >> (1 * 8))) << (2 * 8))
	       | ((0xff & (x >> (2 * 8))) << (1 * 8))
	       | ((0xff & (x >> (3 * 8))) << (0 * 8));
}

static uint32_t w2rev(uint16_t const x)
{
	return   ((0xff & (x >> (0 * 8))) << (1 * 8))
	       | ((0xff & (x >> (1 * 8))) << (0 * 8));
}

static uint64_t w8nat(uint64_t const x)
{
	return x;
}

static uint32_t w4nat(uint32_t const x)
{
	return x;
}

static uint32_t w2nat(uint16_t const x)
{
	return x;
}

static uint64_t (*w8)(uint64_t);
static uint32_t (*w)(uint32_t);
static uint32_t (*w2)(uint16_t);

/* Names of the sections that could contain calls to mcount. */
static int
is_mcounted_section_name(char const *const txtname)
{
	return strncmp(".text",          txtname, 5) == 0 ||
		strcmp(".init.text",     txtname) == 0 ||
		strcmp(".ref.text",      txtname) == 0 ||
		strcmp(".sched.text",    txtname) == 0 ||
		strcmp(".spinlock.text", txtname) == 0 ||
		strcmp(".irqentry.text", txtname) == 0 ||
		strcmp(".softirqentry.text", txtname) == 0 ||
		strcmp(".kprobes.text", txtname) == 0 ||
		strcmp(".cpuidle.text", txtname) == 0 ||
		strcmp(".text.unlikely", txtname) == 0;
}

/* 32 bit and 64 bit are very similar */
#include "recordmcount.h"
#define RECORD_MCOUNT_64
#include "recordmcount.h"

/* 64-bit EM_MIPS has weird ELF64_Rela.r_info.
 * http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf
 * We interpret Table 29 Relocation Operation (Elf64_Rel, Elf64_Rela) [p.40]
 * to imply the order of the members; the spec does not say so.
 *	typedef unsigned char Elf64_Byte;
 * fails on MIPS64 because their <elf.h> already has it!
 */

typedef uint8_t myElf64_Byte;		/* Type for a 8-bit quantity.  */

union mips_r_info {
	Elf64_Xword r_info;
	struct {
		Elf64_Word r_sym;		/* Symbol index.  */
		myElf64_Byte r_ssym;		/* Special symbol.  */
		myElf64_Byte r_type3;		/* Third relocation.  */
		myElf64_Byte r_type2;		/* Second relocation.  */
		myElf64_Byte r_type;		/* First relocation.  */
	} r_mips;
};

static uint64_t MIPS64_r_sym(Elf64_Rel const *rp)
{
	return w(((union mips_r_info){ .r_info = rp->r_info }).r_mips.r_sym);
}

static void MIPS64_r_info(Elf64_Rel *const rp, unsigned sym, unsigned type)
{
	rp->r_info = ((union mips_r_info){
		.r_mips = { .r_sym = w(sym), .r_type = type }
	}).r_info;
}

static void
do_file(char const *const fname)
{
	Elf32_Ehdr *const ehdr = mmap_file(fname);
	unsigned int reltype = 0;

	w = w4nat;
	w2 = w2nat;
	w8 = w8nat;
	switch (ehdr->e_ident[EI_DATA]) {
		static unsigned int const endian = 1;
	default:
		fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
			ehdr->e_ident[EI_DATA], fname);
		fail_file();
		break;
	case ELFDATA2LSB:
		if (*(unsigned char const *)&endian != 1) {
			/* main() is big endian, file.o is little endian. */
			w = w4rev;
			w2 = w2rev;
			w8 = w8rev;
		}
		ideal_nop4_arm = ideal_nop4_arm_le;
		bl_mcount_arm = bl_mcount_arm_le;
		push_arm = push_arm_le;
		ideal_nop2_thumb = ideal_nop2_thumb_le;
		push_bl_mcount_thumb = push_bl_mcount_thumb_le;
		break;
	case ELFDATA2MSB:
		if (*(unsigned char const *)&endian != 0) {
			/* main() is little endian, file.o is big endian. */
			w = w4rev;
			w2 = w2rev;
			w8 = w8rev;
		}
		ideal_nop4_arm = ideal_nop4_arm_be;
		bl_mcount_arm = bl_mcount_arm_be;
		push_arm = push_arm_be;
		ideal_nop2_thumb = ideal_nop2_thumb_be;
		push_bl_mcount_thumb = push_bl_mcount_thumb_be;
		break;
	}  /* end switch */
	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
	||  w2(ehdr->e_type) != ET_REL
	||  ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
		fprintf(stderr, "unrecognized ET_REL file %s\n", fname);
		fail_file();
	}

	gpfx = 0;
	switch (w2(ehdr->e_machine)) {
	default:
		fprintf(stderr, "unrecognized e_machine %u %s\n",
			w2(ehdr->e_machine), fname);
		fail_file();
		break;
	case EM_386:
		reltype = R_386_32;
		rel_type_nop = R_386_NONE;
		make_nop = make_nop_x86;
		ideal_nop = ideal_nop5_x86_32;
		mcount_adjust_32 = -1;
		break;
	case EM_ARM:	 reltype = R_ARM_ABS32;
			 altmcount = "__gnu_mcount_nc";
			 make_nop = make_nop_arm;
			 rel_type_nop = R_ARM_NONE;
			 break;
	case EM_AARCH64:
			reltype = R_AARCH64_ABS64;
			make_nop = make_nop_arm64;
			rel_type_nop = R_AARCH64_NONE;
			ideal_nop = ideal_nop4_arm64;
			gpfx = '_';
			break;
	case EM_IA_64:	 reltype = R_IA64_IMM64;   gpfx = '_'; break;
	case EM_MIPS:	 /* reltype: e_class    */ gpfx = '_'; break;
	case EM_PPC:	 reltype = R_PPC_ADDR32;   gpfx = '_'; break;
	case EM_PPC64:	 reltype = R_PPC64_ADDR64; gpfx = '_'; break;
	case EM_S390:    /* reltype: e_class    */ gpfx = '_'; break;
	case EM_SH:	 reltype = R_SH_DIR32;                 break;
	case EM_SPARCV9: reltype = R_SPARC_64;     gpfx = '_'; break;
	case EM_X86_64:
		make_nop = make_nop_x86;
		ideal_nop = ideal_nop5_x86_64;
		reltype = R_X86_64_64;
		rel_type_nop = R_X86_64_NONE;
		mcount_adjust_64 = -1;
		break;
	}  /* end switch */

	switch (ehdr->e_ident[EI_CLASS]) {
	default:
		fprintf(stderr, "unrecognized ELF class %d %s\n",
			ehdr->e_ident[EI_CLASS], fname);
		fail_file();
		break;
	case ELFCLASS32:
		if (w2(ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
		||  w2(ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
			fprintf(stderr,
				"unrecognized ET_REL file: %s\n", fname);
			fail_file();
		}
		if (w2(ehdr->e_machine) == EM_MIPS) {
			reltype = R_MIPS_32;
			is_fake_mcount32 = MIPS32_is_fake_mcount;
		}
		do32(ehdr, fname, reltype);
		break;
	case ELFCLASS64: {
		Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
		if (w2(ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
		||  w2(ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
			fprintf(stderr,
				"unrecognized ET_REL file: %s\n", fname);
			fail_file();
		}
		if (w2(ghdr->e_machine) == EM_S390) {
			reltype = R_390_64;
			mcount_adjust_64 = -14;
		}
		if (w2(ghdr->e_machine) == EM_MIPS) {
			reltype = R_MIPS_64;
			Elf64_r_sym = MIPS64_r_sym;
			Elf64_r_info = MIPS64_r_info;
			is_fake_mcount64 = MIPS64_is_fake_mcount;
		}
		do64(ghdr, fname, reltype);
		break;
	}
	}  /* end switch */

	write_file(fname);
	cleanup();
}

int
main(int argc, char *argv[])
{
	const char ftrace[] = "/ftrace.o";
	int ftrace_size = sizeof(ftrace) - 1;
	int n_error = 0;  /* gcc-4.3.0 false positive complaint */
	int c;
	int i;

	while ((c = getopt(argc, argv, "w")) >= 0) {
		switch (c) {
		case 'w':
			warn_on_notrace_sect = 1;
			break;
		default:
			fprintf(stderr, "usage: recordmcount [-w] file.o...\n");
			return 0;
		}
	}

	if ((argc - optind) < 1) {
		fprintf(stderr, "usage: recordmcount [-w] file.o...\n");
		return 0;
	}

	/* Process each file in turn, allowing deep failure. */
	for (i = optind; i < argc; i++) {
		char *file = argv[i];
		int const sjval = setjmp(jmpenv);
		int len;

		/*
		 * The file kernel/trace/ftrace.o references the mcount
		 * function but does not call it. Since ftrace.o should
		 * not be traced anyway, we just skip it.
		 */
		len = strlen(file);
		if (len >= ftrace_size &&
		    strcmp(file + (len - ftrace_size), ftrace) == 0)
			continue;

		switch (sjval) {
		default:
			fprintf(stderr, "internal error: %s\n", file);
			exit(1);
			break;
		case SJ_SETJMP:    /* normal sequence */
			/* Avoid problems if early cleanup() */
			fd_map = -1;
			mmap_failed = 1;
			file_map = NULL;
			file_ptr = NULL;
			file_updated = 0;
			do_file(file);
			break;
		case SJ_FAIL:    /* error in do_file or below */
			fprintf(stderr, "%s: failed\n", file);
			++n_error;
			break;
		case SJ_SUCCEED:    /* premature success */
			/* do nothing */
			break;
		}  /* end switch */
	}
	return !!n_error;
}
Commit	Line	Data
81d3858d JR	1	/*
	2	* recordmcount.c: construct a table of the locations of calls to 'mcount'
	3	* so that ftrace can find them quickly.
	4	* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved.
	5	* Licensed under the GNU General Public License, version 2 (GPLv2).
	6	*
	7	* Restructured to fit Linux format, as well as other updates:
	8	* Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
	9	*/
	10
	11	/*
	12	* Strategy: alter the .o file in-place.
	13	*
	14	* Append a new STRTAB that has the new section names, followed by a new array
	15	* ElfXX_Shdr[] that has the new section headers, followed by the section
	16	* contents for __mcount_loc and its relocations. The old shstrtab strings,
	17	* and the old ElfXX_Shdr[] array, remain as "garbage" (commonly, a couple
	18	* kilobytes.) Subsequent processing by /bin/ld (or the kernel module loader)
	19	* will ignore the garbage regions, because they are not designated by the
	20	* new .e_shoff nor the new ElfXX_Shdr[]. [In order to remove the garbage,
	21	* then use "ld -r" to create a new file that omits the garbage.]
	22	*/
	23
	24	#include <sys/types.h>
	25	#include <sys/mman.h>
	26	#include <sys/stat.h>
dfad3d59	27	#include <getopt.h>
81d3858d JR	28	#include <elf.h>
	29	#include <fcntl.h>
	30	#include <setjmp.h>
	31	#include <stdio.h>
	32	#include <stdlib.h>
	33	#include <string.h>
	34	#include <unistd.h>
	35
af64d2aa AT	36	#ifndef EM_AARCH64
af64d2aa AT	37	#define EM_AARCH64 183
2ee8a74f	38	#define R_AARCH64_NONE 0
af64d2aa AT	39	#define R_AARCH64_ABS64 257
	40	#endif
	41
81d3858d JR	42	static int fd_map; /* File descriptor for file being modified. */
81d3858d JR	43	static int mmap_failed; /* Boolean flag. */
81d3858d JR	44	static char gpfx; /* prefix for global symbol name (sometimes '_') */
	45	static struct stat sb; /* Remember .st_size, etc. */
	46	static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */
ed60453f	47	static const char altmcount; / alternate mcount symbol name */
dfad3d59	48	static int warn_on_notrace_sect; /* warn when section has mcount not being recorded */
a50bd439 SRRH	49	static void file_map; / pointer of the mapped file */
	50	static void file_end; / pointer to the end of the mapped file */
	51	static int file_updated; /* flag to state file was changed */
	52	static void file_ptr; / current file pointer location */
	53	static void file_append; / added to the end of the file */
	54	static size_t file_append_size; /* how much is added to end of file */
81d3858d JR	55
	56	/* setjmp() return values */
	57	enum {
	58	SJ_SETJMP = 0, /* hardwired first return */
	59	SJ_FAIL,
	60	SJ_SUCCEED
	61	};
	62
	63	/* Per-file resource cleanup when multiple files. */
	64	static void
	65	cleanup(void)
	66	{
	67	if (!mmap_failed)
a50bd439	68	munmap(file_map, sb.st_size);
81d3858d	69	else
a50bd439 SRRH	70	free(file_map);
	71	file_map = NULL;
	72	free(file_append);
	73	file_append = NULL;
	74	file_append_size = 0;
	75	file_updated = 0;
81d3858d JR	76	}
	77
	78	static void __attribute__((noreturn))
	79	fail_file(void)
	80	{
	81	cleanup();
	82	longjmp(jmpenv, SJ_FAIL);
	83	}
	84
	85	static void __attribute__((noreturn))
	86	succeed_file(void)
	87	{
	88	cleanup();
	89	longjmp(jmpenv, SJ_SUCCEED);
	90	}
	91
	92	/* ulseek, uread, ...: Check return value for errors. */
	93
	94	static off_t
	95	ulseek(int const fd, off_t const offset, int const whence)
	96	{
a50bd439 SRRH	97	switch (whence) {
	98	case SEEK_SET:
	99	file_ptr = file_map + offset;
	100	break;
	101	case SEEK_CUR:
	102	file_ptr += offset;
	103	break;
	104	case SEEK_END:
	105	file_ptr = file_map + (sb.st_size - offset);
	106	break;
	107	}
	108	if (file_ptr < file_map) {
	109	fprintf(stderr, "lseek: seek before file\n");
81d3858d JR	110	fail_file();
81d3858d JR	111	}
a50bd439	112	return file_ptr - file_map;
81d3858d JR	113	}
	114
	115	static size_t
	116	uread(int const fd, void *const buf, size_t const count)
	117	{
	118	size_t const n = read(fd, buf, count);
	119	if (n != count) {
	120	perror("read");
	121	fail_file();
	122	}
	123	return n;
	124	}
	125
	126	static size_t
	127	uwrite(int const fd, void const *const buf, size_t const count)
	128	{
a50bd439 SRRH	129	size_t cnt = count;
	130	off_t idx = 0;
	131
	132	file_updated = 1;
	133
	134	if (file_ptr + count >= file_end) {
	135	off_t aoffset = (file_ptr + count) - file_end;
	136
	137	if (aoffset > file_append_size) {
	138	file_append = realloc(file_append, aoffset);
	139	file_append_size = aoffset;
	140	}
	141	if (!file_append) {
	142	perror("write");
	143	fail_file();
	144	}
	145	if (file_ptr < file_end) {
	146	cnt = file_end - file_ptr;
	147	} else {
	148	cnt = 0;
	149	idx = aoffset - count;
	150	}
81d3858d	151	}
a50bd439 SRRH	152
	153	if (cnt)
	154	memcpy(file_ptr, buf, cnt);
	155
	156	if (cnt < count)
	157	memcpy(file_append + idx, buf + cnt, count - cnt);
	158
	159	file_ptr += count;
	160	return count;
81d3858d JR	161	}
	162
	163	static void *
	164	umalloc(size_t size)
	165	{
	166	void *const addr = malloc(size);
dd5477ff	167	if (addr == 0) {
81d3858d JR	168	fprintf(stderr, "malloc failed: %zu bytes\n", size);
	169	fail_file();
	170	}
	171	return addr;
	172	}
	173
ffd618fa SR	174	static unsigned char ideal_nop5_x86_64[5] = { 0x0f, 0x1f, 0x44, 0x00, 0x00 };
	175	static unsigned char ideal_nop5_x86_32[5] = { 0x3e, 0x8d, 0x74, 0x26, 0x00 };
	176	static unsigned char *ideal_nop;
	177
	178	static char rel_type_nop;
	179
	180	static int (make_nop)(void map, size_t const offset);
	181
	182	static int make_nop_x86(void *map, size_t const offset)
	183	{
	184	uint32_t *ptr;
	185	unsigned char *op;
	186
	187	/* Confirm we have 0xe8 0x0 0x0 0x0 0x0 */
	188	ptr = map + offset;
	189	if (*ptr != 0)
	190	return -1;
	191
	192	op = map + offset - 1;
	193	if (*op != 0xe8)
	194	return -1;
	195
	196	/* convert to nop */
	197	ulseek(fd_map, offset - 1, SEEK_SET);
	198	uwrite(fd_map, ideal_nop, 5);
	199	return 0;
	200	}
	201
9648dc15 SB	202	static unsigned char ideal_nop4_arm_le[4] = { 0x00, 0x00, 0xa0, 0xe1 }; /* mov r0, r0 */
	203	static unsigned char ideal_nop4_arm_be[4] = { 0xe1, 0xa0, 0x00, 0x00 }; /* mov r0, r0 */
	204	static unsigned char *ideal_nop4_arm;
	205
	206	static unsigned char bl_mcount_arm_le[4] = { 0xfe, 0xff, 0xff, 0xeb }; /* bl */
	207	static unsigned char bl_mcount_arm_be[4] = { 0xeb, 0xff, 0xff, 0xfe }; /* bl */
	208	static unsigned char *bl_mcount_arm;
	209
	210	static unsigned char push_arm_le[4] = { 0x04, 0xe0, 0x2d, 0xe5 }; /* push {lr} */
	211	static unsigned char push_arm_be[4] = { 0xe5, 0x2d, 0xe0, 0x04 }; /* push {lr} */
	212	static unsigned char *push_arm;
	213
	214	static unsigned char ideal_nop2_thumb_le[2] = { 0x00, 0xbf }; /* nop */
	215	static unsigned char ideal_nop2_thumb_be[2] = { 0xbf, 0x00 }; /* nop */
	216	static unsigned char *ideal_nop2_thumb;
	217
	218	static unsigned char push_bl_mcount_thumb_le[6] = { 0x00, 0xb5, 0xff, 0xf7, 0xfe, 0xff }; /* push {lr}, bl */
	219	static unsigned char push_bl_mcount_thumb_be[6] = { 0xb5, 0x00, 0xf7, 0xff, 0xff, 0xfe }; /* push {lr}, bl */
	220	static unsigned char *push_bl_mcount_thumb;
	221
	222	static int make_nop_arm(void *map, size_t const offset)
	223	{
	224	char *ptr;
	225	int cnt = 1;
	226	int nop_size;
	227	size_t off = offset;
	228
	229	ptr = map + offset;
	230	if (memcmp(ptr, bl_mcount_arm, 4) == 0) {
	231	if (memcmp(ptr - 4, push_arm, 4) == 0) {
	232	off -= 4;
	233	cnt = 2;
	234	}
	235	ideal_nop = ideal_nop4_arm;
	236	nop_size = 4;
	237	} else if (memcmp(ptr - 2, push_bl_mcount_thumb, 6) == 0) {
	238	cnt = 3;
	239	nop_size = 2;
	240	off -= 2;
	241	ideal_nop = ideal_nop2_thumb;
	242	} else
	243	return -1;
	244
	245	/* Convert to nop */
	246	ulseek(fd_map, off, SEEK_SET);
	247
	248	do {
	249	uwrite(fd_map, ideal_nop, nop_size);
	250	} while (--cnt > 0);
	251
	252	return 0;
	253	}
	254
2ee8a74f LB	255	static unsigned char ideal_nop4_arm64[4] = {0x1f, 0x20, 0x03, 0xd5};
	256	static int make_nop_arm64(void *map, size_t const offset)
	257	{
	258	uint32_t *ptr;
	259
	260	ptr = map + offset;
	261	/* bl <_mcount> is 0x94000000 before relocation */
	262	if (*ptr != 0x94000000)
	263	return -1;
	264
	265	/* Convert to nop */
	266	ulseek(fd_map, offset, SEEK_SET);
	267	uwrite(fd_map, ideal_nop, 4);
	268	return 0;
	269	}
	270
81d3858d JR	271	/*
	272	* Get the whole file as a programming convenience in order to avoid
	273	* malloc+lseek+read+free of many pieces. If successful, then mmap
	274	* avoids copying unused pieces; else just read the whole file.
	275	* Open for both read and write; new info will be appended to the file.
	276	* Use MAP_PRIVATE so that a few changes to the in-memory ElfXX_Ehdr
	277	* do not propagate to the file until an explicit overwrite at the last.
	278	* This preserves most aspects of consistency (all except .st_size)
	279	* for simultaneous readers of the file while we are appending to it.
	280	* However, multiple writers still are bad. We choose not to use
	281	* locking because it is expensive and the use case of kernel build
	282	* makes multiple writers unlikely.
	283	*/
	284	static void mmap_file(char const fname)
	285	{
a50bd439	286	fd_map = open(fname, O_RDONLY);
dd5477ff	287	if (fd_map < 0 \|\| fstat(fd_map, &sb) < 0) {
81d3858d JR	288	perror(fname);
	289	fail_file();
	290	}
	291	if (!S_ISREG(sb.st_mode)) {
	292	fprintf(stderr, "not a regular file: %s\n", fname);
	293	fail_file();
	294	}
a50bd439 SRRH	295	file_map = mmap(0, sb.st_size, PROT_READ\|PROT_WRITE, MAP_PRIVATE,
a50bd439 SRRH	296	fd_map, 0);
81d3858d	297	mmap_failed = 0;
a50bd439	298	if (file_map == MAP_FAILED) {
81d3858d	299	mmap_failed = 1;
a50bd439 SRRH	300	file_map = umalloc(sb.st_size);
a50bd439 SRRH	301	uread(fd_map, file_map, sb.st_size);
81d3858d	302	}
a50bd439 SRRH	303	close(fd_map);
	304
	305	file_end = file_map + sb.st_size;
	306
	307	return file_map;
	308	}
	309
	310	static void write_file(const char *fname)
	311	{
	312	char tmp_file[strlen(fname) + 4];
	313	size_t n;
	314
	315	if (!file_updated)
	316	return;
	317
	318	sprintf(tmp_file, "%s.rc", fname);
	319
	320	/*
	321	* After reading the entire file into memory, delete it
	322	* and write it back, to prevent weird side effects of modifying
	323	* an object file in place.
	324	*/
	325	fd_map = open(tmp_file, O_WRONLY \| O_TRUNC \| O_CREAT, sb.st_mode);
	326	if (fd_map < 0) {
	327	perror(fname);
	328	fail_file();
	329	}
	330	n = write(fd_map, file_map, sb.st_size);
	331	if (n != sb.st_size) {
	332	perror("write");
	333	fail_file();
	334	}
	335	if (file_append_size) {
	336	n = write(fd_map, file_append, file_append_size);
	337	if (n != file_append_size) {
	338	perror("write");
dd39a265 RK	339	fail_file();
dd39a265 RK	340	}
dd39a265	341	}
a50bd439 SRRH	342	close(fd_map);
	343	if (rename(tmp_file, fname) < 0) {
	344	perror(fname);
	345	fail_file();
	346	}
81d3858d JR	347	}
	348
	349	/* w8rev, w8nat, ...: Handle endianness. */
	350
	351	static uint64_t w8rev(uint64_t const x)
	352	{
	353	return ((0xff & (x >> (0 * 8))) << (7 * 8))
	354	\| ((0xff & (x >> (1 * 8))) << (6 * 8))
	355	\| ((0xff & (x >> (2 * 8))) << (5 * 8))
	356	\| ((0xff & (x >> (3 * 8))) << (4 * 8))
	357	\| ((0xff & (x >> (4 * 8))) << (3 * 8))
	358	\| ((0xff & (x >> (5 * 8))) << (2 * 8))
	359	\| ((0xff & (x >> (6 * 8))) << (1 * 8))
	360	\| ((0xff & (x >> (7 * 8))) << (0 * 8));
	361	}
	362
	363	static uint32_t w4rev(uint32_t const x)
	364	{
	365	return ((0xff & (x >> (0 * 8))) << (3 * 8))
	366	\| ((0xff & (x >> (1 * 8))) << (2 * 8))
	367	\| ((0xff & (x >> (2 * 8))) << (1 * 8))
	368	\| ((0xff & (x >> (3 * 8))) << (0 * 8));
	369	}
	370
	371	static uint32_t w2rev(uint16_t const x)
	372	{
	373	return ((0xff & (x >> (0 * 8))) << (1 * 8))
	374	\| ((0xff & (x >> (1 * 8))) << (0 * 8));
	375	}
	376
	377	static uint64_t w8nat(uint64_t const x)
	378	{
	379	return x;
	380	}
	381
	382	static uint32_t w4nat(uint32_t const x)
	383	{
	384	return x;
	385	}
	386
	387	static uint32_t w2nat(uint16_t const x)
	388	{
	389	return x;
	390	}
	391
	392	static uint64_t (*w8)(uint64_t);
	393	static uint32_t (*w)(uint32_t);
	394	static uint32_t (*w2)(uint16_t);
	395
	396	/* Names of the sections that could contain calls to mcount. */
	397	static int
	398	is_mcounted_section_name(char const *const txtname)
	399	{
9c8e2f6d	400	return strncmp(".text", txtname, 5) == 0 \|\|
42c269c8	401	strcmp(".init.text", txtname) == 0 \|\|
dd5477ff SR	402	strcmp(".ref.text", txtname) == 0 \|\|
	403	strcmp(".sched.text", txtname) == 0 \|\|
	404	strcmp(".spinlock.text", txtname) == 0 \|\|
	405	strcmp(".irqentry.text", txtname) == 0 \|\|
e436fd61	406	strcmp(".softirqentry.text", txtname) == 0 \|\|
9f087e76	407	strcmp(".kprobes.text", txtname) == 0 \|\|
6727ad9e	408	strcmp(".cpuidle.text", txtname) == 0 \|\|
dd5477ff	409	strcmp(".text.unlikely", txtname) == 0;
81d3858d JR	410	}
81d3858d JR	411
c28d5077 SR	412	/* 32 bit and 64 bit are very similar */
	413	#include "recordmcount.h"
	414	#define RECORD_MCOUNT_64
	415	#include "recordmcount.h"
81d3858d	416
a2d49358 JR	417	/* 64-bit EM_MIPS has weird ELF64_Rela.r_info.
	418	* http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf
	419	* We interpret Table 29 Relocation Operation (Elf64_Rel, Elf64_Rela) [p.40]
	420	* to imply the order of the members; the spec does not say so.
	421	* typedef unsigned char Elf64_Byte;
	422	* fails on MIPS64 because their <elf.h> already has it!
	423	*/
	424
	425	typedef uint8_t myElf64_Byte; /* Type for a 8-bit quantity. */
	426
	427	union mips_r_info {
	428	Elf64_Xword r_info;
	429	struct {
	430	Elf64_Word r_sym; /* Symbol index. */
	431	myElf64_Byte r_ssym; /* Special symbol. */
	432	myElf64_Byte r_type3; /* Third relocation. */
	433	myElf64_Byte r_type2; /* Second relocation. */
	434	myElf64_Byte r_type; /* First relocation. */
	435	} r_mips;
	436	};
	437
	438	static uint64_t MIPS64_r_sym(Elf64_Rel const *rp)
	439	{
	440	return w(((union mips_r_info){ .r_info = rp->r_info }).r_mips.r_sym);
	441	}
	442
	443	static void MIPS64_r_info(Elf64_Rel *const rp, unsigned sym, unsigned type)
	444	{
	445	rp->r_info = ((union mips_r_info){
	446	.r_mips = { .r_sym = w(sym), .r_type = type }
	447	}).r_info;
	448	}
	449
81d3858d JR	450	static void
	451	do_file(char const *const fname)
	452	{
	453	Elf32_Ehdr *const ehdr = mmap_file(fname);
	454	unsigned int reltype = 0;
	455
81d3858d JR	456	w = w4nat;
	457	w2 = w2nat;
	458	w8 = w8nat;
	459	switch (ehdr->e_ident[EI_DATA]) {
	460	static unsigned int const endian = 1;
e90b0c8b	461	default:
81d3858d JR	462	fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
	463	ehdr->e_ident[EI_DATA], fname);
	464	fail_file();
e90b0c8b SR	465	break;
e90b0c8b SR	466	case ELFDATA2LSB:
dd5477ff	467	if ((unsigned char const )&endian != 1) {
81d3858d JR	468	/* main() is big endian, file.o is little endian. */
	469	w = w4rev;
	470	w2 = w2rev;
	471	w8 = w8rev;
	472	}
9648dc15 SB	473	ideal_nop4_arm = ideal_nop4_arm_le;
	474	bl_mcount_arm = bl_mcount_arm_le;
	475	push_arm = push_arm_le;
	476	ideal_nop2_thumb = ideal_nop2_thumb_le;
	477	push_bl_mcount_thumb = push_bl_mcount_thumb_le;
e90b0c8b SR	478	break;
e90b0c8b SR	479	case ELFDATA2MSB:
dd5477ff	480	if ((unsigned char const )&endian != 0) {
81d3858d JR	481	/* main() is little endian, file.o is big endian. */
	482	w = w4rev;
	483	w2 = w2rev;
	484	w8 = w8rev;
	485	}
9648dc15 SB	486	ideal_nop4_arm = ideal_nop4_arm_be;
	487	bl_mcount_arm = bl_mcount_arm_be;
	488	push_arm = push_arm_be;
	489	ideal_nop2_thumb = ideal_nop2_thumb_be;
	490	push_bl_mcount_thumb = push_bl_mcount_thumb_be;
e90b0c8b	491	break;
81d3858d	492	} /* end switch */
dd5477ff SR	493	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
	494	\|\| w2(ehdr->e_type) != ET_REL
	495	\|\| ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
81d3858d JR	496	fprintf(stderr, "unrecognized ET_REL file %s\n", fname);
	497	fail_file();
	498	}
	499
	500	gpfx = 0;
	501	switch (w2(ehdr->e_machine)) {
e90b0c8b	502	default:
ac5db1fc	503	fprintf(stderr, "unrecognized e_machine %u %s\n",
81d3858d JR	504	w2(ehdr->e_machine), fname);
81d3858d JR	505	fail_file();
e90b0c8b	506	break;
ffd618fa SR	507	case EM_386:
ffd618fa SR	508	reltype = R_386_32;
46a2b61e	509	rel_type_nop = R_386_NONE;
ffd618fa SR	510	make_nop = make_nop_x86;
ffd618fa SR	511	ideal_nop = ideal_nop5_x86_32;
521ccb5c	512	mcount_adjust_32 = -1;
ffd618fa	513	break;
ed60453f RV	514	case EM_ARM: reltype = R_ARM_ABS32;
ed60453f RV	515	altmcount = "__gnu_mcount_nc";
9648dc15 SB	516	make_nop = make_nop_arm;
9648dc15 SB	517	rel_type_nop = R_ARM_NONE;
ed60453f	518	break;
af64d2aa	519	case EM_AARCH64:
2ee8a74f LB	520	reltype = R_AARCH64_ABS64;
	521	make_nop = make_nop_arm64;
	522	rel_type_nop = R_AARCH64_NONE;
	523	ideal_nop = ideal_nop4_arm64;
	524	gpfx = '_';
	525	break;
81d3858d	526	case EM_IA_64: reltype = R_IA64_IMM64; gpfx = '_'; break;
a2d49358	527	case EM_MIPS: /* reltype: e_class */ gpfx = '_'; break;
81d3858d JR	528	case EM_PPC: reltype = R_PPC_ADDR32; gpfx = '_'; break;
	529	case EM_PPC64: reltype = R_PPC64_ADDR64; gpfx = '_'; break;
	530	case EM_S390: /* reltype: e_class */ gpfx = '_'; break;
	531	case EM_SH: reltype = R_SH_DIR32; break;
	532	case EM_SPARCV9: reltype = R_SPARC_64; gpfx = '_'; break;
ffd618fa SR	533	case EM_X86_64:
	534	make_nop = make_nop_x86;
	535	ideal_nop = ideal_nop5_x86_64;
	536	reltype = R_X86_64_64;
46a2b61e	537	rel_type_nop = R_X86_64_NONE;
521ccb5c	538	mcount_adjust_64 = -1;
ffd618fa	539	break;
81d3858d JR	540	} /* end switch */
	541
	542	switch (ehdr->e_ident[EI_CLASS]) {
e90b0c8b	543	default:
81d3858d JR	544	fprintf(stderr, "unrecognized ELF class %d %s\n",
	545	ehdr->e_ident[EI_CLASS], fname);
	546	fail_file();
e90b0c8b SR	547	break;
e90b0c8b SR	548	case ELFCLASS32:
dd5477ff SR	549	if (w2(ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
dd5477ff SR	550	\|\| w2(ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
81d3858d JR	551	fprintf(stderr,
	552	"unrecognized ET_REL file: %s\n", fname);
	553	fail_file();
	554	}
dd5477ff	555	if (w2(ehdr->e_machine) == EM_MIPS) {
a2d49358	556	reltype = R_MIPS_32;
412910cd WZ	557	is_fake_mcount32 = MIPS32_is_fake_mcount;
412910cd WZ	558	}
81d3858d	559	do32(ehdr, fname, reltype);
e90b0c8b	560	break;
81d3858d JR	561	case ELFCLASS64: {
81d3858d JR	562	Elf64_Ehdr const ghdr = (Elf64_Ehdr )ehdr;
dd5477ff SR	563	if (w2(ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
dd5477ff SR	564	\|\| w2(ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
81d3858d JR	565	fprintf(stderr,
	566	"unrecognized ET_REL file: %s\n", fname);
	567	fail_file();
	568	}
f2963886	569	if (w2(ghdr->e_machine) == EM_S390) {
81d3858d	570	reltype = R_390_64;
c933146a	571	mcount_adjust_64 = -14;
f2963886	572	}
dd5477ff	573	if (w2(ghdr->e_machine) == EM_MIPS) {
a2d49358 JR	574	reltype = R_MIPS_64;
	575	Elf64_r_sym = MIPS64_r_sym;
	576	Elf64_r_info = MIPS64_r_info;
412910cd	577	is_fake_mcount64 = MIPS64_is_fake_mcount;
a2d49358	578	}
81d3858d	579	do64(ghdr, fname, reltype);
e90b0c8b SR	580	break;
e90b0c8b SR	581	}
81d3858d JR	582	} /* end switch */
81d3858d JR	583
a50bd439	584	write_file(fname);
81d3858d JR	585	cleanup();
	586	}
	587
	588	int
dfad3d59	589	main(int argc, char *argv[])
81d3858d	590	{
cd3478f2	591	const char ftrace[] = "/ftrace.o";
44475863	592	int ftrace_size = sizeof(ftrace) - 1;
81d3858d	593	int n_error = 0; /* gcc-4.3.0 false positive complaint */
dfad3d59 SR	594	int c;
dfad3d59 SR	595	int i;
44475863	596
dfad3d59 SR	597	while ((c = getopt(argc, argv, "w")) >= 0) {
	598	switch (c) {
	599	case 'w':
	600	warn_on_notrace_sect = 1;
	601	break;
	602	default:
	603	fprintf(stderr, "usage: recordmcount [-w] file.o...\n");
	604	return 0;
	605	}
	606	}
	607
	608	if ((argc - optind) < 1) {
	609	fprintf(stderr, "usage: recordmcount [-w] file.o...\n");
44475863 SR	610	return 0;
	611	}
	612
	613	/* Process each file in turn, allowing deep failure. */
dfad3d59 SR	614	for (i = optind; i < argc; i++) {
dfad3d59 SR	615	char *file = argv[i];
81d3858d	616	int const sjval = setjmp(jmpenv);
44475863 SR	617	int len;
	618
	619	/*
	620	* The file kernel/trace/ftrace.o references the mcount
	621	* function but does not call it. Since ftrace.o should
	622	* not be traced anyway, we just skip it.
	623	*/
dfad3d59	624	len = strlen(file);
44475863	625	if (len >= ftrace_size &&
dfad3d59	626	strcmp(file + (len - ftrace_size), ftrace) == 0)
44475863 SR	627	continue;
44475863 SR	628
81d3858d	629	switch (sjval) {
e90b0c8b	630	default:
dfad3d59	631	fprintf(stderr, "internal error: %s\n", file);
81d3858d	632	exit(1);
e90b0c8b SR	633	break;
e90b0c8b SR	634	case SJ_SETJMP: /* normal sequence */
81d3858d JR	635	/* Avoid problems if early cleanup() */
81d3858d JR	636	fd_map = -1;
81d3858d	637	mmap_failed = 1;
a50bd439 SRRH	638	file_map = NULL;
	639	file_ptr = NULL;
	640	file_updated = 0;
dfad3d59	641	do_file(file);
e90b0c8b SR	642	break;
e90b0c8b SR	643	case SJ_FAIL: /* error in do_file or below */
713a3e4d	644	fprintf(stderr, "%s: failed\n", file);
81d3858d	645	++n_error;
e90b0c8b SR	646	break;
e90b0c8b SR	647	case SJ_SUCCEED: /* premature success */
81d3858d	648	/* do nothing */
e90b0c8b	649	break;
81d3858d JR	650	} /* end switch */
	651	}
	652	return !!n_error;
	653	}