• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *  * Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *  * Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in
12  *    the documentation and/or other materials provided with the
13  *    distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 /* ChangeLog for this library:
30  *
31  * NDK r7c: Fix CPU count computation. The old method only reported the
32  *           number of _active_ CPUs when the library was initialized,
33  *           which could be less than the real total.
34  *
35  * NDK r5: Handle buggy kernels which report a CPU Architecture number of 7
36  *         for an ARMv6 CPU (see below).
37  *
38  *         Handle kernels that only report 'neon', and not 'vfpv3'
39  *         (VFPv3 is mandated by the ARM architecture is Neon is implemented)
40  *
41  *         Handle kernels that only report 'vfpv3d16', and not 'vfpv3'
42  *
43  *         Fix x86 compilation. Report ANDROID_CPU_FAMILY_X86 in
44  *         android_getCpuFamily().
45  *
46  * NDK r4: Initial release
47  */
48 #include <sys/system_properties.h>
49 #ifdef __arm__
50 #include <machine/cpu-features.h>
51 #endif
52 #include <pthread.h>
53 #include "cpu-features.h"
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <fcntl.h>
57 #include <errno.h>
58 
59 static  pthread_once_t     g_once;
60 static  AndroidCpuFamily   g_cpuFamily;
61 static  uint64_t           g_cpuFeatures;
62 static  int                g_cpuCount;
63 
64 static const int  android_cpufeatures_debug = 0;
65 
66 #ifdef __arm__
67 #  define DEFAULT_CPU_FAMILY  ANDROID_CPU_FAMILY_ARM
68 #elif defined __i386__
69 #  define DEFAULT_CPU_FAMILY  ANDROID_CPU_FAMILY_X86
70 #else
71 #  define DEFAULT_CPU_FAMILY  ANDROID_CPU_FAMILY_UNKNOWN
72 #endif
73 
74 #define  D(...) \
75     do { \
76         if (android_cpufeatures_debug) { \
77             printf(__VA_ARGS__); fflush(stdout); \
78         } \
79     } while (0)
80 
81 #ifdef __i386__
x86_cpuid(int func,int values[4])82 static __inline__ void x86_cpuid(int func, int values[4])
83 {
84     int a, b, c, d;
85     /* We need to preserve ebx since we're compiling PIC code */
86     /* this means we can't use "=b" for the second output register */
87     __asm__ __volatile__ ( \
88       "push %%ebx\n"
89       "cpuid\n" \
90       "mov %1, %%ebx\n"
91       "pop %%ebx\n"
92       : "=a" (a), "=r" (b), "=c" (c), "=d" (d) \
93       : "a" (func) \
94     );
95     values[0] = a;
96     values[1] = b;
97     values[2] = c;
98     values[3] = d;
99 }
100 #endif
101 
102 /* Read the content of /proc/cpuinfo into a user-provided buffer.
103  * Return the length of the data, or -1 on error. Does *not*
104  * zero-terminate the content. Will not read more
105  * than 'buffsize' bytes.
106  */
107 static int
read_file(const char * pathname,char * buffer,size_t buffsize)108 read_file(const char*  pathname, char*  buffer, size_t  buffsize)
109 {
110     int  fd, len;
111 
112     fd = open(pathname, O_RDONLY);
113     if (fd < 0)
114         return -1;
115 
116     do {
117         len = read(fd, buffer, buffsize);
118     } while (len < 0 && errno == EINTR);
119 
120     close(fd);
121 
122     return len;
123 }
124 
125 /* Extract the content of a the first occurence of a given field in
126  * the content of /proc/cpuinfo and return it as a heap-allocated
127  * string that must be freed by the caller.
128  *
129  * Return NULL if not found
130  */
131 static char*
extract_cpuinfo_field(char * buffer,int buflen,const char * field)132 extract_cpuinfo_field(char* buffer, int buflen, const char* field)
133 {
134     int  fieldlen = strlen(field);
135     char* bufend = buffer + buflen;
136     char* result = NULL;
137     int len, ignore;
138     const char *p, *q;
139 
140     /* Look for first field occurence, and ensures it starts the line.
141      */
142     p = buffer;
143     bufend = buffer + buflen;
144     for (;;) {
145         p = memmem(p, bufend-p, field, fieldlen);
146         if (p == NULL)
147             goto EXIT;
148 
149         if (p == buffer || p[-1] == '\n')
150             break;
151 
152         p += fieldlen;
153     }
154 
155     /* Skip to the first column followed by a space */
156     p += fieldlen;
157     p  = memchr(p, ':', bufend-p);
158     if (p == NULL || p[1] != ' ')
159         goto EXIT;
160 
161     /* Find the end of the line */
162     p += 2;
163     q = memchr(p, '\n', bufend-p);
164     if (q == NULL)
165         q = bufend;
166 
167     /* Copy the line into a heap-allocated buffer */
168     len = q-p;
169     result = malloc(len+1);
170     if (result == NULL)
171         goto EXIT;
172 
173     memcpy(result, p, len);
174     result[len] = '\0';
175 
176 EXIT:
177     return result;
178 }
179 
180 /* Like strlen(), but for constant string literals */
181 #define STRLEN_CONST(x)  ((sizeof(x)-1)
182 
183 
184 /* Checks that a space-separated list of items contains one given 'item'.
185  * Returns 1 if found, 0 otherwise.
186  */
187 static int
has_list_item(const char * list,const char * item)188 has_list_item(const char* list, const char* item)
189 {
190     const char*  p = list;
191     int itemlen = strlen(item);
192 
193     if (list == NULL)
194         return 0;
195 
196     while (*p) {
197         const char*  q;
198 
199         /* skip spaces */
200         while (*p == ' ' || *p == '\t')
201             p++;
202 
203         /* find end of current list item */
204         q = p;
205         while (*q && *q != ' ' && *q != '\t')
206             q++;
207 
208         if (itemlen == q-p && !memcmp(p, item, itemlen))
209             return 1;
210 
211         /* skip to next item */
212         p = q;
213     }
214     return 0;
215 }
216 
217 /* Parse an decimal integer starting from 'input', but not going further
218  * than 'limit'. Return the value into '*result'.
219  *
220  * NOTE: Does not skip over leading spaces, or deal with sign characters.
221  * NOTE: Ignores overflows.
222  *
223  * The function returns NULL in case of error (bad format), or the new
224  * position after the decimal number in case of success (which will always
225  * be <= 'limit').
226  */
227 static const char*
parse_decimal(const char * input,const char * limit,int * result)228 parse_decimal(const char* input, const char* limit, int* result)
229 {
230     const char* p = input;
231     int val = 0;
232     while (p < limit) {
233         int d = (*p - '0');
234         if ((unsigned)d >= 10U)
235             break;
236         val = val*10 + d;
237         p++;
238     }
239     if (p == input)
240         return NULL;
241 
242     *result = val;
243     return p;
244 }
245 
246 /* This small data type is used to represent a CPU list / mask, as read
247  * from sysfs on Linux. See http://www.kernel.org/doc/Documentation/cputopology.txt
248  *
249  * For now, we don't expect more than 32 cores on mobile devices, so keep
250  * everything simple.
251  */
252 typedef struct {
253     uint32_t mask;
254 } CpuList;
255 
256 static __inline__ void
cpulist_init(CpuList * list)257 cpulist_init(CpuList* list) {
258     list->mask = 0;
259 }
260 
261 static __inline__ void
cpulist_and(CpuList * list1,CpuList * list2)262 cpulist_and(CpuList* list1, CpuList* list2) {
263     list1->mask &= list2->mask;
264 }
265 
266 static __inline__ void
cpulist_set(CpuList * list,int index)267 cpulist_set(CpuList* list, int index) {
268     if ((unsigned)index < 32) {
269         list->mask |= (uint32_t)(1U << index);
270     }
271 }
272 
273 static __inline__ int
cpulist_count(CpuList * list)274 cpulist_count(CpuList* list) {
275     return __builtin_popcount(list->mask);
276 }
277 
278 /* Parse a textual list of cpus and store the result inside a CpuList object.
279  * Input format is the following:
280  * - comma-separated list of items (no spaces)
281  * - each item is either a single decimal number (cpu index), or a range made
282  *   of two numbers separated by a single dash (-). Ranges are inclusive.
283  *
284  * Examples:   0
285  *             2,4-127,128-143
286  *             0-1
287  */
288 static void
cpulist_parse(CpuList * list,const char * line,int line_len)289 cpulist_parse(CpuList* list, const char* line, int line_len)
290 {
291     const char* p = line;
292     const char* end = p + line_len;
293     const char* q;
294 
295     /* NOTE: the input line coming from sysfs typically contains a
296      * trailing newline, so take care of it in the code below
297      */
298     while (p < end && *p != '\n')
299     {
300         int val, start_value, end_value;
301 
302         /* Find the end of current item, and put it into 'q' */
303         q = memchr(p, ',', end-p);
304         if (q == NULL) {
305             q = end;
306         }
307 
308         /* Get first value */
309         p = parse_decimal(p, q, &start_value);
310         if (p == NULL)
311             goto BAD_FORMAT;
312 
313         end_value = start_value;
314 
315         /* If we're not at the end of the item, expect a dash and
316          * and integer; extract end value.
317          */
318         if (p < q && *p == '-') {
319             p = parse_decimal(p+1, q, &end_value);
320             if (p == NULL)
321                 goto BAD_FORMAT;
322         }
323 
324         /* Set bits CPU list bits */
325         for (val = start_value; val <= end_value; val++) {
326             cpulist_set(list, val);
327         }
328 
329         /* Jump to next item */
330         p = q;
331         if (p < end)
332             p++;
333     }
334 
335 BAD_FORMAT:
336     ;
337 }
338 
339 /* Read a CPU list from one sysfs file */
340 static void
cpulist_read_from(CpuList * list,const char * filename)341 cpulist_read_from(CpuList* list, const char* filename)
342 {
343     char   file[64];
344     int    filelen;
345 
346     cpulist_init(list);
347 
348     filelen = read_file(filename, file, sizeof file);
349     if (filelen < 0) {
350         D("Could not read %s: %s\n", filename, strerror(errno));
351         return;
352     }
353 
354     cpulist_parse(list, file, filelen);
355 }
356 
357 /* Return the number of cpus present on a given device.
358  *
359  * To handle all weird kernel configurations, we need to compute the
360  * intersection of the 'present' and 'possible' CPU lists and count
361  * the result.
362  */
363 static int
get_cpu_count(void)364 get_cpu_count(void)
365 {
366     CpuList cpus_present[1];
367     CpuList cpus_possible[1];
368 
369     cpulist_read_from(cpus_present, "/sys/devices/system/cpu/present");
370     cpulist_read_from(cpus_possible, "/sys/devices/system/cpu/possible");
371 
372     /* Compute the intersection of both sets to get the actual number of
373      * CPU cores that can be used on this device by the kernel.
374      */
375     cpulist_and(cpus_present, cpus_possible);
376 
377     return cpulist_count(cpus_present);
378 }
379 
380 static void
android_cpuInit(void)381 android_cpuInit(void)
382 {
383     char cpuinfo[4096];
384     int  cpuinfo_len;
385 
386     g_cpuFamily   = DEFAULT_CPU_FAMILY;
387     g_cpuFeatures = 0;
388     g_cpuCount    = 1;
389 
390     cpuinfo_len = read_file("/proc/cpuinfo", cpuinfo, sizeof cpuinfo);
391     D("cpuinfo_len is (%d):\n%.*s\n", cpuinfo_len,
392       cpuinfo_len >= 0 ? cpuinfo_len : 0, cpuinfo);
393 
394     if (cpuinfo_len < 0)  /* should not happen */ {
395         return;
396     }
397 
398     /* Count the CPU cores, the value may be 0 for single-core CPUs */
399     g_cpuCount = get_cpu_count();
400     if (g_cpuCount == 0) {
401         g_cpuCount = 1;
402     }
403 
404     D("found cpuCount = %d\n", g_cpuCount);
405 
406 #ifdef __ARM_ARCH__
407     {
408         char*  features = NULL;
409         char*  architecture = NULL;
410 
411         /* Extract architecture from the "CPU Architecture" field.
412          * The list is well-known, unlike the the output of
413          * the 'Processor' field which can vary greatly.
414          *
415          * See the definition of the 'proc_arch' array in
416          * $KERNEL/arch/arm/kernel/setup.c and the 'c_show' function in
417          * same file.
418          */
419         char* cpuArch = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "CPU architecture");
420 
421         if (cpuArch != NULL) {
422             char*  end;
423             long   archNumber;
424             int    hasARMv7 = 0;
425 
426             D("found cpuArch = '%s'\n", cpuArch);
427 
428             /* read the initial decimal number, ignore the rest */
429             archNumber = strtol(cpuArch, &end, 10);
430 
431             /* Here we assume that ARMv8 will be upwards compatible with v7
432                 * in the future. Unfortunately, there is no 'Features' field to
433                 * indicate that Thumb-2 is supported.
434                 */
435             if (end > cpuArch && archNumber >= 7) {
436                 hasARMv7 = 1;
437             }
438 
439             /* Unfortunately, it seems that certain ARMv6-based CPUs
440              * report an incorrect architecture number of 7!
441              *
442              * See http://code.google.com/p/android/issues/detail?id=10812
443              *
444              * We try to correct this by looking at the 'elf_format'
445              * field reported by the 'Processor' field, which is of the
446              * form of "(v7l)" for an ARMv7-based CPU, and "(v6l)" for
447              * an ARMv6-one.
448              */
449             if (hasARMv7) {
450                 char* cpuProc = extract_cpuinfo_field(cpuinfo, cpuinfo_len,
451                                                       "Processor");
452                 if (cpuProc != NULL) {
453                     D("found cpuProc = '%s'\n", cpuProc);
454                     if (has_list_item(cpuProc, "(v6l)")) {
455                         D("CPU processor and architecture mismatch!!\n");
456                         hasARMv7 = 0;
457                     }
458                     free(cpuProc);
459                 }
460             }
461 
462             if (hasARMv7) {
463                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_ARMv7;
464             }
465 
466             /* The LDREX / STREX instructions are available from ARMv6 */
467             if (archNumber >= 6) {
468                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_LDREX_STREX;
469             }
470 
471             free(cpuArch);
472         }
473 
474         /* Extract the list of CPU features from 'Features' field */
475         char* cpuFeatures = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "Features");
476 
477         if (cpuFeatures != NULL) {
478 
479             D("found cpuFeatures = '%s'\n", cpuFeatures);
480 
481             if (has_list_item(cpuFeatures, "vfpv3"))
482                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
483 
484             else if (has_list_item(cpuFeatures, "vfpv3d16"))
485                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
486 
487             if (has_list_item(cpuFeatures, "neon")) {
488                 /* Note: Certain kernels only report neon but not vfpv3
489                     *       in their features list. However, ARM mandates
490                     *       that if Neon is implemented, so must be VFPv3
491                     *       so always set the flag.
492                     */
493                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_NEON |
494                                  ANDROID_CPU_ARM_FEATURE_VFPv3;
495             }
496             free(cpuFeatures);
497         }
498     }
499 #endif /* __ARM_ARCH__ */
500 
501 #ifdef __i386__
502     g_cpuFamily = ANDROID_CPU_FAMILY_X86;
503 
504     int regs[4];
505 
506 /* According to http://en.wikipedia.org/wiki/CPUID */
507 #define VENDOR_INTEL_b  0x756e6547
508 #define VENDOR_INTEL_c  0x6c65746e
509 #define VENDOR_INTEL_d  0x49656e69
510 
511     x86_cpuid(0, regs);
512     int vendorIsIntel = (regs[1] == VENDOR_INTEL_b &&
513                          regs[2] == VENDOR_INTEL_c &&
514                          regs[3] == VENDOR_INTEL_d);
515 
516     x86_cpuid(1, regs);
517     if ((regs[2] & (1 << 9)) != 0) {
518         g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_SSSE3;
519     }
520     if ((regs[2] & (1 << 23)) != 0) {
521         g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_POPCNT;
522     }
523     if (vendorIsIntel && (regs[2] & (1 << 22)) != 0) {
524         g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_MOVBE;
525     }
526 #endif
527 
528 #ifdef _MIPS_ARCH
529     g_cpuFamily = ANDROID_CPU_FAMILY_MIPS;
530 #endif /* _MIPS_ARCH */
531 }
532 
533 
534 AndroidCpuFamily
android_getCpuFamily(void)535 android_getCpuFamily(void)
536 {
537     pthread_once(&g_once, android_cpuInit);
538     return g_cpuFamily;
539 }
540 
541 
542 uint64_t
android_getCpuFeatures(void)543 android_getCpuFeatures(void)
544 {
545     pthread_once(&g_once, android_cpuInit);
546     return g_cpuFeatures;
547 }
548 
549 
550 int
android_getCpuCount(void)551 android_getCpuCount(void)
552 {
553     pthread_once(&g_once, android_cpuInit);
554     return g_cpuCount;
555 }
556