[BACK]Return to sysconf.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / gen

Annotation of src/lib/libc/gen/sysconf.c, Revision 1.37

1.37    ! christos    1: /*     $NetBSD: sysconf.c,v 1.36 2013/12/19 19:11:50 rmind Exp $       */
1.2       cgd         2:
1.1       cgd         3: /*-
                      4:  * Copyright (c) 1993
                      5:  *     The Regents of the University of California.  All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to Berkeley by
                      8:  * Sean Eric Fagan of Cygnus Support.
                      9:  *
                     10:  * Redistribution and use in source and binary forms, with or without
                     11:  * modification, are permitted provided that the following conditions
                     12:  * are met:
                     13:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     15:  * 2. Redistributions in binary form must reproduce the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer in the
                     17:  *    documentation and/or other materials provided with the distribution.
1.19      agc        18:  * 3. Neither the name of the University nor the names of its contributors
1.1       cgd        19:  *    may be used to endorse or promote products derived from this software
                     20:  *    without specific prior written permission.
                     21:  *
                     22:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     23:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     24:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     25:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     26:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     27:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     28:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     29:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     30:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     31:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     32:  * SUCH DAMAGE.
                     33:  */
                     34:
1.4       christos   35: #include <sys/cdefs.h>
1.1       cgd        36: #if defined(LIBC_SCCS) && !defined(lint)
1.2       cgd        37: #if 0
1.1       cgd        38: static char sccsid[] = "@(#)sysconf.c  8.2 (Berkeley) 3/20/94";
1.2       cgd        39: #else
1.37    ! christos   40: __RCSID("$NetBSD: sysconf.c,v 1.36 2013/12/19 19:11:50 rmind Exp $");
1.2       cgd        41: #endif
1.1       cgd        42: #endif /* LIBC_SCCS and not lint */
                     43:
1.5       jtc        44: #include "namespace.h"
1.1       cgd        45: #include <sys/param.h>
                     46: #include <sys/sysctl.h>
                     47: #include <sys/time.h>
                     48: #include <sys/resource.h>
                     49:
                     50: #include <errno.h>
1.21      lukem      51: #include <limits.h>
1.7       kleink     52: #include <time.h>
1.1       cgd        53: #include <unistd.h>
1.32      ad         54: #include <paths.h>
1.33      matt       55: #include <pwd.h>
1.5       jtc        56:
                     57: #ifdef __weak_alias
1.13      kleink     58: __weak_alias(sysconf,__sysconf)
1.5       jtc        59: #endif
1.1       cgd        60:
                     61: /*
                     62:  * sysconf --
                     63:  *     get configurable system variables.
                     64:  *
                     65:  * XXX
                     66:  * POSIX 1003.1 (ISO/IEC 9945-1, 4.8.1.3) states that the variable values
                     67:  * not change during the lifetime of the calling process.  This would seem
                     68:  * to require that any change to system limits kill all running processes.
                     69:  * A workaround might be to cache the values when they are first retrieved
                     70:  * and then simply return the cached value on subsequent calls.  This is
                     71:  * less useful than returning up-to-date values, however.
                     72:  */
                     73: long
