1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 /*
29  * Routines for retrieving CTF data from a .SUNW_ctf ELF section
30  */
31 
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <gelf.h>
37 #include <strings.h>
38 #include <sys/types.h>
39 
40 #include "ctftools.h"
41 #include "memory.h"
42 #include "symbol.h"
43 
44 typedef int read_cb_f(tdata_t *, char *, void *);
45 
46 /*
47  * Return the source types that the object was generated from.
48  */
49 source_types_t
50 built_source_types(Elf *elf, char const *file)
51 {
52 	source_types_t types = SOURCE_NONE;
53 	symit_data_t *si;
54 
55 	if ((si = symit_new(elf, file)) == NULL)
56 		return (SOURCE_NONE);
57 
58 	while (symit_next(si, STT_FILE) != NULL) {
59 		char *name = symit_name(si);
60 		size_t len = strlen(name);
61 		if (len < 2 || name[len - 2] != '.') {
62 			types |= SOURCE_UNKNOWN;
63 			continue;
64 		}
65 
66 		switch (name[len - 1]) {
67 		case 'c':
68 			types |= SOURCE_C;
69 			break;
70 		case 'h':
71 			/* ignore */
72 			break;
73 		case 's':
74 		case 'S':
75 			types |= SOURCE_S;
76 			break;
77 		default:
78 			types |= SOURCE_UNKNOWN;
79 		}
80 	}
81 
82 	symit_free(si);
83 	return (types);
84 }
85 
86 static int
87 read_file(Elf *elf, char *file, char *label, read_cb_f *func, void *arg,
88     int require_ctf)
89 {
90 	Elf_Scn *ctfscn;
91 	Elf_Data *ctfdata = NULL;
92 	symit_data_t *si = NULL;
93 	int ctfscnidx;
94 	tdata_t *td;
95 
96 	if ((ctfscnidx = findelfsecidx(elf, file, ".SUNW_ctf")) < 0) {
97 		if (require_ctf &&
98 		    (built_source_types(elf, file) & SOURCE_C)) {
99 			terminate("Input file %s was partially built from "
100 			    "C sources, but no CTF data was present\n", file);
101 		}
102 		return (0);
103 	}
104 
105 	if ((ctfscn = elf_getscn(elf, ctfscnidx)) == NULL ||
106 	    (ctfdata = elf_getdata(ctfscn, NULL)) == NULL)
107 		elfterminate(file, "Cannot read CTF section");
108 
109 	/* Reconstruction of type tree */
110 	if ((si = symit_new(elf, file)) == NULL) {
111 		warning("%s has no symbol table - skipping", file);
112 		return (0);
113 	}
114 
115 	td = ctf_load(file, ctfdata->d_buf, ctfdata->d_size, si, label);
116 	tdata_build_hashes(td);
117 
118 	symit_free(si);
119 
120 	if (td != NULL) {
121 		if (func(td, file, arg) < 0)
122 			return (-1);
123 		else
124 			return (1);
125 	}
126 	return (0);
127 }
128 
129 static int
130 read_archive(int fd, Elf *elf, char *file, char *label, read_cb_f *func,
131     void *arg, int require_ctf)
132 {
133 	Elf *melf;
134 	Elf_Cmd cmd = ELF_C_READ;
135 	Elf_Arhdr *arh;
136 	int secnum = 1, found = 0;
137 
138 	while ((melf = elf_begin(fd, cmd, elf)) != NULL) {
139 		int rc = 0;
140 
141 		if ((arh = elf_getarhdr(melf)) == NULL) {
142 			elfterminate(file, "Can't get archive header for "
143 			    "member %d", secnum);
144 		}
145 
146 		/* skip special sections - their names begin with "/" */
147 		if (*arh->ar_name != '/') {
148 			size_t memlen = strlen(file) + 1 +
149 			    strlen(arh->ar_name) + 1 + 1;
150 			char *memname = xmalloc(memlen);
151 
152 			snprintf(memname, memlen, "%s(%s)", file, arh->ar_name);
153 
154 			switch (elf_kind(melf)) {
155 			case ELF_K_AR:
156 				rc = read_archive(fd, melf, memname, label,
157 				    func, arg, require_ctf);
158 				break;
159 			case ELF_K_ELF:
160 				rc = read_file(melf, memname, label,
161 				    func, arg, require_ctf);
162 				break;
163 			default:
164 				terminate("%s: Unknown elf kind %d\n",
165 				    memname, elf_kind(melf));
166 			}
167 
168 			free(memname);
169 		}
170 
171 		cmd = elf_next(melf);
172 		(void) elf_end(melf);
173 		secnum++;
174 
175 		if (rc < 0)
176 			return (rc);
177 		else
178 			found += rc;
179 	}
180 
181 	return (found);
182 }
183 
184 static int
185 read_ctf_common(char *file, char *label, read_cb_f *func, void *arg,
186     int require_ctf)
187 {
188 	Elf *elf;
189 	int found = 0;
190 	int fd;
191 
192 	debug(3, "Reading %s (label %s)\n", file, (label ? label : "NONE"));
193 
194 	(void) elf_version(EV_CURRENT);
195 
196 	if ((fd = open(file, O_RDONLY)) < 0)
197 		terminate("%s: Cannot open for reading", file);
198 	if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL)
199 		elfterminate(file, "Cannot read");
200 
201 	switch (elf_kind(elf)) {
202 	case ELF_K_AR:
203 		found = read_archive(fd, elf, file, label,
204 		    func, arg, require_ctf);
205 		break;
206 
207 	case ELF_K_ELF:
208 		found = read_file(elf, file, label,
209 		    func, arg, require_ctf);
210 		break;
211 
212 	default:
213 		terminate("%s: Unknown elf kind %d\n", file, elf_kind(elf));
214 	}
215 
216 	(void) elf_end(elf);
217 	(void) close(fd);
218 
219 	return (found);
220 }
221 
222 /*ARGSUSED*/
223 int
224 read_ctf_save_cb(tdata_t *td, char *name __unused, void *retp)
225 {
226 	tdata_t **tdp = retp;
227 
228 	*tdp = td;
229 
230 	return (1);
231 }
232 
233 int
234 read_ctf(char **files, int n, char *label, read_cb_f *func, void *private,
235     int require_ctf)
236 {
237 	int found;
238 	int i, rc;
239 
240 	for (i = 0, found = 0; i < n; i++) {
241 		if ((rc = read_ctf_common(files[i], label, func,
242 		    private, require_ctf)) < 0)
243 			return (rc);
244 		found += rc;
245 	}
246 
247 	return (found);
248 }
249 
250 static int
251 count_archive(int fd, Elf *elf, char *file)
252 {
253 	Elf *melf;
254 	Elf_Cmd cmd = ELF_C_READ;
255 	Elf_Arhdr *arh;
256 	int nfiles = 0, err = 0;
257 
258 	while ((melf = elf_begin(fd, cmd, elf)) != NULL) {
259 		if ((arh = elf_getarhdr(melf)) == NULL) {
260 			warning("Can't process input archive %s\n",
261 			    file);
262 			err++;
263 		}
264 
265 		if (*arh->ar_name != '/')
266 			nfiles++;
267 
268 		cmd = elf_next(melf);
269 		(void) elf_end(melf);
270 	}
271 
272 	if (err > 0)
273 		return (-1);
274 
275 	return (nfiles);
276 }
277 
278 int
279 count_files(char **files, int n)
280 {
281 	int nfiles = 0, err = 0;
282 	Elf *elf;
283 	int fd, rc, i;
284 
285 	(void) elf_version(EV_CURRENT);
286 
287 	for (i = 0; i < n; i++) {
288 		char *file = files[i];
289 
290 		if ((fd = open(file, O_RDONLY)) < 0) {
291 			warning("Can't read input file %s", file);
292 			err++;
293 			continue;
294 		}
295 
296 		if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
297 			warning("Can't open input file %s: %s\n", file,
298 			    elf_errmsg(-1));
299 			err++;
300 			(void) close(fd);
301 			continue;
302 		}
303 
304 		switch (elf_kind(elf)) {
305 		case ELF_K_AR:
306 			if ((rc = count_archive(fd, elf, file)) < 0)
307 				err++;
308 			else
309 				nfiles += rc;
310 			break;
311 		case ELF_K_ELF:
312 			nfiles++;
313 			break;
314 		default:
315 			warning("Input file %s is corrupt\n", file);
316 			err++;
317 		}
318 
319 		(void) elf_end(elf);
320 		(void) close(fd);
321 	}
322 
323 	if (err > 0)
324 		return (-1);
325 
326 	debug(2, "Found %d files in %d input files\n", nfiles, n);
327 
328 	return (nfiles);
329 }
330 
331 struct symit_data {
332 	GElf_Shdr si_shdr;
333 	Elf_Data *si_symd;
334 	Elf_Data *si_strd;
335 	GElf_Sym si_cursym;
336 	char *si_curname;
337 	char *si_curfile;
338 	int si_nument;
339 	int si_next;
340 };
341 
342 symit_data_t *
343 symit_new(Elf *elf, const char *file)
344 {
345 	symit_data_t *si;
346 	Elf_Scn *scn;
347 	int symtabidx;
348 
349 	if ((symtabidx = findelfsecidx(elf, file, ".symtab")) < 0)
350 		return (NULL);
351 
352 	si = xcalloc(sizeof (symit_data_t));
353 
354 	if ((scn = elf_getscn(elf, symtabidx)) == NULL ||
355 	    gelf_getshdr(scn, &si->si_shdr) == NULL ||
356 	    (si->si_symd = elf_getdata(scn, NULL)) == NULL)
357 		elfterminate(file, "Cannot read .symtab");
358 
359 	if ((scn = elf_getscn(elf, si->si_shdr.sh_link)) == NULL ||
360 	    (si->si_strd = elf_getdata(scn, NULL)) == NULL)
361 		elfterminate(file, "Cannot read strings for .symtab");
362 
363 	si->si_nument = si->si_shdr.sh_size / si->si_shdr.sh_entsize;
364 
365 	return (si);
366 }
367 
368 void
369 symit_free(symit_data_t *si)
370 {
371 	free(si);
372 }
373 
374 void
375 symit_reset(symit_data_t *si)
376 {
377 	si->si_next = 0;
378 }
379 
380 char *
381 symit_curfile(symit_data_t *si)
382 {
383 	return (si->si_curfile);
384 }
385 
386 GElf_Sym *
387 symit_next(symit_data_t *si, int type)
388 {
389 	GElf_Sym sym;
390 	char *bname;
391 	int check_sym = (type == STT_OBJECT || type == STT_FUNC);
392 
393 	for (; si->si_next < si->si_nument; si->si_next++) {
394 		gelf_getsym(si->si_symd, si->si_next, &si->si_cursym);
395 		gelf_getsym(si->si_symd, si->si_next, &sym);
396 		si->si_curname = (caddr_t)si->si_strd->d_buf + sym.st_name;
397 
398 		if (GELF_ST_TYPE(sym.st_info) == STT_FILE) {
399 			bname = strrchr(si->si_curname, '/');
400 			si->si_curfile = bname == NULL ? si->si_curname : bname + 1;
401 		}
402 
403 		if (GELF_ST_TYPE(sym.st_info) != type ||
404 		    sym.st_shndx == SHN_UNDEF)
405 			continue;
406 
407 		if (check_sym && ignore_symbol(&sym, si->si_curname))
408 			continue;
409 
410 		si->si_next++;
411 
412 		return (&si->si_cursym);
413 	}
414 
415 	return (NULL);
416 }
417 
418 char *
419 symit_name(symit_data_t *si)
420 {
421 	return (si->si_curname);
422 }
423