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