Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 444758636439810f110f86a3042c2dfd3626a9e2

Authored by Steven Rostedt 2010-10-15 23:49:47 +0800

Committed by Steven Rostedt 2010-10-15 23:49:47 +0800

ftrace: Do not process kernel/trace/ftrace.o with C recordmcount program

The file kernel/trace/ftrace.c references the mcount() call to
convert the mcount() callers to nops. But because it references
mcount(), the mcount() address is placed in the relocation table.

The C version of recordmcount reads the relocation table of all
object files, and it will add all references to mcount to the
__mcount_loc table that is used to find the places that call mcount()
and change the call to a nop. When recordmcount finds the mcount reference
in kernel/trace/ftrace.o, it saves that location even though the code
is not a call, but references mcount as data.

On boot up, when all calls are converted to nops, the code has a safety
check to determine what op code it is actually replacing before it
replaces it. If that op code at the address does not match, then
a warning is printed and the function tracer is disabled.

The reference to mcount in ftrace.c, causes this warning to trigger,
since the reference is not a call to mcount(). The ftrace.c file is
not compiled with the -pg flag, so no calls to mcount() should be
expected.

This patch simply makes recordmcount.c skip the kernel/trace/ftrace.c
file. This was the same solution used by the perl version of
recordmcount.

Reported-by: Ingo Molnar <mingo@elte.hu>
Cc: John Reiser <jreiser@bitwagon.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

Showing 1 changed file with 20 additions and 2 deletions Inline Diff

scripts/recordmcount.c

scripts/recordmcount.c

Diff comments View file @ 4447586

