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) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 25 * Copyright (c) 2017, Joyent, Inc. 26 */ 27 28 /* 29 * Implementation of all external interfaces between ld.so.1 and libc. 30 * 31 * This file started as a set of routines that provided synchronization and 32 * locking operations using calls to libthread. libthread has merged with libc 33 * under the Unified Process Model (UPM), and things have gotten a lot simpler. 34 * This file continues to establish and redirect various events within ld.so.1 35 * to interfaces within libc. 36 * 37 * Until libc is loaded and relocated, any external interfaces are captured 38 * locally. Each link-map list maintains its own set of external vectors, as 39 * each link-map list typically provides its own libc. Although this per-link- 40 * map list vectoring provides a degree of flexibility, there is a protocol 41 * expected when calling various libc interfaces. 42 * 43 * i. Any new alternative link-map list should call CI_THRINIT, and then call 44 * CI_TLS_MODADD to register any TLS for each object of that link-map list 45 * (this item is labeled i. as auditors can be the first objects loaded, 46 * and they exist on their own lik-map list). 47 * 48 * ii. For the primary link-map list, CI_TLS_STATMOD must be called first to 49 * register any static TLS. This routine is called regardless of there 50 * being any TLS, as this routine also establishes the link-map list as the 51 * primary list and fixes the association of uberdata). CI_THRINIT should 52 * then be called. 53 * 54 * iii. Any objects added to an existing link-map list (primary or alternative) 55 * should call CI_TLS_MODADD to register any additional TLS. 56 * 57 * These events are established by: 58 * 59 * i. Typically, libc is loaded as part of the primary dependencies of any 60 * link-map list (since the Unified Process Model (UPM), libc can't be 61 * lazily loaded). To minimize the possibility of loading and registering 62 * objects, and then tearing them down (because of a relocation error), 63 * external vectors are established as part of load_completion(). This 64 * routine is called on completion of any operation that can cause objects 65 * to be loaded. This point of control insures the objects have been fully 66 * analyzed and relocated, and moved to their controlling link-map list. 67 * The external vectors are established prior to any .inits being fired. 68 * 69 * ii. Calls to CI_THRINIT, and CI_TLS_MODADD also occur as part of 70 * load_completion(). CI_THRINIT is only called once for each link-map 71 * control list. 72 * 73 * iii. Calls to CI_TLS_STATMOD, and CI_THRINIT occur for the primary link-map 74 * list in the final stages of setup(). 75 * 76 * The interfaces provide by libc can be divided into two families. The first 77 * family consists of those interfaces that should be called from the link-map 78 * list. It's possible that these interfaces convey state concerning the 79 * link-map list they are part of: 80 * 81 * CI_ATEXIT 82 * CI TLS_MODADD 83 * CI_TLS_MODREM 84 * CI_TLS_STATMOD 85 * CI_THRINIT 86 * 87 * The second family are global in nature, that is, the link-map list from 88 * which they are called provides no state information. In fact, for 89 * CI_BIND_GUARD, the calling link-map isn't even known. The link-map can only 90 * be deduced after ld.so.1's global lock has been obtained. Therefore, the 91 * following interfaces are also maintained as global: 92 * 93 * CI_LCMESSAGES 94 * CI_BIND_GUARD 95 * CI_BIND_CLEAR 96 * CI_THR_SELF 97 * 98 * Note, it is possible that these global interfaces are obtained from an 99 * alternative link-map list that gets torn down because of a processing 100 * failure (unlikely, because the link-map list components must be analyzed 101 * and relocated prior to load_completion(), but perhaps the tear down is still 102 * a possibility). Thus the global interfaces may have to be replaced. Once 103 * the interfaces have been obtained from the primary link-map, they can 104 * remain fixed, as the primary link-map isn't going to go anywhere. 105 * 106 * The last wrinkle in the puzzle is what happens if an alternative link-map 107 * is loaded with no libc dependency? In this case, the alternative objects 108 * can not call CI_THRINIT, can not be allowed to use TLS, and will not receive 109 * any atexit processing. 110 * 111 * The history of these external interfaces is defined by their version: 112 * 113 * TI_VERSION == 1 114 * Under this model libthread provided rw_rwlock/rw_unlock, through which 115 * all rt_mutex_lock/rt_mutex_unlock calls were vectored. 116 * Under libc/libthread these interfaces provided _sigon/_sigoff (unlike 117 * lwp/libthread that provided signal blocking via bind_guard/bind_clear). 118 * 119 * TI_VERSION == 2 120 * Under this model only libthreads bind_guard/bind_clear and thr_self 121 * interfaces were used. Both libthreads blocked signals under the 122 * bind_guard/bind_clear interfaces. Lower level locking is derived 123 * from internally bound _lwp_ interfaces. This removes recursive 124 * problems encountered when obtaining locking interfaces from libthread. 125 * The use of mutexes over reader/writer locks also enables the use of 126 * condition variables for controlling thread concurrency (allows access 127 * to objects only after their .init has completed). 128 * 129 * NOTE, the TI_VERSION indicated the ti_interface version number, where the 130 * ti_interface was a large vector of functions passed to both libc (to override 131 * the thread stub interfaces) and ld.so.1. ld.so.1 used only a small subset of 132 * these interfaces. 133 * 134 * CI_VERSION == 1 135 * Introduced with CI_VERSION & CI_ATEXIT 136 * 137 * CI_VERSION == 2 (Solaris 8 update 2). 138 * Added support for CI_LCMESSAGES 139 * 140 * CI_VERSION == 3 (Solaris 9). 141 * Added the following versions to the CI table: 142 * 143 * CI_BIND_GUARD, CI_BIND_CLEAR, CI_THR_SELF 144 * CI_TLS_MODADD, CI_TLS_MOD_REMOVE, CI_TLS_STATMOD 145 * 146 * This version introduced the DT_SUNW_RTLDINFO structure as a mechanism 147 * to handshake with ld.so.1. 148 * 149 * CI_VERSION == 4 (Solaris 10). 150 * Added the CI_THRINIT handshake as part of the libc/libthread unified 151 * process model. libc now initializes the current thread pointer from 152 * this interface (and no longer relies on the INITFIRST flag - which 153 * others have started to camp out on). 154 * 155 * CI_VERSION == 5 (Solaris 11). 156 * Use of "protected" references within libc, so that symbols are 157 * pre-bound, and don't require ld.so.1 binding. This implementation 158 * protects libc's critical regions from being vectored to auditors. 159 * 160 * CI_VERSION == 6 (Solaris 11). 161 * Added the CI_CRITICAL handshake, to allow "mem*" family to be reexposed 162 * as "global", and thus be redirected to auxiliary filters. 163 * 164 * Release summary: 165 * 166 * Solaris 8 CI_ATEXIT via _ld_libc() 167 * TI_* via _ld_concurrency() 168 * 169 * Solaris 9 CI_ATEXIT and CI_LCMESSAGES via _ld_libc() 170 * CI_* via RTLDINFO and _ld_libc() - new libthread 171 * TI_* via _ld_concurrency() - old libthread 172 * 173 * Solaris 10 CI_ATEXIT and CI_LCMESSAGES via _ld_libc() 174 * CI_* via RTLDINFO and _ld_libc() - new libthread 175 */ 176 177 #include <sys/debug.h> 178 #include <synch.h> 179 #include <signal.h> 180 #include <thread.h> 181 #include <synch.h> 182 #include <strings.h> 183 #include <stdio.h> 184 #include <libintl.h> 185 #include <debug.h> 186 #include <libc_int.h> 187 #include <fcntl.h> 188 #include "_elf.h" 189 #include "_rtld.h" 190 191 /* 192 * This interface provides the unified process model communication between 193 * ld.so.1 and libc. This interface can be called a number of times: 194 * 195 * - Initially, this interface is called to process RTLDINFO. This data 196 * structure is typically provided by libc, and contains the address of 197 * libc interfaces that must be called to initialize threads information. 198 * 199 * - _ld_libc(), this interface can also be called by libc at process 200 * initialization, after libc has been loaded and relocated, but before 201 * control has been passed to any user code (.init's or main()). This 202 * call provides additional libc interface information that ld.so.1 must 203 * call during process execution. 204 * 205 * - _ld_libc() can also be called by libc during process execution to 206 * re-establish interfaces such as the locale. 207 */ 208 static void 209 get_lcinterface(Rt_map *lmp, Lc_interface *funcs) 210 { 211 int threaded = 0, entry = 0, tag; 212 Lm_list *lml; 213 Lc_desc *lcp; 214 215 if ((lmp == NULL) || (funcs == NULL)) 216 return; 217 218 /* 219 * Once the process is active, ensure we grab a lock. 220 */ 221 if (rtld_flags & RT_FL_APPLIC) 222 entry = enter(0); 223 224 lml = LIST(lmp); 225 lcp = &lml->lm_lcs[0]; 226 227 DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 228 229 for (tag = funcs->ci_tag; tag; tag = (++funcs)->ci_tag) { 230 char *gptr; 231 char *lptr = funcs->ci_un.ci_ptr; 232 233 DBG_CALL(Dbg_util_lcinterface(lmp, tag, lptr)); 234 235 if (tag >= CI_MAX) 236 continue; 237 238 /* 239 * Maintain all interfaces on a per-link-map basis. Note, for 240 * most interfaces, only the first interface is used for any 241 * link-map list. This prevents accidents with developers who 242 * manage to load two different versions of libc. 243 */ 244 if ((lcp[tag].lc_lmp) && 245 (tag != CI_LCMESSAGES) && (tag != CI_VERSION)) { 246 DBG_CALL(Dbg_unused_lcinterface(lmp, 247 lcp[tag].lc_lmp, tag)); 248 continue; 249 } 250 251 lcp[tag].lc_un.lc_ptr = lptr; 252 lcp[tag].lc_lmp = lmp; 253 254 gptr = glcs[tag].lc_un.lc_ptr; 255 256 /* 257 * Process any interfaces that must be maintained on a global 258 * basis. 259 */ 260 switch (tag) { 261 case CI_ATEXIT: 262 break; 263 264 case CI_LCMESSAGES: 265 /* 266 * At startup, ld.so.1 can establish a locale from one 267 * of the locale family of environment variables (see 268 * ld_str_env() and readenv_user()). During process 269 * execution the locale can also be changed by the user. 270 * This interface is called from libc should the locale 271 * be modified. Presently, only one global locale is 272 * maintained for all link-map lists, and only objects 273 * on the primrary link-map may change this locale. 274 */ 275 if ((lml->lm_flags & LML_FLG_BASELM) && 276 ((gptr == NULL) || (strcmp(gptr, lptr) != 0))) { 277 /* 278 * If we've obtained a message locale (typically 279 * supplied via libc's setlocale()), then 280 * register the locale for use in dgettext() so 281 * as to reestablish the locale for ld.so.1's 282 * messages. 283 */ 284 if (gptr) { 285 free((void *)gptr); 286 rtld_flags |= RT_FL_NEWLOCALE; 287 } 288 glcs[tag].lc_un.lc_ptr = strdup(lptr); 289 290 /* 291 * Clear any cached messages. 292 */ 293 bzero(err_strs, sizeof (err_strs)); 294 nosym_str = NULL; 295 } 296 break; 297 298 case CI_BIND_GUARD: 299 case CI_BIND_CLEAR: 300 case CI_THR_SELF: 301 case CI_CRITICAL: 302 /* 303 * If the global vector is unset, or this is the primary 304 * link-map, set the global vector. 305 */ 306 if ((gptr == NULL) || (lml->lm_flags & LML_FLG_BASELM)) 307 glcs[tag].lc_un.lc_ptr = lptr; 308 309 /* FALLTHROUGH */ 310 311 case CI_TLS_MODADD: 312 case CI_TLS_MODREM: 313 case CI_TLS_STATMOD: 314 case CI_THRINIT: 315 threaded++; 316 break; 317 318 case CI_VERSION: 319 if ((rtld_flags2 & RT_FL2_RTLDSEEN) == 0) { 320 Aliste idx; 321 Lm_list *lml2; 322 int version; 323 324 rtld_flags2 |= RT_FL2_RTLDSEEN; 325 326 version = funcs->ci_un.ci_val; 327 #if defined(CI_V_FIVE) 328 if (version >= CI_V_FIVE) { 329 thr_flg_nolock = THR_FLG_NOLOCK; 330 thr_flg_reenter = THR_FLG_REENTER; 331 } 332 #endif 333 if (version < CI_V_FOUR) 334 break; 335 336 rtld_flags2 |= RT_FL2_UNIFPROC; 337 338 /* 339 * We might have seen an auditor which is not 340 * dependent on libc. Such an auditor's link 341 * map list has LML_FLG_HOLDLOCK set. This 342 * lock needs to be dropped. Refer to 343 * audit_setup() in audit.c. 344 */ 345 if ((rtld_flags2 & RT_FL2_HASAUDIT) == 0) 346 break; 347 348 /* 349 * Yes, we did. Take care of them. 350 */ 351 for (APLIST_TRAVERSE(dynlm_list, idx, lml2)) { 352 Rt_map *map = (Rt_map *)lml2->lm_head; 353 354 if (FLAGS(map) & FLG_RT_AUDIT) { 355 lml2->lm_flags &= 356 ~LML_FLG_HOLDLOCK; 357 } 358 } 359 } 360 break; 361 362 default: 363 break; 364 } 365 } 366 367 if (threaded) { 368 /* 369 * If a version of libc gives us only a subset of the TLS 370 * interfaces, it's confused and we discard the whole lot. 371 */ 372 if (((lcp[CI_TLS_MODADD].lc_un.lc_func != NULL) && 373 (lcp[CI_TLS_MODREM].lc_un.lc_func != NULL) && 374 (lcp[CI_TLS_STATMOD].lc_un.lc_func != NULL)) == 0) { 375 lcp[CI_TLS_MODADD].lc_un.lc_func = NULL; 376 lcp[CI_TLS_MODREM].lc_un.lc_func = NULL; 377 lcp[CI_TLS_STATMOD].lc_un.lc_func = NULL; 378 } 379 380 /* 381 * Indicate that we're now thread capable. 382 */ 383 if ((lml->lm_flags & LML_FLG_RTLDLM) == 0) 384 rtld_flags |= RT_FL_THREADS; 385 } 386 387 if (entry) 388 leave(lml, 0); 389 } 390 391 /* 392 * At this point we know we have a set of objects that have been fully analyzed 393 * and relocated. Prior to the next major step of running .init sections (ie. 394 * running user code), retrieve any RTLDINFO interfaces. 395 */ 396 int 397 rt_get_extern(Lm_list *lml, Rt_map *lmp) 398 { 399 if (lml->lm_rti) { 400 Aliste idx; 401 Rti_desc *rti; 402 403 for (ALIST_TRAVERSE(lml->lm_rti, idx, rti)) 404 get_lcinterface(rti->rti_lmp, rti->rti_info); 405 406 free(lml->lm_rti); 407 lml->lm_rti = 0; 408 } 409 410 /* 411 * Perform some sanity checks. If we have TLS requirements we better 412 * have the associated external interfaces. 413 */ 414 if (lml->lm_tls && 415 (lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func == NULL)) { 416 eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TLS_NOSUPPORT), 417 NAME(lmp)); 418 return (0); 419 } 420 return (1); 421 } 422 423 /* 424 * Provide an interface for libc to communicate additional interface 425 * information. 426 */ 427 void 428 _ld_libc(void *ptr) 429 { 430 get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr); 431 } 432 433 static int bindmask = 0; 434 435 int 436 rt_bind_guard(int flags) 437 { 438 int (*fptr)(int); 439 int bindflag; 440 441 if ((fptr = glcs[CI_BIND_GUARD].lc_un.lc_func) != NULL) { 442 return ((*fptr)(flags)); 443 } else { 444 bindflag = (flags & THR_FLG_RTLD); 445 if ((bindflag & bindmask) == 0) { 446 bindmask |= bindflag; 447 return (1); 448 } 449 return (0); 450 } 451 } 452 453 int 454 rt_bind_clear(int flags) 455 { 456 int (*fptr)(int); 457 int bindflag; 458 459 if ((fptr = glcs[CI_BIND_CLEAR].lc_un.lc_func) != NULL) { 460 return ((*fptr)(flags)); 461 } else { 462 bindflag = (flags & THR_FLG_RTLD); 463 if (bindflag == 0) 464 return (bindmask); 465 else { 466 bindmask &= ~bindflag; 467 return (0); 468 } 469 } 470 } 471 472 /* 473 * Make sure threads have been initialized. This interface is called once for 474 * each link-map list. 475 */ 476 void 477 rt_thr_init(Lm_list *lml) 478 { 479 int (*fptr)(void); 480 481 if ((fptr = lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != NULL) { 482 lml->lm_lcs[CI_THRINIT].lc_un.lc_func = NULL; 483 484 leave(lml, thr_flg_reenter); 485 (void) (*fptr)(); 486 (void) enter(thr_flg_reenter); 487 488 /* 489 * If this is an alternative link-map list, and this is the 490 * first call to initialize threads, don't let the destination 491 * libc be deleted. It is possible that an auditors complete 492 * initialization fails, but there is presently no main link-map 493 * list. As this libc has established the thread pointer, don't 494 * delete this libc, otherwise the initialization of libc on the 495 * main link-map can be compromised during its threads 496 * initialization. 497 */ 498 if (((lml->lm_flags & LML_FLG_BASELM) == 0) && 499 ((rtld_flags2 & RT_FL2_PLMSETUP) == 0)) 500 MODE(lml->lm_lcs[CI_THRINIT].lc_lmp) |= RTLD_NODELETE; 501 } 502 } 503 504 thread_t 505 rt_thr_self() 506 { 507 thread_t (*fptr)(void); 508 509 if ((fptr = (thread_t (*)())glcs[CI_THR_SELF].lc_un.lc_func) != NULL) 510 return ((*fptr)()); 511 512 return (1); 513 } 514 515 int 516 rt_mutex_lock(Rt_lock *mp) 517 { 518 return (_lwp_mutex_lock((lwp_mutex_t *)mp)); 519 } 520 521 int 522 rt_mutex_unlock(Rt_lock *mp) 523 { 524 return (_lwp_mutex_unlock((lwp_mutex_t *)mp)); 525 } 526 527 /* 528 * Test whether we're in a libc critical region. Certain function references, 529 * like the "mem*" family, might require binding. Although these functions can 530 * safely bind to auxiliary filtees, they should not be captured by auditors. 531 */ 532 int 533 rt_critical() 534 { 535 int (*fptr)(void); 536 537 if ((fptr = glcs[CI_CRITICAL].lc_un.lc_func) != NULL) 538 return ((*fptr)()); 539 540 return (0); 541 } 542 543 /* 544 * Mutex interfaces to resolve references from any objects extracted from 545 * libc_pic.a. Note, as ld.so.1 is essentially single threaded these can be 546 * noops. 547 */ 548 #pragma weak lmutex_lock = mutex_lock 549 /* ARGSUSED */ 550 int 551 mutex_lock(mutex_t *mp) 552 { 553 return (0); 554 } 555 556 #pragma weak lmutex_unlock = mutex_unlock 557 /* ARGSUSED */ 558 int 559 mutex_unlock(mutex_t *mp) 560 { 561 return (0); 562 } 563 564 /* ARGSUSED */ 565 int 566 mutex_init(mutex_t *mp, int type, void *arg) 567 { 568 return (0); 569 } 570 571 /* ARGSUSED */ 572 int 573 mutex_destroy(mutex_t *mp) 574 { 575 return (0); 576 } 577 578 /* 579 * This is needed to satisfy sysconf() (case _SC_THREAD_STACK_MIN) 580 */ 581 size_t 582 thr_min_stack() 583 { 584 return (sizeof (uintptr_t) * 1024); 585 } 586 587 /* 588 * Local str[n]casecmp() interfaces for the dynamic linker, 589 * to avoid problems when linking with libc_pic.a 590 */ 591 int 592 strcasecmp(const char *s1, const char *s2) 593 { 594 extern int ascii_strcasecmp(const char *, const char *); 595 596 return (ascii_strcasecmp(s1, s2)); 597 } 598 599 int 600 strncasecmp(const char *s1, const char *s2, size_t n) 601 { 602 extern int ascii_strncasecmp(const char *, const char *, size_t); 603 604 return (ascii_strncasecmp(s1, s2, n)); 605 } 606 607 /* 608 * The following functions are cancellation points in libc. 609 * They are called from other functions in libc that we extract 610 * and use directly. We don't do cancellation while we are in 611 * the dynamic linker, so we redefine these to call the primitive, 612 * non-cancellation interfaces. 613 */ 614 int 615 close(int fildes) 616 { 617 extern int __close(int); 618 619 return (__close(fildes)); 620 } 621 622 int 623 fcntl(int fildes, int cmd, ...) 624 { 625 extern int __fcntl(int, int, ...); 626 intptr_t arg, arg1 = 0; 627 va_list ap; 628 629 va_start(ap, cmd); 630 switch (cmd) { 631 case F_DUP3FD: 632 arg = va_arg(ap, int); 633 arg1 = va_arg(ap, int); 634 break; 635 default: 636 arg = va_arg(ap, intptr_t); 637 break; 638 } 639 va_end(ap); 640 return (__fcntl(fildes, cmd, arg, arg1)); 641 } 642 643 int 644 open(const char *path, int oflag, ...) 645 { 646 extern int __open(const char *, int, mode_t); 647 mode_t mode; 648 va_list ap; 649 650 va_start(ap, oflag); 651 mode = va_arg(ap, mode_t); 652 va_end(ap); 653 return (__open(path, oflag, mode)); 654 } 655 656 int 657 openat(int fd, const char *path, int oflag, ...) 658 { 659 extern int __openat(int, const char *, int, mode_t); 660 mode_t mode; 661 va_list ap; 662 663 va_start(ap, oflag); 664 mode = va_arg(ap, mode_t); 665 va_end(ap); 666 return (__openat(fd, path, oflag, mode)); 667 } 668 669 ssize_t 670 read(int fd, void *buf, size_t size) 671 { 672 extern ssize_t __read(int, void *, size_t); 673 return (__read(fd, buf, size)); 674 } 675 676 ssize_t 677 write(int fd, const void *buf, size_t size) 678 { 679 extern ssize_t __write(int, const void *, size_t); 680 return (__write(fd, buf, size)); 681 } 682 683 /* 684 * ASCII versions of ctype character classification functions. This avoids 685 * pulling in the entire locale framework that is in libc. 686 */ 687 688 int 689 isdigit(int c) 690 { 691 return ((c >= '0' && c <= '9') ? 1 : 0); 692 } 693 694 int 695 isupper(int c) 696 { 697 return ((c >= 'A' && c <= 'Z') ? 1 : 0); 698 } 699 700 int 701 islower(int c) 702 { 703 return ((c >= 'a' && c <= 'z') ? 1 : 0); 704 } 705 706 int 707 isspace(int c) 708 { 709 return (((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n') || 710 (c == '\v') || (c == '\f')) ? 1 : 0); 711 } 712 713 int 714 isxdigit(int c) 715 { 716 return ((isdigit(c) || (c >= 'A' && c <= 'F') || 717 (c >= 'a' && c <= 'f')) ? 1 : 0); 718 } 719 720 int 721 isalpha(int c) 722 { 723 return ((isupper(c) || islower(c)) ? 1 : 0); 724 } 725 726 int 727 isalnum(int c) 728 { 729 return ((isalpha(c) || isdigit(c)) ? 1 : 0); 730 } 731 732 #if defined(__i386) || defined(__amd64) 733 /* 734 * Instead of utilizing the comm page for clock_gettime and gettimeofday, rtld 735 * uses the raw syscall instead. Doing so decreases the surface of symbols 736 * needed from libc for a modest performance cost. 737 */ 738 extern int __clock_gettime_sys(clockid_t, struct timespec *); 739 740 int 741 __clock_gettime(clockid_t clock_id, struct timespec *tp) 742 { 743 return (__clock_gettime_sys(clock_id, tp)); 744 } 745 746 int 747 gettimeofday(struct timeval *tv, void *tz) 748 { 749 if (tv != NULL) { 750 /* 751 * Perform the same logic as the libc gettimeofday() when it 752 * lacks comm page support: Make the clock_gettime syscall and 753 * divide out the tv_usec field as required. 754 */ 755 (void) __clock_gettime_sys(CLOCK_REALTIME, (timespec_t *)tv); 756 tv->tv_usec /= 1000; 757 } 758 759 return (0); 760 } 761 #endif /* defined(__i386) || defined(__amd64) */ 762 763 /* 764 * In a similar vein to the is* functions above, we also have to define our own 765 * version of strerror, as it is implemented in terms of the locale aware 766 * strerror_l, and we'd rather not have the full set of libc symbols used here. 767 */ 768 extern const char _sys_errs[]; 769 extern const int _sys_index[]; 770 extern int _sys_num_err; 771 772 char * 773 strerror(int errnum) 774 { 775 if (errnum < _sys_num_err && errnum >= 0) { 776 return (dgettext("SUNW_OST_OSLIB", 777 (char *)&_sys_errs[_sys_index[errnum]])); 778 } 779 780 errno = EINVAL; 781 return (dgettext("SUNW_OST_OSLIB", "Unknown error")); 782 } 783