\inmodule QtCore More...

#include <qsysinfo.h>

Collaboration diagram for QSysInfo:

Public Types
enum	Sizes { WordSize = (sizeof(void *)<<3) }
	This enum provides platform-specific information about the sizes of data structures used by the underlying architecture. More...

enum	Endian { BigEndian , LittleEndian , ByteOrder = BigEndian }
	\value BigEndian Big-endian byte order (also called Network byte order) \value LittleEndian Little-endian byte order \value ByteOrder Equals BigEndian or LittleEndian, depending on the platform's byte order. More...

Static Public Member Functions
static QString	buildCpuArchitecture ()

static QString	currentCpuArchitecture ()

static QString	buildAbi ()

static QString	kernelType ()

static QString	kernelVersion ()

static QString	productType ()

static QString	productVersion ()

static QString	prettyProductName ()

static QString	machineHostName ()

static QByteArray	machineUniqueId ()

static QByteArray	bootUniqueId ()

Detailed Description

\inmodule QtCore

The QSysInfo class provides information about the system.

\list

\l WordSize specifies the size of a pointer for the platform on which the application is compiled.
\l ByteOrder specifies whether the platform is big-endian or little-endian. \endlist

Some constants are defined only on certain platforms. You can use the preprocessor symbols Q_OS_WIN and Q_OS_MACOS to test that the application is compiled under Windows or \macos.

See also: QLibraryInfo

Definition at line 21 of file qsysinfo.h.

Member Enumeration Documentation

◆ Endian

enum QSysInfo::Endian

\value BigEndian Big-endian byte order (also called Network byte order) \value LittleEndian Little-endian byte order \value ByteOrder Equals BigEndian or LittleEndian, depending on the platform's byte order.

Enumerator
BigEndian
LittleEndian
ByteOrder

Definition at line 28 of file qsysinfo.h.

◆ Sizes

enum QSysInfo::Sizes

This enum provides platform-specific information about the sizes of data structures used by the underlying architecture.

\value WordSize The size in bits of a pointer for the platform on which the application is compiled (32 or 64).

Enumerator
WordSize

Definition at line 24 of file qsysinfo.h.

Member Function Documentation

◆ bootUniqueId()

QByteArray QSysInfo::bootUniqueId ( )

static

Since: 5.11

Returns a unique ID for this machine's boot, if one can be determined. If no unique ID could be determined, this function returns an empty byte array. This value is expected to change after every boot and can be considered globally unique.

This function is currently only implemented for Linux and Apple operating systems.

See also: machineUniqueId()

Definition at line 1049 of file qsysinfo.cpp.

References QByteArray(), qt_safe_close(), qt_safe_open(), qt_safe_read(), and UuidStringLen.

Referenced by QQmlSystemInformation::bootUniqueId(), QLockFilePrivate::isApparentlyStale(), and QLockFilePrivate::lockFileContents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildAbi()

QString QSysInfo::buildAbi ( )

static

Since: 5.4

Returns the full architecture string that Qt was compiled for. This string is useful for identifying different, incompatible builds. For example, it can be used as an identifier to request an upgrade package from a server.

The values returned from this function are kept stable as follows: the mandatory components of the result will not change in future versions of Qt, but optional suffixes may be added.

The returned value is composed of three or more parts, separated by dashes ("-"). They are:

\table \header

Component
Value \row
CPU Architecture
The same as QSysInfo::buildCpuArchitecture(), such as "arm", "i386", "mips" or "x86_64" \row
Endianness
"little_endian" or "big_endian" \row
Word size
Whether it's a 32- or 64-bit application. Possible values are: "llp64" (Windows 64-bit), "lp64" (Unix 64-bit), "ilp32" (32-bit) \row
(Optional) ABI
Zero or more components identifying different ABIs possible in this architecture. Currently, Qt has optional ABI components for ARM and MIPS processors: one component is the main ABI (such as "eabi", "o32", "n32", "o64"); another is whether the calling convention is using hardware floating point registers ("hardfloat" is present).

Additionally, if Qt was configured with {-qreal float}, the ABI option tag "qreal_float" will be present. If Qt was configured with another type as qreal, that type is present after "qreal_", with all characters other than letters and digits escaped by an underscore, followed by two hex digits. For example, {-qreal long double} becomes "qreal_long_20double". \endtable

See also: QSysInfo::buildCpuArchitecture()

Definition at line 657 of file qsysinfo.cpp.

References ARCH_FULL, and QStringLiteral.

Referenced by QOpenGLProgramBinaryCache::QOpenGLProgramBinaryCache(), automaticPipelineCacheDir(), QQmlSystemInformation::buildAbi(), and persistentQsbcDir().

