1 /* Copyright (C) 1991,1993,1995-1997,2000
2 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 see <http://www.gnu.org/licenses/>. */
18
19 #define _XOPEN_SOURCE 500
20 #include <features.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <limits.h>
24 #include <grp.h>
25 #include <pwd.h>
26 #include <stddef.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <time.h>
30 #include <unistd.h>
31 #include <sys/syscall.h>
32 #include <sys/sysinfo.h>
33 #include <sys/types.h>
34 #include <sys/param.h>
35 #ifdef __UCLIBC_HAS_REGEX__
36 #include <regex.h>
37 #endif
38 #ifdef __UCLIBC_HAS_THREADS_NATIVE__
39 #include <sysdep.h>
40 #endif
41 #include <sys/resource.h>
42 #include <string.h>
43 #include <dirent.h>
44 #include "internal/parse_config.h"
45
nprocessors_onln(void)46 static int nprocessors_onln(void)
47 {
48 char **l = NULL;
49 parser_t *p = config_open("/proc/stat");
50 int ret = 0;
51
52 if (p) {
53 while (config_read(p, &l, 2, 1, " ", 0))
54 if (l[0][0] == 'c'
55 && l[0][1] == 'p'
56 && l[0][2] == 'u'
57 && isdigit(l[0][3]))
58 ++ret;
59 } else if ((p = config_open("/proc/cpuinfo"))) {
60 #if defined __sparc__
61 while (config_read(p, &l, 2, 2, "\0:", PARSE_NORMAL))
62 if (strncmp("ncpus active", l[0], 12) == 0) {
63 ret = atoi(l[1]);
64 break;
65 }
66 #else
67 while (config_read(p, &l, 2, 2, "\0:\t", PARSE_NORMAL))
68 if (strcmp("processor", l[0]) == 0)
69 ++ret;
70 #endif
71 }
72 config_close(p);
73 return ret != 0 ? ret : 1;
74 }
75
76 #if defined __UCLIBC__ && !defined __UCLIBC_HAS_LFS__
77 # define readdir64 readdir
78 # define dirent64 dirent
79 #endif
nprocessors_conf(void)80 static int nprocessors_conf(void)
81 {
82 int ret = 0;
83 DIR *dir = opendir("/sys/devices/system/cpu");
84
85 if (dir) {
86 struct dirent64 *dp;
87
88 while ((dp = readdir64(dir))) {
89 if (dp->d_type == DT_DIR
90 && dp->d_name[0] == 'c'
91 && dp->d_name[1] == 'p'
92 && dp->d_name[2] == 'u'
93 && isdigit(dp->d_name[3]))
94 ++ret;
95 }
96 closedir(dir);
97 } else
98 {
99 #if defined __sparc__
100 char **l = NULL;
101 parser_t *p = config_open("/proc/stat");
102 while (config_read(p, &l, 2, 2, "\0:", PARSE_NORMAL))
103 if (strncmp("ncpus probed", l[0], 13) == 0) {
104 ret = atoi(l[1]);
105 break;
106 }
107 config_close(p);
108 #else
109 ret = nprocessors_onln();
110 #endif
111 }
112 return ret != 0 ? ret : 1;
113 }
114
115
116 #ifndef __UCLIBC_CLK_TCK_CONST
117 #error __UCLIBC_CLK_TCK_CONST not defined!
118 #endif
119
120 /***********************************************************************/
121 /*
122 * Manuel Novoa III Jan 2001
123 *
124 * On i386, the switch-based implementation generates 796 bytes of code.
125 * However, many of the return values are repeats. By collecting these
126 * repeats and moving to a table-based implementation, we generate 283
127 * bytes on i386 (-Os -fomit-frame-pointer).
128 */
129
130 #ifdef _UCLIBC_GENERATE_SYSCONF_ARCH
131 /*
132 * Set some errno's so the auto-gen code knows what it is dealing with.
133 * 1) ENOSYS signifies that we're returning a default value.
134 * This is just extra info for development.
135 * 2) EISNAM signifies that the value returned varies at runtime.
136 *
137 * Option: GETPAGESIZE_IS_DYNAMIC
138 * The current implementation of getpagesize in uClibc returns
139 * a constant. The pagesize on the target arch should not vary,
140 * so it should be safe to set this as 0.
141 */
142 #define RETURN_NEG_1 __set_errno(ENOSYS); return -1
143 #define RETURN_FUNCTION(f) __set_errno(EISNAM); return (long int) #f
144 #define GETPAGESIZE_IS_DYNAMIC 0
145 #else
146 #define RETURN_NEG_1 return -1
147 #define RETURN_FUNCTION(f) return f;
148 #endif /* _UCLIBC_GENERATE_SYSCONF_ARCH */
149
150 /* Legacy value of ARG_MAX. The macro is now not defined since the
151 actual value varies based on the stack size. */
152 #define legacy_ARG_MAX 131072
153
154 /* Get the value of the system variable NAME. */
sysconf(int name)155 long int sysconf(int name)
156 {
157 struct rlimit rlimit;
158
159 switch (name)
160 {
161 default:
162 __set_errno(EINVAL);
163 return -1;
164
165 case _SC_ARG_MAX:
166 /* Use getrlimit to get the stack limit. */
167 if (getrlimit (RLIMIT_STACK, &rlimit) == 0)
168 return MAX (legacy_ARG_MAX, rlimit.rlim_cur / 4);
169 #if defined ARG_MAX
170 return ARG_MAX;
171 #else
172 return legacy_ARG_MAX;
173 #endif
174
175 case _SC_CHILD_MAX:
176 #ifdef CHILD_MAX
177 return CHILD_MAX;
178 #else
179 RETURN_NEG_1;
180 #endif
181
182 case _SC_CLK_TCK:
183 /* Can't use CLK_TCK here since that calls __sysconf(_SC_CLK_TCK) */
184 return __UCLIBC_CLK_TCK_CONST;
185
186 case _SC_NGROUPS_MAX:
187 #ifdef NGROUPS_MAX
188 return NGROUPS_MAX;
189 #else
190 RETURN_NEG_1;
191 #endif
192
193 case _SC_OPEN_MAX:
194 RETURN_FUNCTION(getdtablesize());
195
196 case _SC_STREAM_MAX:
197 #ifdef STREAM_MAX
198 return STREAM_MAX;
199 #else
200 return FOPEN_MAX;
201 #endif
202
203 case _SC_TZNAME_MAX:
204 return _POSIX_TZNAME_MAX;
205
206 case _SC_JOB_CONTROL:
207 #ifdef _POSIX_JOB_CONTROL
208 return 1;
209 #else
210 RETURN_NEG_1;
211 #endif
212
213 case _SC_SAVED_IDS:
214 #ifdef _POSIX_SAVED_IDS
215 return 1;
216 #else
217 RETURN_NEG_1;
218 #endif
219
220 case _SC_REALTIME_SIGNALS:
221 #ifdef _POSIX_REALTIME_SIGNALS
222 return 1;
223 #else
224 RETURN_NEG_1;
225 #endif
226
227 case _SC_PRIORITY_SCHEDULING:
228 #ifdef _POSIX_PRIORITY_SCHEDULING
229 return 1;
230 #else
231 RETURN_NEG_1;
232 #endif
233
234 case _SC_TIMERS:
235 #ifdef _POSIX_TIMERS
236 return 1;
237 #else
238 RETURN_NEG_1;
239 #endif
240
241 case _SC_ASYNCHRONOUS_IO:
242 #ifdef _POSIX_ASYNCHRONOUS_IO
243 return 1;
244 #else
245 RETURN_NEG_1;
246 #endif
247
248 case _SC_PRIORITIZED_IO:
249 #ifdef _POSIX_PRIORITIZED_IO
250 return 1;
251 #else
252 RETURN_NEG_1;
253 #endif
254
255 case _SC_SYNCHRONIZED_IO:
256 #ifdef _POSIX_SYNCHRONIZED_IO
257 return 1;
258 #else
259 RETURN_NEG_1;
260 #endif
261
262 case _SC_FSYNC:
263 #ifdef _POSIX_FSYNC
264 return 1;
265 #else
266 RETURN_NEG_1;
267 #endif
268
269 case _SC_MAPPED_FILES:
270 #ifdef _POSIX_MAPPED_FILES
271 return 1;
272 #else
273 RETURN_NEG_1;
274 #endif
275
276 case _SC_MEMLOCK:
277 #ifdef _POSIX_MEMLOCK
278 return 1;
279 #else
280 RETURN_NEG_1;
281 #endif
282
283 case _SC_MEMLOCK_RANGE:
284 #ifdef _POSIX_MEMLOCK_RANGE
285 return 1;
286 #else
287 RETURN_NEG_1;
288 #endif
289
290 case _SC_MEMORY_PROTECTION:
291 #ifdef _POSIX_MEMORY_PROTECTION
292 return 1;
293 #else
294 RETURN_NEG_1;
295 #endif
296
297 case _SC_MESSAGE_PASSING:
298 #ifdef _POSIX_MESSAGE_PASSING
299 return 1;
300 #else
301 RETURN_NEG_1;
302 #endif
303
304 case _SC_SEMAPHORES:
305 #ifdef _POSIX_SEMAPHORES
306 return 1;
307 #else
308 RETURN_NEG_1;
309 #endif
310
311 case _SC_SHARED_MEMORY_OBJECTS:
312 #ifdef _POSIX_SHARED_MEMORY_OBJECTS
313 return 1;
314 #else
315 RETURN_NEG_1;
316 #endif
317
318 case _SC_VERSION:
319 return _POSIX_VERSION;
320
321 case _SC_PAGESIZE:
322 #if defined(GETPAGESIZE_IS_DYNAMIC) && (GETPAGESIZE_IS_DYNAMIC == 1)
323 RETURN_FUNCTION(getpagesize());
324 #else
325 return getpagesize(); /* note: currently this is not dynamic */
326 #endif
327
328 case _SC_AIO_LISTIO_MAX:
329 #ifdef AIO_LISTIO_MAX
330 return AIO_LISTIO_MAX;
331 #else
332 RETURN_NEG_1;
333 #endif
334
335 case _SC_AIO_MAX:
336 #ifdef AIO_MAX
337 return AIO_MAX;
338 #else
339 RETURN_NEG_1;
340 #endif
341
342 case _SC_AIO_PRIO_DELTA_MAX:
343 #ifdef AIO_PRIO_DELTA_MAX
344 return AIO_PRIO_DELTA_MAX;
345 #else
346 RETURN_NEG_1;
347 #endif
348
349 case _SC_DELAYTIMER_MAX:
350 #ifdef DELAYTIMER_MAX
351 return DELAYTIMER_MAX;
352 #else
353 RETURN_NEG_1;
354 #endif
355
356 case _SC_MQ_OPEN_MAX:
357 #ifdef MQ_OPEN_MAX
358 return MQ_OPEN_MAX;
359 #else
360 RETURN_NEG_1;
361 #endif
362
363 case _SC_MQ_PRIO_MAX:
364 #ifdef MQ_PRIO_MAX
365 return MQ_PRIO_MAX;
366 #else
367 RETURN_NEG_1;
368 #endif
369
370 case _SC_RTSIG_MAX:
371 #ifdef RTSIG_MAX
372 return RTSIG_MAX;
373 #else
374 RETURN_NEG_1;
375 #endif
376
377 case _SC_SEM_NSEMS_MAX:
378 #ifdef SEM_NSEMS_MAX
379 return SEM_NSEMS_MAX;
380 #else
381 RETURN_NEG_1;
382 #endif
383
384 case _SC_SEM_VALUE_MAX:
385 #ifdef SEM_VALUE_MAX
386 return SEM_VALUE_MAX;
387 #else
388 RETURN_NEG_1;
389 #endif
390
391 case _SC_SIGQUEUE_MAX:
392 #ifdef SIGQUEUE_MAX
393 return SIGQUEUE_MAX;
394 #else
395 RETURN_NEG_1;
396 #endif
397
398 case _SC_TIMER_MAX:
399 #ifdef TIMER_MAX
400 return TIMER_MAX;
401 #else
402 RETURN_NEG_1;
403 #endif
404
405 case _SC_BC_BASE_MAX:
406 #ifdef BC_BASE_MAX
407 return BC_BASE_MAX;
408 #else
409 RETURN_NEG_1;
410 #endif
411
412 case _SC_BC_DIM_MAX:
413 #ifdef BC_DIM_MAX
414 return BC_DIM_MAX;
415 #else
416 RETURN_NEG_1;
417 #endif
418
419 case _SC_BC_SCALE_MAX:
420 #ifdef BC_SCALE_MAX
421 return BC_SCALE_MAX;
422 #else
423 RETURN_NEG_1;
424 #endif
425
426 case _SC_BC_STRING_MAX:
427 #ifdef BC_STRING_MAX
428 return BC_STRING_MAX;
429 #else
430 RETURN_NEG_1;
431 #endif
432
433 case _SC_COLL_WEIGHTS_MAX:
434 #ifdef COLL_WEIGHTS_MAX
435 return COLL_WEIGHTS_MAX;
436 #else
437 RETURN_NEG_1;
438 #endif
439
440 case _SC_EQUIV_CLASS_MAX:
441 #ifdef EQUIV_CLASS_MAX
442 return EQUIV_CLASS_MAX;
443 #else
444 RETURN_NEG_1;
445 #endif
446
447 case _SC_EXPR_NEST_MAX:
448 #ifdef EXPR_NEST_MAX
449 return EXPR_NEST_MAX;
450 #else
451 RETURN_NEG_1;
452 #endif
453
454 case _SC_LINE_MAX:
455 #ifdef LINE_MAX
456 return LINE_MAX;
457 #else
458 RETURN_NEG_1;
459 #endif
460
461 case _SC_RE_DUP_MAX:
462 #ifdef RE_DUP_MAX
463 return RE_DUP_MAX;
464 #else
465 RETURN_NEG_1;
466 #endif
467
468 case _SC_CHARCLASS_NAME_MAX:
469 #ifdef CHARCLASS_NAME_MAX
470 return CHARCLASS_NAME_MAX;
471 #else
472 RETURN_NEG_1;
473 #endif
474
475 case _SC_PII:
476 #ifdef _POSIX_PII
477 return 1;
478 #else
479 RETURN_NEG_1;
480 #endif
481
482 case _SC_PII_XTI:
483 #ifdef _POSIX_PII_XTI
484 return 1;
485 #else
486 RETURN_NEG_1;
487 #endif
488
489 case _SC_PII_SOCKET:
490 #ifdef _POSIX_PII_SOCKET
491 return 1;
492 #else
493 RETURN_NEG_1;
494 #endif
495
496 case _SC_PII_INTERNET:
497 #ifdef _POSIX_PII_INTERNET
498 return 1;
499 #else
500 RETURN_NEG_1;
501 #endif
502
503 case _SC_PII_OSI:
504 #ifdef _POSIX_PII_OSI
505 return 1;
506 #else
507 RETURN_NEG_1;
508 #endif
509
510 case _SC_POLL:
511 #ifdef _POSIX_POLL
512 return 1;
513 #else
514 RETURN_NEG_1;
515 #endif
516
517 case _SC_SELECT:
518 #ifdef _POSIX_SELECT
519 return 1;
520 #else
521 RETURN_NEG_1;
522 #endif
523
524 case _SC_UIO_MAXIOV:
525 #ifdef UIO_MAXIOV
526 return UIO_MAXIOV;
527 #else
528 RETURN_NEG_1;
529 #endif
530
531 case _SC_PII_INTERNET_STREAM:
532 #ifdef _POSIX_PII_INTERNET_STREAM
533 return 1;
534 #else
535 RETURN_NEG_1;
536 #endif
537
538 case _SC_PII_INTERNET_DGRAM:
539 #ifdef _POSIX_PII_INTERNET_DGRAM
540 return 1;
541 #else
542 RETURN_NEG_1;
543 #endif
544
545 case _SC_PII_OSI_COTS:
546 #ifdef _POSIX_PII_OSI_COTS
547 return 1;
548 #else
549 RETURN_NEG_1;
550 #endif
551
552 case _SC_PII_OSI_CLTS:
553 #ifdef _POSIX_PII_OSI_CLTS
554 return 1;
555 #else
556 RETURN_NEG_1;
557 #endif
558
559 case _SC_PII_OSI_M:
560 #ifdef _POSIX_PII_OSI_M
561 return 1;
562 #else
563 RETURN_NEG_1;
564 #endif
565
566 case _SC_T_IOV_MAX:
567 #ifdef _T_IOV_MAX
568 return _T_IOV_MAX;
569 #else
570 RETURN_NEG_1;
571 #endif
572
573 case _SC_2_VERSION:
574 return _POSIX2_VERSION;
575
576 case _SC_2_C_BIND:
577 #ifdef _POSIX2_C_BIND
578 return _POSIX2_C_BIND;
579 #else
580 RETURN_NEG_1;
581 #endif
582
583 case _SC_2_C_DEV:
584 #ifdef _POSIX2_C_DEV
585 return _POSIX2_C_DEV;
586 #else
587 RETURN_NEG_1;
588 #endif
589
590 case _SC_2_C_VERSION:
591 #ifdef _POSIX2_C_VERSION
592 return _POSIX2_C_VERSION;
593 #else
594 RETURN_NEG_1;
595 #endif
596
597 case _SC_2_FORT_DEV:
598 #ifdef _POSIX2_FORT_DEV
599 return _POSIX2_FORT_DEV;
600 #else
601 RETURN_NEG_1;
602 #endif
603
604 case _SC_2_FORT_RUN:
605 #ifdef _POSIX2_FORT_RUN
606 return _POSIX2_FORT_RUN;
607 #else
608 RETURN_NEG_1;
609 #endif
610
611 case _SC_2_LOCALEDEF:
612 #ifdef _POSIX2_LOCALEDEF
613 return _POSIX2_LOCALEDEF;
614 #else
615 RETURN_NEG_1;
616 #endif
617
618 case _SC_2_SW_DEV:
619 #ifdef _POSIX2_SW_DEV
620 return _POSIX2_SW_DEV;
621 #else
622 RETURN_NEG_1;
623 #endif
624
625 case _SC_2_CHAR_TERM:
626 #ifdef _POSIX2_CHAR_TERM
627 return _POSIX2_CHAR_TERM;
628 #else
629 RETURN_NEG_1;
630 #endif
631
632 case _SC_2_UPE:
633 #ifdef _POSIX2_UPE
634 return _POSIX2_UPE;
635 #else
636 RETURN_NEG_1;
637 #endif
638
639 /* POSIX 1003.1c (POSIX Threads). */
640 case _SC_THREADS:
641 #ifdef __UCLIBC_HAS_THREADS__
642 return 1;
643 #else
644 RETURN_NEG_1;
645 #endif
646
647 case _SC_THREAD_SAFE_FUNCTIONS:
648 #ifdef __UCLIBC_HAS_THREADS__
649 return 1;
650 #else
651 RETURN_NEG_1;
652 #endif
653
654 /* If you change these, also change libc/pwd_grp/pwd_grp.c to match */
655 case _SC_GETGR_R_SIZE_MAX:
656 return __UCLIBC_GRP_BUFFER_SIZE__;
657
658 case _SC_GETPW_R_SIZE_MAX:
659 return __UCLIBC_PWD_BUFFER_SIZE__;
660
661 /* getlogin() is a worthless interface. In uClibc we let the user specify
662 * whatever they want via the LOGNAME environment variable, or we return NULL
663 * if getenv() fails to find anything. So this is merely how large a env
664 * variable can be. Lets use 256 */
665 case _SC_LOGIN_NAME_MAX:
666 return 256;
667
668 /* If you change this, also change _SC_TTY_NAME_MAX in libc/unistd/sysconf.c */
669 #define TTYNAME_BUFLEN 32
670 case _SC_TTY_NAME_MAX:
671 return TTYNAME_BUFLEN;
672
673 case _SC_THREAD_DESTRUCTOR_ITERATIONS:
674 #ifdef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
675 return _POSIX_THREAD_DESTRUCTOR_ITERATIONS;
676 #else
677 RETURN_NEG_1;
678 #endif
679
680 case _SC_THREAD_KEYS_MAX:
681 #ifdef PTHREAD_KEYS_MAX
682 return PTHREAD_KEYS_MAX;
683 #else
684 RETURN_NEG_1;
685 #endif
686
687 case _SC_THREAD_STACK_MIN:
688 #ifdef PTHREAD_STACK_MIN
689 return PTHREAD_STACK_MIN;
690 #else
691 RETURN_NEG_1;
692 #endif
693
694 case _SC_THREAD_THREADS_MAX:
695 #ifdef PTHREAD_THREADS_MAX
696 return PTHREAD_THREADS_MAX;
697 #else
698 RETURN_NEG_1;
699 #endif
700
701 case _SC_THREAD_ATTR_STACKADDR:
702 #ifdef _POSIX_THREAD_ATTR_STACKADDR
703 return 1;
704 #else
705 RETURN_NEG_1;
706 #endif
707
708 case _SC_THREAD_ATTR_STACKSIZE:
709 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
710 return 1;
711 #else
712 RETURN_NEG_1;
713 #endif
714
715 case _SC_THREAD_PRIORITY_SCHEDULING:
716 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
717 return 1;
718 #else
719 RETURN_NEG_1;
720 #endif
721
722 case _SC_THREAD_PRIO_INHERIT:
723 #ifdef _POSIX_THREAD_PRIO_INHERIT
724 return 1;
725 #else
726 RETURN_NEG_1;
727 #endif
728
729 case _SC_THREAD_PRIO_PROTECT:
730 #ifdef _POSIX_THREAD_PRIO_PROTECT
731 return 1;
732 #else
733 RETURN_NEG_1;
734 #endif
735
736 case _SC_THREAD_PROCESS_SHARED:
737 #ifdef _POSIX_THREAD_PROCESS_SHARED
738 return 1;
739 #else
740 RETURN_NEG_1;
741 #endif
742
743 case _SC_NPROCESSORS_CONF:
744 RETURN_FUNCTION(nprocessors_conf());
745
746 case _SC_NPROCESSORS_ONLN:
747 RETURN_FUNCTION(nprocessors_onln());
748
749 case _SC_PHYS_PAGES:
750 #if 0
751 RETURN_FUNCTION(get_phys_pages());
752 #else
753 RETURN_NEG_1;
754 #endif
755
756 case _SC_AVPHYS_PAGES:
757 #if 0
758 RETURN_FUNCTION(get_avphys_pages());
759 #else
760 RETURN_NEG_1;
761 #endif
762
763 case _SC_ATEXIT_MAX:
764 return __UCLIBC_MAX_ATEXIT;
765
766 case _SC_PASS_MAX:
767 /* We have no limit but since the return value might be used to
768 allocate a buffer we restrict the value. */
769 return BUFSIZ;
770
771 case _SC_XOPEN_VERSION:
772 return _XOPEN_VERSION;
773
774 case _SC_XOPEN_XCU_VERSION:
775 return _XOPEN_XCU_VERSION;
776
777 case _SC_XOPEN_UNIX:
778 return _XOPEN_UNIX;
779
780 case _SC_XOPEN_CRYPT:
781 #ifdef _XOPEN_CRYPT
782 return _XOPEN_CRYPT;
783 #else
784 RETURN_NEG_1;
785 #endif
786
787 case _SC_XOPEN_ENH_I18N:
788 #ifdef _XOPEN_ENH_I18N
789 return _XOPEN_ENH_I18N;
790 #else
791 RETURN_NEG_1;
792 #endif
793
794 case _SC_XOPEN_SHM:
795 #ifdef _XOPEN_SHM
796 return _XOPEN_SHM;
797 #else
798 RETURN_NEG_1;
799 #endif
800
801 case _SC_XOPEN_XPG2:
802 #ifdef _XOPEN_XPG2
803 return _XOPEN_XPG2;
804 #else
805 RETURN_NEG_1;
806 #endif
807
808 case _SC_XOPEN_XPG3:
809 #ifdef _XOPEN_XPG3
810 return _XOPEN_XPG3;
811 #else
812 RETURN_NEG_1;
813 #endif
814
815 case _SC_XOPEN_XPG4:
816 #ifdef _XOPEN_XPG4
817 return _XOPEN_XPG4;
818 #else
819 RETURN_NEG_1;
820 #endif
821
822 case _SC_CHAR_BIT:
823 return CHAR_BIT;
824
825 case _SC_CHAR_MAX:
826 return CHAR_MAX;
827
828 case _SC_CHAR_MIN:
829 return CHAR_MIN;
830
831 case _SC_INT_MAX:
832 return INT_MAX;
833
834 case _SC_INT_MIN:
835 return INT_MIN;
836
837 case _SC_LONG_BIT:
838 return sizeof (long int) * CHAR_BIT;
839
840 case _SC_WORD_BIT:
841 return sizeof (int) * CHAR_BIT;
842
843 case _SC_MB_LEN_MAX:
844 return MB_LEN_MAX;
845
846 case _SC_NZERO:
847 return NZERO;
848
849 case _SC_SSIZE_MAX:
850 return _POSIX_SSIZE_MAX;
851
852 case _SC_SCHAR_MAX:
853 return SCHAR_MAX;
854
855 case _SC_SCHAR_MIN:
856 return SCHAR_MIN;
857
858 case _SC_SHRT_MAX:
859 return SHRT_MAX;
860
861 case _SC_SHRT_MIN:
862 return SHRT_MIN;
863
864 case _SC_UCHAR_MAX:
865 return UCHAR_MAX;
866
867 case _SC_UINT_MAX:
868 return UINT_MAX;
869
870 case _SC_ULONG_MAX:
871 return ULONG_MAX;
872
873 case _SC_USHRT_MAX:
874 return USHRT_MAX;
875
876 case _SC_NL_ARGMAX:
877 #ifdef NL_ARGMAX
878 return NL_ARGMAX;
879 #else
880 RETURN_NEG_1;
881 #endif
882
883 case _SC_NL_LANGMAX:
884 #ifdef NL_LANGMAX
885 return NL_LANGMAX;
886 #else
887 RETURN_NEG_1;
888 #endif
889
890 case _SC_NL_MSGMAX:
891 #ifdef NL_MSGMAX
892 return NL_MSGMAX;
893 #else
894 RETURN_NEG_1;
895 #endif
896
897 case _SC_NL_NMAX:
898 #ifdef NL_NMAX
899 return NL_NMAX;
900 #else
901 RETURN_NEG_1;
902 #endif
903
904 case _SC_NL_SETMAX:
905 #ifdef NL_SETMAX
906 return NL_SETMAX;
907 #else
908 RETURN_NEG_1;
909 #endif
910
911 case _SC_NL_TEXTMAX:
912 #ifdef NL_TEXTMAX
913 return NL_TEXTMAX;
914 #else
915 RETURN_NEG_1;
916 #endif
917
918 case _SC_XBS5_ILP32_OFF32:
919 #ifdef _XBS5_ILP32_OFF32
920 return _XBS5_ILP32_OFF32;
921 #else
922 RETURN_NEG_1;
923 #endif
924 case _SC_XBS5_ILP32_OFFBIG:
925 #ifdef _XBS5_ILP32_OFFBIG
926 return _XBS5_ILP32_OFFBIG;
927 #else
928 RETURN_NEG_1;
929 #endif
930 case _SC_XBS5_LP64_OFF64:
931 #ifdef _XBS5_LP64_OFF64
932 return _XBS5_LP64_OFF64;
933 #else
934 RETURN_NEG_1;
935 #endif
936 case _SC_XBS5_LPBIG_OFFBIG:
937 #ifdef _XBS5_LPBIG_OFFBIG
938 return _XBS5_LPBIG_OFFBIG;
939 #else
940 RETURN_NEG_1;
941 #endif
942 case _SC_V7_ILP32_OFF32:
943 #ifdef _POSIX_V7_ILP32_OFF32
944 return _POSIX_V7_ILP32_OFF32;
945 #else
946 RETURN_NEG_1;
947 #endif
948 case _SC_V7_ILP32_OFFBIG:
949 #ifdef _POSIX_V7_ILP32_OFFBIG
950 return _POSIX_V7_ILP32_OFFBIG;
951 #else
952 RETURN_NEG_1;
953 #endif
954 case _SC_V7_LP64_OFF64:
955 #ifdef _POSIX_V7_LP64_OFF64
956 return _POSIX_V7_LP64_OFF64;
957 #else
958 RETURN_NEG_1;
959 #endif
960 case _SC_V7_LPBIG_OFFBIG:
961 #ifdef _POSIX_V7_LPBIG_OFFBIG
962 return _POSIX_V7_LPBIG_OFFBIG;
963 #else
964 RETURN_NEG_1;
965 #endif
966
967 case _SC_XOPEN_LEGACY:
968 return _XOPEN_LEGACY;
969
970 case _SC_XOPEN_REALTIME:
971 #ifdef _XOPEN_REALTIME
972 return _XOPEN_REALTIME;
973 #else
974 RETURN_NEG_1;
975 #endif
976 case _SC_XOPEN_REALTIME_THREADS:
977 #ifdef _XOPEN_REALTIME_THREADS
978 return _XOPEN_REALTIME_THREADS;
979 #else
980 RETURN_NEG_1;
981 #endif
982
983 case _SC_MONOTONIC_CLOCK:
984 #if defined __UCLIBC_HAS_REALTIME__ && defined __NR_clock_getres
985 if (clock_getres(CLOCK_MONOTONIC, NULL) >= 0)
986 return _POSIX_VERSION;
987 #endif
988 RETURN_NEG_1;
989
990 #ifdef __UCLIBC_HAS_THREADS_NATIVE__
991 case _SC_THREAD_CPUTIME:
992 # if _POSIX_THREAD_CPUTIME > 0
993 return _POSIX_THREAD_CPUTIME;
994 # else
995 RETURN_NEG_1;
996 # endif
997 #endif
998 }
999 }
1000 libc_hidden_def(sysconf)
1001