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 #ifdef illumos
46 #include <sys/machelf.h>
47
48 #include <kstat.h>
49 #else
50 #include <sys/elf.h>
51 #include <sys/ksyms.h>
52 #include <sys/param.h>
53 #include <sys/module.h>
54 #include <sys/linker.h>
55 #endif
56 #include <sys/cpuvar.h>
57
58 typedef struct syment {
59 uintptr_t addr;
60 char *name;
61 size_t size;
62 } syment_t;
63
64 static syment_t *symbol_table;
65 static int nsyms, maxsyms;
66 static char maxsymname[64];
67
68 #ifdef illumos
69 #ifdef _ELF64
70 #define elf_getshdr elf64_getshdr
71 #else
72 #define elf_getshdr elf32_getshdr
73 #endif
74 #endif
75
76 static void
add_symbol(char * name,uintptr_t addr,size_t size)77 add_symbol(char *name, uintptr_t addr, size_t size)
78 {
79 syment_t *sep;
80
81 if (nsyms >= maxsyms) {
82 maxsyms += 10000;
83 symbol_table = realloc(symbol_table, maxsyms * sizeof (*sep));
84 if (symbol_table == NULL) {
85 (void) fprintf(stderr, "can't allocate symbol table\n");
86 exit(3);
87 }
88 }
89 sep = &symbol_table[nsyms++];
90
91 sep->name = name;
92 sep->addr = addr;
93 sep->size = size;
94 }
95
96 static void
remove_symbol(uintptr_t addr)97 remove_symbol(uintptr_t addr)
98 {
99 int i;
100 syment_t *sep = symbol_table;
101
102 for (i = 0; i < nsyms; i++, sep++)
103 if (sep->addr == addr)
104 sep->addr = 0;
105 }
106
107 #ifdef illumos
108 static void
fake_up_certain_popular_kernel_symbols(void)109 fake_up_certain_popular_kernel_symbols(void)
110 {
111 kstat_ctl_t *kc;
112 kstat_t *ksp;
113 char *name;
114
115 if ((kc = kstat_open()) == NULL)
116 return;
117
118 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
119 if (strcmp(ksp->ks_module, "cpu_info") == 0) {
120 if ((name = malloc(20)) == NULL)
121 break;
122 /*
123 * For consistency, keep cpu[0] and toss cpu0
124 * or any other such symbols.
125 */
126 if (ksp->ks_instance == 0)
127 remove_symbol((uintptr_t)ksp->ks_private);
128 (void) sprintf(name, "cpu[%d]", ksp->ks_instance);
129 add_symbol(name, (uintptr_t)ksp->ks_private,
130 sizeof (struct cpu));
131 }
132 }
133 (void) kstat_close(kc);
134 }
135 #else /* !illumos */
136 static void
fake_up_certain_popular_kernel_symbols(void)137 fake_up_certain_popular_kernel_symbols(void)
138 {
139 char *name;
140 uintptr_t addr;
141 int i;
142
143 /* Good for up to 256 CPUs */
144 for(i=0; i < 256; i++) {
145 if ((name = malloc(20)) == NULL)
146 break;
147 (void) sprintf(name, "cpu[%d]", i);
148 addr = 0x01000000 + (i << 16);
149 add_symbol(name, addr, sizeof (uintptr_t));
150 }
151 }
152 #endif /* illumos */
153
154 static int
symcmp(const void * p1,const void * p2)155 symcmp(const void *p1, const void *p2)
156 {
157 uintptr_t a1 = ((syment_t *)p1)->addr;
158 uintptr_t a2 = ((syment_t *)p2)->addr;
159
160 if (a1 < a2)
161 return (-1);
162 if (a1 > a2)
163 return (1);
164 return (0);
165 }
166
167 int
symtab_init(void)168 symtab_init(void)
169 {
170 Elf *elf;
171 Elf_Scn *scn = NULL;
172 Sym *symtab, *symp, *lastsym;
173 char *strtab;
174 uint_t cnt;
175 int fd;
176 int i;
177 int strindex = -1;
178 #ifndef illumos
179 void *ksyms;
180 size_t sz;
181 #endif
182
183 #ifndef illumos
184 if ((fd = open("/dev/ksyms", O_RDONLY)) == -1) {
185 if (errno == ENOENT && modfind("ksyms") == -1) {
186 kldload("ksyms");
187 fd = open("/dev/ksyms", O_RDONLY);
188 }
189 if (fd == -1)
190 return (-1);
191 }
192 #else
193 if ((fd = open("/dev/ksyms", O_RDONLY)) == -1)
194 return (-1);
195 #endif
196
197 #ifdef illumos
198 (void) elf_version(EV_CURRENT);
199
200 elf = elf_begin(fd, ELF_C_READ, NULL);
201 #else
202 /*
203 * XXX - libelf needs to be fixed so it will work with
204 * non 'ordinary' files like /dev/ksyms. The following
205 * is a work around for now.
206 */
207 if (elf_version(EV_CURRENT) == EV_NONE) {
208 close(fd);
209 return (-1);
210 }
211 if (ioctl(fd, KIOCGSIZE, &sz) < 0) {
212 close(fd);
213 return (-1);
214 }
215 if (ioctl(fd, KIOCGADDR, &ksyms) < 0) {
216 close(fd);
217 return (-1);
218 }
219 if ((elf = elf_memory(ksyms, sz)) == NULL) {
220 close(fd);
221 return (-1);
222 }
223 #endif
224
225 for (cnt = 1; (scn = elf_nextscn(elf, scn)) != NULL; cnt++) {
226 Shdr *shdr = elf_getshdr(scn);
227 if (shdr->sh_type == SHT_SYMTAB) {
228 symtab = (Sym *)elf_getdata(scn, NULL)->d_buf;
229 nsyms = shdr->sh_size / shdr->sh_entsize;
230 strindex = shdr->sh_link;
231 }
232 }
233
234 for (cnt = 1; (scn = elf_nextscn(elf, scn)) != NULL; cnt++) {
235 if (cnt == strindex)
236 strtab = (char *)elf_getdata(scn, NULL)->d_buf;
237 }
238
239 lastsym = symtab + nsyms;
240 nsyms = 0;
241 for (symp = symtab; symp < lastsym; symp++)
242 if ((uint_t)ELF32_ST_TYPE(symp->st_info) <= STT_FUNC &&
243 symp->st_size != 0)
244 add_symbol(symp->st_name + strtab,
245 (uintptr_t)symp->st_value, (size_t)symp->st_size);
246
247 fake_up_certain_popular_kernel_symbols();
248 (void) sprintf(maxsymname, "0x%lx", ULONG_MAX);
249 add_symbol(maxsymname, ULONG_MAX, 1);
250
251 qsort(symbol_table, nsyms, sizeof (syment_t), symcmp);
252
253 /*
254 * Destroy all duplicate symbols, then sort it again.
255 */
256 for (i = 0; i < nsyms - 1; i++)
257 if (symbol_table[i].addr == symbol_table[i + 1].addr)
258 symbol_table[i].addr = 0;
259
260 qsort(symbol_table, nsyms, sizeof (syment_t), symcmp);
261
262 while (symbol_table[1].addr == 0) {
263 symbol_table++;
264 nsyms--;
265 }
266 symbol_table[0].name = "(usermode)";
267 symbol_table[0].addr = 0;
268 symbol_table[0].size = 1;
269
270 close(fd);
271 return (0);
272 }
273
274 char *
addr_to_sym(uintptr_t addr,uintptr_t * offset,size_t * sizep)275 addr_to_sym(uintptr_t addr, uintptr_t *offset, size_t *sizep)
276 {
277 int lo = 0;
278 int hi = nsyms - 1;
279 int mid;
280 syment_t *sep;
281
282 while (hi - lo > 1) {
283 mid = (lo + hi) / 2;
284 if (addr >= symbol_table[mid].addr) {
285 lo = mid;
286 } else {
287 hi = mid;
288 }
289 }
290 sep = &symbol_table[lo];
291 *offset = addr - sep->addr;
292 *sizep = sep->size;
293 return (sep->name);
294 }
295
296 uintptr_t
sym_to_addr(char * name)297 sym_to_addr(char *name)
298 {
299 int i;
300 syment_t *sep = symbol_table;
301
302 for (i = 0; i < nsyms; i++) {
303 if (strcmp(name, sep->name) == 0)
304 return (sep->addr);
305 sep++;
306 }
307 return (0);
308 }
309
310 size_t
sym_size(char * name)311 sym_size(char *name)
312 {
313 int i;
314 syment_t *sep = symbol_table;
315
316 for (i = 0; i < nsyms; i++) {
317 if (strcmp(name, sep->name) == 0)
318 return (sep->size);
319 sep++;
320 }
321 return (0);
322 }
323