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 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1988 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 
31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 
33 #include <stdio.h>
34 #include <fcntl.h>
35 #include <string.h>
36 #include "symint.h"
37 #include "debug.h"
38 
39 /*
40  * symintFcns.c -- symbol information interface routines.
41  *
42  * these routines form a symbol information access
43  * interface, for the profilers to get at object file
44  * information.  this interface was designed to aid
45  * in the COFF to ELF conversion of prof, lprof and friends.
46  *
47  */
48 
49 
50 /*
51  * _symintOpen(aout_name)
52  * aout_name 	- char string file name of object file
53  *		to open.
54  *
55  * returns PROF_FILE * - pointer to the PROF_FILE structure built,
56  *			or NULL if fails.
57  */
58 
59 /*
60  *
61  * .H 3 "Executable File Open and Close"
62  *
63  * Under COFF, the routine ldopen, given a file name, returns a pointer to a
64  * structure called an LDFILE.  This descriptor is then passed to each of
65  * the library routines (such as read header, read symbol table entry, etc)
66  * to access the information contained in the file.  These calls are spread
67  * throughout the profiling code.
68  *
69  * Under ELF, the file must be opened using a system open call.  The file
70  * descriptor is then passed to a routine which returns a pointer to an
71  * Elf structure.  This pointer is then passed along to another routine which
72  * returns a different pointer which is in turn passed along to another
73  * routine.  In an attempt to avoid disturbing the current format of the
74  * code (by having to pass around different types of pointers), we plan to
75  * build a PROF_FILE descriptor which will then be passed around in the
76  * same way as the pointer to LDFILE.
77  *
78  * Thus, for ELF, an open will consist of opening the file and extracting
79  * enough from it to fill in the PROF_FILE structure.  The code for the
80  * open is as follows; the code for building the symbol table (extracting
81  * information from the sections to fill an array of PROF_SYMBOLS) has
82  * yet to be written.
83  *
84  */
85 
86 /*
87  * globals
88  */
89 
90 
91 static char
92 	*fail_open_s =	"Unable to open file",
93 	*fail_begin_s =	"Unable to read (begin) file",
94 	*fail_ehdr_s =	"Unable to get elf header in",
95 	*fail_sec_s =	"Unable to get section",
96 	*fail_shd_s =	"Unable to get header for section",
97 	*fail_dat_s =	"Unable to get data for section",
98 	*fail_sym_s =	"Cannot find symbol table section in",
99 	*fail_pfsym_s =	"Unable to process symbols in",
100 	*fail_buf_s =	"Data buffer is null for section",
101 	*fail_sym32_s =	"Cannot handle more than 2^32 symbols"
102 	;
103 
104 
105 /*
106  * this points at the name of the executable.
107  */
108 static  char *executableName;
109 
110 
111 
112 /*
113  * section_data_p() - return ptr to section data,
114  * 	given section ptr and name of section.
115  */
116 
117 static Elf_Data *
section_data_p(Elf_Scn * sec_p,char * str)118 section_data_p(Elf_Scn *sec_p, char *str)
119 {
120 	Elf_Data *dat_p;
121 
122 	if ((dat_p = elf_getdata(sec_p, NULL)) == NULL)
123 		_err_exit("%s %s in %s.", fail_dat_s, str, executableName);
124 	return (dat_p);
125 }
126 
127 
128 PROF_FILE *
_symintOpen(char * aout_name)129 _symintOpen(char *aout_name)
130 {
131 /*
132  * Elf file open operation
133  *
134  * - point at executable's name, globally
135  * - open file
136  * - align to current version
137  * - read the elf descriptor and header
138  * - read header-names section descriptor, header, and data
139  * - allocate space for all the section hdrs (pf_shdarr_p).
140  * - set a pointer to the header-names buffer
141  * - search the section headers for
142  *	- debug section header and data
143  *	- line section header and data
144  *	- symbol table header, data, strings, and number of symbols
145  *	  and copy each section hdr into our array.
146  *  - populate the PROF_SYMBOL array and anchor it in (pf_symarr_p).
147  */
148 
149 	PROF_FILE	*pfile_p;	/* PROF_FILE ptr to return. */
150 
151 	Elf		*telf_p;
152 	Elf_Scn		*tscn_p;
153 	Elf32_Shdr	*tshd_p;
154 	int		k;
155 	Elf64_Xword	nsyms_pri = 0, nsyms_aux = 0;
156 
157 	executableName = aout_name;
158 
159 	DEBUG_LOC("_symintOpen: top");
160 	if (aout_name == NULL) {
161 		_err_exit("name of executable is null\n");
162 	}
163 	DEBUG_EXP(printf("Attempting to open %s\n", aout_name));
164 	pfile_p = _Malloc(sizeof (PROF_FILE), 1);
165 
166 	if ((pfile_p->pf_fildes = open(aout_name, O_RDONLY)) == -1)
167 		_err_exit("%s %s.", fail_open_s, aout_name);
168 	if ((elf_version(EV_CURRENT)) == EV_NONE)
169 		_err_exit("Elf library out of date");
170 	if ((pfile_p->pf_elf_p = elf_begin(pfile_p->pf_fildes,
171 	    ELF_C_READ, (Elf *)NULL)) == NULL)
172 		_err_exit("%s %s.", fail_begin_s, aout_name);
173 
174 	DEBUG_EXP(printf("elfkind = %d\n", elf_kind(pfile_p->pf_elf_p)));
175 	if ((pfile_p->pf_elfhd_p = elf32_getehdr(pfile_p->pf_elf_p)) == NULL)
176 		_err_exit("%s %s.", fail_ehdr_s, aout_name);
177 
178 	DEBUG_LOC("_symintOpen: after call to getehdr");
179 	telf_p = pfile_p->pf_elf_p;
180 
181 	tscn_p = elf_getscn(telf_p, k = pfile_p->pf_elfhd_p->e_shstrndx);
182 	if (tscn_p == NULL)
183 		_err_exit("%s %d in %s.", fail_sec_s, k, aout_name);
184 
185 	if (elf32_getshdr(tscn_p) == NULL)
186 		_err_exit("%s %s in %s.", fail_shd_s, "header names",
187 		    aout_name);
188 	if ((pfile_p->pf_snmdat_p = elf_getdata(tscn_p, NULL)) == NULL)
189 		_err_exit("%s %s in %s.", fail_dat_s, "header names",
190 		    aout_name);
191 
192 	DEBUG_EXP(printf("Address of data header = 0x%lx\n",
193 	    pfile_p->pf_snmdat_p));
194 	DEBUG_EXP(printf("d_buf     = 0x%lx\n",
195 	    pfile_p->pf_snmdat_p->d_buf));
196 	DEBUG_EXP(printf("d_type    = %d\n",
197 	    pfile_p->pf_snmdat_p->d_type));
198 	DEBUG_EXP(printf("d_size    = %d\n",
199 	    pfile_p->pf_snmdat_p->d_size));
200 	DEBUG_EXP(printf("d_off     = %d\n",
201 	    pfile_p->pf_snmdat_p->d_off));
202 	DEBUG_EXP(printf("d_align   = %d\n",
203 	    pfile_p->pf_snmdat_p->d_align));
204 	DEBUG_EXP(printf("d_version = %d\n",
205 	    pfile_p->pf_snmdat_p->d_version));
206 
207 	if (pfile_p->pf_snmdat_p->d_buf == NULL)
208 		_err_exit("%s %s in %s.", fail_buf_s, "header names",
209 		    aout_name);
210 
211 	DEBUG_LOC("_symintOpen: after call to getdata (for header names)");
212 
213 	pfile_p->pf_shdarr_p = _Malloc(pfile_p->pf_elfhd_p->e_shentsize,
214 	    pfile_p->pf_elfhd_p->e_shnum);
215 
216 	{
217 #ifdef DEBUG
218 	char	*shdnms_p = (char *)pfile_p->pf_snmdat_p->d_buf;
219 #endif
220 
221 	char	*dest_p = (char *)pfile_p->pf_shdarr_p;
222 	int	shdsize = pfile_p->pf_elfhd_p->e_shentsize;
223 	int	i = 0;
224 	int		symtab_found = 0;
225 
226 	tscn_p = 0;
227 	DEBUG_EXP(printf("Section header entry size = %d\n", shdsize));
228 	DEBUG_EXP(printf("First section header name = %s\n", &shdnms_p[1]));
229 	pfile_p->pf_symdat_aux_p = NULL;
230 	/*
231 	 * Scan the section headers looking for a symbol table. Our
232 	 * preference is to use .symtab, because it contains the full
233 	 * set of symbols. If we find it, we stop looking immediately
234 	 * and use it. In the absence of a .symtab section, we are
235 	 * willing to use the dynamic symbol table (.dynsym), possibly
236 	 * augmented by the .SUNW_ldynsym, which contains local symbols.
237 	 */
238 	while ((tscn_p = elf_nextscn(telf_p, tscn_p)) != NULL) {
239 		if ((tshd_p = elf32_getshdr(tscn_p)) == NULL)
240 			_err_exit("%s %d in %s.", fail_shd_s, i, aout_name);
241 		i++;
242 
243 		(void) memcpy(dest_p, tshd_p, shdsize);
244 		dest_p += shdsize;
245 
246 		DEBUG_EXP(printf("index of section name = %d\n",
247 		    tshd_p->sh_name));
248 		DEBUG_EXP(printf("_symintOpen: reading section %s\n",
249 		    &shdnms_p[tshd_p->sh_name]));
250 
251 		if (symtab_found)
252 			continue;
253 		switch (tshd_p->sh_type) {
254 		case SHT_SYMTAB:
255 			DEBUG_LOC("_symintOpen: found symbol section");
256 			pfile_p->pf_symstr_ndx = tshd_p->sh_link;
257 			pfile_p->pf_symdat_pri_p =
258 			    section_data_p(tscn_p, "symtab");
259 			nsyms_pri = tshd_p->sh_size / tshd_p->sh_entsize;
260 			/* Throw away .SUNW_ldynsym. It is for .dynsym only */
261 			nsyms_aux = 0;
262 			pfile_p->pf_symdat_aux_p = NULL;
263 			/* We have found the best symbol table. Stop looking */
264 			symtab_found = 1;
265 			break;
266 
267 		case SHT_DYNSYM:
268 			/* We will use .dynsym if no .symtab is found */
269 			DEBUG_LOC("_symintOpen: found dynamic symbol section");
270 			pfile_p->pf_symstr_ndx = tshd_p->sh_link;
271 			pfile_p->pf_symdat_pri_p =
272 			    section_data_p(tscn_p, "dynsym");
273 			nsyms_pri = tshd_p->sh_size / tshd_p->sh_entsize;
274 			break;
275 
276 		case SHT_SUNW_LDYNSYM:
277 			/* Auxiliary table, used with .dynsym */
278 			DEBUG_LOC("_symintOpen: found dynamic symbol section");
279 			pfile_p->pf_symdat_aux_p =
280 			    section_data_p(tscn_p, "SUNW_ldynsym");
281 			nsyms_aux = tshd_p->sh_size / tshd_p->sh_entsize;
282 			break;
283 		}
284 
285 	}
286 	}
287 
288 	if (pfile_p->pf_symdat_pri_p == NULL || pfile_p->pf_symstr_ndx == 0)
289 		_err_exit("%s %s.", fail_sym_s, executableName);
290 
291 	pfile_p->pf_nstsyms = (int)(nsyms_pri + nsyms_aux);
292 	pfile_p->pf_nstsyms_aux = (int)nsyms_aux;
293 	if ((nsyms_pri + nsyms_aux) != (Elf64_Xword)pfile_p->pf_nstsyms)
294 		_err_exit("%s %s.", fail_sym32_s, executableName);
295 
296 
297 	DEBUG_LOC("_symintOpen: after for loop that reads the sections");
298 
299 	DEBUG_LOC("_symintOpen: before call to _symintLoad");
300 
301 	if ((pfile_p->pf_symarr_p = _symintLoad(pfile_p)) == NULL)
302 		_err_exit("%s %s.", fail_pfsym_s, executableName);
303 
304 	DEBUG_LOC("_symintOpen: after call to _symintLoad");
305 
306 	/*
307 	 * At this point we might want to include some consistency
308 	 * checks to be sure all is well.  For example, we can check
309 	 * symbol table consistency by comparing "the product of the
310 	 * number of symbols and the size of each symbol" to "the
311 	 * length of the symbol table data".
312 	 *
313 	 * Also, NULL may be a proper value (e.g., the debugger
314 	 * information when there is none) for some things that
315 	 * we cannot afford to be without.  We should check these
316 	 * at this point also.
317 	 */
318 
319 	DEBUG_LOC("_symintOpen: bottom");
320 	return (pfile_p);
321 }
322