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 (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 #include <link.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/regset.h>
31 #include <sys/frame.h>
32 #include <sys/lwp.h>
33 #include <fcntl.h>
34 #include <stdio.h>
35 #include <sys/mman.h>
36 #include <errno.h>
37 #include <signal.h>
38 #include <synch.h>
39 #include <string.h>
40
41 #include "bindings.h"
42 #include "env.h"
43
44 static Elist *bindto_list = NULL;
45 static Elist *bindfrom_list = NULL;
46
47 static bindhead *bhp = NULL;
48 static unsigned int current_map_len = 0;
49 static char *buffer_name;
50 static const sigset_t iset = { ~0U, ~0U, ~0U, ~0U };
51 static lwp_mutex_t sharedmutex = SHAREDMUTEX;
52
53 /*
54 * This routine was stolen from libelf.so.1
55 */
56 static unsigned long
ehash(const char * name)57 ehash(const char *name)
58 {
59 unsigned int g, h = 0;
60 const unsigned char *nm = (unsigned char *)name;
61
62 while (*nm != '\0') {
63 h = (h << 4) + *nm++;
64 /* LINTED */
65 if ((g = (unsigned int)(h & MASK)) != 0)
66 h ^= g >> 24;
67 h &= ~MASK;
68 }
69 return ((unsigned long)h);
70 }
71
72
73 static void
output_err_message(const char * msg)74 output_err_message(const char *msg)
75 {
76 int fd;
77 if ((fd = open("/tmp/bind_err", O_RDWR | O_CREAT, 0666)) == -1) {
78 (void) fprintf(stderr, "bindings.so: unable to open err_log\n");
79 perror("open");
80 }
81 (void) lseek(fd, 0, SEEK_END);
82 (void) write(fd, msg, strlen(msg));
83 (void) close(fd);
84 }
85
86 /*
87 * common mutex locking & unlocking routines for this module. This is to
88 * control the setting of 'lock_held'.
89 */
90 static void
bt_lock(lwp_mutex_t * lock)91 bt_lock(lwp_mutex_t *lock)
92 {
93 if (_lwp_mutex_lock(lock) != 0) {
94 output_err_message("bt_lock failed!!\n");
95 (void) fprintf(stderr, "bindings.so: unable to obtain lock\n");
96 perror("_lwp_mutex_lock");
97 }
98 }
99
100 static void
bt_unlock(lwp_mutex_t * lock)101 bt_unlock(lwp_mutex_t *lock)
102 {
103 if (_lwp_mutex_unlock(lock) != 0) {
104 output_err_message("bt_unlock failed!!\n");
105 (void) fprintf(stderr, "bindings.so: unable to unlock lock\n");
106 perror("_lwp_mutex_unlock");
107 }
108 }
109
110
111
112 /*
113 * It's always possible that another process sharing our buffer
114 * has caused it to grow. If this is the case we must adjust our
115 * mappings to compensate.
116 */
117 static void
remap_buffer(int fd)118 remap_buffer(int fd)
119 {
120 void * new_bhp;
121 if ((new_bhp = mmap(0, bhp->bh_size, PROT_READ | PROT_WRITE,
122 MAP_SHARED, fd, 0)) == MAP_FAILED) {
123 (void) fprintf(stderr, "bindings: remap: mmap failed\n");
124 perror("mmap");
125
126 bt_unlock(&bhp->bh_lock);
127 exit(1);
128 }
129 /*
130 * clean up old mapping
131 */
132 (void) munmap((caddr_t)bhp, current_map_len);
133 bhp = (bindhead *)new_bhp;
134 current_map_len = bhp->bh_size;
135 }
136
137 static void
grow_buffer(void)138 grow_buffer(void)
139 {
140 int fd;
141 if ((fd = open(buffer_name, O_RDWR)) == -1) {
142 (void) fprintf(stderr,
143 "bidings: grow_buffer: open failed: %s\n", buffer_name);
144 perror("open");
145 bt_unlock(&bhp->bh_lock);
146 exit(1);
147 }
148 if (ftruncate(fd, bhp->bh_size + BLKSIZE) == -1) {
149 (void) fprintf(stderr, "grow_buffer failed\n");
150 perror("ftruncate");
151 bt_unlock(&bhp->bh_lock);
152 exit(1);
153 }
154 bhp->bh_size += BLKSIZE;
155 remap_buffer(fd);
156 (void) close(fd);
157 }
158
159 static void
get_new_strbuf(void)160 get_new_strbuf(void)
161 {
162 bt_lock(&bhp->bh_lock);
163 while (bhp->bh_end + STRBLKSIZE > bhp->bh_size)
164 grow_buffer();
165
166 bhp->bh_strcur = bhp->bh_end;
167 bhp->bh_end = bhp->bh_strend = bhp->bh_strcur + STRBLKSIZE;
168 bt_unlock(&bhp->bh_lock);
169 }
170
171 static unsigned int
save_str(const char * str)172 save_str(const char *str)
173 {
174 char *sptr;
175 unsigned int bptr;
176 unsigned int slen;
177
178 bt_lock(&bhp->bh_strlock);
179 /* LINTED */
180 slen = (unsigned int)strlen(str);
181
182 /*
183 * will string fit into our current string buffer?
184 */
185 if ((slen + 1) > (bhp->bh_strend - bhp->bh_strcur))
186 get_new_strbuf();
187 bptr = bhp->bh_strcur;
188 sptr = (char *)bhp + bhp->bh_strcur;
189 bhp->bh_strcur += slen + 1;
190 (void) strncpy(sptr, str, slen);
191 sptr[slen] = '\0';
192 bt_unlock(&bhp->bh_strlock);
193 return (bptr);
194 }
195
196
197 static unsigned int
get_new_entry(void)198 get_new_entry(void)
199 {
200 unsigned int new_ent;
201 bt_lock(&bhp->bh_lock);
202 while ((sizeof (binding_entry) + bhp->bh_end) > bhp->bh_size)
203 grow_buffer();
204 new_ent = bhp->bh_end;
205 bhp->bh_end += sizeof (binding_entry);
206 bt_unlock(&bhp->bh_lock);
207 return (new_ent);
208 }
209
210
211
212 static void
init_locks(void)213 init_locks(void)
214 {
215 int i;
216
217 (void) memcpy(&bhp->bh_lock, &sharedmutex, sizeof (lwp_mutex_t));
218 for (i = 0; i < DEFBKTS; i++)
219 (void) memcpy(&bhp->bh_bkts[i].bb_lock, &sharedmutex,
220 sizeof (lwp_mutex_t));
221
222 (void) memcpy(&bhp->bh_strlock, &sharedmutex, sizeof (lwp_mutex_t));
223 }
224
225 uint_t
la_version(uint_t version)226 la_version(uint_t version)
227 {
228 int fd;
229 sigset_t omask;
230
231 if (version < LAV_CURRENT) {
232 (void) fprintf(stderr,
233 "bindings.so: unexpected link_audit version: %d\n",
234 version);
235 return (0);
236 }
237
238 build_env_list(&bindto_list, (const char *)"BT_BINDTO");
239 build_env_list(&bindfrom_list, (const char *)"BT_BINDFROM");
240
241 if ((buffer_name = getenv(FILEENV)) == NULL)
242 buffer_name = DEFFILE;
243
244 (void) sigprocmask(SIG_BLOCK, &iset, &omask);
245 if ((fd = open(buffer_name, O_RDWR | O_CREAT | O_EXCL, 0666)) != -1) {
246 int init_size = sizeof (bindhead) + BLKSIZE;
247
248 if (ftruncate(fd, init_size) == -1) {
249 perror("ftruncate");
250 return (0);
251 }
252
253 /* LINTED */
254 if ((bhp = (bindhead *)mmap(0, init_size,
255 PROT_READ | PROT_WRITE,
256 MAP_SHARED, fd, 0)) == MAP_FAILED) {
257 perror("bindings.so: mmap");
258 return (0);
259 }
260
261 (void) close(fd);
262
263 init_locks();
264 /*
265 * Lock our structure and then initialize the data
266 */
267 bt_lock(&bhp->bh_lock);
268 bhp->bh_vers = BINDCURVERS;
269 current_map_len = bhp->bh_size = init_size;
270 bhp->bh_end = sizeof (bindhead);
271 bhp->bh_bktcnt = DEFBKTS;
272 bt_unlock(&bhp->bh_lock);
273 /*
274 * Set up our initial string buffer
275 */
276 get_new_strbuf();
277 } else if ((fd = open(buffer_name, O_RDWR)) != -1) {
278 struct stat stbuf;
279 int i;
280 for (i = 0; i < 4; i++) {
281 if (fstat(fd, &stbuf) == -1) {
282 (void) sleep(1);
283 continue;
284 }
285 if (stbuf.st_size < sizeof (bindhead)) {
286 (void) sleep(1);
287 continue;
288 }
289 /* LINTED */
290 if ((bhp = (bindhead *)mmap(0, stbuf.st_size,
291 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) ==
292 MAP_FAILED) {
293 (void) fprintf(stderr,
294 "bindings: mmap failed\n");
295 perror("mmap");
296 return (0);
297 }
298
299 /* LINTED */
300 current_map_len = (unsigned int)stbuf.st_size;
301 }
302 if (bhp == NULL) {
303 (void) fprintf(stderr,
304 "bindings: buffer mapping timed out\n");
305 return (0);
306 }
307 for (i = 0; i < 4; i++) {
308 if (bhp->bh_vers == 0) {
309 (void) sleep(1);
310 continue;
311 }
312 }
313 if (bhp->bh_vers == 0) {
314 (void) fprintf(stderr,
315 "bindings: %s not initialized\n", buffer_name);
316 return (0);
317 }
318
319 bt_lock(&bhp->bh_lock);
320
321 if (bhp->bh_size != current_map_len)
322 remap_buffer(fd);
323 (void) close(fd);
324 } else {
325 (void) fprintf(stderr, "bindings: unable to open %s\n",
326 buffer_name);
327 perror("open");
328 return (0);
329 }
330
331 (void) sigprocmask(SIG_SETMASK, &omask, NULL);
332 bt_unlock(&bhp->bh_lock);
333
334 return (LAV_CURRENT);
335 }
336
337 /* ARGSUSED 0 */
338 uint_t
la_objopen(Link_map * lmp,Lmid_t lmid,uintptr_t * cookie)339 la_objopen(Link_map *lmp, Lmid_t lmid, uintptr_t *cookie)
340 {
341 uint_t flags;
342
343 if ((bindto_list == NULL) ||
344 (check_list(bindto_list, lmp->l_name)))
345 flags = LA_FLG_BINDTO;
346 else
347 flags = 0;
348
349 if ((bindfrom_list == NULL) ||
350 (check_list(bindfrom_list, lmp->l_name)))
351 flags |= LA_FLG_BINDFROM;
352
353 return (flags);
354 }
355
356
357 /* ARGSUSED 1 */
358 #if defined(__sparcv9)
359 uintptr_t
la_sparcv9_pltenter(Elf64_Sym * symp,uint_t symndx,uintptr_t * refcooke,uintptr_t * defcook,La_sparcv9_regs * regset,uint_t * sb_flags,const char * sym_name)360 la_sparcv9_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcooke,
361 uintptr_t *defcook, La_sparcv9_regs *regset, uint_t *sb_flags,
362 const char *sym_name)
363 #elif defined(__sparc)
364 uintptr_t
365 la_sparcv8_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcooke,
366 uintptr_t *defcook, La_sparcv8_regs *regset, uint_t *sb_flags)
367 #elif defined(__amd64)
368 uintptr_t
369 la_amd64_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcooke,
370 uintptr_t *defcook, La_amd64_regs *regset, uint_t *sb_flags,
371 const char *sym_name)
372 #elif defined(__i386)
373 uintptr_t
374 la_i86_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcooke,
375 uintptr_t *defcook, La_i86_regs *regset, uint_t *sb_flags)
376 #endif
377 {
378 unsigned long bktno;
379 Link_map *dlmp = (Link_map *)*defcook;
380 const char *lib_name;
381 sigset_t omask;
382 #if !defined(_LP64)
383 const char *sym_name = (const char *)symp->st_name;
384 #endif
385
386
387 lib_name = dlmp->l_name;
388
389 (void) sigprocmask(SIG_BLOCK, &iset, &omask);
390 if (sym_name == NULL) {
391 output_err_message("null symname\n");
392 return (symp->st_value);
393 }
394
395 bktno = ehash(sym_name) % bhp->bh_bktcnt;
396
397 bt_lock(&bhp->bh_bkts[bktno].bb_lock);
398
399 /*
400 * The buffer has been grown (by another process) and
401 * we need to remap it into memory.
402 */
403 if (bhp->bh_size != current_map_len) {
404 int fd;
405 if ((fd = open(buffer_name, O_RDWR)) == -1) {
406 (void) fprintf(stderr,
407 "bidings: plt_enter: open failed: %s\n",
408 buffer_name);
409 perror("open");
410 bt_unlock(&bhp->bh_lock);
411 exit(1);
412 }
413 bt_lock(&bhp->bh_lock);
414 remap_buffer(fd);
415 bt_unlock(&bhp->bh_lock);
416 (void) close(fd);
417 }
418
419 if (bhp->bh_bkts[bktno].bb_head == 0) {
420 binding_entry * bep;
421 unsigned int be_off;
422 unsigned int sym_off;
423 unsigned int lib_off;
424
425 be_off = get_new_entry();
426 sym_off = save_str(sym_name);
427 lib_off = save_str(lib_name);
428 /* LINTED */
429 bep = (binding_entry *)((char *)bhp + be_off);
430 bep->be_next = 0;
431 bep->be_sym_name = sym_off;
432 bep->be_lib_name = lib_off;
433 bep->be_count = 1;
434 bhp->bh_bkts[bktno].bb_head = be_off;
435 } else {
436 int strcmp_res;
437 unsigned int prev_off = 0;
438 binding_entry *prev_bep = NULL;
439 unsigned int cur_off;
440 binding_entry *cur_bep;
441 unsigned int lib_off = 0;
442
443 /*
444 * Once we get to the bucket, we do a two tiered
445 * search. First we search for a library match, then
446 * we search for a symbol match.
447 */
448 cur_off = bhp->bh_bkts[bktno].bb_head;
449 /* LINTED */
450 cur_bep = (binding_entry *)((char *)bhp +
451 cur_off);
452 while (cur_off && (strcmp_res = strcmp((char *)bhp +
453 cur_bep->be_lib_name, lib_name)) < 0) {
454 prev_off = cur_off;
455 cur_off = cur_bep->be_next;
456 /* LINTED */
457 cur_bep = (binding_entry *)((char *)bhp +
458 cur_off);
459 }
460 if (cur_off && (strcmp_res == 0)) {
461 /*
462 * This is a small optimization. For
463 * each bucket we will only record a library
464 * name once. Once it has been recorded in
465 * a bucket we will just re-use the same
466 * string.
467 */
468 lib_off = cur_bep->be_lib_name;
469 while (cur_off && (strcmp_res = strcmp((char *)bhp +
470 cur_bep->be_sym_name, sym_name)) < 0) {
471 prev_off = cur_off;
472 cur_off = cur_bep->be_next;
473 /* LINTED */
474 cur_bep = (binding_entry *)((char *)bhp +
475 cur_off);
476 }
477 }
478 if (strcmp_res == 0) {
479 /*
480 * We've got a match
481 */
482 cur_bep->be_count++;
483 } else {
484 unsigned int new_off;
485 binding_entry * new_bep;
486 unsigned int sym_off;
487
488 new_off = get_new_entry();
489 if (lib_off == 0)
490 lib_off = save_str(lib_name);
491 sym_off = save_str(sym_name);
492
493 /* LINTED */
494 new_bep = (binding_entry *)((char *)bhp +
495 new_off);
496 new_bep->be_sym_name = sym_off;
497 new_bep->be_lib_name = lib_off;
498 new_bep->be_count = 1;
499 new_bep->be_next = cur_off;
500 if (prev_off) {
501 /* LINTED */
502 prev_bep = (binding_entry *)((char *)bhp +
503 prev_off);
504 prev_bep->be_next = new_off;
505 } else
506 /*
507 * Insert at head of list.
508 */
509 bhp->bh_bkts[bktno].bb_head = new_off;
510
511 }
512 }
513 bt_unlock(&bhp->bh_bkts[bktno].bb_lock);
514 (void) sigprocmask(SIG_SETMASK, &omask, NULL);
515 return (symp->st_value);
516 }
517