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 types |= SOURCE_S; 75 break; 76 default: 77 types |= SOURCE_UNKNOWN; 78 } 79 } 80 81 symit_free(si); 82 return (types); 83 } 84 85 static int 86 read_file(Elf *elf, char *file, char *label, read_cb_f *func, void *arg, 87 int require_ctf) 88 { 89 Elf_Scn *ctfscn; 90 Elf_Data *ctfdata; 91 symit_data_t *si = NULL; 92 int ctfscnidx; 93 tdata_t *td; 94 95 if ((ctfscnidx = findelfsecidx(elf, file, ".SUNW_ctf")) < 0) { 96 if (require_ctf && 97 (built_source_types(elf, file) & SOURCE_C)) { 98 terminate("Input file %s was partially built from " 99 "C sources, but no CTF data was present\n", file); 100 } 101 return (0); 102 } 103 104 if ((ctfscn = elf_getscn(elf, ctfscnidx)) == NULL || 105 (ctfdata = elf_getdata(ctfscn, NULL)) == NULL) 106 elfterminate(file, "Cannot read CTF section"); 107 108 /* Reconstruction of type tree */ 109 if ((si = symit_new(elf, file)) == NULL) { 110 warning("%s has no symbol table - skipping", file); 111 return (0); 112 } 113 114 td = ctf_load(file, ctfdata->d_buf, ctfdata->d_size, si, label); 115 tdata_build_hashes(td); 116 117 symit_free(si); 118 119 if (td != NULL) { 120 if (func(td, file, arg) < 0) 121 return (-1); 122 else 123 return (1); 124 } 125 return (0); 126 } 127 128 static int 129 read_archive(int fd, Elf *elf, char *file, char *label, read_cb_f *func, 130 void *arg, int require_ctf) 131 { 132 Elf *melf; 133 Elf_Cmd cmd = ELF_C_READ; 134 Elf_Arhdr *arh; 135 int secnum = 1, found = 0; 136 137 while ((melf = elf_begin(fd, cmd, elf)) != NULL) { 138 int rc = 0; 139 140 if ((arh = elf_getarhdr(melf)) == NULL) { 141 elfterminate(file, "Can't get archive header for " 142 "member %d", secnum); 143 } 144 145 /* skip special sections - their names begin with "/" */ 146 if (*arh->ar_name != '/') { 147 size_t memlen = strlen(file) + 1 + 148 strlen(arh->ar_name) + 1 + 1; 149 char *memname = xmalloc(memlen); 150 151 snprintf(memname, memlen, "%s(%s)", file, arh->ar_name); 152 153 switch (elf_kind(melf)) { 154 case ELF_K_AR: 155 rc = read_archive(fd, melf, memname, label, 156 func, arg, require_ctf); 157 break; 158 case ELF_K_ELF: 159 rc = read_file(melf, memname, label, 160 func, arg, require_ctf); 161 break; 162 default: 163 terminate("%s: Unknown elf kind %d\n", 164 memname, elf_kind(melf)); 165 } 166 167 free(memname); 168 } 169 170 cmd = elf_next(melf); 171 (void) elf_end(melf); 172 secnum++; 173 174 if (rc < 0) 175 return (rc); 176 else 177 found += rc; 178 } 179 180 return (found); 181 } 182 183 static int 184 read_ctf_common(char *file, char *label, read_cb_f *func, void *arg, 185 int require_ctf) 186 { 187 Elf *elf; 188 int found = 0; 189 int fd; 190 191 debug(3, "Reading %s (label %s)\n", file, (label ? label : "NONE")); 192 193 (void) elf_version(EV_CURRENT); 194 195 if ((fd = open(file, O_RDONLY)) < 0) 196 terminate("%s: Cannot open for reading", file); 197 if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) 198 elfterminate(file, "Cannot read"); 199 200 switch (elf_kind(elf)) { 201 case ELF_K_AR: 202 found = read_archive(fd, elf, file, label, 203 func, arg, require_ctf); 204 break; 205 206 case ELF_K_ELF: 207 found = read_file(elf, file, label, 208 func, arg, require_ctf); 209 break; 210 211 default: 212 terminate("%s: Unknown elf kind %d\n", file, elf_kind(elf)); 213 } 214 215 (void) elf_end(elf); 216 (void) close(fd); 217 218 return (found); 219 } 220 221 /*ARGSUSED*/ 222 int 223 read_ctf_save_cb(tdata_t *td, char *name, void *retp) 224 { 225 tdata_t **tdp = retp; 226 227 *tdp = td; 228 229 return (1); 230 } 231 232 int 233 read_ctf(char **files, int n, char *label, read_cb_f *func, void *private, 234 int require_ctf) 235 { 236 int found; 237 int i, rc; 238 239 for (i = 0, found = 0; i < n; i++) { 240 if ((rc = read_ctf_common(files[i], label, func, 241 private, require_ctf)) < 0) 242 return (rc); 243 found += rc; 244 } 245 246 return (found); 247 } 248 249 static int 250 count_archive(int fd, Elf *elf, char *file) 251 { 252 Elf *melf; 253 Elf_Cmd cmd = ELF_C_READ; 254 Elf_Arhdr *arh; 255 int nfiles = 0, err = 0; 256 257 while ((melf = elf_begin(fd, cmd, elf)) != NULL) { 258 if ((arh = elf_getarhdr(melf)) == NULL) { 259 warning("Can't process input archive %s\n", 260 file); 261 err++; 262 } 263 264 if (*arh->ar_name != '/') 265 nfiles++; 266 267 cmd = elf_next(melf); 268 (void) elf_end(melf); 269 } 270 271 if (err > 0) 272 return (-1); 273 274 return (nfiles); 275 } 276 277 int 278 count_files(char **files, int n) 279 { 280 int nfiles = 0, err = 0; 281 Elf *elf; 282 int fd, rc, i; 283 284 (void) elf_version(EV_CURRENT); 285 286 for (i = 0; i < n; i++) { 287 char *file = files[i]; 288 289 if ((fd = open(file, O_RDONLY)) < 0) { 290 warning("Can't read input file %s", file); 291 err++; 292 continue; 293 } 294 295 if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 296 warning("Can't open input file %s: %s\n", file, 297 elf_errmsg(-1)); 298 err++; 299 (void) close(fd); 300 continue; 301 } 302 303 switch (elf_kind(elf)) { 304 case ELF_K_AR: 305 if ((rc = count_archive(fd, elf, file)) < 0) 306 err++; 307 else 308 nfiles += rc; 309 break; 310 case ELF_K_ELF: 311 nfiles++; 312 break; 313 default: 314 warning("Input file %s is corrupt\n", file); 315 err++; 316 } 317 318 (void) elf_end(elf); 319 (void) close(fd); 320 } 321 322 if (err > 0) 323 return (-1); 324 325 debug(2, "Found %d files in %d input files\n", nfiles, n); 326 327 return (nfiles); 328 } 329 330 struct symit_data { 331 GElf_Shdr si_shdr; 332 Elf_Data *si_symd; 333 Elf_Data *si_strd; 334 GElf_Sym si_cursym; 335 char *si_curname; 336 char *si_curfile; 337 int si_nument; 338 int si_next; 339 }; 340 341 symit_data_t * 342 symit_new(Elf *elf, const char *file) 343 { 344 symit_data_t *si; 345 Elf_Scn *scn; 346 int symtabidx; 347 348 if ((symtabidx = findelfsecidx(elf, file, ".symtab")) < 0) 349 return (NULL); 350 351 si = xcalloc(sizeof (symit_data_t)); 352 353 if ((scn = elf_getscn(elf, symtabidx)) == NULL || 354 gelf_getshdr(scn, &si->si_shdr) == NULL || 355 (si->si_symd = elf_getdata(scn, NULL)) == NULL) 356 elfterminate(file, "Cannot read .symtab"); 357 358 if ((scn = elf_getscn(elf, si->si_shdr.sh_link)) == NULL || 359 (si->si_strd = elf_getdata(scn, NULL)) == NULL) 360 elfterminate(file, "Cannot read strings for .symtab"); 361 362 si->si_nument = si->si_shdr.sh_size / si->si_shdr.sh_entsize; 363 364 return (si); 365 } 366 367 void 368 symit_free(symit_data_t *si) 369 { 370 free(si); 371 } 372 373 void 374 symit_reset(symit_data_t *si) 375 { 376 si->si_next = 0; 377 } 378 379 char * 380 symit_curfile(symit_data_t *si) 381 { 382 return (si->si_curfile); 383 } 384 385 GElf_Sym * 386 symit_next(symit_data_t *si, int type) 387 { 388 GElf_Sym sym; 389 int check_sym = (type == STT_OBJECT || type == STT_FUNC); 390 391 for (; si->si_next < si->si_nument; si->si_next++) { 392 gelf_getsym(si->si_symd, si->si_next, &si->si_cursym); 393 gelf_getsym(si->si_symd, si->si_next, &sym); 394 si->si_curname = (caddr_t)si->si_strd->d_buf + sym.st_name; 395 396 if (GELF_ST_TYPE(sym.st_info) == STT_FILE) 397 si->si_curfile = si->si_curname; 398 399 if (GELF_ST_TYPE(sym.st_info) != type || 400 sym.st_shndx == SHN_UNDEF) 401 continue; 402 403 if (check_sym && ignore_symbol(&sym, si->si_curname)) 404 continue; 405 406 si->si_next++; 407 408 return (&si->si_cursym); 409 } 410 411 return (NULL); 412 } 413 414 char * 415 symit_name(symit_data_t *si) 416 { 417 return (si->si_curname); 418 } 419