]> sourceware.org Git - newlib-cygwin.git/blob - winsup/cygwin/sysconf.cc
git://sourceware.org / newlib-cygwin.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Cygwin: Cleanup time handling
[newlib-cygwin.git] / winsup / cygwin / sysconf.cc
1 /* sysconf.cc
2
3 This file is part of Cygwin.
4
5 This software is a copyrighted work licensed under the terms of the
6 Cygwin license. Please consult the file "CYGWIN_LICENSE" for
7 details. */
8
9 #include "winsup.h"
10 #include <unistd.h>
11 #include <sys/param.h>
12 #include <sys/sysinfo.h>
13 #include "cygerrno.h"
14 #include "security.h"
15 #include "path.h"
16 #include "fhandler.h"
17 #include "dtable.h"
18 #include "pinfo.h"
19 #include "ntdll.h"
20 #include "tls_pbuf.h"
21 #include "cpuid.h"
22 #include "hires.h"
23
24 static long
25 get_open_max (int in)
26 {
27 long max = getdtablesize ();
28 if (max < OPEN_MAX)
29 max = OPEN_MAX;
30 return max;
31 }
32
33 static long
34 get_page_size (int in)
35 {
36 return wincap.allocation_granularity ();
37 }
38
39 static bool
40 __nt_query_system (PSYSTEM_BASIC_INFORMATION psbi)
41 {
42 NTSTATUS status;
43
44 status = NtQuerySystemInformation (SystemBasicInformation, (PVOID) psbi,
45 sizeof *psbi, NULL);
46 return NT_SUCCESS (status);
47 }
48
49 #define add_size(p,s) ((p) = ((__typeof__(p))((PBYTE)(p)+(s))))
50
51 static long
52 get_nproc_values (int in)
53 {
54 if (!wincap.has_processor_groups ()) /* Pre Windows 7 */
55 {
56 SYSTEM_BASIC_INFORMATION sbi;
57
58 if (!__nt_query_system (&sbi))
59 return -1;
60 switch (in)
61 {
62 case _SC_NPROCESSORS_CONF:
63 return sbi.NumberProcessors;
64 case _SC_NPROCESSORS_ONLN:
65 {
66 int i = 0;
67 do
68 if (sbi.ActiveProcessors & 1)
69 i++;
70 while (sbi.ActiveProcessors >>= 1);
71 return i;
72 }
73 }
74 }
75
76 tmp_pathbuf tp;
77 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX lpi, plpi;
78 DWORD lpi_size = NT_MAX_PATH;
79 long cnt = 0;
80
81 lpi = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) tp.c_get ();
82 if (!GetLogicalProcessorInformationEx (RelationGroup, lpi, &lpi_size))
83 return -1;
84 plpi = lpi;
85 for (DWORD size = lpi_size; size > 0;
86 size -= plpi->Size, add_size (plpi, plpi->Size))
87 if (plpi->Relationship == RelationGroup)
88 {
89 for (WORD i = 0; i < plpi->Group.MaximumGroupCount; ++i)
90 switch (in)
91 {
92 case _SC_NPROCESSORS_CONF:
93 cnt += plpi->Group.GroupInfo[0].MaximumProcessorCount;
94 break;
95 case _SC_NPROCESSORS_ONLN:
96 cnt += plpi->Group.GroupInfo[0].ActiveProcessorCount;
97 break;
98 }
99 }
100 return cnt;
101 }
102
103 static long
104 get_phys_pages (int in)
105 {
106 SYSTEM_BASIC_INFORMATION sbi;
107
108 if (!__nt_query_system (&sbi))
109 return -1;
110 return sbi.NumberOfPhysicalPages
111 / (wincap.allocation_granularity () / wincap.page_size ());
112 }
113
114 static long
115 get_avphys (int in)
116 {
117 NTSTATUS status;
118 SYSTEM_PERFORMANCE_INFORMATION spi;
119
120 status = NtQuerySystemInformation (SystemPerformanceInformation,
121 (PVOID) &spi, sizeof spi, NULL);
122 if (!NT_SUCCESS (status))
123 {
124 __seterrno_from_nt_status (status);
125 debug_printf ("NtQuerySystemInformation: status %y, %E", status);
126 return -1;
127 }
128 return spi.AvailablePages
129 / (wincap.allocation_granularity () / wincap.page_size ());
130 }
131
132 enum cache_level
133 {
134 LevelNone,
135 Level1I,
136 Level1D,
137 Level2,
138 Level3,
139 Level4
140 };
141
142 struct cpuid2_cache_desc
143 {
144 uint8_t desc;
145 cache_level level;
146 uint32_t size;
147 uint32_t assoc;
148 uint32_t linesize;
149 };
150
151 static const cpuid2_cache_desc cpuid2_cache_descriptor[] =
152 {
153 { 0x06, Level1I, 8, 4, 32 },
154 { 0x08, Level1I, 16, 4, 32 },
155 { 0x09, Level1I, 32, 4, 64 },
156 { 0x0a, Level1D, 8, 2, 32 },
157 { 0x0c, Level1D, 16, 4, 32 },
158 { 0x0d, Level1D, 16, 4, 64 },
159 { 0x0e, Level1D, 24, 6, 64 },
160 { 0x21, Level2, 256, 8, 64 },
161 { 0x22, Level3, 512, 4, 64 },
162 { 0x23, Level3, 1024, 8, 64 },
163 { 0x25, Level3, 2048, 8, 64 },
164 { 0x29, Level3, 4096, 8, 64 },
165 { 0x2c, Level1D, 32, 8, 64 },
166 { 0x30, Level1I, 32, 8, 64 },
167 { 0x39, Level2, 128, 4, 64 },
168 { 0x3a, Level2, 192, 6, 64 },
169 { 0x3b, Level2, 128, 2, 64 },
170 { 0x3c, Level2, 256, 4, 64 },
171 { 0x3d, Level2, 384, 6, 64 },
172 { 0x3e, Level2, 512, 4, 64 },
173 { 0x3f, Level2, 256, 2, 64 },
174 { 0x41, Level2, 128, 4, 32 },
175 { 0x42, Level2, 256, 4, 32 },
176 { 0x43, Level2, 512, 4, 32 },
177 { 0x44, Level2, 1024, 4, 32 },
178 { 0x45, Level2, 2048, 4, 32 },
179 { 0x46, Level3, 4096, 4, 64 },
180 { 0x47, Level3, 8192, 8, 64 },
181 { 0x48, Level2, 3072, 12, 64 },
182 { 0x49, Level3, 4096, 16, 64 },
183 { 0x4a, Level3, 6144, 12, 64 },
184 { 0x4b, Level3, 8192, 16, 64 },
185 { 0x4c, Level3, 12288, 12, 64 },
186 { 0x4d, Level3, 16384, 16, 64 },
187 { 0x4e, Level2, 6144, 24, 64 },
188 { 0x60, Level1D, 16, 8, 64 },
189 { 0x66, Level1D, 8, 4, 64 },
190 { 0x67, Level1D, 16, 4, 64 },
191 { 0x68, Level1D, 32, 4, 64 },
192 { 0x78, Level2, 1024, 4, 64 },
193 { 0x79, Level2, 128, 8, 64 },
194 { 0x7a, Level2, 256, 8, 64 },
195 { 0x7b, Level2, 512, 8, 64 },
196 { 0x7c, Level2, 1024, 8, 64 },
197 { 0x7d, Level2, 2048, 8, 64 },
198 { 0x7f, Level2, 512, 2, 64 },
199 { 0x80, Level2, 512, 8, 64 },
200 { 0x82, Level2, 256, 8, 32 },
201 { 0x83, Level2, 512, 8, 32 },
202 { 0x84, Level2, 1024, 8, 32 },
203 { 0x85, Level2, 2048, 8, 32 },
204 { 0x86, Level2, 512, 4, 64 },
205 { 0x87, Level2, 1024, 8, 64 },
206 { 0xd0, Level3, 512, 4, 64 },
207 { 0xd1, Level3, 1024, 4, 64 },
208 { 0xd2, Level3, 2048, 4, 64 },
209 { 0xd6, Level3, 1024, 8, 64 },
210 { 0xd7, Level3, 2048, 8, 64 },
211 { 0xd8, Level3, 4096, 12, 64 },
212 { 0xdc, Level3, 2048, 12, 64 },
213 { 0xdd, Level3, 4096, 12, 64 },
214 { 0xde, Level3, 8192, 12, 64 },
215 { 0xe2, Level3, 2048, 16, 64 },
216 { 0xe3, Level3, 4096, 16, 64 },
217 { 0xe4, Level3, 8192, 16, 64 },
218 { 0xea, Level3, 12288, 24, 64 },
219 { 0xeb, Level3, 18432, 24, 64 },
220 { 0xec, Level3, 24576, 24, 64 },
221 };
222
223 static int
224 cpuid2_cache_desc_compar (const void *key, const void *memb)
225 {
226 cpuid2_cache_desc *ckey = (cpuid2_cache_desc *) key;
227 cpuid2_cache_desc *cmemb = (cpuid2_cache_desc *) memb;
228 return ckey->desc - cmemb->desc;
229 }
230
231 static long
232 get_cpu_cache_intel_cpuid2 (int in)
233 {
234 uint32_t reg[4];
235 long ret = 0;
236 int num;
237
238 cpuid (reg, reg + 1, reg + 2, reg + 3, 0x00000002);
239 num = reg[0] & 0xff;
240 for (int i = 0; i < num; ++i)
241 {
242 cpuid (reg, reg + 1, reg + 2, reg + 3, 0x00000002);
243 for (int r = 0; r < 4; ++r)
244 {
245 if (reg[r] & 0x80000000)
246 continue;
247 for (int b = (r == 0) ? 1 : 0; b < 4; ++b)
248 {
249 cpuid2_cache_desc key, *cdp;
250
251 key.desc = ((uint8_t *) &reg[r])[b];
252 cdp = (cpuid2_cache_desc *)
253 bsearch (&key, cpuid2_cache_descriptor,
254 sizeof cpuid2_cache_descriptor
255 / sizeof *cpuid2_cache_descriptor,
256 sizeof *cpuid2_cache_descriptor,
257 cpuid2_cache_desc_compar);
258 if (!cdp)
259 continue;
260 switch (in)
261 {
262 case _SC_LEVEL1_ICACHE_SIZE:
263 if (cdp->level == Level1I)
264 ret += cdp->size * 1024;
265 break;
266 case _SC_LEVEL1_ICACHE_ASSOC:
267 if (cdp->level == Level1I)
268 return cdp->assoc;
269 break;
270 case _SC_LEVEL1_ICACHE_LINESIZE:
271 if (cdp->level == Level1I)
272 return cdp->linesize;
273 break;
274 case _SC_LEVEL1_DCACHE_SIZE:
275 if (cdp->level == Level1D)
276 ret += cdp->size * 1024;
277 break;
278 case _SC_LEVEL1_DCACHE_ASSOC:
279 if (cdp->level == Level1D)
280 return cdp->assoc;
281 break;
282 case _SC_LEVEL1_DCACHE_LINESIZE:
283 if (cdp->level == Level1D)
284 return cdp->linesize;
285 break;
286 case _SC_LEVEL2_CACHE_SIZE:
287 if (cdp->level == Level2)
288 ret += cdp->size * 1024;
289 break;
290 case _SC_LEVEL2_CACHE_ASSOC:
291 if (cdp->level == Level2)
292 return cdp->assoc;
293 break;
294 case _SC_LEVEL2_CACHE_LINESIZE:
295 if (cdp->level == Level2)
296 return cdp->linesize;
297 break;
298 case _SC_LEVEL3_CACHE_SIZE:
299 if (cdp->level == Level3)
300 ret += cdp->size * 1024;
301 break;
302 case _SC_LEVEL3_CACHE_ASSOC:
303 if (cdp->level == Level3)
304 return cdp->assoc;
305 break;
306 case _SC_LEVEL3_CACHE_LINESIZE:
307 if (cdp->level == Level3)
308 return cdp->linesize;
309 break;
310 }
311 }
312 }
313 }
314 return ret;
315 }
316
317 static long
318 get_cpu_cache_intel_cpuid4 (int in)
319 {
320 uint32_t eax, ebx, ecx, edx;
321 long ret = 0;
322
323 for (int idx = 0; ; ++idx)
324 {
325 uint32_t cache_type, cur_level, assoc, part, linesize, sets;
326
327 cpuid (&eax, &ebx, &ecx, &edx, 0x00000004, idx);
328 if ((cache_type = (eax & 0x1f))== 0)
329 break;
330 cur_level = ((eax >> 5) & 0x7);
331 assoc = ((ebx >> 22) & 0x3ff) + 1;
332 part = ((ebx >> 12) & 0x3ff) + 1;
333 linesize = (ebx & 0xfff) + 1;
334 sets = ecx + 1;
335 switch (in)
336 {
337 case _SC_LEVEL1_ICACHE_SIZE:
338 if (cur_level == 1 && cache_type == 2)
339 ret += assoc * part * linesize * sets;
340 break;
341 case _SC_LEVEL1_ICACHE_ASSOC:
342 if (cur_level == 1 && cache_type == 2)
343 return assoc;
344 case _SC_LEVEL1_ICACHE_LINESIZE:
345 if (cur_level == 1 && cache_type == 2)
346 return linesize;
347 case _SC_LEVEL1_DCACHE_SIZE:
348 if (cur_level == 1 && cache_type == 1)
349 ret += assoc * part * linesize * sets;
350 break;
351 case _SC_LEVEL1_DCACHE_ASSOC:
352 if (cur_level == 1 && cache_type == 1)
353 return assoc;
354 case _SC_LEVEL1_DCACHE_LINESIZE:
355 if (cur_level == 1 && cache_type == 1)
356 return linesize;
357 case _SC_LEVEL2_CACHE_SIZE:
358 if (cur_level == 2)
359 ret += assoc * part * linesize * sets;
360 break;
361 case _SC_LEVEL2_CACHE_ASSOC:
362 if (cur_level == 2)
363 return assoc;
364 case _SC_LEVEL2_CACHE_LINESIZE:
365 if (cur_level == 2)
366 return linesize;
367 case _SC_LEVEL3_CACHE_SIZE:
368 if (cur_level == 3)
369 ret += assoc * part * linesize * sets;
370 break;
371 case _SC_LEVEL3_CACHE_ASSOC:
372 if (cur_level == 3)
373 return assoc;
374 case _SC_LEVEL3_CACHE_LINESIZE:
375 if (cur_level == 3)
376 return linesize;
377 }
378 }
379 return ret;
380 }
381
382 /* Also called from format_proc_cpuinfo */
383 long
384 get_cpu_cache_intel (int in, uint32_t maxf)
385 {
386 long ret = 0;
387
388 switch (in)
389 {
390 case _SC_LEVEL1_ICACHE_SIZE:
391 case _SC_LEVEL1_ICACHE_ASSOC:
392 case _SC_LEVEL1_ICACHE_LINESIZE:
393 case _SC_LEVEL1_DCACHE_SIZE:
394 case _SC_LEVEL1_DCACHE_ASSOC:
395 case _SC_LEVEL1_DCACHE_LINESIZE:
396 case _SC_LEVEL2_CACHE_SIZE:
397 case _SC_LEVEL2_CACHE_ASSOC:
398 case _SC_LEVEL2_CACHE_LINESIZE:
399 case _SC_LEVEL3_CACHE_SIZE:
400 case _SC_LEVEL3_CACHE_ASSOC:
401 case _SC_LEVEL3_CACHE_LINESIZE:
402 if (maxf >= 4)
403 ret = get_cpu_cache_intel_cpuid4 (in);
404 else if (maxf >= 2)
405 ret = get_cpu_cache_intel_cpuid2 (in);
406 break;
407 default:
408 break;
409 }
410 return ret;
411 }
412
413 static const long assoc[16] = { 0, 1, 2, 2, 4, 4, 8, 8,
414 16, 16, 32, 48, 64, 96, 128, 0x8000 };
415
416 /* Also called from format_proc_cpuinfo */
417 long
418 get_cpu_cache_amd (int in, uint32_t maxe)
419 {
420 uint32_t eax, ebx, ecx, edx;
421 long ret = 0;
422
423 if (in >= _SC_LEVEL1_ICACHE_SIZE && in <= _SC_LEVEL1_DCACHE_LINESIZE
424 && maxe >= 0x80000005)
425 cpuid (&eax, &ebx, &ecx, &edx, 0x80000005);
426 else if (in >= _SC_LEVEL2_CACHE_SIZE && in <= _SC_LEVEL3_CACHE_LINESIZE
427 && maxe >= 0x80000006)
428 cpuid (&eax, &ebx, &ecx, &edx, 0x80000006);
429 else
430 return 0;
431
432 switch (in)
433 {
434 case _SC_LEVEL1_ICACHE_SIZE:
435 ret = (edx & 0xff000000) >> 14;
436 break;
437 case _SC_LEVEL1_ICACHE_ASSOC:
438 ret = (edx & 0xff0000) >> 16;
439 if (ret == 0xff)
440 ret = 0x8000;
441 break;
442 case _SC_LEVEL1_ICACHE_LINESIZE:
443 ret = (edx & 0xff);
444 break;
445 case _SC_LEVEL1_DCACHE_SIZE:
446 ret = (ecx & 0xff000000) >> 14;
447 break;
448 case _SC_LEVEL1_DCACHE_ASSOC:
449 ret = (ecx & 0xff0000) >> 16;
450 if (ret == 0xff)
451 ret = 0x8000;
452 break;
453 case _SC_LEVEL1_DCACHE_LINESIZE:
454 ret = (ecx & 0xff);
455 break;
456 case _SC_LEVEL2_CACHE_SIZE:
457 ret = (ecx & 0xffff0000) >> 6;
458 break;
459 case _SC_LEVEL2_CACHE_ASSOC:
460 ret = assoc[(ecx & 0xf000) >> 12];
461 break;
462 case _SC_LEVEL2_CACHE_LINESIZE:
463 ret = (ecx & 0xff);
464 break;
465 case _SC_LEVEL3_CACHE_SIZE:
466 ret = (long) ((edx & 0xfffc0000) >> 18) * 512 * 1024;
467 break;
468 case _SC_LEVEL3_CACHE_ASSOC:
469 ret = assoc[(edx & 0xf000) >> 12];
470 break;
471 case _SC_LEVEL3_CACHE_LINESIZE:
472 ret = (edx & 0xff);
473 break;
474 default:
475 break;
476 }
477 return ret;
478 }
479
480 static long
481 get_cpu_cache (int in)
482 {
483 uint32_t maxf, vendor_id[4];
484 cpuid (&maxf, &vendor_id[0], &vendor_id[2], &vendor_id[1], 0x00000000);
485
486 vendor_id[3] = 0;
487 if (!strcmp ((char*) vendor_id, "GenuineIntel"))
488 return get_cpu_cache_intel (in, maxf & 0xffff);
489 else if (!strcmp ((char*)vendor_id, "AuthenticAMD"))
490 {
491 uint32_t maxe = 0, unused;
492 cpuid (&maxe, &unused, &unused, &unused, 0x80000000);
493 return get_cpu_cache_amd (in, maxe);
494 }
495 return 0;
496 }
497
498 enum sc_type { nsup, cons, func };
499
500 static struct
501 {
502 sc_type type;
503 union
504 {
505 long c;
506 long (*f)(int);
507 };
508 } sca[] =
509 {
510 {cons, {c:ARG_MAX}}, /* 0, _SC_ARG_MAX */
511 {cons, {c:CHILD_MAX}}, /* 1, _SC_CHILD_MAX */
512 {cons, {c:CLOCKS_PER_SEC}}, /* 2, _SC_CLK_TCK */
513 {cons, {c:NGROUPS_MAX}}, /* 3, _SC_NGROUPS_MAX */
514 {func, {f:get_open_max}}, /* 4, _SC_OPEN_MAX */
515 {cons, {c:_POSIX_JOB_CONTROL}}, /* 5, _SC_JOB_CONTROL */
516 {cons, {c:_POSIX_SAVED_IDS}}, /* 6, _SC_SAVED_IDS */
517 {cons, {c:_POSIX_VERSION}}, /* 7, _SC_VERSION */
518 {func, {f:get_page_size}}, /* 8, _SC_PAGESIZE */
519 {func, {f:get_nproc_values}}, /* 9, _SC_NPROCESSORS_CONF */
520 {func, {f:get_nproc_values}}, /* 10, _SC_NPROCESSORS_ONLN */
521 {func, {f:get_phys_pages}}, /* 11, _SC_PHYS_PAGES */
522 {func, {f:get_avphys}}, /* 12, _SC_AVPHYS_PAGES */
523 {cons, {c:MQ_OPEN_MAX}}, /* 13, _SC_MQ_OPEN_MAX */
524 {cons, {c:MQ_PRIO_MAX}}, /* 14, _SC_MQ_PRIO_MAX */
525 {cons, {c:RTSIG_MAX}}, /* 15, _SC_RTSIG_MAX */
526 {cons, {c:-1L}}, /* 16, _SC_SEM_NSEMS_MAX */
527 {cons, {c:SEM_VALUE_MAX}}, /* 17, _SC_SEM_VALUE_MAX */
528 {cons, {c:SIGQUEUE_MAX}}, /* 18, _SC_SIGQUEUE_MAX */
529 {cons, {c:TIMER_MAX}}, /* 19, _SC_TIMER_MAX */
530 {nsup, {c:0}}, /* 20, _SC_TZNAME_MAX */
531 {cons, {c:-1L}}, /* 21, _SC_ASYNCHRONOUS_IO */
532 {cons, {c:_POSIX_FSYNC}}, /* 22, _SC_FSYNC */
533 {cons, {c:_POSIX_MAPPED_FILES}}, /* 23, _SC_MAPPED_FILES */
534 {cons, {c:-1L}}, /* 24, _SC_MEMLOCK */
535 {cons, {c:_POSIX_MEMLOCK_RANGE}}, /* 25, _SC_MEMLOCK_RANGE */
536 {cons, {c:_POSIX_MEMORY_PROTECTION}}, /* 26, _SC_MEMORY_PROTECTION */
537 {cons, {c:_POSIX_MESSAGE_PASSING}}, /* 27, _SC_MESSAGE_PASSING */
538 {cons, {c:-1L}}, /* 28, _SC_PRIORITIZED_IO */
539 {cons, {c:_POSIX_REALTIME_SIGNALS}}, /* 29, _SC_REALTIME_SIGNALS */
540 {cons, {c:_POSIX_SEMAPHORES}}, /* 30, _SC_SEMAPHORES */
541 {cons, {c:_POSIX_SHARED_MEMORY_OBJECTS}}, /* 31, _SC_SHARED_MEMORY_OBJECTS */
542 {cons, {c:_POSIX_SYNCHRONIZED_IO}}, /* 32, _SC_SYNCHRONIZED_IO */
543 {cons, {c:_POSIX_TIMERS}}, /* 33, _SC_TIMERS */
544 {nsup, {c:0}}, /* 34, _SC_AIO_LISTIO_MAX */
545 {nsup, {c:0}}, /* 35, _SC_AIO_MAX */
546 {nsup, {c:0}}, /* 36, _SC_AIO_PRIO_DELTA_MAX */
547 {nsup, {c:0}}, /* 37, _SC_DELAYTIMER_MAX */
548 {cons, {c:PTHREAD_KEYS_MAX}}, /* 38, _SC_THREAD_KEYS_MAX */
549 {cons, {c:PTHREAD_STACK_MIN}}, /* 39, _SC_THREAD_STACK_MIN */
550 {cons, {c:-1L}}, /* 40, _SC_THREAD_THREADS_MAX */
551 {cons, {c:TTY_NAME_MAX}}, /* 41, _SC_TTY_NAME_MAX */
552 {cons, {c:_POSIX_THREADS}}, /* 42, _SC_THREADS */
553 {cons, {c:_POSIX_THREAD_ATTR_STACKADDR}},/* 43, _SC_THREAD_ATTR_STACKADDR */
554 {cons, {c:_POSIX_THREAD_ATTR_STACKSIZE}},/* 44, _SC_THREAD_ATTR_STACKSIZE */
555 {cons, {c:_POSIX_THREAD_PRIORITY_SCHEDULING}}, /* 45, _SC_THREAD_PRIORITY_SCHEDULING */
556 {cons, {c:-1L}}, /* 46, _SC_THREAD_PRIO_INHERIT */
557 {cons, {c:-1L}}, /* 47, _SC_THREAD_PRIO_PROTECT */
558 {cons, {c:_POSIX_THREAD_PROCESS_SHARED}}, /* 48, _SC_THREAD_PROCESS_SHARED */
559 {cons, {c:_POSIX_THREAD_SAFE_FUNCTIONS}}, /* 49, _SC_THREAD_SAFE_FUNCTIONS */
560 {cons, {c:16384L}}, /* 50, _SC_GETGR_R_SIZE_MAX */
561 {cons, {c:16384L}}, /* 51, _SC_GETPW_R_SIZE_MAX */
562 {cons, {c:LOGIN_NAME_MAX}}, /* 52, _SC_LOGIN_NAME_MAX */
563 {cons, {c:PTHREAD_DESTRUCTOR_ITERATIONS}}, /* 53, _SC_THREAD_DESTRUCTOR_ITERATIONS */
564 {cons, {c:_POSIX_ADVISORY_INFO}}, /* 54, _SC_ADVISORY_INFO */
565 {cons, {c:ATEXIT_MAX}}, /* 55, _SC_ATEXIT_MAX */
566 {cons, {c:_POSIX_BARRIERS}}, /* 56, _SC_BARRIERS */
567 {cons, {c:BC_BASE_MAX}}, /* 57, _SC_BC_BASE_MAX */
568 {cons, {c:BC_DIM_MAX}}, /* 58, _SC_BC_DIM_MAX */
569 {cons, {c:BC_SCALE_MAX}}, /* 59, _SC_BC_SCALE_MAX */
570 {cons, {c:BC_STRING_MAX}}, /* 60, _SC_BC_STRING_MAX */
571 {cons, {c:_POSIX_CLOCK_SELECTION}}, /* 61, _SC_CLOCK_SELECTION */
572 {nsup, {c:0}}, /* 62, _SC_COLL_WEIGHTS_MAX */
573 {cons, {c:_POSIX_CPUTIME}}, /* 63, _SC_CPUTIME */
574 {cons, {c:EXPR_NEST_MAX}}, /* 64, _SC_EXPR_NEST_MAX */
575 {cons, {c:HOST_NAME_MAX}}, /* 65, _SC_HOST_NAME_MAX */
576 {cons, {c:IOV_MAX}}, /* 66, _SC_IOV_MAX */
577 {cons, {c:_POSIX_IPV6}}, /* 67, _SC_IPV6 */
578 {cons, {c:LINE_MAX}}, /* 68, _SC_LINE_MAX */
579 {cons, {c:_POSIX_MONOTONIC_CLOCK}}, /* 69, _SC_MONOTONIC_CLOCK */
580 {cons, {c:_POSIX_RAW_SOCKETS}}, /* 70, _SC_RAW_SOCKETS */
581 {cons, {c:_POSIX_READER_WRITER_LOCKS}}, /* 71, _SC_READER_WRITER_LOCKS */
582 {cons, {c:_POSIX_REGEXP}}, /* 72, _SC_REGEXP */
583 {cons, {c:RE_DUP_MAX}}, /* 73, _SC_RE_DUP_MAX */
584 {cons, {c:_POSIX_SHELL}}, /* 74, _SC_SHELL */
585 {cons, {c:_POSIX_SPAWN}}, /* 75, _SC_SPAWN */
586 {cons, {c:_POSIX_SPIN_LOCKS}}, /* 76, _SC_SPIN_LOCKS */
587 {cons, {c:-1L}}, /* 77, _SC_SPORADIC_SERVER */
588 {nsup, {c:0}}, /* 78, _SC_SS_REPL_MAX */
589 {cons, {c:SYMLOOP_MAX}}, /* 79, _SC_SYMLOOP_MAX */
590 {cons, {c:_POSIX_THREAD_CPUTIME}}, /* 80, _SC_THREAD_CPUTIME */
591 {cons, {c:-1L}}, /* 81, _SC_THREAD_SPORADIC_SERVER */
592 {cons, {c:_POSIX_TIMEOUTS}}, /* 82, _SC_TIMEOUTS */
593 {cons, {c:-1L}}, /* 83, _SC_TRACE */
594 {cons, {c:-1L}}, /* 84, _SC_TRACE_EVENT_FILTER */
595 {nsup, {c:0}}, /* 85, _SC_TRACE_EVENT_NAME_MAX */
596 {cons, {c:-1L}}, /* 86, _SC_TRACE_INHERIT */
597 {cons, {c:-1L}}, /* 87, _SC_TRACE_LOG */
598 {nsup, {c:0}}, /* 88, _SC_TRACE_NAME_MAX */
599 {nsup, {c:0}}, /* 89, _SC_TRACE_SYS_MAX */
600 {nsup, {c:0}}, /* 90, _SC_TRACE_USER_EVENT_MAX */
601 {cons, {c:-1L}}, /* 91, _SC_TYPED_MEMORY_OBJECTS */
602 {cons, {c:_POSIX_V6_ILP32_OFF32}}, /* 92, _SC_V6_ILP32_OFF32 */
603 {cons, {c:_POSIX_V6_ILP32_OFFBIG}}, /* 93, _SC_V6_ILP32_OFFBIG */
604 {cons, {c:_POSIX_V6_LP64_OFF64}}, /* 94, _SC_V6_LP64_OFF64 */
605 {cons, {c:_POSIX_V6_LPBIG_OFFBIG}}, /* 95, _SC_V6_LPBIG_OFFBIG */
606 {cons, {c:_XOPEN_CRYPT}}, /* 96, _SC_XOPEN_CRYPT */
607 {cons, {c:_XOPEN_ENH_I18N}}, /* 97, _SC_XOPEN_ENH_I18N */
608 {cons, {c:-1L}}, /* 98, _SC_XOPEN_LEGACY */
609 {cons, {c:-1L}}, /* 99, _SC_XOPEN_REALTIME */
610 {cons, {c:STREAM_MAX}}, /* 100, _SC_STREAM_MAX */
611 {cons, {c:_POSIX_PRIORITY_SCHEDULING}}, /* 101, _SC_PRIORITY_SCHEDULING */
612 {cons, {c:-1L}}, /* 102, _SC_XOPEN_REALTIME_THREADS */
613 {cons, {c:_XOPEN_SHM}}, /* 103, _SC_XOPEN_SHM */
614 {cons, {c:-1L}}, /* 104, _SC_XOPEN_STREAMS */
615 {cons, {c:-1L}}, /* 105, _SC_XOPEN_UNIX */
616 {cons, {c:_XOPEN_VERSION}}, /* 106, _SC_XOPEN_VERSION */
617 {cons, {c:_POSIX2_CHAR_TERM}}, /* 107, _SC_2_CHAR_TERM */
618 {cons, {c:_POSIX2_C_BIND}}, /* 108, _SC_2_C_BIND */
619 {cons, {c:_POSIX2_C_DEV}}, /* 109, _SC_2_C_DEV */
620 {cons, {c:-1L}}, /* 110, _SC_2_FORT_DEV */
621 {cons, {c:-1L}}, /* 111, _SC_2_FORT_RUN */
622 {cons, {c:-1L}}, /* 112, _SC_2_LOCALEDEF */
623 {cons, {c:-1L}}, /* 113, _SC_2_PBS */
624 {cons, {c:-1L}}, /* 114, _SC_2_PBS_ACCOUNTING */
625 {cons, {c:-1L}}, /* 115, _SC_2_PBS_CHECKPOINT */
626 {cons, {c:-1L}}, /* 116, _SC_2_PBS_LOCATE */
627 {cons, {c:-1L}}, /* 117, _SC_2_PBS_MESSAGE */
628 {cons, {c:-1L}}, /* 118, _SC_2_PBS_TRACK */
629 {cons, {c:_POSIX2_SW_DEV}}, /* 119, _SC_2_SW_DEV */
630 {cons, {c:_POSIX2_UPE}}, /* 120, _SC_2_UPE */
631 {cons, {c:_POSIX2_VERSION}}, /* 121, _SC_2_VERSION */
632 {cons, {c:-1L}}, /* 122, _SC_THREAD_ROBUST_PRIO_INHERIT */
633 {cons, {c:-1L}}, /* 123, _SC_THREAD_ROBUST_PRIO_PROTECT */
634 {cons, {c:-1L}}, /* 124, _SC_XOPEN_UUCP */
635 {func, {f:get_cpu_cache}}, /* 125, _SC_LEVEL1_ICACHE_SIZE */
636 {func, {f:get_cpu_cache}}, /* 126, _SC_LEVEL1_ICACHE_ASSOC */
637 {func, {f:get_cpu_cache}}, /* 127, _SC_LEVEL1_ICACHE_LINESIZE */
638 {func, {f:get_cpu_cache}}, /* 128, _SC_LEVEL1_DCACHE_SIZE */
639 {func, {f:get_cpu_cache}}, /* 129, _SC_LEVEL1_DCACHE_ASSOC */
640 {func, {f:get_cpu_cache}}, /* 130, _SC_LEVEL1_DCACHE_LINESIZE */
641 {func, {f:get_cpu_cache}}, /* 131, _SC_LEVEL2_CACHE_SIZE */
642 {func, {f:get_cpu_cache}}, /* 132, _SC_LEVEL2_CACHE_ASSOC */
643 {func, {f:get_cpu_cache}}, /* 133, _SC_LEVEL2_CACHE_LINESIZE */
644 {func, {f:get_cpu_cache}}, /* 134, _SC_LEVEL3_CACHE_SIZE */
645 {func, {f:get_cpu_cache}}, /* 135, _SC_LEVEL3_CACHE_ASSOC */
646 {func, {f:get_cpu_cache}}, /* 136, _SC_LEVEL3_CACHE_LINESIZE */
647 {func, {f:get_cpu_cache}}, /* 137, _SC_LEVEL4_CACHE_SIZE */
648 {func, {f:get_cpu_cache}}, /* 138, _SC_LEVEL4_CACHE_ASSOC */
649 {func, {f:get_cpu_cache}}, /* 139, _SC_LEVEL4_CACHE_LINESIZE */
650 };
651
652 #define SC_MIN _SC_ARG_MAX
653 #define SC_MAX _SC_LEVEL4_CACHE_LINESIZE
654
655 /* sysconf: POSIX 4.8.1.1 */
656 /* Allows a portable app to determine quantities of resources or
657 presence of an option at execution time. */
658 long int
659 sysconf (int in)
660 {
661 if (in >= SC_MIN && in <= SC_MAX)
662 {
663 switch (sca[in].type)
664 {
665 case nsup:
666 break;
667 case cons:
668 return sca[in].c;
669 case func:
670 return sca[in].f (in);
671 }
672 }
673 /* Unimplemented sysconf name or invalid option value. */
674 set_errno (EINVAL);
675 return -1L;
676 }
677
678 #define ls(s) sizeof(s),s
679
680 static struct
681 {
682 size_t l;
683 const char *s;
684 } csa[] =
685 {
686 {ls ("/bin:/usr/bin")}, /* _CS_PATH */
687 {0, NULL}, /* _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
688 {0, NULL}, /* _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
689 {0, NULL}, /* _CS_POSIX_V6_ILP32_OFF32_LIBS */
690 {0, NULL}, /* _CS_XBS5_ILP32_OFF32_LINTFLAGS */
691 #ifdef __x86_64__
692 {0, NULL}, /* _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
693 {0, NULL}, /* _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
694 {0, NULL}, /* _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
695 {0, NULL}, /* _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
696 {ls ("")}, /* _CS_POSIX_V6_LP64_OFF64_CFLAGS */
697 {ls ("")}, /* _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
698 {ls ("")}, /* _CS_POSIX_V6_LP64_OFF64_LIBS */
699 {ls ("")}, /* _CS_XBS5_LP64_OFF64_LINTFLAGS */
700 {ls ("")}, /* _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
701 {ls ("")}, /* _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
702 {ls ("")}, /* _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
703 {ls ("")}, /* _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
704 {ls ("POSIX_V6_LP64_OFF64")}, /* _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS */
705 #else
706 {ls ("")}, /* _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
707 {ls ("")}, /* _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
708 {ls ("")}, /* _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
709 {ls ("")}, /* _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
710 {0, NULL}, /* _CS_POSIX_V6_LP64_OFF64_CFLAGS */
711 {0, NULL}, /* _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
712 {0, NULL}, /* _CS_POSIX_V6_LP64_OFF64_LIBS */
713 {0, NULL}, /* _CS_XBS5_LP64_OFF64_LINTFLAGS */
714 {0, NULL}, /* _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
715 {0, NULL}, /* _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
716 {0, NULL}, /* _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
717 {0, NULL}, /* _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
718 {ls ("POSIX_V6_ILP32_OFFBIG")}, /* _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS */
719 #endif
720 {ls ("")}, /* _CS_POSIX_V7_THREADS_CFLAGS */
721 {ls ("")}, /* _CS_POSIX_V7_THREADS_LDFLAGS */
722 {ls ("POSIXLY_CORRECT=1")}, /* _CS_V7_ENV */
723 {ls ("")}, /* _CS_LFS_CFLAGS */
724 {ls ("")}, /* _CS_LFS_LDFLAGS */
725 {ls ("")}, /* _CS_LFS_LIBS */
726 {ls ("")}, /* _CS_LFS_LINTFLAGS */
727 };
728
729 #define CS_MIN _CS_PATH
730 #define CS_MAX _CS_LFS_LINTFLAGS
731
732 extern "C" size_t
733 confstr (int in, char *buf, size_t len)
734 {
735 if (in >= CS_MIN && in <= CS_MAX)
736 {
737 if (csa[in].l && len)
738 {
739 buf[0] = 0;
740 strncat (buf, csa[in].s, MIN (len, csa[in].l) - 1);
741 }
742 return csa[in].l;
743 }
744 /* Invalid option value. */
745 set_errno (EINVAL);
746 return 0;
747 }
748
749 extern "C" int
750 get_nprocs_conf (void)
751 {
752 return get_nproc_values (_SC_NPROCESSORS_CONF);
753 }
754
755 extern "C" int
756 get_nprocs (void)
757 {
758 return get_nproc_values (_SC_NPROCESSORS_ONLN);
759 }
760
761 extern "C" long
762 get_phys_pages (void)
763 {
764 return get_phys_pages (_SC_PHYS_PAGES);
765 }
766
767 extern "C" long
768 get_avphys_pages (void)
769 {
770 return get_avphys (_SC_AVPHYS_PAGES);
771 }
772
773 extern "C" int
774 sysinfo (struct sysinfo *info)
775 {
776 unsigned long long uptime = 0ULL, totalram = 0ULL, freeram = 0ULL,
777 totalswap = 0ULL, freeswap = 0ULL;
778 MEMORYSTATUSEX memory_status;
779 PSYSTEM_PAGEFILE_INFORMATION spi = NULL;
780 ULONG sizeof_spi = 512;
781 PSYSTEM_TIMEOFDAY_INFORMATION stodi = NULL;
782 const ULONG sizeof_stodi = sizeof (SYSTEM_TIMEOFDAY_INFORMATION);
783 NTSTATUS status = STATUS_SUCCESS;
784 winpids pids ((DWORD) 0);
785
786 if (!info)
787 {
788 set_errno (EFAULT);
789 return -1;
790 }
791
792 stodi = (PSYSTEM_TIMEOFDAY_INFORMATION) malloc (sizeof_stodi);
793 status = NtQuerySystemInformation (SystemTimeOfDayInformation, (PVOID) stodi,
794 sizeof_stodi, NULL);
795 if (NT_SUCCESS (status))
796 uptime = (stodi->CurrentTime.QuadPart - stodi->BootTime.QuadPart)
797 / NS100PERSEC;
798 else
799 debug_printf ("NtQuerySystemInformation(SystemTimeOfDayInformation), "
800 "status %y", status);
801
802 if (stodi)
803 free (stodi);
804
805 memory_status.dwLength = sizeof (MEMORYSTATUSEX);
806 GlobalMemoryStatusEx (&memory_status);
807 totalram = memory_status.ullTotalPhys / wincap.page_size ();
808 freeram = memory_status.ullAvailPhys / wincap.page_size ();
809
810 spi = (PSYSTEM_PAGEFILE_INFORMATION) malloc (sizeof_spi);
811 if (spi)
812 {
813 status = NtQuerySystemInformation (SystemPagefileInformation, (PVOID) spi,
814 sizeof_spi, &sizeof_spi);
815 if (status == STATUS_INFO_LENGTH_MISMATCH)
816 {
817 free (spi);
818 spi = (PSYSTEM_PAGEFILE_INFORMATION) malloc (sizeof_spi);
819 if (spi)
820 status = NtQuerySystemInformation (SystemPagefileInformation,
821 (PVOID) spi, sizeof_spi,
822 &sizeof_spi);
823 }
824 }
825 if (!spi || !NT_SUCCESS (status))
826 {
827 debug_printf ("NtQuerySystemInformation(SystemPagefileInformation), "
828 "status %y", status);
829 totalswap = (memory_status.ullTotalPageFile - memory_status.ullTotalPhys)
830 / wincap.page_size ();
831 freeswap = (memory_status.ullAvailPageFile - memory_status.ullTotalPhys)
832 / wincap.page_size ();
833 }
834 else
835 {
836 PSYSTEM_PAGEFILE_INFORMATION spp = spi;
837 do
838 {
839 totalswap += spp->CurrentSize;
840 freeswap += spp->CurrentSize - spp->TotalUsed;
841 }
842 while (spp->NextEntryOffset
843 && (spp = (PSYSTEM_PAGEFILE_INFORMATION)
844 ((char *) spp + spp->NextEntryOffset)));
845 }
846 if (spi)
847 free (spi);
848
849 info->uptime = (long) uptime;
850 info->totalram = (unsigned long) totalram;
851 info->freeram = (unsigned long) freeram;
852 info->totalswap = (unsigned long) totalswap;
853 info->freeswap = (unsigned long) freeswap;
854 info->procs = (unsigned short) pids.npids;
855 info->mem_unit = (unsigned int) wincap.page_size ();
856
857 /* FIXME: unsupported */
858 info->loads[0] = 0UL;
859 info->loads[1] = 0UL;
860 info->loads[2] = 0UL;
861 info->sharedram = 0UL;
862 info->bufferram = 0UL;
863 info->totalhigh = 0UL;
864 info->freehigh = 0UL;
865
866 return 0;
867 }
newlib and cygwin
This page took 0.079042 seconds and 5 git commands to generate.