1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 
12 /*
13  * Copyright 2019 Joyent, Inc.
14  * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
15  */
16 
17 /*
18  * Create CTF from extant debugging information
19  */
20 
21 #include <stdio.h>
22 #include <unistd.h>
23 #include <stdlib.h>
24 #include <stdarg.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <fcntl.h>
28 #include <errno.h>
29 #include <libelf.h>
30 #include <libctf.h>
31 #include <string.h>
32 #include <libgen.h>
33 #include <limits.h>
34 #include <strings.h>
35 #include <sys/debug.h>
36 
37 #define	CTFCONVERT_OK		0
38 #define	CTFCONVERT_FATAL	1
39 #define	CTFCONVERT_USAGE	2
40 
41 static char *ctfconvert_progname;
42 
43 static void
ctfconvert_fatal(const char * fmt,...)44 ctfconvert_fatal(const char *fmt, ...)
45 {
46 	va_list ap;
47 
48 	(void) fprintf(stderr, "%s: ", ctfconvert_progname);
49 	va_start(ap, fmt);
50 	(void) vfprintf(stderr, fmt, ap);
51 	va_end(ap);
52 
53 	exit(CTFCONVERT_FATAL);
54 }
55 
56 static void
ctfconvert_warning(void * arg,const char * fmt,...)57 ctfconvert_warning(void *arg, const char *fmt, ...)
58 {
59 	va_list ap;
60 	char *buf;
61 
62 	va_start(ap, fmt);
63 	if (vasprintf(&buf, fmt, ap) != -1) {
64 		(void) fprintf(stderr, "%s: WARNING: %s", ctfconvert_progname,
65 		    buf);
66 		free(buf);
67 	}
68 	va_end(ap);
69 }
70 
71 static void
ctfconvert_usage(const char * fmt,...)72 ctfconvert_usage(const char *fmt, ...)
73 {
74 	if (fmt != NULL) {
75 		va_list ap;
76 
77 		(void) fprintf(stderr, "%s: ", ctfconvert_progname);
78 		va_start(ap, fmt);
79 		(void) vfprintf(stderr, fmt, ap);
80 		va_end(ap);
81 	}
82 
83 	(void) fprintf(stderr, "Usage: %s [-fikms] [-j nthrs] [-l label | "
84 	    "-L labelenv] [-b batchsize]\n"
85 	    "                  [-o outfile] [-M ignorefile] input\n"
86 	    "\n"
87 	    "\t-b  batch process this many dies at a time (default %d)\n"
88 	    "\t-f  always attempt to convert files\n"
89 	    "\t-i  ignore files not built partially from C sources\n"
90 	    "\t-j  use nthrs threads to perform the merge (default %d)\n"
91 	    "\t-k  keep around original input file on failure\n"
92 	    "\t-l  set output container's label to specified value\n"
93 	    "\t-L  set output container's label to value from environment\n"
94 	    "\t-m  allow input to have missing debug info\n"
95 	    "\t-M  allow files listed in ignorefile to have missing debug\n"
96 	    "\t-o  copy input to outfile and add CTF\n"
97 	    "\t-s  allow truncation of data that cannot be fully converted\n",
98 	    ctfconvert_progname,
99 	    CTF_CONVERT_DEFAULT_BATCHSIZE,
100 	    CTF_CONVERT_DEFAULT_NTHREADS);
101 }
102 
103 /*
104  * This is a bit unfortunate. Traditionally we do type uniquification across all
105  * modules in the kernel, including ip and unix against genunix. However, when
106  * _MACHDEP is defined, then the cpu_t ends up having an additional member
107  * (cpu_m), thus changing the ability for us to uniquify against it. This in
108  * turn causes a lot of type sprawl, as there's a lot of things that end up
109  * referring to the cpu_t and it chains out from there.
110  *
111  * So, if we find that a cpu_t has been defined and it has a couple of useful
112  * sentinel members and it does *not* have the cpu_m member, then we will try
113  * and lookup or create a forward declaration to the machcpu, append it to the
114  * end, and update the file.
115  *
116  * This currently is only invoked if an undocumented option -X is passed. This
117  * value is private to illumos and it can be changed at any time inside of it,
118  * so if -X wants to be used for something, it should be. The ability to rely on
119  * -X for others is strictly not an interface in any way, shape, or form.
120  *
121  * The following struct contains most of the information that we care about and
122  * that we want to validate exists before we decide what to do.
123  */
124 
125 typedef struct ctfconvert_fixup {
126 	boolean_t	cf_cyclic;	/* Do we have a cpu_cyclic member */
127 	boolean_t	cf_mcpu;	/* We have a cpu_m member */
128 	boolean_t	cf_lastpad;	/* Is the pad member the last entry */
129 	ulong_t		cf_padoff;	/* offset of the pad */
130 } ctfconvert_fixup_t;
131 
132 /* ARGSUSED */
133 static int
ctfconvert_fixup_genunix_cb(const char * name,ctf_id_t tid,ulong_t off,void * arg)134 ctfconvert_fixup_genunix_cb(const char *name, ctf_id_t tid, ulong_t off,
135     void *arg)
136 {
137 	ctfconvert_fixup_t *cfp = arg;
138 
139 	cfp->cf_lastpad = B_FALSE;
140 	if (strcmp(name, "cpu_cyclic") == 0) {
141 		cfp->cf_cyclic = B_TRUE;
142 		return (0);
143 	}
144 
145 	if (strcmp(name, "cpu_m") == 0) {
146 		cfp->cf_mcpu = B_TRUE;
147 		return (0);
148 	}
149 
150 	if (strcmp(name, "cpu_m_pad") == 0) {
151 		cfp->cf_lastpad = B_TRUE;
152 		cfp->cf_padoff = off;
153 		return (0);
154 	}
155 
156 	return (0);
157 }
158 
159 static void
ctfconvert_fixup_genunix(ctf_file_t * fp)160 ctfconvert_fixup_genunix(ctf_file_t *fp)
161 {
162 	ctf_id_t cpuid, mcpu;
163 	ssize_t sz;
164 	ctfconvert_fixup_t cf;
165 	int model, ptrsz;
166 
167 	cpuid = ctf_lookup_by_name(fp, "struct cpu");
168 	if (cpuid == CTF_ERR)
169 		return;
170 
171 	if (ctf_type_kind(fp, cpuid) != CTF_K_STRUCT)
172 		return;
173 
174 	if ((sz = ctf_type_size(fp, cpuid)) == CTF_ERR)
175 		return;
176 
177 	model = ctf_getmodel(fp);
178 	VERIFY(model == CTF_MODEL_ILP32 || model == CTF_MODEL_LP64);
179 	ptrsz = model == CTF_MODEL_ILP32 ? 4 : 8;
180 
181 	bzero(&cf, sizeof (ctfconvert_fixup_t));
182 	if (ctf_member_iter(fp, cpuid, ctfconvert_fixup_genunix_cb, &cf) ==
183 	    CTF_ERR)
184 		return;
185 
186 	/*
187 	 * Finally, we want to verify that the cpu_m is actually the last member
188 	 * that we have here.
189 	 */
190 	if (cf.cf_cyclic == B_FALSE || cf.cf_mcpu == B_TRUE ||
191 	    cf.cf_lastpad == B_FALSE) {
192 		return;
193 	}
194 
195 	if (cf.cf_padoff + ptrsz * NBBY != sz * NBBY) {
196 		return;
197 	}
198 
199 	/*
200 	 * Okay, we're going to do this, try to find a struct machcpu. We either
201 	 * want a forward or a struct. If we find something else, error. If we
202 	 * find nothing, add a forward and then add the member.
203 	 */
204 	mcpu = ctf_lookup_by_name(fp, "struct machcpu");
205 	if (mcpu == CTF_ERR) {
206 		mcpu = ctf_add_forward(fp, CTF_ADD_NONROOT, "machcpu",
207 		    CTF_K_STRUCT);
208 		if (mcpu == CTF_ERR) {
209 			ctfconvert_fatal("failed to add 'struct machcpu' "
210 			    "forward: %s\n", ctf_errmsg(ctf_errno(fp)));
211 		}
212 	} else {
213 		int kind;
214 		if ((kind = ctf_type_kind(fp, mcpu)) == CTF_ERR) {
215 			ctfconvert_fatal("failed to get the type kind for "
216 			    "the struct machcpu: %s\n",
217 			    ctf_errmsg(ctf_errno(fp)));
218 		}
219 
220 		if (kind != CTF_K_STRUCT && kind != CTF_K_FORWARD)
221 			ctfconvert_fatal("encountered a struct machcpu of the "
222 			    "wrong type, found type kind %d\n", kind);
223 	}
224 
225 	if (ctf_update(fp) == CTF_ERR) {
226 		ctfconvert_fatal("failed to update output file: %s\n",
227 		    ctf_errmsg(ctf_errno(fp)));
228 	}
229 
230 	if (ctf_add_member(fp, cpuid, "cpu_m", mcpu, sz * NBBY) == CTF_ERR) {
231 		ctfconvert_fatal("failed to add the m_cpu member: %s\n",
232 		    ctf_errmsg(ctf_errno(fp)));
233 	}
234 
235 	if (ctf_update(fp) == CTF_ERR) {
236 		ctfconvert_fatal("failed to update output file: %s\n",
237 		    ctf_errmsg(ctf_errno(fp)));
238 	}
239 
240 	VERIFY(ctf_type_size(fp, cpuid) == sz);
241 }
242 
243 int
main(int argc,char * argv[])244 main(int argc, char *argv[])
245 {
246 	int c, ifd, err;
247 	boolean_t keep = B_FALSE;
248 	ctf_convert_flag_t flags = 0;
249 	uint_t bsize = CTF_CONVERT_DEFAULT_BATCHSIZE;
250 	uint_t nthreads = CTF_CONVERT_DEFAULT_NTHREADS;
251 	const char *outfile = NULL;
252 	const char *label = NULL;
253 	const char *infile = NULL;
254 	const char *ignorefile = NULL;
255 	char *tmpfile;
256 	ctf_file_t *ofp;
257 	char buf[4096] = "";
258 	boolean_t optx = B_FALSE;
259 	boolean_t ignore_non_c = B_FALSE;
260 	ctf_convert_t *cch;
261 
262 	ctfconvert_progname = basename(argv[0]);
263 
264 	while ((c = getopt(argc, argv, ":b:fij:kl:L:mM:o:sX")) != -1) {
265 		switch (c) {
266 		case 'b': {
267 			long argno;
268 			const char *errstr;
269 
270 			argno = strtonum(optarg, 1, UINT_MAX, &errstr);
271 			if (errstr != NULL) {
272 				ctfconvert_fatal("invalid argument for -b: "
273 				    "%s - %s\n", optarg, errstr);
274 			}
275 			bsize = (uint_t)argno;
276 			break;
277 		}
278 		case 'f':
279 			flags |= CTF_FORCE_CONVERSION;
280 			break;
281 		case 'i':
282 			ignore_non_c = B_TRUE;
283 			break;
284 		case 'j': {
285 			long argno;
286 			const char *errstr;
287 
288 			argno = strtonum(optarg, 1, 1024, &errstr);
289 			if (errstr != NULL) {
290 				ctfconvert_fatal("invalid argument for -j: "
291 				    "%s - %s\n", optarg, errstr);
292 			}
293 			nthreads = (uint_t)argno;
294 			break;
295 		}
296 		case 'k':
297 			keep = B_TRUE;
298 			break;
299 		case 'l':
300 			label = optarg;
301 			break;
302 		case 'L':
303 			label = getenv(optarg);
304 			break;
305 		case 'm':
306 			flags |= CTF_ALLOW_MISSING_DEBUG;
307 			break;
308 		case 'M':
309 			ignorefile = optarg;
310 			break;
311 		case 'o':
312 			outfile = optarg;
313 			break;
314 		case 's':
315 			flags |= CTF_ALLOW_TRUNCATION;
316 			break;
317 		case 'X':
318 			optx = B_TRUE;
319 			break;
320 		case ':':
321 			ctfconvert_usage("Option -%c requires an operand\n",
322 			    optopt);
323 			return (CTFCONVERT_USAGE);
324 		case '?':
325 			ctfconvert_usage("Unknown option: -%c\n", optopt);
326 			return (CTFCONVERT_USAGE);
327 		}
328 	}
329 
330 	argv += optind;
331 	argc -= optind;
332 
333 	if (argc != 1) {
334 		ctfconvert_usage("Exactly one input file is required\n");
335 		return (CTFCONVERT_USAGE);
336 	}
337 	infile = argv[0];
338 
339 	if (elf_version(EV_CURRENT) == EV_NONE)
340 		ctfconvert_fatal("failed to initialize libelf: library is "
341 		    "out of date\n");
342 
343 	ifd = open(infile, O_RDONLY);
344 	if (ifd < 0) {
345 		ctfconvert_fatal("failed to open input file %s: %s\n", infile,
346 		    strerror(errno));
347 	}
348 
349 	/*
350 	 * By default we remove the input file on failure unless we've been
351 	 * given an output file or -k has been specified.
352 	 */
353 	if (outfile != NULL && strcmp(infile, outfile) != 0)
354 		keep = B_TRUE;
355 
356 	cch = ctf_convert_init(&err);
357 	if (cch == NULL) {
358 		ctfconvert_fatal(
359 		    "failed to create libctf conversion handle: %s\n",
360 		    strerror(err));
361 	}
362 	if ((err = ctf_convert_set_nthreads(cch, nthreads)) != 0)
363 		ctfconvert_fatal("Could not set number of threads: %s\n",
364 		    strerror(err));
365 	if ((err = ctf_convert_set_batchsize(cch, bsize)) != 0)
366 		ctfconvert_fatal("Could not set batch size: %s\n",
367 		    strerror(err));
368 	if ((err = ctf_convert_set_flags(cch, flags)) != 0)
369 		ctfconvert_fatal("Could not set conversion flags: %s\n",
370 		    strerror(err));
371 	if (label != NULL && (err = ctf_convert_set_label(cch, label)) != 0)
372 		ctfconvert_fatal("Could not set label: %s\n",
373 		    strerror(err));
374 	if ((err = ctf_convert_set_warncb(cch, ctfconvert_warning, NULL)) != 0)
375 		ctfconvert_fatal("Could not set warning callback: %s\n",
376 		    strerror(err));
377 
378 	if (ignorefile != NULL) {
379 		char *buf = NULL;
380 		ssize_t cnt;
381 		size_t len = 0;
382 		FILE *fp;
383 
384 		if ((fp = fopen(ignorefile, "r")) == NULL) {
385 			ctfconvert_fatal("Could not open ignorefile '%s': %s\n",
386 			    ignorefile, strerror(errno));
387 		}
388 
389 		while ((cnt = getline(&buf, &len, fp)) != -1) {
390 			char *p = buf;
391 
392 			if (cnt == 0 || *p == '#')
393 				continue;
394 
395 			(void) strsep(&p, "\n");
396 			if ((err = ctf_convert_add_ignore(cch, buf)) != 0) {
397 				ctfconvert_fatal(
398 				    "Failed to add '%s' to ignore list: %s\n",
399 				    buf, strerror(err));
400 			}
401 		}
402 		free(buf);
403 		if (cnt == -1 && ferror(fp) != 0) {
404 			ctfconvert_fatal(
405 			    "Error reading from ignorefile '%s': %s\n",
406 			    ignorefile, strerror(errno));
407 		}
408 
409 		(void) fclose(fp);
410 	}
411 
412 	ofp = ctf_fdconvert(cch, ifd, &err, buf, sizeof (buf));
413 
414 	ctf_convert_fini(cch);
415 
416 	if (ofp == NULL) {
417 		/*
418 		 * Normally, ctfconvert requires that its input file has at
419 		 * least one C-source compilation unit, and that every C-source
420 		 * compilation unit has DWARF. This is to avoid accidentally
421 		 * leaving out useful CTF.
422 		 *
423 		 * However, for the benefit of intransigent build environments,
424 		 * the -i and -m options can be used to relax this.
425 		 */
426 		if (err == ECTF_CONVNOCSRC && ignore_non_c) {
427 			exit(CTFCONVERT_OK);
428 		}
429 
430 		if (err == ECTF_CONVNODEBUG &&
431 		    (flags & CTF_ALLOW_MISSING_DEBUG) != 0) {
432 			exit(CTFCONVERT_OK);
433 		}
434 
435 		if (keep == B_FALSE)
436 			(void) unlink(infile);
437 
438 		switch (err) {
439 		case ECTF_CONVBKERR:
440 			ctfconvert_fatal("CTF conversion failed: %s", buf);
441 			break;
442 		case ECTF_CONVNODEBUG:
443 			ctfconvert_fatal("CTF conversion failed due to "
444 			    "missing debug data; use -m to override\n");
445 			break;
446 		default:
447 			if (*buf != '\0') {
448 				(void) fprintf(stderr, "%s: %s",
449 				    ctfconvert_progname, buf);
450 			}
451 			ctfconvert_fatal("CTF conversion failed: %s\n",
452 			    ctf_errmsg(err));
453 		}
454 	}
455 
456 	if (optx == B_TRUE)
457 		ctfconvert_fixup_genunix(ofp);
458 
459 	tmpfile = NULL;
460 	if (outfile == NULL || strcmp(infile, outfile) == 0) {
461 		if (asprintf(&tmpfile, "%s.ctf", infile) == -1) {
462 			if (keep == B_FALSE)
463 				(void) unlink(infile);
464 			ctfconvert_fatal("failed to allocate memory for "
465 			    "temporary file: %s\n", strerror(errno));
466 		}
467 		outfile = tmpfile;
468 	}
469 	err = ctf_elfwrite(ofp, infile, outfile, CTF_ELFWRITE_F_COMPRESS);
470 	if (err == CTF_ERR) {
471 		(void) unlink(outfile);
472 		if (keep == B_FALSE)
473 			(void) unlink(infile);
474 		ctfconvert_fatal("failed to write CTF section to output file: "
475 		    "%s\n", ctf_errmsg(ctf_errno(ofp)));
476 	}
477 	ctf_close(ofp);
478 
479 	if (tmpfile != NULL) {
480 		if (rename(tmpfile, infile) != 0) {
481 			int e = errno;
482 			(void) unlink(outfile);
483 			if (keep == B_FALSE)
484 				(void) unlink(infile);
485 			ctfconvert_fatal("failed to rename temporary file: "
486 			    "%s\n", strerror(e));
487 		}
488 	}
489 	free(tmpfile);
490 
491 	return (CTFCONVERT_OK);
492 }
493