crashpad/snapshot/system_snapshot.h
Justin Cohen c11d49db88 Add a mask to MinidumpCrashpadInfo to indicate valid pointer addresses.
ARM64 supports storing pointer authentication codes in the upper bits of
a pointer. This mask can be used by LLDB to mimic ptrauth_strip and
strip the pointer authentication codes. To recover an address from
pointer with an authentication code, `AND` this mask with the pointer.

If the platform does not support pointer authentication, or the range of
valid addressees for a pointer was unaccessible, this field will be 0
and should be ignored.

Change-Id: Ie5cef90802dd1e892d456195ab8874223eac6a1b
Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/2773358
Commit-Queue: Justin Cohen <justincohen@chromium.org>
Reviewed-by: Mark Mentovai <mark@chromium.org>
2023-01-30 18:27:02 +00:00

297 lines
13 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Copyright 2014 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.
#ifndef CRASHPAD_SNAPSHOT_SYSTEM_SNAPSHOT_H_
#define CRASHPAD_SNAPSHOT_SYSTEM_SNAPSHOT_H_
#include <stdint.h>
#include <sys/types.h>
#include <string>
#include "snapshot/cpu_architecture.h"
namespace crashpad {
//! \brief An abstract interface to a snapshot representing the state of a
//! system, comprising an operating system, CPU architecture, and various
//! other characteristics.
class SystemSnapshot {
public:
virtual ~SystemSnapshot() {}
//! \brief A systems operating system family.
enum OperatingSystem {
//! \brief The snapshot systems operating system is unknown.
kOperatingSystemUnknown = 0,
//! \brief macOS.
kOperatingSystemMacOSX,
//! \brief Windows.
kOperatingSystemWindows,
//! \brief Linux.
kOperatingSystemLinux,
//! \brief Android.
kOperatingSystemAndroid,
//! \brief Fuchsia.
kOperatingSystemFuchsia,
//! \brief iOS.
kOperatingSystemIOS,
};
//! \brief A systems daylight saving time status.
//!
//! The daylight saving time status is taken partially from the systems
//! locale configuration. This determines whether daylight saving time is
//! ever observed on the system. If it is, the snapshots time
//! (ProcessSnapshot::SnapshotTime()) is used to determine whether the system
//! was observing daylight saving time at the time of the snapshot.
enum DaylightSavingTimeStatus {
//! \brief Daylight saving time is never observed on the snapshot system.
kDoesNotObserveDaylightSavingTime = 0,
//! \brief Daylight saving time is observed on the snapshot system when in
//! effect, but standard time was in effect at the time of the snapshot.
kObservingStandardTime,
//! \brief Daylight saving time is observed on the snapshot system when in
//! effect, and daylight saving time was in effect at the time of the
//! snapshot.
kObservingDaylightSavingTime,
};
//! \brief Returns the snapshot systems CPU architecture.
//!
//! In some cases, a system may be able to run processes of multiple specific
//! architecture types. For example, systems based on 64-bit architectures
//! such as x86_64 are often able to run 32-bit code of another architecture
//! in the same family, such as 32-bit x86. On these systems, this method will
//! return the architecture of the process that the snapshot is associated
//! with, provided that the SystemSnapshot object was obtained from
//! ProcessSnapshot::System(). This renders one aspect of this methods return
//! value a process attribute rather than a system attribute, but its defined
//! here rather than in ProcessSnapshot because the CPU architecture is a
//! better conceptual fit for the system abstraction alongside these other
//! related methods.
virtual CPUArchitecture GetCPUArchitecture() const = 0;
//! \brief Returns the snapshot systems CPU revision.
//!
//! For x86-family CPUs (including x86_64 and 32-bit x86), this is the CPU
//! family, model, and stepping ID values from `cpuid 1` `eax`. The family and
//! model values are adjusted to take the extended family and model IDs into
//! account. These values are encoded in this methods return value with the
//! family in the high high 16 bits, the model in the next 8 bits, and the
//! stepping in the low 8 bits.
//!
//! \return A CPU architecture-specific value identifying the CPU revision.
virtual uint32_t CPURevision() const = 0;
//! \brief Returns the total number of CPUs present in the snapshot system.
virtual uint8_t CPUCount() const = 0;
//! \brief Returns the vendor of the snapshot systems CPUs.
//!
//! For x86-family CPUs (including x86_64 and 32-bit x86), this is the CPU
//! vendor identification string as encoded in `cpuid 0` `ebx`, `edx`, and
//! `ecx`.
//!
//! \return A string identifying the vendor of the snapshot systems CPUs.
virtual std::string CPUVendor() const = 0;
//! \brief Returns frequency information about the snapshot systems CPUs in
//! \a current_hz and \a max_hz.
//!
//! \param[out] current_hz The snapshot systems CPU clock frequency in Hz at
//! the time of the snapshot.
//! \param[out] max_hz The snapshot systems maximum possible CPU clock
//! frequency.
virtual void CPUFrequency(uint64_t* current_hz, uint64_t* max_hz) const = 0;
//! \brief Returns an x86-family snapshot systems CPU signature.
//!
//! This is the family, model, and stepping ID values as encoded in `cpuid 1`
//! `eax`.
//!
//! This method must only be called when GetCPUArchitecture() indicates an
//! x86-family CPU architecture (#kCPUArchitectureX86 or
//! #kCPUArchitectureX86_64).
//!
//! \return An x86 family-specific value identifying the CPU signature.
virtual uint32_t CPUX86Signature() const = 0;
//! \brief Returns an x86-family snapshot systems CPU features.
//!
//! This is the feature information as encoded in `cpuid 1` `edx` and `ecx`.
//! `edx` is placed in the low half of the return value, and `ecx` is placed
//! in the high half.
//!
//! This method must only be called when GetCPUArchitecture() indicates an
//! x86-family CPU architecture (#kCPUArchitectureX86 or
//! #kCPUArchitectureX86_64).
//!
//! \return An x86 family-specific value identifying CPU features.
//!
//! \sa CPUX86ExtendedFeatures()
//! \sa CPUX86Leaf7Features()
virtual uint64_t CPUX86Features() const = 0;
//! \brief Returns an x86-family snapshot systems extended CPU features.
//!
//! This is the extended feature information as encoded in `cpuid 0x80000001`
//! `edx` and `ecx`. `edx` is placed in the low half of the return value, and
//! `ecx` is placed in the high half.
//!
//! This method must only be called when GetCPUArchitecture() indicates an
//! x86-family CPU architecture (#kCPUArchitectureX86 or
//! #kCPUArchitectureX86_64).
//!
//! \return An x86 family-specific value identifying extended CPU features.
//!
//! \sa CPUX86Features()
//! \sa CPUX86Leaf7Features()
virtual uint64_t CPUX86ExtendedFeatures() const = 0;
//! \brief Returns an x86-family snapshot systems “leaf 7” CPU features.
//!
//! This is the “leaf 7” feature information as encoded in `cpuid 7` `ebx`. If
//! `cpuid 7` is not supported by the snapshot CPU, this returns `0`.
//!
//! This method must only be called when GetCPUArchitecture() indicates an
//! x86-family CPU architecture (#kCPUArchitectureX86 or
//! #kCPUArchitectureX86_64).
//!
//! \return An x86 family-specific value identifying “leaf 7” CPU features.
//!
//! \sa CPUX86Features()
//! \sa CPUX86ExtendedFeatures()
virtual uint32_t CPUX86Leaf7Features() const = 0;
//! \brief Returns an x86-family snapshot systems CPUs support for the SSE
//! DAZ (“denormals are zeros”) mode.
//!
//! This determines whether the CPU supports DAZ mode at all, not whether this
//! mode is enabled for any particular thread. DAZ mode support is detected by
//! examining the DAZ bit in the `mxcsr_mask` field of the floating-point
//! context saved by `fxsave`.
//!
//! This method must only be called when GetCPUArchitecture() indicates an
//! x86-family CPU architecture (#kCPUArchitectureX86 or
//! #kCPUArchitectureX86_64).
//!
//! \return `true` if the snapshot systems CPUs support the SSE DAZ mode,
//! `false` if they do not.
virtual bool CPUX86SupportsDAZ() const = 0;
//! \brief Returns the snapshot systems operating system family.
virtual OperatingSystem GetOperatingSystem() const = 0;
//! \brief Returns whether the snapshot system runs a server variant of its
//! operating system.
virtual bool OSServer() const = 0;
//! \brief Returns the snapshot systems operating system version information
//! in \a major, \a minor, \a bugfix, and \a build.
//!
//! \param[out] major The snapshot systems operating systems first (major)
//! version number component. This would be `10` for macOS 10.12.1, and
//! `6` for Windows 7 (NT 6.1) SP1 version 6.1.7601.
//! \param[out] minor The snapshot systems operating systems second (minor)
//! version number component. This would be `12` for macOS 10.12.1, and
//! `1` for Windows 7 (NT 6.1) SP1 version 6.1.7601.
//! \param[out] bugfix The snapshot systems operating systems third (bugfix)
//! version number component. This would be `1` for macOS 10.12.1, and
//! `7601` for Windows 7 (NT 6.1) SP1 version 6.1.7601.
//! \param[out] build A string further identifying an operating system
//! version. For macOS 10.12.1, this would be `"16B2657"`. For Windows,
//! this would be `"Service Pack 1"` if that service pack was installed.
//! On Android, the `ro.build.fingerprint` system property would be
//! appended. For Linux and other Unix-like systems, this would be the
//! kernel version from `uname -srvm`, possibly with additional
//! information appended.
virtual void OSVersion(int* major,
int* minor,
int* bugfix,
std::string* build) const = 0;
//! \brief Returns the snapshot systems full operating system version
//! information in string format.
//!
//! For macOS, the string contains values from the operating system and
//! kernel. A macOS 10.12.1 system snapshot would be identified as `"Mac OS
//! X 10.12.1 (16B2657); Darwin 16.1.0 Darwin Kernel Version 16.1.0: Wed Oct
//! 19 20:31:56 PDT 2016; root:xnu-3789.21.4~4/RELEASE_X86_64 x86_64"`.
virtual std::string OSVersionFull() const = 0;
//! \brief Returns a description of the snapshot systems hardware in string
//! format.
//!
//! For macOS, the string contains the Mac model and board ID. A mid-2014 15"
//! MacBook Pro would be identified as `"MacBookPro11,3
//! (Mac-2BD1B31983FE1663)"`.
virtual std::string MachineDescription() const = 0;
//! \brief Returns the status of the NX (no-execute, or XD, execute-disable)
//! feature on the snapshot system.
//!
//! This refers to a feature that allows mapped readable pages to be marked
//! as non-executable.
//!
//! \return `true` if the snapshot system supports NX and it is enabled.
virtual bool NXEnabled() const = 0;
//! \brief Returns time zone information from the snapshot system, based on
//! its locale configuration and real-time clock.
//!
//! \param[out] dst_status Whether the location observes daylight saving time,
//! and if so, whether it or standard time is currently being observed.
//! \param[out] standard_offset_seconds The number of seconds that the
//! locations time zone is east (ahead) of UTC during standard time.
//! \param[out] daylight_offset_seconds The number of seconds that the
//! locations time zone is east (ahead) of UTC during daylight saving.
//! time.
//! \param[out] standard_name The name of the time zone while standard time is
//! being observed.
//! \param[out] daylight_name The name of the time zone while daylight saving
//! time is being observed.
virtual void TimeZone(DaylightSavingTimeStatus* dst_status,
int* standard_offset_seconds,
int* daylight_offset_seconds,
std::string* standard_name,
std::string* daylight_name) const = 0;
//! \brief Returns a mask indicating the range of valid addresses for a
//! pointer.
//!
//! ARM64 supports storing pointer authentication codes in the upper bits of
//! a pointer. This mask is generated based on the number of bits in a pointer
//! reserved for the authentication codes. To recover an address from pointer
//! with an authentication code, `AND` this mask with the pointer. If the pac
//! sign extension bit is set, instead `~` and `OR` this mask with the
//! pointer.
//!
//! If the platform does not support pointer authentication, or the range of
//! valid addressees for a pointer was inaccessible, this field will be 0.
virtual uint64_t AddressMask() const = 0;
};
} // namespace crashpad
#endif // CRASHPAD_SNAPSHOT_SYSTEM_SNAPSHOT_H_