Commit | Line | Data |
---|---|---|
984263bc MD |
1 | /*- |
2 | * Copyright (c) 1993 | |
3 | * The Regents of the University of California. All rights reserved. | |
4 | * | |
5 | * This code is derived from software contributed to Berkeley by | |
6 | * Sean Eric Fagan of Cygnus Support. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * 1. Redistributions of source code must retain the above copyright | |
12 | * notice, this list of conditions and the following disclaimer. | |
13 | * 2. Redistributions in binary form must reproduce the above copyright | |
14 | * notice, this list of conditions and the following disclaimer in the | |
15 | * documentation and/or other materials provided with the distribution. | |
dc71b7ab | 16 | * 3. Neither the name of the University nor the names of its contributors |
984263bc MD |
17 | * may be used to endorse or promote products derived from this software |
18 | * without specific prior written permission. | |
19 | * | |
20 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
21 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
22 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
23 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
24 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
25 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
26 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
27 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
28 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
29 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
30 | * SUCH DAMAGE. | |
1de703da MD |
31 | * |
32 | * @(#)sysconf.c 8.2 (Berkeley) 3/20/94 | |
9d66746c | 33 | * $FreeBSD: src/lib/libc/gen/sysconf.c,v 1.26 2008/02/27 05:56:57 wollman Exp $ |
984263bc MD |
34 | */ |
35 | ||
806a5ed7 | 36 | #include "namespace.h" |
984263bc MD |
37 | #include <sys/param.h> |
38 | #include <sys/time.h> | |
39 | #include <sys/sysctl.h> | |
40 | #include <sys/resource.h> | |
9d66746c | 41 | #include <sys/socket.h> |
984263bc MD |
42 | |
43 | #include <errno.h> | |
9d66746c PA |
44 | #include <limits.h> |
45 | #include <paths.h> | |
46 | #include <pthread.h> /* we just need the limits */ | |
94f03308 | 47 | #include <semaphore.h> |
984263bc MD |
48 | #include <time.h> |
49 | #include <unistd.h> | |
806a5ed7 | 50 | #include "un-namespace.h" |
984263bc | 51 | |
9d66746c PA |
52 | #include "../stdlib/atexit.h" |
53 | #include "../stdtime/tzfile.h" | |
54 | ||
55 | #define _PATH_ZONEINFO TZDIR /* from tzfile.h */ | |
56 | ||
984263bc MD |
57 | /* |
58 | * sysconf -- | |
59 | * get configurable system variables. | |
60 | * | |
61 | * XXX | |
62 | * POSIX 1003.1 (ISO/IEC 9945-1, 4.8.1.3) states that the variable values | |
63 | * not change during the lifetime of the calling process. This would seem | |
64 | * to require that any change to system limits kill all running processes. | |
65 | * A workaround might be to cache the values when they are first retrieved | |
66 | * and then simply return the cached value on subsequent calls. This is | |
67 | * less useful than returning up-to-date values, however. | |
68 | */ | |
69 | long | |
0f52d283 | 70 | sysconf(int name) |
984263bc MD |
71 | { |
72 | struct rlimit rl; | |
73 | size_t len; | |
9d66746c PA |
74 | int mib[2], sverrno, value; |
75 | long lvalue, defaultresult; | |
76 | const char *path; | |
984263bc | 77 | |
984263bc MD |
78 | defaultresult = -1; |
79 | ||
80 | switch (name) { | |
984263bc MD |
81 | case _SC_ARG_MAX: |
82 | mib[0] = CTL_KERN; | |
83 | mib[1] = KERN_ARGMAX; | |
84 | break; | |
85 | case _SC_CHILD_MAX: | |
9d66746c PA |
86 | if (getrlimit(RLIMIT_NPROC, &rl) != 0) |
87 | return (-1); | |
88 | if (rl.rlim_cur == RLIM_INFINITY) | |
89 | return (-1); | |
90 | if (rl.rlim_cur > LONG_MAX) { | |
91 | errno = EOVERFLOW; | |
92 | return (-1); | |
93 | } | |
94 | return ((long)rl.rlim_cur); | |
984263bc MD |
95 | case _SC_CLK_TCK: |
96 | return (CLK_TCK); | |
984263bc MD |
97 | case _SC_NGROUPS_MAX: |
98 | mib[0] = CTL_KERN; | |
99 | mib[1] = KERN_NGROUPS; | |
100 | break; | |
101 | case _SC_OPEN_MAX: | |
9d66746c PA |
102 | if (getrlimit(RLIMIT_NOFILE, &rl) != 0) |
103 | return (-1); | |
104 | if (rl.rlim_cur == RLIM_INFINITY) | |
105 | return (-1); | |
106 | if (rl.rlim_cur > LONG_MAX) { | |
107 | errno = EOVERFLOW; | |
108 | return (-1); | |
109 | } | |
110 | return ((long)rl.rlim_cur); | |
94f03308 SW |
111 | case _SC_SEM_VALUE_MAX: |
112 | return (SEM_VALUE_MAX); | |
984263bc | 113 | case _SC_STREAM_MAX: |
9d66746c PA |
114 | if (getrlimit(RLIMIT_NOFILE, &rl) != 0) |
115 | return (-1); | |
116 | if (rl.rlim_cur == RLIM_INFINITY) | |
117 | return (-1); | |
118 | if (rl.rlim_cur > LONG_MAX) { | |
119 | errno = EOVERFLOW; | |
120 | return (-1); | |
121 | } | |
122 | /* | |
123 | * struct __sFILE currently has a limitation that | |
124 | * file descriptors must fit in a signed short. | |
125 | * This doesn't precisely capture the letter of POSIX | |
126 | * but approximates the spirit. | |
127 | */ | |
128 | if (rl.rlim_cur > SHRT_MAX) | |
129 | return (SHRT_MAX); | |
130 | ||
131 | return ((long)rl.rlim_cur); | |
132 | case _SC_JOB_CONTROL: | |
133 | return (_POSIX_JOB_CONTROL); | |
984263bc | 134 | case _SC_SAVED_IDS: |
9d66746c | 135 | /* XXX - must be 1 */ |
984263bc MD |
136 | mib[0] = CTL_KERN; |
137 | mib[1] = KERN_SAVED_IDS; | |
138 | goto yesno; | |
139 | case _SC_VERSION: | |
140 | mib[0] = CTL_KERN; | |
141 | mib[1] = KERN_POSIX1; | |
142 | break; | |
984263bc | 143 | case _SC_BC_BASE_MAX: |
9d66746c | 144 | return (BC_BASE_MAX); |
984263bc | 145 | case _SC_BC_DIM_MAX: |
9d66746c | 146 | return (BC_DIM_MAX); |
984263bc | 147 | case _SC_BC_SCALE_MAX: |
9d66746c | 148 | return (BC_SCALE_MAX); |
984263bc | 149 | case _SC_BC_STRING_MAX: |
9d66746c | 150 | return (BC_STRING_MAX); |
984263bc | 151 | case _SC_COLL_WEIGHTS_MAX: |
9d66746c | 152 | return (COLL_WEIGHTS_MAX); |
984263bc | 153 | case _SC_EXPR_NEST_MAX: |
9d66746c | 154 | return (EXPR_NEST_MAX); |
984263bc | 155 | case _SC_LINE_MAX: |
9d66746c | 156 | return (LINE_MAX); |
984263bc | 157 | case _SC_RE_DUP_MAX: |
9d66746c | 158 | return (RE_DUP_MAX); |
984263bc | 159 | case _SC_2_VERSION: |
9d66746c PA |
160 | /* |
161 | * This is something of a lie, but it would be silly at | |
162 | * this point to try to deduce this from the contents | |
163 | * of the filesystem. | |
164 | */ | |
165 | return (_POSIX2_VERSION); | |
984263bc | 166 | case _SC_2_C_BIND: |
9d66746c | 167 | return (_POSIX2_C_BIND); |
984263bc | 168 | case _SC_2_C_DEV: |
9d66746c | 169 | return (_POSIX2_C_DEV); |
984263bc | 170 | case _SC_2_CHAR_TERM: |
9d66746c | 171 | return (_POSIX2_CHAR_TERM); |
984263bc | 172 | case _SC_2_FORT_DEV: |
9d66746c | 173 | return (_POSIX2_FORT_DEV); |
984263bc | 174 | case _SC_2_FORT_RUN: |
9d66746c | 175 | return (_POSIX2_FORT_RUN); |
984263bc | 176 | case _SC_2_LOCALEDEF: |
9d66746c | 177 | return (_POSIX2_LOCALEDEF); |
984263bc | 178 | case _SC_2_SW_DEV: |
9d66746c | 179 | return (_POSIX2_SW_DEV); |
984263bc | 180 | case _SC_2_UPE: |
9d66746c PA |
181 | return (_POSIX2_UPE); |
182 | case _SC_TZNAME_MAX: | |
183 | path = _PATH_ZONEINFO; | |
184 | do_NAME_MAX: | |
185 | sverrno = errno; | |
186 | errno = 0; | |
187 | lvalue = pathconf(path, _PC_NAME_MAX); | |
188 | if (lvalue == -1 && errno != 0) | |
189 | return (-1); | |
190 | errno = sverrno; | |
191 | return (lvalue); | |
984263bc MD |
192 | |
193 | case _SC_ASYNCHRONOUS_IO: | |
9d66746c | 194 | #if _POSIX_ASYNCHRONOUS_IO == 0 |
984263bc MD |
195 | mib[0] = CTL_P1003_1B; |
196 | mib[1] = CTL_P1003_1B_ASYNCHRONOUS_IO; | |
9d66746c PA |
197 | break; |
198 | #else | |
199 | return (_POSIX_ASYNCHRONOUS_IO); | |
200 | #endif | |
984263bc | 201 | case _SC_MAPPED_FILES: |
9d66746c | 202 | return (_POSIX_MAPPED_FILES); |
984263bc | 203 | case _SC_MEMLOCK: |
9d66746c | 204 | return (_POSIX_MEMLOCK); |
984263bc | 205 | case _SC_MEMLOCK_RANGE: |
9d66746c | 206 | return (_POSIX_MEMLOCK_RANGE); |
984263bc | 207 | case _SC_MEMORY_PROTECTION: |
9d66746c | 208 | return (_POSIX_MEMORY_PROTECTION); |
984263bc | 209 | case _SC_MESSAGE_PASSING: |
9d66746c | 210 | return (_POSIX_MESSAGE_PASSING); |
984263bc | 211 | case _SC_PRIORITIZED_IO: |
9d66746c | 212 | #if _POSIX_PRIORITIZED_IO == 0 |
984263bc MD |
213 | mib[0] = CTL_P1003_1B; |
214 | mib[1] = CTL_P1003_1B_PRIORITIZED_IO; | |
215 | goto yesno; | |
9d66746c PA |
216 | #else |
217 | return (_POSIX_PRIORITIZED_IO); | |
218 | #endif | |
984263bc | 219 | case _SC_PRIORITY_SCHEDULING: |
9d66746c | 220 | #if _POSIX_PRIORITY_SCHEDULING == 0 |
984263bc MD |
221 | mib[0] = CTL_P1003_1B; |
222 | mib[1] = CTL_P1003_1B_PRIORITY_SCHEDULING; | |
223 | goto yesno; | |
9d66746c PA |
224 | #else |
225 | return (_POSIX_PRIORITY_SCHEDULING); | |
226 | #endif | |
984263bc | 227 | case _SC_REALTIME_SIGNALS: |
9d66746c | 228 | #if _POSIX_REALTIME_SIGNALS == 0 |
984263bc MD |
229 | mib[0] = CTL_P1003_1B; |
230 | mib[1] = CTL_P1003_1B_REALTIME_SIGNALS; | |
231 | goto yesno; | |
9d66746c PA |
232 | #else |
233 | return (_POSIX_REALTIME_SIGNALS); | |
234 | #endif | |
984263bc | 235 | case _SC_SEMAPHORES: |
9d66746c | 236 | #if _POSIX_SEMAPHORES == 0 |
984263bc MD |
237 | mib[0] = CTL_P1003_1B; |
238 | mib[1] = CTL_P1003_1B_SEMAPHORES; | |
239 | goto yesno; | |
9d66746c PA |
240 | #else |
241 | return (_POSIX_SEMAPHORES); | |
242 | #endif | |
984263bc | 243 | case _SC_FSYNC: |
9d66746c PA |
244 | return (_POSIX_FSYNC); |
245 | ||
984263bc | 246 | case _SC_SHARED_MEMORY_OBJECTS: |
9d66746c | 247 | return (_POSIX_SHARED_MEMORY_OBJECTS); |
984263bc | 248 | case _SC_SYNCHRONIZED_IO: |
9d66746c | 249 | #if _POSIX_SYNCHRONIZED_IO == 0 |
984263bc MD |
250 | mib[0] = CTL_P1003_1B; |
251 | mib[1] = CTL_P1003_1B_SYNCHRONIZED_IO; | |
252 | goto yesno; | |
9d66746c PA |
253 | #else |
254 | return (_POSIX_SYNCHRONIZED_IO); | |
255 | #endif | |
984263bc | 256 | case _SC_TIMERS: |
9d66746c | 257 | #if _POSIX_TIMERS == 0 |
984263bc MD |
258 | mib[0] = CTL_P1003_1B; |
259 | mib[1] = CTL_P1003_1B_TIMERS; | |
260 | goto yesno; | |
9d66746c PA |
261 | #else |
262 | return (_POSIX_TIMERS); | |
263 | #endif | |
984263bc MD |
264 | case _SC_AIO_LISTIO_MAX: |
265 | mib[0] = CTL_P1003_1B; | |
266 | mib[1] = CTL_P1003_1B_AIO_LISTIO_MAX; | |
9d66746c | 267 | break; |
984263bc MD |
268 | case _SC_AIO_MAX: |
269 | mib[0] = CTL_P1003_1B; | |
270 | mib[1] = CTL_P1003_1B_AIO_MAX; | |
9d66746c | 271 | break; |
984263bc MD |
272 | case _SC_AIO_PRIO_DELTA_MAX: |
273 | mib[0] = CTL_P1003_1B; | |
274 | mib[1] = CTL_P1003_1B_AIO_PRIO_DELTA_MAX; | |
9d66746c | 275 | break; |
984263bc MD |
276 | case _SC_DELAYTIMER_MAX: |
277 | mib[0] = CTL_P1003_1B; | |
278 | mib[1] = CTL_P1003_1B_DELAYTIMER_MAX; | |
279 | goto yesno; | |
984263bc MD |
280 | case _SC_PAGESIZE: |
281 | defaultresult = getpagesize(); | |
282 | mib[0] = CTL_P1003_1B; | |
283 | mib[1] = CTL_P1003_1B_PAGESIZE; | |
284 | goto yesno; | |
285 | case _SC_RTSIG_MAX: | |
286 | mib[0] = CTL_P1003_1B; | |
287 | mib[1] = CTL_P1003_1B_RTSIG_MAX; | |
288 | goto yesno; | |
289 | case _SC_SEM_NSEMS_MAX: | |
290 | mib[0] = CTL_P1003_1B; | |
291 | mib[1] = CTL_P1003_1B_SEM_NSEMS_MAX; | |
292 | goto yesno; | |
984263bc MD |
293 | case _SC_SIGQUEUE_MAX: |
294 | mib[0] = CTL_P1003_1B; | |
295 | mib[1] = CTL_P1003_1B_SIGQUEUE_MAX; | |
296 | goto yesno; | |
297 | case _SC_TIMER_MAX: | |
298 | mib[0] = CTL_P1003_1B; | |
299 | mib[1] = CTL_P1003_1B_TIMER_MAX; | |
9d66746c PA |
300 | yesno: |
301 | len = sizeof(value); | |
302 | if (sysctl(mib, 2, &value, &len, NULL, 0) == -1) | |
303 | return (-1); | |
304 | if (value == 0) | |
305 | return (defaultresult); | |
306 | return ((long)value); | |
307 | ||
308 | case _SC_2_PBS: | |
309 | case _SC_2_PBS_ACCOUNTING: | |
310 | case _SC_2_PBS_CHECKPOINT: | |
311 | case _SC_2_PBS_LOCATE: | |
312 | case _SC_2_PBS_MESSAGE: | |
313 | case _SC_2_PBS_TRACK: | |
314 | #if _POSIX2_PBS == 0 | |
315 | #error "don't know how to determine _SC_2_PBS" | |
316 | /* | |
317 | * This probably requires digging through the filesystem | |
318 | * to see if the appropriate package has been installed. | |
319 | * Since we don't currently support this option at all, | |
320 | * it's not worth the effort to write the code now. | |
321 | * Figuring out which of the sub-options are supported | |
322 | * would be even more difficult, so it's probably easier | |
323 | * to always say ``no''. | |
324 | */ | |
325 | #else | |
326 | return (_POSIX2_PBS); | |
327 | #endif | |
328 | case _SC_ADVISORY_INFO: | |
329 | #if _POSIX_ADVISORY_INFO == 0 | |
330 | #error "_POSIX_ADVISORY_INFO" | |
331 | #else | |
332 | return (_POSIX_ADVISORY_INFO); | |
333 | #endif | |
334 | case _SC_BARRIERS: | |
335 | #if _POSIX_BARRIERS == 0 | |
336 | #error "_POSIX_BARRIERS" | |
337 | #else | |
338 | return (_POSIX_BARRIERS); | |
339 | #endif | |
340 | case _SC_CLOCK_SELECTION: | |
341 | #if _POSIX_CLOCK_SELECTION == 0 | |
342 | #error "_POSIX_CLOCK_SELECTION" | |
343 | #else | |
344 | return (_POSIX_CLOCK_SELECTION); | |
345 | #endif | |
346 | case _SC_CPUTIME: | |
347 | #if _POSIX_CPUTIME == 0 | |
348 | #error "_POSIX_CPUTIME" | |
349 | #else | |
350 | return (_POSIX_CPUTIME); | |
351 | #endif | |
352 | #ifdef notdef | |
353 | case _SC_FILE_LOCKING: | |
354 | /* | |
355 | * XXX - The standard doesn't tell us how to define | |
356 | * _POSIX_FILE_LOCKING, so we can't answer this one. | |
357 | */ | |
358 | #endif | |
9d66746c PA |
359 | case _SC_GETGR_R_SIZE_MAX: |
360 | case _SC_GETPW_R_SIZE_MAX: | |
10afbee5 | 361 | return (-1); |
9d66746c PA |
362 | case _SC_HOST_NAME_MAX: |
363 | return (MAXHOSTNAMELEN - 1); /* does not include \0 */ | |
364 | case _SC_LOGIN_NAME_MAX: | |
365 | return (MAXLOGNAME); | |
366 | case _SC_MONOTONIC_CLOCK: | |
367 | #if _POSIX_MONOTONIC_CLOCK == 0 | |
368 | #error "_POSIX_MONOTONIC_CLOCK" | |
369 | #else | |
370 | return (_POSIX_MONOTONIC_CLOCK); | |
371 | #endif | |
60601fa0 SK |
372 | case _SC_MQ_OPEN_MAX: |
373 | len = sizeof(lvalue); | |
374 | if (sysctlbyname("kern.mqueue.mq_open_max", &lvalue, &len, | |
375 | NULL, 0) == -1) | |
376 | return (-1); | |
d8c823ac SK |
377 | return (lvalue); |
378 | ||
9d66746c | 379 | case _SC_MQ_PRIO_MAX: |
d2506be8 SK |
380 | len = sizeof(lvalue); |
381 | if (sysctlbyname("kern.mqueue.mq_prio_max", &lvalue, &len, | |
382 | NULL, 0) == -1) | |
383 | return (-1); | |
384 | return (lvalue); | |
385 | ||
9d66746c PA |
386 | case _SC_READER_WRITER_LOCKS: |
387 | return (_POSIX_READER_WRITER_LOCKS); | |
388 | case _SC_REGEXP: | |
389 | return (_POSIX_REGEXP); | |
390 | case _SC_SHELL: | |
391 | return (_POSIX_SHELL); | |
392 | case _SC_SPAWN: | |
393 | return (_POSIX_SPAWN); | |
394 | case _SC_SPIN_LOCKS: | |
395 | return (_POSIX_SPIN_LOCKS); | |
396 | case _SC_SPORADIC_SERVER: | |
397 | #if _POSIX_SPORADIC_SERVER == 0 | |
398 | #error "_POSIX_SPORADIC_SERVER" | |
399 | #else | |
400 | return (_POSIX_SPORADIC_SERVER); | |
401 | #endif | |
402 | case _SC_THREAD_ATTR_STACKADDR: | |
403 | return (_POSIX_THREAD_ATTR_STACKADDR); | |
404 | case _SC_THREAD_ATTR_STACKSIZE: | |
405 | return (_POSIX_THREAD_ATTR_STACKSIZE); | |
406 | case _SC_THREAD_CPUTIME: | |
407 | return (_POSIX_THREAD_CPUTIME); | |
408 | case _SC_THREAD_DESTRUCTOR_ITERATIONS: | |
409 | return (PTHREAD_DESTRUCTOR_ITERATIONS); | |
410 | case _SC_THREAD_KEYS_MAX: | |
411 | return (PTHREAD_KEYS_MAX); | |
412 | case _SC_THREAD_PRIO_INHERIT: | |
413 | return (_POSIX_THREAD_PRIO_INHERIT); | |
414 | case _SC_THREAD_PRIO_PROTECT: | |
415 | return (_POSIX_THREAD_PRIO_PROTECT); | |
416 | case _SC_THREAD_PRIORITY_SCHEDULING: | |
417 | return (_POSIX_THREAD_PRIORITY_SCHEDULING); | |
418 | case _SC_THREAD_PROCESS_SHARED: | |
419 | return (_POSIX_THREAD_PROCESS_SHARED); | |
4c2cc5d2 SW |
420 | case _SC_THREAD_ROBUST_PRIO_INHERIT: |
421 | return (_POSIX_THREAD_ROBUST_PRIO_INHERIT); | |
422 | case _SC_THREAD_ROBUST_PRIO_PROTECT: | |
423 | return (_POSIX_THREAD_ROBUST_PRIO_PROTECT); | |
9d66746c PA |
424 | case _SC_THREAD_SAFE_FUNCTIONS: |
425 | return (_POSIX_THREAD_SAFE_FUNCTIONS); | |
ded2cbe5 SW |
426 | case _SC_THREAD_SPORADIC_SERVER: |
427 | return (_POSIX_THREAD_SPORADIC_SERVER); | |
9d66746c PA |
428 | case _SC_THREAD_STACK_MIN: |
429 | return (PTHREAD_STACK_MIN); | |
430 | case _SC_THREAD_THREADS_MAX: | |
431 | return (PTHREAD_THREADS_MAX); /* XXX wrong type! */ | |
432 | case _SC_TIMEOUTS: | |
433 | return (_POSIX_TIMEOUTS); | |
434 | case _SC_THREADS: | |
435 | return (_POSIX_THREADS); | |
436 | case _SC_TRACE: | |
437 | #if _POSIX_TRACE == 0 | |
438 | #error "_POSIX_TRACE" | |
439 | /* While you're implementing this, also do the ones below. */ | |
440 | #else | |
441 | return (_POSIX_TRACE); | |
442 | #endif | |
443 | #if _POSIX_TRACE > -1 | |
444 | case _SC_TRACE_EVENT_FILTER: | |
445 | return (_POSIX_TRACE_EVENT_FILTER); | |
446 | case _SC_TRACE_INHERIT: | |
447 | return (_POSIX_TRACE_INHERIT); | |
448 | case _SC_TRACE_LOG: | |
449 | return (_POSIX_TRACE_LOG); | |
450 | #endif | |
451 | case _SC_TTY_NAME_MAX: | |
452 | path = _PATH_DEV; | |
453 | goto do_NAME_MAX; | |
454 | case _SC_TYPED_MEMORY_OBJECTS: | |
455 | #if _POSIX_TYPED_MEMORY_OBJECTS == 0 | |
456 | #error "_POSIX_TYPED_MEMORY_OBJECTS" | |
457 | #else | |
458 | return (_POSIX_TYPED_MEMORY_OBJECTS); | |
459 | #endif | |
460 | case _SC_V6_ILP32_OFF32: | |
461 | #if _V6_ILP32_OFF32 == 0 | |
462 | if (sizeof(int) * CHAR_BIT == 32 && | |
463 | sizeof(int) == sizeof(long) && | |
464 | sizeof(long) == sizeof(void *) && | |
465 | sizeof(void *) == sizeof(off_t)) | |
466 | return 1; | |
467 | else | |
468 | return -1; | |
469 | #else | |
470 | return (_V6_ILP32_OFF32); | |
471 | #endif | |
472 | case _SC_V6_ILP32_OFFBIG: | |
473 | #if _V6_ILP32_OFFBIG == 0 | |
474 | if (sizeof(int) * CHAR_BIT == 32 && | |
475 | sizeof(int) == sizeof(long) && | |
476 | sizeof(long) == sizeof(void *) && | |
477 | sizeof(off_t) * CHAR_BIT >= 64) | |
478 | return 1; | |
479 | else | |
480 | return -1; | |
481 | #else | |
482 | return (_V6_ILP32_OFFBIG); | |
483 | #endif | |
484 | case _SC_V6_LP64_OFF64: | |
485 | #if _V6_LP64_OFF64 == 0 | |
486 | if (sizeof(int) * CHAR_BIT == 32 && | |
487 | sizeof(long) * CHAR_BIT == 64 && | |
488 | sizeof(long) == sizeof(void *) && | |
489 | sizeof(void *) == sizeof(off_t)) | |
490 | return 1; | |
491 | else | |
492 | return -1; | |
493 | #else | |
494 | return (_V6_LP64_OFF64); | |
495 | #endif | |
496 | case _SC_V6_LPBIG_OFFBIG: | |
497 | #if _V6_LPBIG_OFFBIG == 0 | |
498 | if (sizeof(int) * CHAR_BIT >= 32 && | |
499 | sizeof(long) * CHAR_BIT >= 64 && | |
500 | sizeof(void *) * CHAR_BIT >= 64 && | |
501 | sizeof(off_t) * CHAR_BIT >= 64) | |
502 | return 1; | |
503 | else | |
504 | return -1; | |
505 | #else | |
506 | return (_V6_LPBIG_OFFBIG); | |
84b31f29 SW |
507 | #endif |
508 | case _SC_V7_ILP32_OFF32: | |
509 | #if _V7_ILP32_OFF32 == 0 | |
510 | if (sizeof(int) * CHAR_BIT == 32 && | |
511 | sizeof(int) == sizeof(long) && | |
512 | sizeof(long) == sizeof(void *) && | |
513 | sizeof(void *) == sizeof(off_t)) | |
514 | return 1; | |
515 | else | |
516 | return -1; | |
517 | #else | |
518 | return (_V7_ILP32_OFF32); | |
519 | #endif | |
520 | case _SC_V7_ILP32_OFFBIG: | |
521 | #if _V7_ILP32_OFFBIG == 0 | |
522 | if (sizeof(int) * CHAR_BIT == 32 && | |
523 | sizeof(int) == sizeof(long) && | |
524 | sizeof(long) == sizeof(void *) && | |
525 | sizeof(off_t) * CHAR_BIT >= 64) | |
526 | return 1; | |
527 | else | |
528 | return -1; | |
529 | #else | |
530 | return (_V7_ILP32_OFFBIG); | |
531 | #endif | |
532 | case _SC_V7_LP64_OFF64: | |
533 | #if _V7_LP64_OFF64 == 0 | |
534 | if (sizeof(int) * CHAR_BIT == 32 && | |
535 | sizeof(long) * CHAR_BIT == 64 && | |
536 | sizeof(long) == sizeof(void *) && | |
537 | sizeof(void *) == sizeof(off_t)) | |
538 | return 1; | |
539 | else | |
540 | return -1; | |
541 | #else | |
542 | return (_V7_LP64_OFF64); | |
543 | #endif | |
544 | case _SC_V7_LPBIG_OFFBIG: | |
545 | #if _V7_LPBIG_OFFBIG == 0 | |
546 | if (sizeof(int) * CHAR_BIT >= 32 && | |
547 | sizeof(long) * CHAR_BIT >= 64 && | |
548 | sizeof(void *) * CHAR_BIT >= 64 && | |
549 | sizeof(off_t) * CHAR_BIT >= 64) | |
550 | return 1; | |
551 | else | |
552 | return -1; | |
553 | #else | |
554 | return (_V7_LPBIG_OFFBIG); | |
9d66746c PA |
555 | #endif |
556 | case _SC_ATEXIT_MAX: | |
557 | return (ATEXIT_SIZE); | |
558 | case _SC_IOV_MAX: | |
559 | mib[0] = CTL_KERN; | |
560 | mib[1] = KERN_IOV_MAX; | |
561 | break; | |
562 | case _SC_XOPEN_CRYPT: | |
563 | return (_XOPEN_CRYPT); | |
564 | case _SC_XOPEN_ENH_I18N: | |
565 | return (_XOPEN_ENH_I18N); | |
566 | case _SC_XOPEN_LEGACY: | |
567 | return (_XOPEN_LEGACY); | |
568 | case _SC_XOPEN_REALTIME: | |
569 | #if _XOPEN_REALTIME == 0 | |
570 | sverrno = errno; | |
571 | value = sysconf(_SC_ASYNCHRONOUS_IO) > 0 && | |
572 | sysconf(_SC_MEMLOCK) > 0 && | |
573 | sysconf(_SC_MEMLOCK_RANGE) > 0 && | |
574 | sysconf(_SC_MESSAGE_PASSING) > 0 && | |
575 | sysconf(_SC_PRIORITY_SCHEDULING) > 0 && | |
576 | sysconf(_SC_REALTIME_SIGNALS) > 0 && | |
577 | sysconf(_SC_SEMAPHORES) > 0 && | |
578 | sysconf(_SC_SHARED_MEMORY_OBJECTS) > 0 && | |
579 | sysconf(_SC_SYNCHRONIZED_IO) > 0 && | |
580 | sysconf(_SC_TIMERS) > 0; | |
581 | errno = sverrno; | |
582 | if (value) | |
583 | return (200112L); | |
584 | else | |
585 | return (-1); | |
586 | #else | |
587 | return (_XOPEN_REALTIME); | |
588 | #endif | |
589 | case _SC_XOPEN_REALTIME_THREADS: | |
590 | #if _XOPEN_REALTIME_THREADS == 0 | |
591 | #error "_XOPEN_REALTIME_THREADS" | |
592 | #else | |
593 | return (_XOPEN_REALTIME_THREADS); | |
594 | #endif | |
595 | case _SC_XOPEN_SHM: | |
2f6482ab | 596 | return (_XOPEN_SHM); |
9d66746c PA |
597 | case _SC_XOPEN_STREAMS: |
598 | return (_XOPEN_STREAMS); | |
599 | case _SC_XOPEN_UNIX: | |
600 | return (_XOPEN_UNIX); | |
601 | #ifdef _XOPEN_VERSION | |
602 | case _SC_XOPEN_VERSION: | |
603 | return (_XOPEN_VERSION); | |
604 | #endif | |
605 | #ifdef _XOPEN_XCU_VERSION | |
606 | case _SC_XOPEN_XCU_VERSION: | |
607 | return (_XOPEN_XCU_VERSION); | |
608 | #endif | |
609 | case _SC_SYMLOOP_MAX: | |
610 | return (MAXSYMLINKS); | |
611 | case _SC_RAW_SOCKETS: | |
612 | return (_POSIX_RAW_SOCKETS); | |
613 | case _SC_IPV6: | |
614 | #if _POSIX_IPV6 == 0 | |
615 | sverrno = errno; | |
806a5ed7 | 616 | value = _socket(PF_INET6, SOCK_DGRAM, 0); |
9d66746c PA |
617 | errno = sverrno; |
618 | if (value >= 0) { | |
806a5ed7 | 619 | _close(value); |
9d66746c PA |
620 | return (200112L); |
621 | } else | |
622 | return (0); | |
623 | #else | |
624 | return (_POSIX_IPV6); | |
625 | #endif | |
626 | ||
dd47c5d8 HT |
627 | case _SC_NPROCESSORS_CONF: |
628 | case _SC_NPROCESSORS_ONLN: | |
629 | mib[0] = CTL_HW; | |
630 | mib[1] = HW_NCPU; | |
9d66746c | 631 | break; |
984263bc | 632 | |
9d66746c PA |
633 | #ifdef _SC_PHYS_PAGES |
634 | case _SC_PHYS_PAGES: | |
635 | len = sizeof(lvalue); | |
636 | if (sysctlbyname("hw.availpages", &lvalue, &len, NULL, 0) == -1) | |
984263bc | 637 | return (-1); |
9d66746c PA |
638 | return (lvalue); |
639 | #endif | |
640 | ||
32f8d3b4 SW |
641 | case _SC_LEVEL1_DCACHE_LINESIZE: |
642 | return (__VM_CACHELINE_SIZE); | |
643 | ||
984263bc MD |
644 | default: |
645 | errno = EINVAL; | |
646 | return (-1); | |
647 | } | |
9d66746c PA |
648 | len = sizeof(value); |
649 | if (sysctl(mib, 2, &value, &len, NULL, 0) == -1) | |
650 | value = -1; | |
651 | return ((long)value); | |
984263bc | 652 | } |