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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright (c) 1997-1999 by Sun Microsystems, Inc.
24  * All rights reserved.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <stdio.h>
30 #include <fcntl.h>
31 #include <ctype.h>
32 #include <string.h>
33 #include <signal.h>
34 #include <errno.h>
35 #include <stdlib.h>
36 #include <stdarg.h>
37 #include <unistd.h>
38 #include <limits.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 
42 #include <libelf.h>
43 #include <link.h>
44 #include <elf.h>
45 #if defined(sun)
46 #include <sys/machelf.h>
47 
48 #include <kstat.h>
49 #else
50 /* FreeBSD */
51 #include <sys/elf.h>
52 #include <sys/ksyms.h>
53 #endif
54 #include <sys/cpuvar.h>
55 
56 typedef struct syment {
57 	uintptr_t	addr;
58 	char		*name;
59 	size_t		size;
60 } syment_t;
61 
62 static syment_t *symbol_table;
63 static int nsyms, maxsyms;
64 static char maxsymname[64];
65 
66 #if defined(sun)
67 #ifdef _ELF64
68 #define	elf_getshdr elf64_getshdr
69 #else
70 #define	elf_getshdr elf32_getshdr
71 #endif
72 #endif
73 
74 static void
75 add_symbol(char *name, uintptr_t addr, size_t size)
76 {
77 	syment_t *sep;
78 
79 	if (nsyms >= maxsyms) {
80 		maxsyms += 10000;
81 		symbol_table = realloc(symbol_table, maxsyms * sizeof (*sep));
82 		if (symbol_table == NULL) {
83 			(void) fprintf(stderr, "can't allocate symbol table\n");
84 			exit(3);
85 		}
86 	}
87 	sep = &symbol_table[nsyms++];
88 
89 	sep->name = name;
90 	sep->addr = addr;
91 	sep->size = size;
92 }
93 
94 static void
95 remove_symbol(uintptr_t addr)
96 {
97 	int i;
98 	syment_t *sep = symbol_table;
99 
100 	for (i = 0; i < nsyms; i++, sep++)
101 		if (sep->addr == addr)
102 			sep->addr = 0;
103 }
104 
105 #if defined(sun)
106 static void
107 fake_up_certain_popular_kernel_symbols(void)
108 {
109 	kstat_ctl_t *kc;
110 	kstat_t *ksp;
111 	char *name;
112 
113 	if ((kc = kstat_open()) == NULL)
114 		return;
115 
116 	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
117 		if (strcmp(ksp->ks_module, "cpu_info") == 0) {
118 			if ((name = malloc(20)) == NULL)
119 				break;
120 			/*
121 			 * For consistency, keep cpu[0] and toss cpu0
122 			 * or any other such symbols.
123 			 */
124 			if (ksp->ks_instance == 0)
125 				remove_symbol((uintptr_t)ksp->ks_private);
126 			(void) sprintf(name, "cpu[%d]", ksp->ks_instance);
127 			add_symbol(name, (uintptr_t)ksp->ks_private,
128 			    sizeof (struct cpu));
129 		}
130 	}
131 	(void) kstat_close(kc);
132 }
133 #else
134 /* FreeBSD */
135 static void
136 fake_up_certain_popular_kernel_symbols(void)
137 {
138 	char *name;
139 	uintptr_t addr;
140 	int i;
141 
142 	/* Good for up to 256 CPUs */
143 	for(i=0; i < 256;  i++) {
144 		if ((name = malloc(20)) == NULL)
145 			break;
146 		(void) sprintf(name, "cpu[%d]", i);
147 		addr = 0x01000000 + (i << 16);
148 		add_symbol(name, addr, sizeof (uintptr_t));
149 	}
150 }
151 #endif /* !defined(sun) */
152 
153 static int
154 symcmp(const void *p1, const void *p2)
155 {
156 	uintptr_t a1 = ((syment_t *)p1)->addr;
157 	uintptr_t a2 = ((syment_t *)p2)->addr;
158 
159 	if (a1 < a2)
160 		return (-1);
161 	if (a1 > a2)
162 		return (1);
163 	return (0);
164 }
165 
166 int
167 symtab_init(void)
168 {
169 	Elf		*elf;
170 	Elf_Scn		*scn = NULL;
171 	Sym		*symtab, *symp, *lastsym;
172 	char		*strtab;
173 	uint_t		cnt;
174 	int		fd;
175 	int		i;
176 	int		strindex = -1;
177 #if !defined(sun)
178 	void		*ksyms;
179 	size_t		sz;
180 #endif
181 
182 	if ((fd = open("/dev/ksyms", O_RDONLY)) == -1)
183 		return (-1);
184 
185 #if defined(sun)
186 	(void) elf_version(EV_CURRENT);
187 
188 	elf = elf_begin(fd, ELF_C_READ, NULL);
189 #else
190 	/* FreeBSD */
191 	/*
192 	 * XXX - libelf needs to be fixed so it will work with
193 	 * non 'ordinary' files like /dev/ksyms.  The following
194 	 * is a work around for now.
195 	 */
196 	if (elf_version(EV_CURRENT) == EV_NONE) {
197 		close(fd);
198 		return (-1);
199 	}
200 	if (ioctl(fd, KIOCGSIZE, &sz) < 0) {
201 		close(fd);
202 		return (-1);
203 	}
204 	if (ioctl(fd, KIOCGADDR, &ksyms) < 0) {
205 		close(fd);
206 		return (-1);
207 	}
208 	if ((elf = elf_memory(ksyms, sz)) == NULL) {
209 		close(fd);
210 		return (-1);
211 	}
212 #endif
213 
214 	for (cnt = 1; (scn = elf_nextscn(elf, scn)) != NULL; cnt++) {
215 		Shdr *shdr = elf_getshdr(scn);
216 		if (shdr->sh_type == SHT_SYMTAB) {
217 			symtab = (Sym *)elf_getdata(scn, NULL)->d_buf;
218 			nsyms = shdr->sh_size / shdr->sh_entsize;
219 			strindex = shdr->sh_link;
220 		}
221 	}
222 
223 	for (cnt = 1; (scn = elf_nextscn(elf, scn)) != NULL; cnt++) {
224 		if (cnt == strindex)
225 			strtab = (char *)elf_getdata(scn, NULL)->d_buf;
226 	}
227 
228 	lastsym = symtab + nsyms;
229 	nsyms = 0;
230 	for (symp = symtab; symp < lastsym; symp++)
231 		if ((uint_t)ELF32_ST_TYPE(symp->st_info) <= STT_FUNC &&
232 		    symp->st_size != 0)
233 			add_symbol(symp->st_name + strtab,
234 			    (uintptr_t)symp->st_value, (size_t)symp->st_size);
235 
236 	fake_up_certain_popular_kernel_symbols();
237 	(void) sprintf(maxsymname, "0x%lx", ULONG_MAX);
238 	add_symbol(maxsymname, ULONG_MAX, 1);
239 
240 	qsort(symbol_table, nsyms, sizeof (syment_t), symcmp);
241 
242 	/*
243 	 * Destroy all duplicate symbols, then sort it again.
244 	 */
245 	for (i = 0; i < nsyms - 1; i++)
246 		if (symbol_table[i].addr == symbol_table[i + 1].addr)
247 			symbol_table[i].addr = 0;
248 
249 	qsort(symbol_table, nsyms, sizeof (syment_t), symcmp);
250 
251 	while (symbol_table[1].addr == 0) {
252 		symbol_table++;
253 		nsyms--;
254 	}
255 	symbol_table[0].name = "(usermode)";
256 	symbol_table[0].addr = 0;
257 	symbol_table[0].size = 1;
258 
259 	close(fd);
260 	return (0);
261 }
262 
263 char *
264 addr_to_sym(uintptr_t addr, uintptr_t *offset, size_t *sizep)
265 {
266 	int lo = 0;
267 	int hi = nsyms - 1;
268 	int mid;
269 	syment_t *sep;
270 
271 	while (hi - lo > 1) {
272 		mid = (lo + hi) / 2;
273 		if (addr >= symbol_table[mid].addr) {
274 			lo = mid;
275 		} else {
276 			hi = mid;
277 		}
278 	}
279 	sep = &symbol_table[lo];
280 	*offset = addr - sep->addr;
281 	*sizep = sep->size;
282 	return (sep->name);
283 }
284 
285 uintptr_t
286 sym_to_addr(char *name)
287 {
288 	int i;
289 	syment_t *sep = symbol_table;
290 
291 	for (i = 0; i < nsyms; i++) {
292 		if (strcmp(name, sep->name) == 0)
293 			return (sep->addr);
294 		sep++;
295 	}
296 	return (0);
297 }
298 
299 size_t
300 sym_size(char *name)
301 {
302 	int i;
303 	syment_t *sep = symbol_table;
304 
305 	for (i = 0; i < nsyms; i++) {
306 		if (strcmp(name, sep->name) == 0)
307 			return (sep->size);
308 		sep++;
309 	}
310 	return (0);
311 }
312