Here is the caller graph for this function:

◆ buildCpuArchitecture()

QString QSysInfo::buildCpuArchitecture ( )

static

Since: 5.4

Returns the architecture of the CPU that Qt was compiled for, in text format. Note that this may not match the actual CPU that the application is running on if there's an emulation layer or if the CPU supports multiple architectures (like x86-64 processors supporting i386 applications). To detect that, use currentCpuArchitecture().

Values returned by this function are stable and will not change over time, so applications can rely on the returned value as an identifier, except that new CPU types may be added over time.

Typical returned values are (note: list not exhaustive): \list

"arm"
"arm64"
"i386"
"ia64"
"mips"
"mips64"
"power"
"power64"
"sparc"
"sparcv9"
"x86_64" \endlist

See also: QSysInfo::buildAbi(), QSysInfo::currentCpuArchitecture()

Definition at line 506 of file qsysinfo.cpp.

References ARCH_PROCESSOR, and QStringLiteral.

Referenced by QQmlSystemInformation::buildCpuArchitecture().

Here is the caller graph for this function:

◆ currentCpuArchitecture()

QString QSysInfo::currentCpuArchitecture ( )

static

Since: 5.4

Returns the architecture of the CPU that the application is running on, in text format. Note that this function depends on what the OS will report and may not detect the actual CPU architecture if the OS hides that information or is unable to provide it. For example, a 32-bit OS running on a 64-bit CPU is usually unable to determine the CPU is actually capable of running 64-bit programs.

Values returned by this function are mostly stable: an attempt will be made to ensure that they stay constant over time and match the values returned by QSysInfo::builldCpuArchitecture(). However, due to the nature of the operating system functions being used, there may be discrepancies.

Typical returned values are (note: list not exhaustive): \list

"arm"
"arm64"
"i386"
"ia64"
"mips"
"mips64"
"power"
"power64"
"sparc"
"sparcv9"
"x86_64" \endlist

See also: QSysInfo::buildAbi(), QSysInfo::buildCpuArchitecture()

Definition at line 543 of file qsysinfo.cpp.

References QString::fromLatin1(), info, QStringLiteral, and ret.

Referenced by QQmlSystemInformation::currentCpuArchitecture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kernelType()

QString QSysInfo::kernelType ( )

static

Since: 5.4

Returns the type of the operating system kernel Qt was compiled for. It's also the kernel the application is running on, unless the host operating system is running a form of compatibility or virtualization layer.

Values returned by this function are stable and will not change over time, so applications can rely on the returned value as an identifier, except that new OS kernel types may be added over time.

On Windows, this function returns the type of Windows kernel, like "winnt". On Unix systems, it returns the same as the output of {uname -s} (lowercased).

Note: This function may return surprising values: it returns "linux" for all operating systems running Linux (including Android), "qnx" for all operating systems running QNX, "freebsd" for Debian/kFreeBSD, and "darwin" for \macos and iOS. For information on the type of product the application is running on, see productType().

See also: QFileSelector, kernelVersion(), productType(), productVersion(), prettyProductName()

Definition at line 694 of file qsysinfo.cpp.

References QString::fromLatin1(), QStringLiteral, and unknownText().

Referenced by QQmlSystemInformation::kernelType(), and QFileSelectorPrivate::platformSelectors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kernelVersion()

QString QSysInfo::kernelVersion ( )

static

Since: 5.4

Returns the release version of the operating system kernel. On Windows, it returns the version of the NT kernel. On Unix systems, including Android and \macos, it returns the same as the {uname -r} command would return.

If the version could not be determined, this function may return an empty string.

See also: kernelType(), productType(), productVersion(), prettyProductName()

Definition at line 719 of file qsysinfo.cpp.

References QString::asprintf(), QOperatingSystemVersionBase::current(), and QString::fromLatin1().

Referenced by QQmlSystemInformation::kernelVersion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ machineHostName()

QString QSysInfo::machineHostName ( )

static

Since: 5.6

Returns this machine's host name, if one is configured. Note that hostnames are not guaranteed to be globally unique, especially if they were configured automatically.

This function does not guarantee the returned host name is a Fully Qualified Domain Name (FQDN). For that, use QHostInfo to resolve the returned name to an FQDN.

This function returns the same as QHostInfo::localHostName().

See also: QHostInfo::localDomainName, machineUniqueId()

Definition at line 929 of file qsysinfo.cpp.

References QString::fromLocal8Bit(), QString::resize(), QString::size(), QString::truncate(), and QString::utf16().

