Clean up handling of invalid HWID when running ChromeOS in VMs

chromeos/system/statistics_provider.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/system/statistics_provider.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chromeos/app_mode/kiosk_oem_manifest_parser.h"
 #include "chromeos/chromeos_constants.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/system/name_value_pairs_parser.h"
 
 namespace chromeos {
 namespace system {
 
 namespace {
 
 // Path to the tool used to get system info, and delimiters for the output
 // format of the tool.
 const char* kCrosSystemTool[] = { "/usr/bin/crossystem" };
 const char kCrosSystemEq[] = "=";
 const char kCrosSystemDelim[] = "\n";
 const char kCrosSystemCommentDelim[] = "#";
-const char kCrosSystemUnknownValue[] = "(error)";
+const char kCrosSystemValueError[] = "(error)";
 
 const char kHardwareClassCrosSystemKey[] = "hwid";
-const char kUnknownHardwareClass[] = "unknown";
+const char kHardwareClassValueUnknown[] = "unknown";
 
-// File to get system vendor information from.
+const char kIsVmCrosSystemKey[] = "inside_vm";
+
+// File to get system vendor information from. (x86-only)
 const char kSystemVendorFile[] = "/sys/class/dmi/id/sys_vendor";
+const char kSystemVendorValueUnknown[] = "unknown";
 
 // Key/value delimiters of machine hardware info file. machine-info is generated
 // only for OOBE and enterprise enrollment and may not be present. See
 // login-manager/init/machine-info.conf.
 const char kMachineHardwareInfoEq[] = "=";
 const char kMachineHardwareInfoDelim[] = " \n";
 
 // File to get ECHO coupon info from, and key/value delimiters of
 // the file.
 const char kEchoCouponFile[] = "/var/cache/echo/vpd_echo.txt";
@@ skipping 90 matching lines @@
 const char kCheckEnrollmentKey[] = "check_enrollment";
 const char kCustomizationIdKey[] = "customization_id";
 const char kDevSwitchBootKey[] = "devsw_boot";
 const char kDevSwitchBootValueDev[] = "1";
 const char kDevSwitchBootValueVerified[] = "0";
 const char kFirmwareTypeKey[] = "mainfw_type";
 const char kFirmwareTypeValueDeveloper[] = "developer";
 const char kFirmwareTypeValueNonchrome[] = "nonchrome";
 const char kFirmwareTypeValueNormal[] = "normal";
 const char kHardwareClassKey[] = "hardware_class";
+const char kIsCrosVmKey[] = "inside_cros_vm";

[Daniel Erat, 2016/08/10 16:32:28]

this code is only built for chrome os, so including "cros" here (in both the
constant names and in this value) seems a bit redundant. mind switching to just
something like:

  const char kIsVmKey[] = "is_vm";

?

[norvez, 2016/08/11 17:10:34]

Done.

+const char kIsCrosVmValueTrue[] = "1";
+const char kIsCrosVmValueFalse[] = "0";
 const char kSystemVendorKey[] = "system_vendor";
 const char kOffersCouponCodeKey[] = "ubind_attribute";
 const char kOffersGroupCodeKey[] = "gbind_attribute";
 const char kRlzBrandCodeKey[] = "rlz_brand_code";
 const char kWriteProtectSwitchBootKey[] = "wpsw_boot";
 const char kWriteProtectSwitchBootValueOff[] = "0";
 const char kWriteProtectSwitchBootValueOn[] = "1";
 const char kRegionKey[] = "region";
 const char kInitialLocaleKey[] = "initial_locale";
 const char kInitialTimezoneKey[] = "initial_timezone";
@@ skipping 14 matching lines @@
  public:
   // StatisticsProvider implementation:
   void StartLoadingMachineStatistics(
       const scoped_refptr<base::TaskRunner>& file_task_runner,
       bool load_oem_manifest) override;
   bool GetMachineStatistic(const std::string& name,
                            std::string* result) override;
   bool GetMachineFlag(const std::string& name, bool* result) override;
   void Shutdown() override;
 
+  // Returns true when Chrome OS is running in a VM. NOTE: if crossystem is not
+  // installed it will return false even if Chrome OS is running in a VM.
+  bool IsRunningOnVm() override;
+
   static StatisticsProviderImpl* GetInstance();
 
  protected:
   typedef std::map<std::string, bool> MachineFlags;
   typedef bool (*RegionDataExtractor)(const base::DictionaryValue*,
                                       std::string*);
   friend struct base::DefaultSingletonTraits<StatisticsProviderImpl>;
 
   StatisticsProviderImpl();
   ~StatisticsProviderImpl() override;
@@ skipping 163 matching lines @@
   }
   if (result != nullptr)
     *result = iter->second;
   return true;
 }
 
 void StatisticsProviderImpl::Shutdown() {
   cancellation_flag_.Set();  // Cancel any pending loads
 }
 
+bool StatisticsProviderImpl::IsRunningOnVm() {
+  if (!base::SysInfo::IsRunningOnChromeOS())
+    return false;
+  std::string is_vm;
+  return GetMachineStatistic(kIsCrosVmKey, &is_vm) &&
+         is_vm == kIsCrosVmValueTrue;
+}
+
 StatisticsProviderImpl::StatisticsProviderImpl()
     : load_statistics_started_(false),
       on_statistics_loaded_(base::WaitableEvent::ResetPolicy::MANUAL,
                             base::WaitableEvent::InitialState::NOT_SIGNALED),
       oem_manifest_loaded_(false) {
   regional_data_extractors_[kInitialLocaleKey] =
       &GetInitialLocaleFromRegionalData;
   regional_data_extractors_[kKeyboardLayoutKey] =
       &GetKeyboardLayoutFromRegionalData;
   regional_data_extractors_[kInitialTimezoneKey] =
@@ skipping 52 matching lines @@
     int bytes_written = base::WriteFile(machine_info_path,
                                         stub_contents.c_str(),
                                         stub_contents.size());
     // static_cast<int> is fine because stub_contents is small.
     if (bytes_written < static_cast<int>(stub_contents.size())) {
       LOG(ERROR) << "Error writing machine info stub: "
                  << machine_info_path.value();
     }
   }
 
-  if (base::SysInfo::IsRunningOnChromeOS()) {
-    std::string system_vendor;
-    base::ReadFileToString(base::FilePath(kSystemVendorFile), &system_vendor);
-    machine_info_[kSystemVendorKey] = system_vendor;
-  }
-
   parser.GetNameValuePairsFromFile(machine_info_path,
                                    kMachineHardwareInfoEq,
                                    kMachineHardwareInfoDelim);
   parser.GetNameValuePairsFromFile(base::FilePath(kEchoCouponFile),
                                    kEchoCouponEq,
                                    kEchoCouponDelim);
   parser.GetNameValuePairsFromFile(base::FilePath(kVpdFile),
                                    kVpdEq,
                                    kVpdDelim);
 
   // Ensure that the hardware class key is present with the expected
   // key name, and if it couldn't be retrieved, that the value is "unknown".
   std::string hardware_class = machine_info_[kHardwareClassCrosSystemKey];
-  if (hardware_class.empty() || hardware_class == kCrosSystemUnknownValue)
-    machine_info_[kHardwareClassKey] = kUnknownHardwareClass;
-  else
+  if (hardware_class.empty() || hardware_class == kCrosSystemValueError) {
+    machine_info_[kHardwareClassKey] = kHardwareClassValueUnknown;
+  } else {
     machine_info_[kHardwareClassKey] = hardware_class;
+  }
+
+  if (base::SysInfo::IsRunningOnChromeOS()) {
+    // By default, assume that this is *not* a VM. If crossystem is not present,
+    // report that we are not in a VM.
+    machine_info_[kIsCrosVmKey] = kIsCrosVmValueFalse;
+    const auto is_vm_iter = machine_info_.find(kIsVmCrosSystemKey);
+    if (is_vm_iter != machine_info_.end() &&
+        is_vm_iter->second == kIsCrosVmValueTrue) {
+      machine_info_[kIsCrosVmKey] = kIsCrosVmValueTrue;
+    }
+
+    // Ensure that the system vendor key is present, in particular it is
+    // potentially useful for VM environments from different vendors.
+    // On non-x86 architectures the value will be "unknown".
+    machine_info_[kSystemVendorKey] = kSystemVendorValueUnknown;
+    std::string system_vendor;
+    if (base::ReadFileToString(base::FilePath(kSystemVendorFile),
+                               &system_vendor)) {
+      base::TrimWhitespaceASCII(system_vendor, base::TRIM_ALL, &system_vendor);
+      if (!system_vendor.empty())
+        machine_info_[kSystemVendorKey] = system_vendor;

[achuithb, 2016/08/10 18:24:58]

Do we actually care about this?

[norvez, 2016/08/11 17:10:34]

Removed system_vendor altogether

+    }
+  }
 
   if (load_oem_manifest) {
     // If kAppOemManifestFile switch is specified, load OEM Manifest file.
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     if (command_line->HasSwitch(switches::kAppOemManifestFile)) {
       LoadOemManifestFromFile(
           command_line->GetSwitchValuePath(switches::kAppOemManifestFile));
     } else if (base::SysInfo::IsRunningOnChromeOS()) {
       LoadOemManifestFromFile(base::FilePath(kOemManifestFilePath));
     }
@@ skipping 88 matching lines @@
   return StatisticsProviderImpl::GetInstance();
 }
 
 // static
 void StatisticsProvider::SetTestProvider(StatisticsProvider* test_provider) {
   g_test_statistics_provider = test_provider;
 }
 
 }  // namespace system
 }  // namespace chromeos