1.23      rmind      74: sysconf(int name)
1.1       cgd        75: {
                     76:        struct rlimit rl;
                     77:        size_t len;
1.35      christos   78:        uint64_t mem;
1.23      rmind      79:        int mib[CTL_MAXNAME], value;
                     80:        unsigned int mib_len;
1.15      perry      81:        struct clockinfo tmpclock;
                     82:        static int clk_tck;
1.1       cgd        83:
                     84:        len = sizeof(value);
                     85:
1.23      rmind      86:        /* Default length of the MIB */
                     87:        mib_len = 2;
                     88:
1.1       cgd        89:        switch (name) {
1.20      lukem      90:
1.1       cgd        91: /* 1003.1 */
                     92:        case _SC_ARG_MAX:
                     93:                mib[0] = CTL_KERN;
                     94:                mib[1] = KERN_ARGMAX;
                     95:                break;
                     96:        case _SC_CHILD_MAX:
1.6       perry      97:                return (getrlimit(RLIMIT_NPROC, &rl) ? -1 : (long)rl.rlim_cur);
1.16      bjh21      98:        case _O_SC_CLK_TCK:
                     99:                /*
                    100:                 * For applications compiled when CLK_TCK was a compile-time
                    101:                 * constant.
                    102:                 */
                    103:                return 100;
1.1       cgd       104:        case _SC_CLK_TCK:
1.15      perry     105:                /*
                    106:                 * Has to be handled specially because it returns a
                    107:                 * struct clockinfo instead of an integer. Also, since
                    108:                 * this might be called often by some things that
                    109:                 * don't grok CLK_TCK can be a macro expanding to a
                    110:                 * function, cache the value.
                    111:                 */
                    112:                if (clk_tck == 0) {
                    113:                        mib[0] = CTL_KERN;
                    114:                        mib[1] = KERN_CLOCKRATE;
                    115:                        len = sizeof(struct clockinfo);
                    116:                        clk_tck = sysctl(mib, 2, &tmpclock, &len, NULL, 0)
                    117:                            == -1 ? -1 : tmpclock.hz;
                    118:                }
                    119:                return(clk_tck);
1.1       cgd       120:        case _SC_JOB_CONTROL:
                    121:                mib[0] = CTL_KERN;
                    122:                mib[1] = KERN_JOB_CONTROL;
                    123:                goto yesno;
                    124:        case _SC_NGROUPS_MAX:
                    125:                mib[0] = CTL_KERN;
                    126:                mib[1] = KERN_NGROUPS;
                    127:                break;
                    128:        case _SC_OPEN_MAX:
1.6       perry     129:                return (getrlimit(RLIMIT_NOFILE, &rl) ? -1 : (long)rl.rlim_cur);
1.1       cgd       130:        case _SC_STREAM_MAX:
                    131:                mib[0] = CTL_USER;
                    132:                mib[1] = USER_STREAM_MAX;
                    133:                break;
                    134:        case _SC_TZNAME_MAX:
                    135:                mib[0] = CTL_USER;
                    136:                mib[1] = USER_TZNAME_MAX;
                    137:                break;
                    138:        case _SC_SAVED_IDS:
                    139:                mib[0] = CTL_KERN;
                    140:                mib[1] = KERN_SAVED_IDS;
                    141:                goto yesno;
                    142:        case _SC_VERSION:
                    143:                mib[0] = CTL_KERN;
                    144:                mib[1] = KERN_POSIX1;
                    145:                break;
                    146:
1.8       kleink    147: /* 1003.1b */
                    148:        case _SC_PAGESIZE:
1.28      yamt      149:                return _getpagesize();
1.8       kleink    150:        case _SC_FSYNC:
                    151:                mib[0] = CTL_KERN;
                    152:                mib[1] = KERN_FSYNC;
                    153:                goto yesno;
1.9       kleink    154:        case _SC_SYNCHRONIZED_IO:
                    155:                mib[0] = CTL_KERN;
                    156:                mib[1] = KERN_SYNCHRONIZED_IO;
1.10      kleink    157:                goto yesno;
                    158:        case _SC_MAPPED_FILES:
                    159:                mib[0] = CTL_KERN;
                    160:                mib[1] = KERN_MAPPED_FILES;
                    161:                goto yesno;
                    162:        case _SC_MEMLOCK:
                    163:                mib[0] = CTL_KERN;
                    164:                mib[1] = KERN_MEMLOCK;
                    165:                goto yesno;
                    166:        case _SC_MEMLOCK_RANGE:
                    167:                mib[0] = CTL_KERN;
                    168:                mib[1] = KERN_MEMLOCK_RANGE;
                    169:                goto yesno;
                    170:        case _SC_MEMORY_PROTECTION:
                    171:                mib[0] = CTL_KERN;
                    172:                mib[1] = KERN_MEMORY_PROTECTION;
1.14      kleink    173:                goto yesno;
                    174:        case _SC_MONOTONIC_CLOCK:
                    175:                mib[0] = CTL_KERN;
                    176:                mib[1] = KERN_MONOTONIC_CLOCK;
1.9       kleink    177:                goto yesno;
1.18      kleink    178:        case _SC_SEMAPHORES:
                    179:                mib[0] = CTL_KERN;
                    180:                mib[1] = KERN_POSIX_SEMAPHORES;
                    181:                goto yesno;
                    182:        case _SC_TIMERS:
                    183:                mib[0] = CTL_KERN;
                    184:                mib[1] = KERN_POSIX_TIMERS;
                    185:                goto yesno;
1.11      kleink    186:
                    187: /* 1003.1c */
                    188:        case _SC_LOGIN_NAME_MAX:
                    189:                mib[0] = CTL_KERN;
                    190:                mib[1] = KERN_LOGIN_NAME_MAX;
                    191:                break;
1.18      kleink    192:        case _SC_THREADS:
                    193:                mib[0] = CTL_KERN;
                    194:                mib[1] = KERN_POSIX_THREADS;
                    195:                goto yesno;
                    196:
                    197: /* 1003.1j */
                    198:        case _SC_BARRIERS:
                    199:                mib[0] = CTL_KERN;
                    200:                mib[1] = KERN_POSIX_BARRIERS;
                    201:                goto yesno;
                    202:        case _SC_SPIN_LOCKS:
                    203:                mib[0] = CTL_KERN;
                    204:                mib[1] = KERN_POSIX_SPIN_LOCKS;
                    205:                goto yesno;
                    206:        /* Historical; Threads option in 1003.1-2001 */
                    207:        case _SC_READER_WRITER_LOCKS:
                    208:                mib[0] = CTL_KERN;
                    209:                mib[1] = KERN_POSIX_READER_WRITER_LOCKS;
                    210:                goto yesno;
1.8       kleink    211:
1.1       cgd       212: /* 1003.2 */
                    213:        case _SC_BC_BASE_MAX:
                    214:                mib[0] = CTL_USER;
                    215:                mib[1] = USER_BC_BASE_MAX;
                    216:                break;
                    217:        case _SC_BC_DIM_MAX:
                    218:                mib[0] = CTL_USER;
                    219:                mib[1] = USER_BC_DIM_MAX;
                    220:                break;
                    221:        case _SC_BC_SCALE_MAX:
                    222:                mib[0] = CTL_USER;
                    223:                mib[1] = USER_BC_SCALE_MAX;
                    224:                break;
                    225:        case _SC_BC_STRING_MAX:
                    226:                mib[0] = CTL_USER;
                    227:                mib[1] = USER_BC_STRING_MAX;
                    228:                break;
                    229:        case _SC_COLL_WEIGHTS_MAX:
                    230:                mib[0] = CTL_USER;
                    231:                mib[1] = USER_COLL_WEIGHTS_MAX;
                    232:                break;
                    233:        case _SC_EXPR_NEST_MAX:
                    234:                mib[0] = CTL_USER;
                    235:                mib[1] = USER_EXPR_NEST_MAX;
                    236:                break;
                    237:        case _SC_LINE_MAX:
                    238:                mib[0] = CTL_USER;
                    239:                mib[1] = USER_LINE_MAX;
                    240:                break;
                    241:        case _SC_RE_DUP_MAX:
                    242:                mib[0] = CTL_USER;
                    243:                mib[1] = USER_RE_DUP_MAX;
                    244:                break;
                    245:        case _SC_2_VERSION:
                    246:                mib[0] = CTL_USER;
                    247:                mib[1] = USER_POSIX2_VERSION;
                    248:                break;
                    249:        case _SC_2_C_BIND:
                    250:                mib[0] = CTL_USER;
                    251:                mib[1] = USER_POSIX2_C_BIND;
                    252:                goto yesno;
                    253:        case _SC_2_C_DEV:
                    254:                mib[0] = CTL_USER;
                    255:                mib[1] = USER_POSIX2_C_DEV;
                    256:                goto yesno;
                    257:        case _SC_2_CHAR_TERM:
                    258:                mib[0] = CTL_USER;
                    259:                mib[1] = USER_POSIX2_CHAR_TERM;
                    260:                goto yesno;
                    261:        case _SC_2_FORT_DEV:
                    262:                mib[0] = CTL_USER;
                    263:                mib[1] = USER_POSIX2_FORT_DEV;
                    264:                goto yesno;
                    265:        case _SC_2_FORT_RUN:
                    266:                mib[0] = CTL_USER;
                    267:                mib[1] = USER_POSIX2_FORT_RUN;
                    268:                goto yesno;
                    269:        case _SC_2_LOCALEDEF:
                    270:                mib[0] = CTL_USER;
                    271:                mib[1] = USER_POSIX2_LOCALEDEF;
                    272:                goto yesno;
                    273:        case _SC_2_SW_DEV:
                    274:                mib[0] = CTL_USER;
                    275:                mib[1] = USER_POSIX2_SW_DEV;
                    276:                goto yesno;
                    277:        case _SC_2_UPE:
                    278:                mib[0] = CTL_USER;
                    279:                mib[1] = USER_POSIX2_UPE;
1.8       kleink    280:                goto yesno;
                    281:
                    282: /* XPG 4.2 */
1.9       kleink    283:        case _SC_IOV_MAX:
                    284:                mib[0] = CTL_KERN;
                    285:                mib[1] = KERN_IOV_MAX;
                    286:                break;
1.8       kleink    287:        case _SC_XOPEN_SHM:
                    288:                mib[0] = CTL_KERN;
1.22      christos  289:                mib[1] = KERN_SYSVIPC;
                    290:                mib[2] = KERN_SYSVIPC_SHM;
1.23      rmind     291:                mib_len = 3;
                    292:                goto yesno;
1.17      kleink    293:
                    294: /* 1003.1-2001, XSI Option Group */
1.23      rmind     295:        case _SC_AIO_LISTIO_MAX:
                    296:                if (sysctlgetmibinfo("kern.aio_listio_max", &mib[0], &mib_len,
                    297:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    298:                        return -1;
                    299:                break;
                    300:        case _SC_AIO_MAX:
                    301:                if (sysctlgetmibinfo("kern.aio_max", &mib[0], &mib_len,
                    302:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    303:                        return -1;
                    304:                break;
                    305:        case _SC_ASYNCHRONOUS_IO:
                    306:                if (sysctlgetmibinfo("kern.posix_aio", &mib[0], &mib_len,
                    307:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    308:                        return -1;
                    309:                goto yesno;
1.24      rmind     310:        case _SC_MESSAGE_PASSING:
                    311:                if (sysctlgetmibinfo("kern.posix_msg", &mib[0], &mib_len,
                    312:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    313:                        return -1;
                    314:                goto yesno;
                    315:        case _SC_MQ_OPEN_MAX:
1.29      njoly     316:                if (sysctlgetmibinfo("kern.mqueue.mq_open_max", &mib[0],
                    317:                    &mib_len, NULL, NULL, NULL, SYSCTL_VERSION))
1.24      rmind     318:                        return -1;
                    319:                break;
                    320:        case _SC_MQ_PRIO_MAX:
1.29      njoly     321:                if (sysctlgetmibinfo("kern.mqueue.mq_prio_max", &mib[0],
                    322:                    &mib_len, NULL, NULL, NULL, SYSCTL_VERSION))
1.24      rmind     323:                        return -1;
                    324:                break;
1.26      rmind     325:        case _SC_PRIORITY_SCHEDULING:
                    326:                if (sysctlgetmibinfo("kern.posix_sched", &mib[0], &mib_len,
                    327:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    328:                        return -1;
                    329:                goto yesno;
1.17      kleink    330:        case _SC_ATEXIT_MAX:
                    331:                mib[0] = CTL_USER;
                    332:                mib[1] = USER_ATEXIT_MAX;
                    333:                break;
                    334:
1.20      lukem     335: /* 1003.1-2001, TSF */
                    336:        case _SC_GETGR_R_SIZE_MAX:
                    337:                return _GETGR_R_SIZE_MAX;
                    338:        case _SC_GETPW_R_SIZE_MAX:
                    339:                return _GETPW_R_SIZE_MAX;
                    340:
1.33      matt      341: /* Unsorted */
                    342:        case _SC_HOST_NAME_MAX:
                    343:                return MAXHOSTNAMELEN;
                    344:        case _SC_PASS_MAX:
                    345:                return _PASSWORD_LEN;
                    346:        case _SC_REGEXP:
                    347:                return _POSIX_REGEXP;
1.36      rmind     348:        case _SC_SHARED_MEMORY_OBJECTS:
                    349:                return _POSIX_SHARED_MEMORY_OBJECTS;
1.33      matt      350:        case _SC_SHELL:
                    351:                return _POSIX_SHELL;
1.34      martin    352:        case _SC_SPAWN:
                    353:                return _POSIX_SPAWN;
1.33      matt      354:        case _SC_SYMLOOP_MAX:
                    355:                return MAXSYMLINKS;
                    356:
1.23      rmind     357: yesno:         if (sysctl(mib, mib_len, &value, &len, NULL, 0) == -1)
1.1       cgd       358:                        return (-1);
                    359:                if (value == 0)
                    360:                        return (-1);
                    361:                return (value);
1.25      ad        362:
                    363: /* Extensions */
                    364:        case _SC_NPROCESSORS_CONF:
                    365:                mib[0] = CTL_HW;
                    366:                mib[1] = HW_NCPU;
                    367:                break;
                    368:        case _SC_NPROCESSORS_ONLN:
                    369:                mib[0] = CTL_HW;
                    370:                mib[1] = HW_NCPUONLINE;
                    371:                break;
                    372:
1.35      christos  373: /* Linux/Solaris */
                    374:        case _SC_PHYS_PAGES:
                    375:                len = sizeof(mem);
                    376:                mib[0] = CTL_HW;
                    377:                mib[1] = HW_PHYSMEM64;
                    378:                return sysctl(mib, 2, &mem, &len, NULL, 0) == -1 ? -1 :
                    379:                    (long)(mem / _getpagesize());
                    380:
1.26      rmind     381: /* Native */
                    382:        case _SC_SCHED_RT_TS:
1.27      rmind     383:                if (sysctlgetmibinfo("kern.sched.rtts", &mib[0], &mib_len,
1.26      rmind     384:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    385:                        return -1;
                    386:                break;
                    387:        case _SC_SCHED_PRI_MIN:
                    388:                if (sysctlgetmibinfo("kern.sched.pri_min", &mib[0], &mib_len,
                    389:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    390:                        return -1;
                    391:                break;
                    392:        case _SC_SCHED_PRI_MAX:
                    393:                if (sysctlgetmibinfo("kern.sched.pri_max", &mib[0], &mib_len,
                    394:                    NULL, NULL, NULL, SYSCTL_VERSION))
                    395:                        return -1;
                    396:                break;
1.30      ad        397:        case _SC_THREAD_DESTRUCTOR_ITERATIONS:
                    398:                return _POSIX_THREAD_DESTRUCTOR_ITERATIONS;
                    399:        case _SC_THREAD_KEYS_MAX:
                    400:                return _POSIX_THREAD_KEYS_MAX;
                    401:        case _SC_THREAD_STACK_MIN:
                    402:                return _getpagesize();
                    403:        case _SC_THREAD_THREADS_MAX:
                    404:                if (sysctlgetmibinfo("kern.maxproc", &mib[0], &mib_len,
                    405:                    NULL, NULL, NULL, SYSCTL_VERSION))  /* XXX */
                    406:                        return -1;
                    407:                goto yesno;
                    408:        case _SC_THREAD_ATTR_STACKADDR:
                    409:                return _POSIX_THREAD_ATTR_STACKADDR;
                    410:        case _SC_THREAD_ATTR_STACKSIZE:
                    411:                return _POSIX_THREAD_ATTR_STACKSIZE;
                    412:        case _SC_THREAD_SAFE_FUNCTIONS:
                    413:                return _POSIX_THREAD_SAFE_FUNCTIONS;
                    414:        case _SC_THREAD_PRIORITY_SCHEDULING:
                    415:        case _SC_THREAD_PRIO_INHERIT:
                    416:        case _SC_THREAD_PRIO_PROTECT:
                    417:        case _SC_THREAD_PROCESS_SHARED:
1.31      ad        418:                return -1;
1.32      ad        419:        case _SC_TTY_NAME_MAX:
                    420:                return pathconf(_PATH_DEV, _PC_NAME_MAX);
1.37    ! christos  421:        case _SC_TIMER_MAX:
        !           422:                return _POSIX_TIMER_MAX;
1.1       cgd       423:        default:
                    424:                errno = EINVAL;
                    425:                return (-1);
                    426:        }
1.23      rmind     427:        return (sysctl(mib, mib_len, &value, &len, NULL, 0) == -1 ? -1 : value);
1.1       cgd       428: }

CVSweb <webmaster@jp.NetBSD.org>