| OLD | NEW |
|---|
| (Empty) |
| 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::HardwareModelName() { | |
| 159 char device_model_str[PROP_VALUE_MAX]; | |
| 160 __system_property_get("ro.product.model", device_model_str); | |
| 161 return std::string(device_model_str); | |
| 162 } | |
| 163 | |
| 164 std::string SysInfo::OperatingSystemName() { | |
| 165 return "Android"; | |
| 166 } | |
| 167 | |
| 168 std::string SysInfo::OperatingSystemVersion() { | |
| 169 int32 major, minor, bugfix; | |
| 170 OperatingSystemVersionNumbers(&major, &minor, &bugfix); | |
| 171 return StringPrintf("%d.%d.%d", major, minor, bugfix); | |
| 172 } | |
| 173 | |
| 174 void SysInfo::OperatingSystemVersionNumbers(int32* major_version, | |
| 175 int32* minor_version, | |
| 176 int32* bugfix_version) { | |
| 177 // Read the version number string out from the properties. | |
| 178 char os_version_str[PROP_VALUE_MAX]; | |
| 179 __system_property_get("ro.build.version.release", os_version_str); | |
| 180 | |
| 181 // Parse out the numbers. | |
| 182 ParseOSVersionNumbers(os_version_str, major_version, minor_version, | |
| 183 bugfix_version); | |
| 184 } | |
| 185 | |
| 186 std::string SysInfo::GetAndroidBuildCodename() { | |
| 187 char os_version_codename_str[PROP_VALUE_MAX]; | |
| 188 __system_property_get("ro.build.version.codename", os_version_codename_str); | |
| 189 return std::string(os_version_codename_str); | |
| 190 } | |
| 191 | |
| 192 std::string SysInfo::GetAndroidBuildID() { | |
| 193 char os_build_id_str[PROP_VALUE_MAX]; | |
| 194 __system_property_get("ro.build.id", os_build_id_str); | |
| 195 return std::string(os_build_id_str); | |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
