1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/sys_info.h"
6
7 #include <dlfcn.h>
8 #include <stddef.h>
9 #include <stdint.h>
10 #include <sys/system_properties.h>
11
12 #include "base/android/jni_android.h"
13 #include "base/android/sys_utils.h"
14 #include "base/lazy_instance.h"
15 #include "base/logging.h"
16 #include "base/strings/string_number_conversions.h"
17 #include "base/strings/string_piece.h"
18 #include "base/strings/stringprintf.h"
19 #include "base/sys_info_internal.h"
20
21 #if (__ANDROID_API__ >= 21 /* 5.0 - Lollipop */)
22
23 namespace {
24
25 typedef int (SystemPropertyGetFunction)(const char*, char*);
26
DynamicallyLoadRealSystemPropertyGet()27 SystemPropertyGetFunction* DynamicallyLoadRealSystemPropertyGet() {
28 // libc.so should already be open, get a handle to it.
29 void* handle = dlopen("libc.so", RTLD_NOLOAD);
30 if (!handle) {
31 LOG(FATAL) << "Cannot dlopen libc.so: " << dlerror();
32 }
33 SystemPropertyGetFunction* real_system_property_get =
34 reinterpret_cast<SystemPropertyGetFunction*>(
35 dlsym(handle, "__system_property_get"));
36 if (!real_system_property_get) {
37 LOG(FATAL) << "Cannot resolve __system_property_get(): " << dlerror();
38 }
39 return real_system_property_get;
40 }
41
42 static base::LazyInstance<base::internal::LazySysInfoValue<
43 SystemPropertyGetFunction*, DynamicallyLoadRealSystemPropertyGet> >::Leaky
44 g_lazy_real_system_property_get = LAZY_INSTANCE_INITIALIZER;
45
46 } // namespace
47
48 // Android 'L' removes __system_property_get from the NDK, however it is still
49 // a hidden symbol in libc. Until we remove all calls of __system_property_get
50 // from Chrome we work around this by defining a weak stub here, which uses
51 // dlsym to but ensures that Chrome uses the real system
52 // implementatation when loaded. http://crbug.com/392191.
__system_property_get(const char * name,char * value)53 BASE_EXPORT int __system_property_get(const char* name, char* value) {
54 return g_lazy_real_system_property_get.Get().value()(name, value);
55 }
56
57 #endif
58
59 namespace {
60
61 // Default version of Android to fall back to when actual version numbers
62 // cannot be acquired. Use the latest Android release with a higher bug fix
63 // version to avoid unnecessarily comparison errors with the latest release.
64 // This should be manually kept up to date on each Android release.
65 const int kDefaultAndroidMajorVersion = 8;
66 const int kDefaultAndroidMinorVersion = 1;
67 const int kDefaultAndroidBugfixVersion = 99;
68
69 // Get and parse out the OS version numbers from the system properties.
70 // Note if parse fails, the "default" version is returned as fallback.
GetOsVersionStringAndNumbers(std::string * version_string,int32_t * major_version,int32_t * minor_version,int32_t * bugfix_version)71 void GetOsVersionStringAndNumbers(std::string* version_string,
72 int32_t* major_version,
73 int32_t* minor_version,
74 int32_t* bugfix_version) {
75 // Read the version number string out from the properties.
76 char os_version_str[PROP_VALUE_MAX];
77 __system_property_get("ro.build.version.release", os_version_str);
78
79 if (os_version_str[0]) {
80 // Try to parse out the version numbers from the string.
81 int num_read = sscanf(os_version_str, "%d.%d.%d", major_version,
82 minor_version, bugfix_version);
83
84 if (num_read > 0) {
85 // If we don't have a full set of version numbers, make the extras 0.
86 if (num_read < 2)
87 *minor_version = 0;
88 if (num_read < 3)
89 *bugfix_version = 0;
90 *version_string = std::string(os_version_str);
91 return;
92 }
93 }
94
95 // For some reason, we couldn't parse the version number string.
96 *major_version = kDefaultAndroidMajorVersion;
97 *minor_version = kDefaultAndroidMinorVersion;
98 *bugfix_version = kDefaultAndroidBugfixVersion;
99 *version_string = ::base::StringPrintf("%d.%d.%d", *major_version,
100 *minor_version, *bugfix_version);
101 }
102
103 // Parses a system property (specified with unit 'k','m' or 'g').
104 // Returns a value in bytes.
105 // Returns -1 if the string could not be parsed.
ParseSystemPropertyBytes(const base::StringPiece & str)106 int64_t ParseSystemPropertyBytes(const base::StringPiece& str) {
107 const int64_t KB = 1024;
108 const int64_t MB = 1024 * KB;
109 const int64_t GB = 1024 * MB;
110 if (str.size() == 0u)
111 return -1;
112 int64_t unit_multiplier = 1;
113 size_t length = str.size();
114 if (str[length - 1] == 'k') {
115 unit_multiplier = KB;
116 length--;
117 } else if (str[length - 1] == 'm') {
118 unit_multiplier = MB;
119 length--;
120 } else if (str[length - 1] == 'g') {
121 unit_multiplier = GB;
122 length--;
123 }
124 int64_t result = 0;
125 bool parsed = base::StringToInt64(str.substr(0, length), &result);
126 bool negative = result <= 0;
127 bool overflow =
128 result >= std::numeric_limits<int64_t>::max() / unit_multiplier;
129 if (!parsed || negative || overflow)
130 return -1;
131 return result * unit_multiplier;
132 }
133
GetDalvikHeapSizeMB()134 int GetDalvikHeapSizeMB() {
135 char heap_size_str[PROP_VALUE_MAX];
136 __system_property_get("dalvik.vm.heapsize", heap_size_str);
137 // dalvik.vm.heapsize property is writable by a root user.
138 // Clamp it to reasonable range as a sanity check,
139 // a typical android device will never have less than 48MB.
140 const int64_t MB = 1024 * 1024;
141 int64_t result = ParseSystemPropertyBytes(heap_size_str);
142 if (result == -1) {
143 // We should consider not exposing these values if they are not reliable.
144 LOG(ERROR) << "Can't parse dalvik.vm.heapsize: " << heap_size_str;
145 result = base::SysInfo::AmountOfPhysicalMemoryMB() / 3;
146 }
147 result =
148 std::min<int64_t>(std::max<int64_t>(32 * MB, result), 1024 * MB) / MB;
149 return static_cast<int>(result);
150 }
151
GetDalvikHeapGrowthLimitMB()152 int GetDalvikHeapGrowthLimitMB() {
153 char heap_size_str[PROP_VALUE_MAX];
154 __system_property_get("dalvik.vm.heapgrowthlimit", heap_size_str);
155 // dalvik.vm.heapgrowthlimit property is writable by a root user.
156 // Clamp it to reasonable range as a sanity check,
157 // a typical android device will never have less than 24MB.
158 const int64_t MB = 1024 * 1024;
159 int64_t result = ParseSystemPropertyBytes(heap_size_str);
160 if (result == -1) {
161 // We should consider not exposing these values if they are not reliable.
162 LOG(ERROR) << "Can't parse dalvik.vm.heapgrowthlimit: " << heap_size_str;
163 result = base::SysInfo::AmountOfPhysicalMemoryMB() / 6;
164 }
165 result = std::min<int64_t>(std::max<int64_t>(16 * MB, result), 512 * MB) / MB;
166 return static_cast<int>(result);
167 }
168
169 } // anonymous namespace
170
171 namespace base {
172
HardwareModelName()173 std::string SysInfo::HardwareModelName() {
174 char device_model_str[PROP_VALUE_MAX];
175 __system_property_get("ro.product.model", device_model_str);
176 return std::string(device_model_str);
177 }
178
OperatingSystemName()179 std::string SysInfo::OperatingSystemName() {
180 return "Android";
181 }
182
OperatingSystemVersion()183 std::string SysInfo::OperatingSystemVersion() {
184 std::string version_string;
185 int32_t major, minor, bugfix;
186 GetOsVersionStringAndNumbers(&version_string, &major, &minor, &bugfix);
187 return version_string;
188 }
189
OperatingSystemVersionNumbers(int32_t * major_version,int32_t * minor_version,int32_t * bugfix_version)190 void SysInfo::OperatingSystemVersionNumbers(int32_t* major_version,
191 int32_t* minor_version,
192 int32_t* bugfix_version) {
193 std::string version_string;
194 GetOsVersionStringAndNumbers(&version_string, major_version, minor_version,
195 bugfix_version);
196 }
197
GetAndroidBuildCodename()198 std::string SysInfo::GetAndroidBuildCodename() {
199 char os_version_codename_str[PROP_VALUE_MAX];
200 __system_property_get("ro.build.version.codename", os_version_codename_str);
201 return std::string(os_version_codename_str);
202 }
203
GetAndroidBuildID()204 std::string SysInfo::GetAndroidBuildID() {
205 char os_build_id_str[PROP_VALUE_MAX];
206 __system_property_get("ro.build.id", os_build_id_str);
207 return std::string(os_build_id_str);
208 }
209
DalvikHeapSizeMB()210 int SysInfo::DalvikHeapSizeMB() {
211 static int heap_size = GetDalvikHeapSizeMB();
212 return heap_size;
213 }
214
DalvikHeapGrowthLimitMB()215 int SysInfo::DalvikHeapGrowthLimitMB() {
216 static int heap_growth_limit = GetDalvikHeapGrowthLimitMB();
217 return heap_growth_limit;
218 }
219
220 static base::LazyInstance<
221 base::internal::LazySysInfoValue<bool,
222 android::SysUtils::IsLowEndDeviceFromJni> >::Leaky
223 g_lazy_low_end_device = LAZY_INSTANCE_INITIALIZER;
224
IsLowEndDeviceImpl()225 bool SysInfo::IsLowEndDeviceImpl() {
226 // This code might be used in some environments
227 // which might not have a Java environment.
228 // Note that we need to call the Java version here.
229 // There exists a complete native implementation in
230 // sys_info.cc but calling that here would mean that
231 // the Java code and the native code would call different
232 // implementations which could give different results.
233 // Also the Java code cannot depend on the native code
234 // since it might not be loaded yet.
235 if (!base::android::IsVMInitialized())
236 return false;
237 return g_lazy_low_end_device.Get().value();
238 }
239
240
241 } // namespace base
242