1 /* Get file-specific information about a file. Linux version.
2 Copyright (C) 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
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 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 #include <hp-timing.h>
26 static long int linux_sysconf (int name
);
29 static long int __attribute__ ((noinline
))
30 handle_i486 (int name
)
32 /* The processor only has a unified level 1 cache of 8k. */
35 case _SC_LEVEL1_ICACHE_SIZE
:
36 case _SC_LEVEL1_DCACHE_SIZE
:
39 case _SC_LEVEL1_ICACHE_ASSOC
:
40 case _SC_LEVEL1_DCACHE_ASSOC
:
41 // XXX Anybody know this?
44 case _SC_LEVEL1_ICACHE_LINESIZE
:
45 case _SC_LEVEL1_DCACHE_LINESIZE
:
46 // XXX Anybody know for sure?
49 case _SC_LEVEL2_CACHE_SIZE
:
50 case _SC_LEVEL2_CACHE_ASSOC
:
51 case _SC_LEVEL2_CACHE_LINESIZE
:
52 case _SC_LEVEL3_CACHE_SIZE
:
53 case _SC_LEVEL3_CACHE_ASSOC
:
54 case _SC_LEVEL3_CACHE_LINESIZE
:
55 case _SC_LEVEL4_CACHE_SIZE
:
56 case _SC_LEVEL4_CACHE_ASSOC
:
61 assert (! "cannot happen");
68 static const struct intel_02_cache_info
77 { 0x06, _SC_LEVEL1_ICACHE_SIZE
, 8192, 4, 32 },
78 { 0x08, _SC_LEVEL1_ICACHE_SIZE
, 16384, 4, 32 },
79 { 0x0a, _SC_LEVEL1_DCACHE_SIZE
, 8192, 2, 32 },
80 { 0x0c, _SC_LEVEL1_DCACHE_SIZE
, 16384, 4, 32 },
81 { 0x22, _SC_LEVEL3_CACHE_SIZE
, 524288, 4, 64 },
82 { 0x23, _SC_LEVEL3_CACHE_SIZE
, 1048576, 8, 64 },
83 { 0x25, _SC_LEVEL3_CACHE_SIZE
, 2097152, 8, 64 },
84 { 0x29, _SC_LEVEL3_CACHE_SIZE
, 4194304, 8, 64 },
85 { 0x2c, _SC_LEVEL1_DCACHE_SIZE
, 32768, 8, 64 },
86 { 0x30, _SC_LEVEL1_ICACHE_SIZE
, 32768, 8, 64 },
87 { 0x39, _SC_LEVEL2_CACHE_SIZE
, 131072, 4, 64 },
88 { 0x3a, _SC_LEVEL2_CACHE_SIZE
, 196608, 6, 64 },
89 { 0x3b, _SC_LEVEL2_CACHE_SIZE
, 131072, 2, 64 },
90 { 0x3c, _SC_LEVEL2_CACHE_SIZE
, 262144, 4, 64 },
91 { 0x3d, _SC_LEVEL2_CACHE_SIZE
, 393216, 6, 64 },
92 { 0x3e, _SC_LEVEL2_CACHE_SIZE
, 524288, 4, 64 },
93 { 0x3f, _SC_LEVEL2_CACHE_SIZE
, 262144, 2, 64 },
94 { 0x41, _SC_LEVEL2_CACHE_SIZE
, 131072, 4, 32 },
95 { 0x42, _SC_LEVEL2_CACHE_SIZE
, 262144, 4, 32 },
96 { 0x43, _SC_LEVEL2_CACHE_SIZE
, 524288, 4, 32 },
97 { 0x44, _SC_LEVEL2_CACHE_SIZE
, 1048576, 4, 32 },
98 { 0x45, _SC_LEVEL2_CACHE_SIZE
, 2097152, 4, 32 },
99 { 0x46, _SC_LEVEL3_CACHE_SIZE
, 4194304, 4, 64 },
100 { 0x47, _SC_LEVEL3_CACHE_SIZE
, 8388608, 8, 64 },
101 { 0x48, _SC_LEVEL2_CACHE_SIZE
, 3145728, 12, 64 },
102 { 0x49, _SC_LEVEL2_CACHE_SIZE
, 4194304, 16, 64 },
103 { 0x4a, _SC_LEVEL3_CACHE_SIZE
, 6291456, 12, 64 },
104 { 0x4b, _SC_LEVEL3_CACHE_SIZE
, 8388608, 16, 64 },
105 { 0x4c, _SC_LEVEL3_CACHE_SIZE
, 12582912, 12, 64 },
106 { 0x4d, _SC_LEVEL3_CACHE_SIZE
, 16777216, 16, 64 },
107 { 0x4e, _SC_LEVEL2_CACHE_SIZE
, 6291456, 24, 64 },
108 { 0x60, _SC_LEVEL1_DCACHE_SIZE
, 16384, 8, 64 },
109 { 0x66, _SC_LEVEL1_DCACHE_SIZE
, 8192, 4, 64 },
110 { 0x67, _SC_LEVEL1_DCACHE_SIZE
, 16384, 4, 64 },
111 { 0x68, _SC_LEVEL1_DCACHE_SIZE
, 32768, 4, 64 },
112 { 0x78, _SC_LEVEL2_CACHE_SIZE
, 1048576, 8, 64 },
113 { 0x79, _SC_LEVEL2_CACHE_SIZE
, 131072, 8, 64 },
114 { 0x7a, _SC_LEVEL2_CACHE_SIZE
, 262144, 8, 64 },
115 { 0x7b, _SC_LEVEL2_CACHE_SIZE
, 524288, 8, 64 },
116 { 0x7c, _SC_LEVEL2_CACHE_SIZE
, 1048576, 8, 64 },
117 { 0x7d, _SC_LEVEL2_CACHE_SIZE
, 2097152, 8, 64 },
118 { 0x7f, _SC_LEVEL2_CACHE_SIZE
, 524288, 2, 64 },
119 { 0x82, _SC_LEVEL2_CACHE_SIZE
, 262144, 8, 32 },
120 { 0x83, _SC_LEVEL2_CACHE_SIZE
, 524288, 8, 32 },
121 { 0x84, _SC_LEVEL2_CACHE_SIZE
, 1048576, 8, 32 },
122 { 0x85, _SC_LEVEL2_CACHE_SIZE
, 2097152, 8, 32 },
123 { 0x86, _SC_LEVEL2_CACHE_SIZE
, 524288, 4, 64 },
124 { 0x87, _SC_LEVEL2_CACHE_SIZE
, 1048576, 8, 64 },
126 #define nintel_02_known (sizeof (intel_02_known) / sizeof (intel_02_known[0]))
130 intel_02_known_compare (const void *p1
, const void *p2
)
132 const struct intel_02_cache_info
*i1
;
133 const struct intel_02_cache_info
*i2
;
135 i1
= (const struct intel_02_cache_info
*) p1
;
136 i2
= (const struct intel_02_cache_info
*) p2
;
138 if (i1
->idx
== i2
->idx
)
141 return i1
->idx
< i2
->idx
? -1 : 1;
146 __attribute__ ((noinline
))
147 intel_check_word (int name
, unsigned int value
, bool *has_level_2
,
148 bool *no_level_2_or_3
)
150 if ((value
& 0x80000000) != 0)
151 /* The register value is reserved. */
154 /* Fold the name. The _SC_ constants are always in the order SIZE,
156 int folded_name
= (_SC_LEVEL1_ICACHE_SIZE
157 + ((name
- _SC_LEVEL1_ICACHE_SIZE
) / 3) * 3);
161 unsigned int byte
= value
& 0xff;
165 *no_level_2_or_3
= true;
167 if (folded_name
== _SC_LEVEL3_CACHE_SIZE
)
168 /* No need to look further. */
173 if (byte
== 0x49 && folded_name
== _SC_LEVEL3_CACHE_SIZE
)
175 /* Intel reused this value. For family 15, model 6 it
176 specifies the 3rd level cache. Otherwise the 2nd
182 asm volatile ("xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
183 : "=a" (eax
), "=r" (ebx
), "=c" (ecx
), "=d" (edx
)
186 unsigned int family
= ((eax
>> 20) & 0xff) + ((eax
>> 8) & 0xf);
187 unsigned int model
= ((((eax
>>16) & 0xf) << 4)
188 + ((eax
>> 4) & 0xf));
189 if (family
== 15 && model
== 6)
191 /* The level 3 cache is encoded for this model like
192 the level 2 cache is for other models. Pretend
193 the caller asked for the level 2 cache. */
194 name
= (_SC_LEVEL2_CACHE_SIZE
195 + (name
- _SC_LEVEL3_CACHE_SIZE
));
196 folded_name
= _SC_LEVEL3_CACHE_SIZE
;
200 struct intel_02_cache_info
*found
;
201 struct intel_02_cache_info search
;
204 found
= bsearch (&search
, intel_02_known
, nintel_02_known
,
205 sizeof (intel_02_known
[0]), intel_02_known_compare
);
208 if (found
->name
== folded_name
)
210 unsigned int offset
= name
- folded_name
;
218 assert (offset
== 2);
219 return found
->linesize
;
222 if (found
->name
== _SC_LEVEL2_CACHE_SIZE
)
227 /* Next byte for the next round. */
236 static long int __attribute__ ((noinline
))
237 handle_intel (int name
, unsigned int maxidx
)
241 // XXX Do such processors exist? When we know we can fill in some
246 /* OK, we can use the CPUID instruction to get all info about the
248 unsigned int cnt
= 0;
249 unsigned int max
= 1;
251 bool no_level_2_or_3
= false;
252 bool has_level_2
= false;
259 asm volatile ("xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
260 : "=a" (eax
), "=r" (ebx
), "=c" (ecx
), "=d" (edx
)
263 /* The low byte of EAX in the first round contain the number of
264 rounds we have to make. At least one, the one we are already
272 /* Process the individual registers' value. */
273 result
= intel_check_word (name
, eax
, &has_level_2
, &no_level_2_or_3
);
277 result
= intel_check_word (name
, ebx
, &has_level_2
, &no_level_2_or_3
);
281 result
= intel_check_word (name
, ecx
, &has_level_2
, &no_level_2_or_3
);
285 result
= intel_check_word (name
, edx
, &has_level_2
, &no_level_2_or_3
);
290 if (name
>= _SC_LEVEL2_CACHE_SIZE
&& name
<= _SC_LEVEL3_CACHE_LINESIZE
298 static long int __attribute__ ((noinline
))
299 handle_amd (int name
)
305 asm volatile ("xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
306 : "=a" (eax
), "=r" (ebx
), "=c" (ecx
), "=d" (edx
)
309 if (name
>= _SC_LEVEL3_CACHE_SIZE
)
312 unsigned int fn
= 0x80000005 + (name
>= _SC_LEVEL2_CACHE_SIZE
);
316 asm volatile ("xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
317 : "=a" (eax
), "=r" (ebx
), "=c" (ecx
), "=d" (edx
)
320 if (name
< _SC_LEVEL1_DCACHE_SIZE
)
322 name
+= _SC_LEVEL1_DCACHE_SIZE
- _SC_LEVEL1_ICACHE_SIZE
;
328 case _SC_LEVEL1_DCACHE_SIZE
:
329 return (ecx
>> 14) & 0x3fc00;
330 case _SC_LEVEL1_DCACHE_ASSOC
:
332 if ((ecx
& 0xff) == 0xff)
333 /* Fully associative. */
334 return (ecx
<< 2) & 0x3fc00;
336 case _SC_LEVEL1_DCACHE_LINESIZE
:
338 case _SC_LEVEL2_CACHE_SIZE
:
339 return (ecx
& 0xf000) == 0 ? 0 : (ecx
>> 6) & 0x3fffc00;
340 case _SC_LEVEL2_CACHE_ASSOC
:
354 return (ecx
<< 6) & 0x3fffc00;
358 case _SC_LEVEL2_CACHE_LINESIZE
:
359 return (ecx
& 0xf000) == 0 ? 0 : ecx
& 0xff;
361 assert (! "cannot happen");
368 i386_i486_test (void)
372 asm volatile ("pushfl;\n\t"
374 "movl $0x240000, %1;\n\t"
383 : "=r" (eflags
), "=r" (ac
));
389 /* Get the value of the system variable NAME. */
393 /* All the remainder, except the cache information, is handled in
395 if (name
< _SC_LEVEL1_ICACHE_SIZE
|| name
> _SC_LEVEL4_CACHE_LINESIZE
)
396 return linux_sysconf (name
);
398 /* Recognize i386 and compatible. These don't have any cache on
400 int ac
= i386_i486_test ();
403 /* This is an i386. */
404 // XXX Is this true for all brands?
407 /* Detect i486, the last Intel processor without CPUID. */
408 if ((ac
& (1 << 21)) == 0)
411 // XXX Fill in info about other brands. For now only Intel.
412 return handle_i486 (name
);
415 /* Find out what brand of processor. */
420 asm volatile ("xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
421 : "=a" (eax
), "=r" (ebx
), "=c" (ecx
), "=d" (edx
)
424 /* This spells out "GenuineIntel". */
425 if (ebx
== 0x756e6547 && ecx
== 0x6c65746e && edx
== 0x49656e69)
426 return handle_intel (name
, eax
);
428 /* This spells out "AuthenticAMD". */
429 if (ebx
== 0x68747541 && ecx
== 0x444d4163 && edx
== 0x69746e65)
430 return handle_amd (name
);
432 // XXX Fill in more vendors.
434 /* CPU not known, we have no information. */
438 /* Now the generic Linux version. */
440 #define __sysconf static linux_sysconf
441 #include "../sysconf.c"