Referenced by QNativeSocketEnginePrivate::QNativeSocketEnginePrivate(), QXcbWindow::create(), QHostInfo::localHostName(), QQmlSystemInformation::machineHostName(), machineName(), and QJUnitTestLogger::startLogging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ machineUniqueId()

QByteArray QSysInfo::machineUniqueId ( )

static

Since: 5.11

Returns a unique ID for this machine, if one can be determined. If no unique ID could be determined, this function returns an empty byte array. Unlike machineHostName(), the value returned by this function is likely globally unique.

A unique ID is useful in network operations to identify this machine for an extended period of time, when the IP address could change or if this machine could have more than one IP address. For example, the ID could be used when communicating with a server or when storing device-specific data in shared network storage.

Note that on some systems, this value will persist across reboots and on some it will not. Applications should not blindly depend on this fact without verifying the OS capabilities. In particular, on Linux systems, this ID is usually permanent and it matches the D-Bus machine ID, except for nodes without their own storage (replicated nodes).

See also: machineHostName(), bootUniqueId()

Definition at line 993 of file qsysinfo.cpp.

References QByteArray(), qt_safe_close(), qt_safe_open(), qt_safe_read(), QWinRegistryKey::stringValue(), QString::toLatin1(), and UuidStringLen.

Referenced by QLockFilePrivate::isApparentlyStale(), QLockFilePrivate::lockFileContents(), and QQmlSystemInformation::machineUniqueId().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prettyProductName()

QString QSysInfo::prettyProductName ( )

static

Since: 5.4

Returns a prettier form of productType() and productVersion(), containing other tokens like the operating system type, codenames and other information. The result of this function is suitable for displaying to the user, but not for long-term storage, as the string may change with updates to Qt.

If productType() is "unknown", this function will instead use the kernelType() and kernelVersion() functions.

See also: kernelType(), kernelVersion(), productType(), productVersion()

Definition at line 877 of file qsysinfo.cpp.

References QString::asprintf(), QOperatingSystemVersionBase::current(), QString::fromLatin1(), and unknownText().

Referenced by QQmlSystemInformation::prettyProductName(), and QSecureTransportBackend::tlsLibraryVersionString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ productType()

QString QSysInfo::productType ( )

static

Since: 5.4

Returns the product name of the operating system this application is running in. If the application is running on some sort of emulation or virtualization layer (such as WINE on a Unix system), this function will inspect the emulation / virtualization layer.

Values returned by this function are stable and will not change over time, so applications can rely on the returned value as an identifier, except that new OS types may be added over time.

{Linux and Android note}: this function returns "android" for Linux systems running Android userspace, notably when using the Bionic library. For all other Linux systems, regardless of C library being used, it tries to determine the distribution name and returns that. If determining the distribution name failed, it returns "unknown".

{\macos note}: this function returns "macos" for all \macos systems, regardless of Apple naming convention. Previously, in Qt 5, it returned "osx", again regardless of Apple naming conventions.

{Darwin, iOS, tvOS, and watchOS note}: this function returns "ios" for iOS systems, "tvos" for tvOS systems, "watchos" for watchOS systems, and "darwin" in case the system could not be determined.

{FreeBSD note}: this function returns "debian" for Debian/kFreeBSD and "unknown" otherwise.

{Windows note}: this function return "windows"

For other Unix-type systems, this function usually returns "unknown".

See also: QFileSelector, kernelType(), kernelVersion(), productVersion(), prettyProductName()

Definition at line 769 of file qsysinfo.cpp.

References QStringLiteral, and unknownText().

Referenced by activeConditions(), QFileSelectorPrivate::platformSelectors(), QQmlSystemInformation::productType(), and QPlainTestLogger::startLogging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ productVersion()

QString QSysInfo::productVersion ( )

static

Since: 5.4

Returns the product version of the operating system in string form. If the version could not be determined, this function returns "unknown".

It will return the Android, iOS, \macos, Windows full-product versions on those systems.

Typical returned values are (note: list not exhaustive): \list

"12" (Android 12)
"36" (Fedora 36)
"15.5" (iOS 15.5)
"12.4" (macOS Monterey)
"22.04" (Ubuntu 22.04)
"8.6" (watchOS 8.6)
"11" (Windows 11)
"Server 2022" (Windows Server 2022) \endlist

On Linux systems, it will try to determine the distribution version and will return that. This is also done on Debian/kFreeBSD, so this function will return Debian version in that case.

In all other Unix-type systems, this function always returns "unknown".

Note: The version string returned from this function is not guaranteed to be orderable. On Linux, the version of the distribution may jump unexpectedly, please refer to the distribution's documentation for versioning practices.