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