base/sys_info_android.cc

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