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