// Copyright 2020 The Crashpad Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "snapshot/ios/system_snapshot_ios_intermediate_dump.h"
#include <mach/mach.h>
#include <stddef.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <algorithm>
#include "base/apple/mach_logging.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "snapshot/cpu_context.h"
#include "snapshot/ios/intermediate_dump_reader_util.h"
#include "snapshot/posix/timezone.h"
#include "util/ios/ios_intermediate_dump_data.h"
#include "util/mac/mac_util.h"
#include "util/numeric/in_range_cast.h"
namespace crashpad {
namespace internal {
using Key = IntermediateDumpKey;
SystemSnapshotIOSIntermediateDump::SystemSnapshotIOSIntermediateDump()
: SystemSnapshot(),
os_version_build_(),
machine_description_(),
os_version_major_(0),
os_version_minor_(0),
os_version_bugfix_(0),
active_(0),
inactive_(0),
wired_(0),
free_(0),
cpu_count_(0),
cpu_vendor_(),
dst_status_(),
standard_offset_seconds_(0),
daylight_offset_seconds_(0),
standard_name_(),
daylight_name_(),
address_mask_(0),
initialized_() {}
SystemSnapshotIOSIntermediateDump::~SystemSnapshotIOSIntermediateDump() {}
void SystemSnapshotIOSIntermediateDump::Initialize(
const IOSIntermediateDumpMap* system_data) {
INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
GetDataStringFromMap(system_data, Key::kOSVersionBuild, &os_version_build_);
GetDataStringFromMap(
system_data, Key::kMachineDescription, &machine_description_);
GetDataStringFromMap(system_data, Key::kCpuVendor, &cpu_vendor_);
GetDataStringFromMap(system_data, Key::kStandardName, &standard_name_);
GetDataStringFromMap(system_data, Key::kDaylightName, &daylight_name_);
GetDataValueFromMap(system_data, Key::kOSVersionMajor, &os_version_major_);
GetDataValueFromMap(system_data, Key::kOSVersionMinor, &os_version_minor_);
GetDataValueFromMap(system_data, Key::kOSVersionBugfix, &os_version_bugfix_);
GetDataValueFromMap(system_data, Key::kCpuCount, &cpu_count_);
GetDataValueFromMap(
system_data, Key::kStandardOffsetSeconds, &standard_offset_seconds_);
GetDataValueFromMap(
system_data, Key::kDaylightOffsetSeconds, &daylight_offset_seconds_);
bool has_daylight_saving_time;
GetDataValueFromMap(
system_data, Key::kHasDaylightSavingTime, &has_daylight_saving_time);
bool is_daylight_saving_time;
GetDataValueFromMap(
system_data, Key::kIsDaylightSavingTime, &is_daylight_saving_time);
if (has_daylight_saving_time) {
dst_status_ = is_daylight_saving_time
? SystemSnapshot::kObservingDaylightSavingTime
: SystemSnapshot::kObservingStandardTime;
} else {
dst_status_ = SystemSnapshot::kDoesNotObserveDaylightSavingTime;
}
GetDataValueFromMap(system_data, Key::kAddressMask, &address_mask_);
vm_size_t page_size;
if (GetDataValueFromMap(system_data, Key::kPageSize, &page_size)) {
const IOSIntermediateDumpMap* vm_stat =
GetMapFromMap(system_data, Key::kVMStat);
if (vm_stat) {
GetDataValueFromMap(vm_stat, Key::kActive, &active_);
active_ *= page_size;
GetDataValueFromMap(vm_stat, Key::kInactive, &inactive_);
inactive_ *= page_size;
GetDataValueFromMap(vm_stat, Key::kWired, &wired_);
wired_ *= page_size;
GetDataValueFromMap(vm_stat, Key::kFree, &free_);
free_ *= page_size;
}
}
GetDataValueFromMap(system_data, Key::kCrashpadUptime, &crashpad_uptime_ns_);
INITIALIZATION_STATE_SET_VALID(initialized_);
}
CPUArchitecture SystemSnapshotIOSIntermediateDump::GetCPUArchitecture() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
#if defined(ARCH_CPU_X86_64)
return kCPUArchitectureX86_64;
#elif defined(ARCH_CPU_ARM64)
return kCPUArchitectureARM64;
#endif
}
uint32_t SystemSnapshotIOSIntermediateDump::CPURevision() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): sysctlbyname machdep.cpu.* returns -1 on iOS/ARM64, but
// consider recording this for X86_64 only.
return 0;
}
uint8_t SystemSnapshotIOSIntermediateDump::CPUCount() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return cpu_count_;
}
std::string SystemSnapshotIOSIntermediateDump::CPUVendor() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return cpu_vendor_;
}
void SystemSnapshotIOSIntermediateDump::CPUFrequency(uint64_t* current_hz,
uint64_t* max_hz) const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): sysctlbyname hw.cpufrequency returns -1 on iOS/ARM64,
// but consider recording this for X86_64 only.
*current_hz = 0;
*max_hz = 0;
}
uint32_t SystemSnapshotIOSIntermediateDump::CPUX86Signature() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): Consider recording this for X86_64 only.
return 0;
}
uint64_t SystemSnapshotIOSIntermediateDump::CPUX86Features() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): Consider recording this for X86_64 only.
return 0;
}
uint64_t SystemSnapshotIOSIntermediateDump::CPUX86ExtendedFeatures() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): Consider recording this for X86_64 only.
return 0;
}
uint32_t SystemSnapshotIOSIntermediateDump::CPUX86Leaf7Features() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): Consider recording this for X86_64 only.
return 0;
}
bool SystemSnapshotIOSIntermediateDump::CPUX86SupportsDAZ() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): Consider recording this for X86_64 only.
return false;
}
SystemSnapshot::OperatingSystem
SystemSnapshotIOSIntermediateDump::GetOperatingSystem() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return kOperatingSystemIOS;
}
bool SystemSnapshotIOSIntermediateDump::OSServer() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return false;
}
void SystemSnapshotIOSIntermediateDump::OSVersion(int* major,
int* minor,
int* bugfix,
std::string* build) const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
*major = os_version_major_;
*minor = os_version_minor_;
*bugfix = os_version_bugfix_;
build->assign(os_version_build_);
}
std::string SystemSnapshotIOSIntermediateDump::OSVersionFull() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return base::StringPrintf("%d.%d.%d %s",
os_version_major_,
os_version_minor_,
os_version_bugfix_,
os_version_build_.c_str());
}
std::string SystemSnapshotIOSIntermediateDump::MachineDescription() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return machine_description_;
}
bool SystemSnapshotIOSIntermediateDump::NXEnabled() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
// TODO(justincohen): Consider using kern.nx when available (pre-iOS 13,
// pre-OS X 10.15). Otherwise the bit is always enabled.
return true;
}
void SystemSnapshotIOSIntermediateDump::TimeZone(
DaylightSavingTimeStatus* dst_status,
int* standard_offset_seconds,
int* daylight_offset_seconds,
std::string* standard_name,
std::string* daylight_name) const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
*dst_status = dst_status_;
*standard_offset_seconds = standard_offset_seconds_;
*daylight_offset_seconds = daylight_offset_seconds_;
standard_name->assign(standard_name_);
daylight_name->assign(daylight_name_);
}
uint64_t SystemSnapshotIOSIntermediateDump::AddressMask() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return address_mask_;
}
uint64_t SystemSnapshotIOSIntermediateDump::CrashpadUptime() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return crashpad_uptime_ns_;
}
} // namespace internal
} // namespace crashpad
Codebase Browser
chromium