1	/*	1	/*
2	* recordmcount.c: construct a table of the locations of calls to 'mcount'	2	* recordmcount.c: construct a table of the locations of calls to 'mcount'
3	* so that ftrace can find them quickly.	3	* so that ftrace can find them quickly.
4	* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved.	4	* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved.
5	* Licensed under the GNU General Public License, version 2 (GPLv2).	5	* Licensed under the GNU General Public License, version 2 (GPLv2).
6	*	6	*
7	* Restructured to fit Linux format, as well as other updates:	7	* Restructured to fit Linux format, as well as other updates:
8	* Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.	8	* Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
9	*/	9	*/
10		10
11	/*	11	/*
12	* Strategy: alter the .o file in-place.	12	* Strategy: alter the .o file in-place.
13	*	13	*
14	* Append a new STRTAB that has the new section names, followed by a new array	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	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,	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	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)	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	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,	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.]	21	* then use "ld -r" to create a new file that omits the garbage.]
22	*/	22	*/
23		23
24	#include <sys/types.h>	24	#include <sys/types.h>
25	#include <sys/mman.h>	25	#include <sys/mman.h>
26	#include <sys/stat.h>	26	#include <sys/stat.h>
27	#include <elf.h>	27	#include <elf.h>
28	#include <fcntl.h>	28	#include <fcntl.h>
29	#include <setjmp.h>	29	#include <setjmp.h>
30	#include <stdio.h>	30	#include <stdio.h>
31	#include <stdlib.h>	31	#include <stdlib.h>
32	#include <string.h>	32	#include <string.h>
33	#include <unistd.h>	33	#include <unistd.h>
34		34
35	static int fd_map; /* File descriptor for file being modified. */	35	static int fd_map; /* File descriptor for file being modified. */
36	static int mmap_failed; /* Boolean flag. */	36	static int mmap_failed; /* Boolean flag. */
37	static void ehdr_curr; / current ElfXX_Ehdr * for resource cleanup */	37	static void ehdr_curr; / current ElfXX_Ehdr * for resource cleanup */
38	static char gpfx; /* prefix for global symbol name (sometimes '_') */	38	static char gpfx; /* prefix for global symbol name (sometimes '_') */
39	static struct stat sb; /* Remember .st_size, etc. */	39	static struct stat sb; /* Remember .st_size, etc. */
40	static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */	40	static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */
41		41
42	/* setjmp() return values */	42	/* setjmp() return values */
43	enum {	43	enum {
44	SJ_SETJMP = 0, /* hardwired first return */	44	SJ_SETJMP = 0, /* hardwired first return */
45	SJ_FAIL,	45	SJ_FAIL,
46	SJ_SUCCEED	46	SJ_SUCCEED
47	};	47	};
48		48
49	/* Per-file resource cleanup when multiple files. */	49	/* Per-file resource cleanup when multiple files. */
50	static void	50	static void
51	cleanup(void)	51	cleanup(void)
52	{	52	{
53	if (!mmap_failed)	53	if (!mmap_failed)
54	munmap(ehdr_curr, sb.st_size);	54	munmap(ehdr_curr, sb.st_size);
55	else	55	else
56	free(ehdr_curr);	56	free(ehdr_curr);
57	close(fd_map);	57	close(fd_map);
58	}	58	}
59		59
60	static void __attribute__((noreturn))	60	static void __attribute__((noreturn))
61	fail_file(void)	61	fail_file(void)
62	{	62	{
63	cleanup();	63	cleanup();
64	longjmp(jmpenv, SJ_FAIL);	64	longjmp(jmpenv, SJ_FAIL);
65	}	65	}
66		66
67	static void __attribute__((noreturn))	67	static void __attribute__((noreturn))
68	succeed_file(void)	68	succeed_file(void)
69	{	69	{
70	cleanup();	70	cleanup();
71	longjmp(jmpenv, SJ_SUCCEED);	71	longjmp(jmpenv, SJ_SUCCEED);
72	}	72	}
73		73
74	/* ulseek, uread, ...: Check return value for errors. */	74	/* ulseek, uread, ...: Check return value for errors. */
75		75
76	static off_t	76	static off_t
77	ulseek(int const fd, off_t const offset, int const whence)	77	ulseek(int const fd, off_t const offset, int const whence)
78	{	78	{
79	off_t const w = lseek(fd, offset, whence);	79	off_t const w = lseek(fd, offset, whence);
80	if ((off_t)-1 == w) {	80	if ((off_t)-1 == w) {
81	perror("lseek");	81	perror("lseek");
82	fail_file();	82	fail_file();
83	}	83	}
84	return w;	84	return w;
85	}	85	}
86		86
87	static size_t	87	static size_t
88	uread(int const fd, void *const buf, size_t const count)	88	uread(int const fd, void *const buf, size_t const count)
89	{	89	{
90	size_t const n = read(fd, buf, count);	90	size_t const n = read(fd, buf, count);
91	if (n != count) {	91	if (n != count) {
92	perror("read");	92	perror("read");
93	fail_file();	93	fail_file();
94	}	94	}
95	return n;	95	return n;
96	}	96	}
97		97
98	static size_t	98	static size_t
99	uwrite(int const fd, void const *const buf, size_t const count)	99	uwrite(int const fd, void const *const buf, size_t const count)
100	{	100	{
101	size_t const n = write(fd, buf, count);	101	size_t const n = write(fd, buf, count);
102	if (n != count) {	102	if (n != count) {
103	perror("write");	103	perror("write");
104	fail_file();	104	fail_file();
105	}	105	}
106	return n;	106	return n;
107	}	107	}
108		108
109	static void *	109	static void *
110	umalloc(size_t size)	110	umalloc(size_t size)
111	{	111	{
112	void *const addr = malloc(size);	112	void *const addr = malloc(size);
113	if (0 == addr) {	113	if (0 == addr) {
114	fprintf(stderr, "malloc failed: %zu bytes\n", size);	114	fprintf(stderr, "malloc failed: %zu bytes\n", size);
115	fail_file();	115	fail_file();
116	}	116	}
117	return addr;	117	return addr;
118	}	118	}
119		119
120	/*	120	/*
121	* Get the whole file as a programming convenience in order to avoid	121	* Get the whole file as a programming convenience in order to avoid
122	* malloc+lseek+read+free of many pieces. If successful, then mmap	122	* malloc+lseek+read+free of many pieces. If successful, then mmap
123	* avoids copying unused pieces; else just read the whole file.	123	* avoids copying unused pieces; else just read the whole file.
124	* Open for both read and write; new info will be appended to the file.	124	* Open for both read and write; new info will be appended to the file.
125	* Use MAP_PRIVATE so that a few changes to the in-memory ElfXX_Ehdr	125	* Use MAP_PRIVATE so that a few changes to the in-memory ElfXX_Ehdr
126	* do not propagate to the file until an explicit overwrite at the last.	126	* do not propagate to the file until an explicit overwrite at the last.
127	* This preserves most aspects of consistency (all except .st_size)	127	* This preserves most aspects of consistency (all except .st_size)
128	* for simultaneous readers of the file while we are appending to it.	128	* for simultaneous readers of the file while we are appending to it.
129	* However, multiple writers still are bad. We choose not to use	129	* However, multiple writers still are bad. We choose not to use
130	* locking because it is expensive and the use case of kernel build	130	* locking because it is expensive and the use case of kernel build
131	* makes multiple writers unlikely.	131	* makes multiple writers unlikely.
132	*/	132	*/
133	static void mmap_file(char const fname)	133	static void mmap_file(char const fname)
134	{	134	{
135	void *addr;	135	void *addr;
136		136
137	fd_map = open(fname, O_RDWR);	137	fd_map = open(fname, O_RDWR);
138	if (0 > fd_map \|\| 0 > fstat(fd_map, &sb)) {	138	if (0 > fd_map \|\| 0 > fstat(fd_map, &sb)) {
139	perror(fname);	139	perror(fname);
140	fail_file();	140	fail_file();
141	}	141	}
142	if (!S_ISREG(sb.st_mode)) {	142	if (!S_ISREG(sb.st_mode)) {
143	fprintf(stderr, "not a regular file: %s\n", fname);	143	fprintf(stderr, "not a regular file: %s\n", fname);
144	fail_file();	144	fail_file();
145	}	145	}
146	addr = mmap(0, sb.st_size, PROT_READ\|PROT_WRITE, MAP_PRIVATE,	146	addr = mmap(0, sb.st_size, PROT_READ\|PROT_WRITE, MAP_PRIVATE,
147	fd_map, 0);	147	fd_map, 0);
148	mmap_failed = 0;	148	mmap_failed = 0;
149	if (MAP_FAILED == addr) {	149	if (MAP_FAILED == addr) {
150	mmap_failed = 1;	150	mmap_failed = 1;
151	addr = umalloc(sb.st_size);	151	addr = umalloc(sb.st_size);
152	uread(fd_map, addr, sb.st_size);	152	uread(fd_map, addr, sb.st_size);
153	}	153	}
154	return addr;	154	return addr;
155	}	155	}
156		156
157	/* w8rev, w8nat, ...: Handle endianness. */	157	/* w8rev, w8nat, ...: Handle endianness. */
158		158
159	static uint64_t w8rev(uint64_t const x)	159	static uint64_t w8rev(uint64_t const x)
160	{	160	{
161	return ((0xff & (x >> (0 * 8))) << (7 * 8))	161	return ((0xff & (x >> (0 * 8))) << (7 * 8))
162	\| ((0xff & (x >> (1 * 8))) << (6 * 8))	162	\| ((0xff & (x >> (1 * 8))) << (6 * 8))
163	\| ((0xff & (x >> (2 * 8))) << (5 * 8))	163	\| ((0xff & (x >> (2 * 8))) << (5 * 8))
164	\| ((0xff & (x >> (3 * 8))) << (4 * 8))	164	\| ((0xff & (x >> (3 * 8))) << (4 * 8))
165	\| ((0xff & (x >> (4 * 8))) << (3 * 8))	165	\| ((0xff & (x >> (4 * 8))) << (3 * 8))
166	\| ((0xff & (x >> (5 * 8))) << (2 * 8))	166	\| ((0xff & (x >> (5 * 8))) << (2 * 8))
167	\| ((0xff & (x >> (6 * 8))) << (1 * 8))	167	\| ((0xff & (x >> (6 * 8))) << (1 * 8))
168	\| ((0xff & (x >> (7 * 8))) << (0 * 8));	168	\| ((0xff & (x >> (7 * 8))) << (0 * 8));
169	}	169	}
170		170
171	static uint32_t w4rev(uint32_t const x)	171	static uint32_t w4rev(uint32_t const x)
172	{	172	{
173	return ((0xff & (x >> (0 * 8))) << (3 * 8))	173	return ((0xff & (x >> (0 * 8))) << (3 * 8))
174	\| ((0xff & (x >> (1 * 8))) << (2 * 8))	174	\| ((0xff & (x >> (1 * 8))) << (2 * 8))
175	\| ((0xff & (x >> (2 * 8))) << (1 * 8))	175	\| ((0xff & (x >> (2 * 8))) << (1 * 8))
176	\| ((0xff & (x >> (3 * 8))) << (0 * 8));	176	\| ((0xff & (x >> (3 * 8))) << (0 * 8));
177	}	177	}
178		178
179	static uint32_t w2rev(uint16_t const x)	179	static uint32_t w2rev(uint16_t const x)
180	{	180	{
181	return ((0xff & (x >> (0 * 8))) << (1 * 8))	181	return ((0xff & (x >> (0 * 8))) << (1 * 8))
182	\| ((0xff & (x >> (1 * 8))) << (0 * 8));	182	\| ((0xff & (x >> (1 * 8))) << (0 * 8));
183	}	183	}
184		184
185	static uint64_t w8nat(uint64_t const x)	185	static uint64_t w8nat(uint64_t const x)
186	{	186	{
187	return x;	187	return x;
188	}	188	}
189		189
190	static uint32_t w4nat(uint32_t const x)	190	static uint32_t w4nat(uint32_t const x)
191	{	191	{
192	return x;	192	return x;
193	}	193	}
194		194
195	static uint32_t w2nat(uint16_t const x)	195	static uint32_t w2nat(uint16_t const x)
196	{	196	{
197	return x;	197	return x;
198	}	198	}
199		199
200	static uint64_t (*w8)(uint64_t);	200	static uint64_t (*w8)(uint64_t);
201	static uint32_t (*w)(uint32_t);	201	static uint32_t (*w)(uint32_t);
202	static uint32_t (*w2)(uint16_t);	202	static uint32_t (*w2)(uint16_t);
203		203
204	/* Names of the sections that could contain calls to mcount. */	204	/* Names of the sections that could contain calls to mcount. */
205	static int	205	static int
206	is_mcounted_section_name(char const *const txtname)	206	is_mcounted_section_name(char const *const txtname)
207	{	207	{
208	return 0 == strcmp(".text", txtname) \|\|	208	return 0 == strcmp(".text", txtname) \|\|
209	0 == strcmp(".sched.text", txtname) \|\|	209	0 == strcmp(".sched.text", txtname) \|\|
210	0 == strcmp(".spinlock.text", txtname) \|\|	210	0 == strcmp(".spinlock.text", txtname) \|\|
211	0 == strcmp(".irqentry.text", txtname) \|\|	211	0 == strcmp(".irqentry.text", txtname) \|\|
212	0 == strcmp(".text.unlikely", txtname);	212	0 == strcmp(".text.unlikely", txtname);
213	}	213	}
214		214
215	/* 32 bit and 64 bit are very similar */	215	/* 32 bit and 64 bit are very similar */
216	#include "recordmcount.h"	216	#include "recordmcount.h"
217	#define RECORD_MCOUNT_64	217	#define RECORD_MCOUNT_64
218	#include "recordmcount.h"	218	#include "recordmcount.h"
219		219
220	static void	220	static void
221	do_file(char const *const fname)	221	do_file(char const *const fname)
222	{	222	{
223	Elf32_Ehdr *const ehdr = mmap_file(fname);	223	Elf32_Ehdr *const ehdr = mmap_file(fname);
224	unsigned int reltype = 0;	224	unsigned int reltype = 0;
225		225
226	ehdr_curr = ehdr;	226	ehdr_curr = ehdr;
227	w = w4nat;	227	w = w4nat;
228	w2 = w2nat;	228	w2 = w2nat;
229	w8 = w8nat;	229	w8 = w8nat;
230	switch (ehdr->e_ident[EI_DATA]) {	230	switch (ehdr->e_ident[EI_DATA]) {
231	static unsigned int const endian = 1;	231	static unsigned int const endian = 1;
232	default: {	232	default: {
233	fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",	233	fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
234	ehdr->e_ident[EI_DATA], fname);	234	ehdr->e_ident[EI_DATA], fname);
235	fail_file();	235	fail_file();
236	} break;	236	} break;
237	case ELFDATA2LSB: {	237	case ELFDATA2LSB: {
238	if (1 != (unsigned char const )&endian) {	238	if (1 != (unsigned char const )&endian) {
239	/* main() is big endian, file.o is little endian. */	239	/* main() is big endian, file.o is little endian. */
240	w = w4rev;	240	w = w4rev;
241	w2 = w2rev;	241	w2 = w2rev;
242	w8 = w8rev;	242	w8 = w8rev;
243	}	243	}
244	} break;	244	} break;
245	case ELFDATA2MSB: {	245	case ELFDATA2MSB: {
246	if (0 != (unsigned char const )&endian) {	246	if (0 != (unsigned char const )&endian) {
247	/* main() is little endian, file.o is big endian. */	247	/* main() is little endian, file.o is big endian. */
248	w = w4rev;	248	w = w4rev;
249	w2 = w2rev;	249	w2 = w2rev;
250	w8 = w8rev;	250	w8 = w8rev;
251	}	251	}
252	} break;	252	} break;
253	} /* end switch */	253	} /* end switch */
254	if (0 != memcmp(ELFMAG, ehdr->e_ident, SELFMAG)	254	if (0 != memcmp(ELFMAG, ehdr->e_ident, SELFMAG)
255	\|\| ET_REL != w2(ehdr->e_type)	255	\|\| ET_REL != w2(ehdr->e_type)
256	\|\| EV_CURRENT != ehdr->e_ident[EI_VERSION]) {	256	\|\| EV_CURRENT != ehdr->e_ident[EI_VERSION]) {
257	fprintf(stderr, "unrecognized ET_REL file %s\n", fname);	257	fprintf(stderr, "unrecognized ET_REL file %s\n", fname);
258	fail_file();	258	fail_file();
259	}	259	}
260		260
261	gpfx = 0;	261	gpfx = 0;
262	switch (w2(ehdr->e_machine)) {	262	switch (w2(ehdr->e_machine)) {
263	default: {	263	default: {
264	fprintf(stderr, "unrecognized e_machine %d %s\n",	264	fprintf(stderr, "unrecognized e_machine %d %s\n",
265	w2(ehdr->e_machine), fname);	265	w2(ehdr->e_machine), fname);
266	fail_file();	266	fail_file();
267	} break;	267	} break;
268	case EM_386: reltype = R_386_32; break;	268	case EM_386: reltype = R_386_32; break;
269	case EM_ARM: reltype = R_ARM_ABS32; break;	269	case EM_ARM: reltype = R_ARM_ABS32; break;
270	case EM_IA_64: reltype = R_IA64_IMM64; gpfx = '_'; break;	270	case EM_IA_64: reltype = R_IA64_IMM64; gpfx = '_'; break;
271	case EM_PPC: reltype = R_PPC_ADDR32; gpfx = '_'; break;	271	case EM_PPC: reltype = R_PPC_ADDR32; gpfx = '_'; break;
272	case EM_PPC64: reltype = R_PPC64_ADDR64; gpfx = '_'; break;	272	case EM_PPC64: reltype = R_PPC64_ADDR64; gpfx = '_'; break;
273	case EM_S390: /* reltype: e_class */ gpfx = '_'; break;	273	case EM_S390: /* reltype: e_class */ gpfx = '_'; break;
274	case EM_SH: reltype = R_SH_DIR32; break;	274	case EM_SH: reltype = R_SH_DIR32; break;
275	case EM_SPARCV9: reltype = R_SPARC_64; gpfx = '_'; break;	275	case EM_SPARCV9: reltype = R_SPARC_64; gpfx = '_'; break;
276	case EM_X86_64: reltype = R_X86_64_64; break;	276	case EM_X86_64: reltype = R_X86_64_64; break;
277	} /* end switch */	277	} /* end switch */
278		278
279	switch (ehdr->e_ident[EI_CLASS]) {	279	switch (ehdr->e_ident[EI_CLASS]) {
280	default: {	280	default: {
281	fprintf(stderr, "unrecognized ELF class %d %s\n",	281	fprintf(stderr, "unrecognized ELF class %d %s\n",
282	ehdr->e_ident[EI_CLASS], fname);	282	ehdr->e_ident[EI_CLASS], fname);
283	fail_file();	283	fail_file();
284	} break;	284	} break;
285	case ELFCLASS32: {	285	case ELFCLASS32: {
286	if (sizeof(Elf32_Ehdr) != w2(ehdr->e_ehsize)	286	if (sizeof(Elf32_Ehdr) != w2(ehdr->e_ehsize)
287	\|\| sizeof(Elf32_Shdr) != w2(ehdr->e_shentsize)) {	287	\|\| sizeof(Elf32_Shdr) != w2(ehdr->e_shentsize)) {
288	fprintf(stderr,	288	fprintf(stderr,
289	"unrecognized ET_REL file: %s\n", fname);	289	"unrecognized ET_REL file: %s\n", fname);
290	fail_file();	290	fail_file();
291	}	291	}
292	if (EM_S390 == w2(ehdr->e_machine))	292	if (EM_S390 == w2(ehdr->e_machine))
293	reltype = R_390_32;	293	reltype = R_390_32;
294	do32(ehdr, fname, reltype);	294	do32(ehdr, fname, reltype);
295	} break;	295	} break;
296	case ELFCLASS64: {	296	case ELFCLASS64: {
297	Elf64_Ehdr const ghdr = (Elf64_Ehdr )ehdr;	297	Elf64_Ehdr const ghdr = (Elf64_Ehdr )ehdr;
298	if (sizeof(Elf64_Ehdr) != w2(ghdr->e_ehsize)	298	if (sizeof(Elf64_Ehdr) != w2(ghdr->e_ehsize)
299	\|\| sizeof(Elf64_Shdr) != w2(ghdr->e_shentsize)) {	299	\|\| sizeof(Elf64_Shdr) != w2(ghdr->e_shentsize)) {
300	fprintf(stderr,	300	fprintf(stderr,
301	"unrecognized ET_REL file: %s\n", fname);	301	"unrecognized ET_REL file: %s\n", fname);
302	fail_file();	302	fail_file();
303	}	303	}
304	if (EM_S390 == w2(ghdr->e_machine))	304	if (EM_S390 == w2(ghdr->e_machine))
305	reltype = R_390_64;	305	reltype = R_390_64;
306	do64(ghdr, fname, reltype);	306	do64(ghdr, fname, reltype);
307	} break;	307	} break;
308	} /* end switch */	308	} /* end switch */
309		309
310	cleanup();	310	cleanup();
311	}	311	}
312		312
313	int	313	int
314	main(int argc, char const *argv[])	314	main(int argc, char const *argv[])
315	{	315	{
		316	const char ftrace[] = "kernel/trace/ftrace.o";
		317	int ftrace_size = sizeof(ftrace) - 1;
316	int n_error = 0; /* gcc-4.3.0 false positive complaint */	318	int n_error = 0; /* gcc-4.3.0 false positive complaint */
317	if (argc <= 1)	319
		320	if (argc <= 1) {
318	fprintf(stderr, "usage: recordmcount file.o...\n");	321	fprintf(stderr, "usage: recordmcount file.o...\n");
319	else /* Process each file in turn, allowing deep failure. */	322	return 0;
		323	}
		324
		325	/* Process each file in turn, allowing deep failure. */
320	for (--argc, ++argv; 0 < argc; --argc, ++argv) {	326	for (--argc, ++argv; 0 < argc; --argc, ++argv) {
321	int const sjval = setjmp(jmpenv);	327	int const sjval = setjmp(jmpenv);
		328	int len;
		329
		330	/*
		331	* The file kernel/trace/ftrace.o references the mcount
		332	* function but does not call it. Since ftrace.o should
		333	* not be traced anyway, we just skip it.
		334	*/
		335	len = strlen(argv[0]);
		336	if (len >= ftrace_size &&
		337	strcmp(argv[0] + (len - ftrace_size), ftrace) == 0)
		338	continue;
		339
322	switch (sjval) {	340	switch (sjval) {
323	default: {	341	default: {
324	fprintf(stderr, "internal error: %s\n", argv[0]);	342	fprintf(stderr, "internal error: %s\n", argv[0]);
325	exit(1);	343	exit(1);
326	} break;	344	} break;
327	case SJ_SETJMP: { /* normal sequence */	345	case SJ_SETJMP: { /* normal sequence */
328	/* Avoid problems if early cleanup() */	346	/* Avoid problems if early cleanup() */
329	fd_map = -1;	347	fd_map = -1;
330	ehdr_curr = NULL;	348	ehdr_curr = NULL;
331	mmap_failed = 1;	349	mmap_failed = 1;
332	do_file(argv[0]);	350	do_file(argv[0]);
333	} break;	351	} break;
334	case SJ_FAIL: { /* error in do_file or below */	352	case SJ_FAIL: { /* error in do_file or below */
335	++n_error;	353	++n_error;
336	} break;	354	} break;
337	case SJ_SUCCEED: { /* premature success */	355	case SJ_SUCCEED: { /* premature success */
338	/* do nothing */	356	/* do nothing */
339	} break;	357	} break;
340	} /* end switch */	358	} /* end switch */
341	}	359	}
342	return !!n_error;	360	return !!n_error;
343	}	361	}
344		362
345		363
346		364