libc/unistd/sysconf.c

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