Linux Audio

Check our new training course

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