26546993077

Committed 27 May 2026 08:34PM UTC coverage: 72.995% (+0.3%) from 72.667%

Build # 26546993077

Build Type

push

github

Committed by

bluca

Commit Message

test-pressure: set timeout to make not wait forever

If this runs on a slow or busy machine, then we may not get enough
pressure to trigger the event sources. In such case, the test does not
finish. It is problematic when the test is _not_ run with 'meson test',
e.g. debian/ubuntu CIs.

Let's introduce a timeout for each event loop, and skip test cases
gracefully.

Coverage Stats

8 of 12 new or added lines in 1 file covered. (66.67%)

19671 existing lines in 226 files now uncovered.

337119 of 461841 relevant lines covered (72.99%)

1326365.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/report/report-basic.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <fcntl.h>
#include <sys/utsname.h>

#include "sd-device.h"
#include "sd-id128.h"
#include "sd-json.h"
#include "sd-varlink.h"

#include "alloc-util.h"
#include "architecture.h"
#include "confidential-virt.h"
#include "cpu-set-util.h"
#include "env-file.h"
#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "hostname-setup.h"
#include "hostname-util.h"
#include "limits-util.h"
#include "log.h"
#include "metrics.h"
#include "os-util.h"
#include "report-basic.h"
#include "string-util.h"
#include "virt.h"

static int architecture_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        assert(mf && mf->name);
        assert(link);

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        architecture_to_string(uname_architecture()),
                        /* fields= */ NULL);
}

static int boot_id_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        sd_id128_t id;
        int r;

        assert(mf && mf->name);
        assert(link);

        r = sd_id128_get_boot(&id);
        if (r < 0)
                return r;

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        SD_ID128_TO_STRING(id),
                        /* fields= */ NULL);
}

static int hostname_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        _cleanup_free_ char *hostname = NULL;
        int r;

        assert(mf && mf->name);
        assert(link);

        r = gethostname_full(GET_HOSTNAME_ALLOW_LOCALHOST | GET_HOSTNAME_FALLBACK_DEFAULT, &hostname);
        if (r < 0)
                return r;

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        hostname,
                        /* fields= */ NULL);
}

static int kernel_version_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        struct utsname u;

        assert(mf && mf->name);
        assert(link);

        assert_se(uname(&u) >= 0);

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        u.release,
                        /* fields= */ NULL);
}

static int machine_id_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        sd_id128_t id;
        int r;

        assert(mf && mf->name);
        assert(link);

        r = sd_id128_get_machine(&id);
        if (r < 0)
                return r;

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        SD_ID128_TO_STRING(id),
                        /* fields= */ NULL);
}

static int physical_memory_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        assert(mf && mf->name);
        assert(link);

        return metric_build_send_unsigned(
                        mf,
                        link,
                        /* object= */ NULL,
                        physical_memory(),
                        /* fields= */ NULL);
}

static int cpus_online_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        int r;

        assert(mf && mf->name);
        assert(link);

        unsigned n_cpus;
        r = cpus_online(&n_cpus);
        if (r < 0)
                return r;

        return metric_build_send_unsigned(
                        mf,
                        link,
                        /* object= */ NULL,
                        n_cpus,
                        /* fields= */ NULL);
}

enum {
        FIELD_PRETTY_NAME,
        FIELD_NAME,
        FIELD_ID,
        FIELD_CPE_NAME,
        FIELD_VARIANT_ID,
        FIELD_VERSION_ID,
        FIELD_BUILD_ID,
        FIELD_IMAGE_VERSION,
        FIELD_IMAGE_ID,
        FIELD_SUPPORT_END,
        FIELD_EXPERIMENT,
        FIELD_SYSEXT_LEVEL,
        FIELD_CONFEXT_LEVEL,
        _FIELD_MAX,
};

static int os_release_generate(const MetricFamily mf[static _FIELD_MAX - 1], sd_varlink *link, void *userdata) {
        char* values[_FIELD_MAX] = {};
        CLEANUP_ELEMENTS(values, free_many_charp);
        int r;

        assert(mf && mf->name);
        assert(link);

        r = parse_os_release(NULL,
                             "PRETTY_NAME",   &values[FIELD_PRETTY_NAME],
                             "NAME",          &values[FIELD_NAME],
                             "ID",            &values[FIELD_ID],
                             "CPE_NAME",      &values[FIELD_CPE_NAME],
                             "VARIANT_ID",    &values[FIELD_VARIANT_ID],
                             "VERSION_ID",    &values[FIELD_VERSION_ID],
                             "BUILD_ID",      &values[FIELD_BUILD_ID],
                             "IMAGE_VERSION", &values[FIELD_IMAGE_VERSION],
                             "IMAGE_ID",      &values[FIELD_IMAGE_ID],
                             "SUPPORT_END",   &values[FIELD_SUPPORT_END],
                             "EXPERIMENT",    &values[FIELD_EXPERIMENT],
                             "SYSEXT_LEVEL",  &values[FIELD_SYSEXT_LEVEL],
                             "CONFEXT_LEVEL", &values[FIELD_CONFEXT_LEVEL]);
        if (r < 0) {
                log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
                               "Failed to read os-release file, ignoring: %m");
                return 0;
        }

        for (size_t i = 1; i < _FIELD_MAX; i++) {
                const char *v = values[i];
                if (i == FIELD_NAME && values[FIELD_PRETTY_NAME])
                        v = values[FIELD_PRETTY_NAME];  /* Prefer PRETTY_NAME to NAME */

                if (v) {
                        r = metric_build_send_string(
                                        mf + i - 1,
                                        link,
                                        /* object= */ NULL,
                                        v,
                                        /* fields= */ NULL);
                        if (r < 0)
                                return r;
                }
        }

        return 0;
}

static int machine_info_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        enum {
                MACHINE_INFO_FIELD_PRETTY_HOSTNAME,
                MACHINE_INFO_FIELD_DEPLOYMENT,
                MACHINE_INFO_FIELD_LOCATION,
                MACHINE_INFO_FIELD_TAGS,
                _MACHINE_INFO_FIELD_MAX,
        };

        char* values[_MACHINE_INFO_FIELD_MAX] = {};
        CLEANUP_ELEMENTS(values, free_many_charp);
        int r;

        assert(mf && mf->name);
        assert(link);

        r = parse_env_file(/* f= */ NULL, etc_machine_info(),
                           "PRETTY_HOSTNAME", &values[MACHINE_INFO_FIELD_PRETTY_HOSTNAME],
                           "DEPLOYMENT",      &values[MACHINE_INFO_FIELD_DEPLOYMENT],
                           "LOCATION",        &values[MACHINE_INFO_FIELD_LOCATION],
                           "TAGS",            &values[MACHINE_INFO_FIELD_TAGS]);
        if (r < 0) {
                log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
                               "Failed to read machine-info file, ignoring: %m");
                return 0;
        }

        for (size_t i = 0; i < _MACHINE_INFO_FIELD_MAX; i++) {
                const char *v = values[i];
                if (!v)
                        continue;

                r = metric_build_send_string(
                                mf + i,
                                link,
                                /* object= */ NULL,
                                v,
                                /* fields= */ NULL);
                if (r < 0)
                        return r;
        }

        return 0;
}

static int smbios_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        enum {
                SMBIOS_FIELD_SYS_VENDOR,
                SMBIOS_FIELD_PRODUCT_NAME,
                SMBIOS_FIELD_PRODUCT_VERSION,
                SMBIOS_FIELD_PRODUCT_SKU,
                SMBIOS_FIELD_PRODUCT_FAMILY,
                SMBIOS_FIELD_PRODUCT_SERIAL,
                SMBIOS_FIELD_PRODUCT_UUID,
                SMBIOS_FIELD_BOARD_VENDOR,
                SMBIOS_FIELD_BOARD_NAME,
                SMBIOS_FIELD_BOARD_VERSION,
                SMBIOS_FIELD_BOARD_SERIAL,
                SMBIOS_FIELD_BOARD_ASSET_TAG,
                SMBIOS_FIELD_BIOS_VENDOR,
                SMBIOS_FIELD_BIOS_VERSION,
                SMBIOS_FIELD_BIOS_DATE,
                SMBIOS_FIELD_CHASSIS_TYPE,
                SMBIOS_FIELD_CHASSIS_VENDOR,
                SMBIOS_FIELD_CHASSIS_SERIAL,
                SMBIOS_FIELD_CHASSIS_ASSET_TAG,
                _SMBIOS_FIELD_MAX,
        };

        /* The sysfs attribute names exposed by the kernel below /sys/class/dmi/id/. The order must match the
         * SMBIOS_STANDARD_FIELD() entries in the metric family table below. */
        static const char* const smbios_files[_SMBIOS_FIELD_MAX] = {
                /* SMBIOS Type 1 */
                [SMBIOS_FIELD_SYS_VENDOR]        = "sys_vendor",
                [SMBIOS_FIELD_PRODUCT_NAME]      = "product_name",
                [SMBIOS_FIELD_PRODUCT_VERSION]   = "product_version",
                [SMBIOS_FIELD_PRODUCT_SKU]       = "product_sku",
                [SMBIOS_FIELD_PRODUCT_FAMILY]    = "product_family",
                [SMBIOS_FIELD_PRODUCT_SERIAL]    = "product_serial",
                [SMBIOS_FIELD_PRODUCT_UUID]      = "product_uuid",
                /* SMBIOS Type 2 */
                [SMBIOS_FIELD_BOARD_VENDOR]      = "board_vendor",
                [SMBIOS_FIELD_BOARD_NAME]        = "board_name",
                [SMBIOS_FIELD_BOARD_VERSION]     = "board_version",
                [SMBIOS_FIELD_BOARD_SERIAL]      = "board_serial",
                [SMBIOS_FIELD_BOARD_ASSET_TAG]   = "board_asset_tag",
                /* SMBIOS Type 0 */
                [SMBIOS_FIELD_BIOS_VENDOR]       = "bios_vendor",
                [SMBIOS_FIELD_BIOS_VERSION]      = "bios_version",
                [SMBIOS_FIELD_BIOS_DATE]         = "bios_date",
                /* SMBIOS Type 3 */
                [SMBIOS_FIELD_CHASSIS_TYPE]      = "chassis_type",
                [SMBIOS_FIELD_CHASSIS_VENDOR]    = "chassis_vendor",
                [SMBIOS_FIELD_CHASSIS_SERIAL]    = "chassis_serial",
                [SMBIOS_FIELD_CHASSIS_ASSET_TAG] = "chassis_asset_tag",
        };

        int r;

        assert(mf && mf->name);
        assert(link);

        /* Reports the fundamental SMBIOS/DMI identification fields. Some of these (serial numbers, asset
         * tags, the system UUID) are privacy sensitive and only readable by root — if we lack the
         * privileges to read them we simply skip them. */

        _cleanup_close_ int dir_fd = open("/sys/class/dmi/id", O_RDONLY|O_DIRECTORY|O_CLOEXEC);
        if (dir_fd < 0) {
                log_full_errno(ERRNO_IS_DEVICE_ABSENT(errno) ? LOG_DEBUG : LOG_WARNING, errno,
                               "Failed to open /sys/class/dmi/id/, ignoring: %m");
                return 0;
        }

        for (size_t i = 0; i < _SMBIOS_FIELD_MAX; i++) {
                _cleanup_free_ char *buf = NULL;

                r = read_virtual_file_at(dir_fd, smbios_files[i], /* max_size= */ SIZE_MAX, &buf, /* ret_size= */ NULL);
                if (r < 0) {
                        log_full_errno(r == -ENOENT || ERRNO_IS_NEG_PRIVILEGE(r) ? LOG_DEBUG : LOG_WARNING, r,
                                       "Failed to read SMBIOS field '%s', ignoring: %m", smbios_files[i]);
                        continue;
                }

                delete_trailing_chars(buf, NEWLINE);

                if (isempty(buf))
                        continue;

                if (!string_is_safe(buf, STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS)) {
                        log_debug("SMBIOS field '%s' contains unsafe characters, ignoring.", smbios_files[i]);
                        continue;
                }

                r = metric_build_send_string(
                                mf + i,
                                link,
                                /* object= */ NULL,
                                buf,
                                /* fields= */ NULL);
                if (r < 0)
                        return r;
        }

        return 0;
}

static int tpm2_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        enum {
                TPM2_FIELD_MANUFACTURER,
                TPM2_FIELD_VENDOR_STRING,
                _TPM2_FIELD_MAX,
        };

        /* The udev properties set by the 'tpm2_id' builtin on the tpmrm device. The order must match the
         * metric family table entries below. */
        static const char* const tpm2_properties[_TPM2_FIELD_MAX] = {
                [TPM2_FIELD_MANUFACTURER]  = "ID_TPM2_MANUFACTURER",
                [TPM2_FIELD_VENDOR_STRING] = "ID_TPM2_VENDOR_STRING",
        };

        int r;

        assert(mf && mf->name);
        assert(link);

        _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
        r = sd_device_new_from_subsystem_sysname(&dev, "tpmrm", "tpmrm0");
        if (r < 0) {
                log_full_errno(ERRNO_IS_NEG_DEVICE_ABSENT(r) ? LOG_DEBUG : LOG_WARNING, r,
                               "Failed to open tpmrm0 device, ignoring: %m");
                return 0;
        }

        for (size_t i = 0; i < _TPM2_FIELD_MAX; i++) {
                const char *v;

                r = sd_device_get_property_value(dev, tpm2_properties[i], &v);
                if (r < 0) {
                        log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
                                       "Failed to read TPM2 property '%s', ignoring: %m", tpm2_properties[i]);
                        continue;
                }

                if (isempty(v))
                        continue;

                r = metric_build_send_string(
                                mf + i,
                                link,
                                /* object= */ NULL,
                                v,
                                /* fields= */ NULL);
                if (r < 0)
                        return r;
        }

        return 0;
}

static int confidential_virtualization_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        assert(mf && mf->name);
        assert(link);

        ConfidentialVirtualization cv = detect_confidential_virtualization();
        if (cv < 0)
                return cv;

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        confidential_virtualization_to_string(cv),
                        /* fields= */ NULL);
}

static int virtualization_generate(const MetricFamily *mf, sd_varlink *link, void *userdata) {
        assert(mf && mf->name);
        assert(link);

        Virtualization v = detect_virtualization();
        if (v < 0)
                return v;

        return metric_build_send_string(
                        mf,
                        link,
                        /* object= */ NULL,
                        virtualization_to_string(v),
                        /* fields= */ NULL);
}

#define OS_RELEASE_STANDARD_FIELD(name)                                 \
        {                                                               \
                METRIC_IO_SYSTEMD_BASIC_PREFIX "OSRelease." name,       \
                "Operating system identification (" name "= field from os-release)", \
                METRIC_FAMILY_TYPE_STRING,                              \
                .generate = NULL,                                       \
        }

#define MACHINE_INFO_STANDARD_FIELD(name)                               \
        {                                                               \
                METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineInfo." name,     \
                "Machine identification (" name "= field from machine-info)", \
                METRIC_FAMILY_TYPE_STRING,                              \
                .generate = NULL,                                       \
        }

#define SMBIOS_STANDARD_FIELD(name)                                     \
        {                                                               \
                METRIC_IO_SYSTEMD_BASIC_PREFIX "SMBIOS." name,          \
                "Firmware/hardware identification (" name " field from SMBIOS/DMI)", \
                METRIC_FAMILY_TYPE_STRING,                              \
                .generate = NULL,                                       \
        }

static const MetricFamily metric_family_table[] = {
        /* Keep entries ordered alphabetically */
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "Architecture",
                "CPU architecture",
                METRIC_FAMILY_TYPE_STRING,
                .generate = architecture_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "BootID",
                "Current boot ID",
                METRIC_FAMILY_TYPE_STRING,
                .generate = boot_id_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "ConfidentialVirtualization",
                "Confidential computing technology",
                METRIC_FAMILY_TYPE_STRING,
                .generate = confidential_virtualization_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "CPUsOnline",
                "Number of CPUs currently online",
                METRIC_FAMILY_TYPE_GAUGE,
                .generate = cpus_online_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "Hostname",
                "System hostname",
                METRIC_FAMILY_TYPE_STRING,
                .generate = hostname_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "KernelVersion",
                "Kernel version",
                METRIC_FAMILY_TYPE_STRING,
                .generate = kernel_version_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineID",
                "Machine ID",
                METRIC_FAMILY_TYPE_STRING,
                .generate = machine_id_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineInfo.PRETTY_HOSTNAME",
                "Pretty hostname (PRETTY_HOSTNAME= field from machine-info)",
                METRIC_FAMILY_TYPE_STRING,
                .generate = machine_info_generate,
        },
        MACHINE_INFO_STANDARD_FIELD("DEPLOYMENT"),
        MACHINE_INFO_STANDARD_FIELD("LOCATION"),
        MACHINE_INFO_STANDARD_FIELD("TAGS"),
        /* Keep those ↑ in sync with machine_info_generate(). */
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "OSRelease.NAME",
                "Operating system human-readable name (PRETTY_NAME= or NAME= field from os-release)",
                METRIC_FAMILY_TYPE_STRING,
                .generate = os_release_generate,
        },
        OS_RELEASE_STANDARD_FIELD("ID"),
        OS_RELEASE_STANDARD_FIELD("CPE_NAME"),
        OS_RELEASE_STANDARD_FIELD("VARIANT_ID"),
        OS_RELEASE_STANDARD_FIELD("VERSION_ID"),
        OS_RELEASE_STANDARD_FIELD("BUILD_ID"),
        OS_RELEASE_STANDARD_FIELD("IMAGE_VERSION"),
        OS_RELEASE_STANDARD_FIELD("IMAGE_ID"),
        OS_RELEASE_STANDARD_FIELD("SUPPORT_END"),
        OS_RELEASE_STANDARD_FIELD("EXPERIMENT"),
        OS_RELEASE_STANDARD_FIELD("SYSEXT_LEVEL"),
        OS_RELEASE_STANDARD_FIELD("CONFEXT_LEVEL"),
        /* Keep those ↑ in sync with os_release_generate(). */
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "PhysicalMemoryBytes",
                "Installed physical memory in bytes",
                METRIC_FAMILY_TYPE_GAUGE,
                .generate = physical_memory_generate,
        },
        {
                /* NB: Here we use the naming of the field as per SMBIOS specification, i.e. undo the weird
                 * renaming that Linux did on the fields. When new fields are added here, please make sure to
                 * check the specification again for naming them. */
                METRIC_IO_SYSTEMD_BASIC_PREFIX "SMBIOS.SystemManufacturer",
                "Firmware/hardware identification (SystemManufacturer field from SMBIOS/DMI)",
                METRIC_FAMILY_TYPE_STRING,
                .generate = smbios_generate,
        },
        SMBIOS_STANDARD_FIELD("SystemProductName"),
        SMBIOS_STANDARD_FIELD("SystemVersion"),
        SMBIOS_STANDARD_FIELD("SystemSKUNumber"),
        SMBIOS_STANDARD_FIELD("SystemFamily"),
        SMBIOS_STANDARD_FIELD("SystemSerialNumber"),
        SMBIOS_STANDARD_FIELD("SystemUUID"),
        SMBIOS_STANDARD_FIELD("BaseBoardManufacturer"),
        SMBIOS_STANDARD_FIELD("BaseBoardProduct"),
        SMBIOS_STANDARD_FIELD("BaseBoardVersion"),
        SMBIOS_STANDARD_FIELD("BaseBoardSerial"),
        SMBIOS_STANDARD_FIELD("BaseBoardAssetTag"),
        SMBIOS_STANDARD_FIELD("FirmwareVendor"),
        SMBIOS_STANDARD_FIELD("FirmwareVersion"),
        SMBIOS_STANDARD_FIELD("FirmwareReleaseDate"),
        SMBIOS_STANDARD_FIELD("ChassisType"),
        SMBIOS_STANDARD_FIELD("ChassisManufacturer"),
        SMBIOS_STANDARD_FIELD("ChassisSerialNumber"),
        SMBIOS_STANDARD_FIELD("ChassisAssetTagNumber"),
        /* Keep those ↑ in sync with smbios_generate(). */
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "TPM2.Manufacturer",
                "TPM2 device manufacturer (ID_TPM2_MANUFACTURER property of the tpmrm0 device)",
                METRIC_FAMILY_TYPE_STRING,
                .generate = tpm2_generate,
        },
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "TPM2.VendorString",
                "TPM2 device vendor string (ID_TPM2_VENDOR_STRING property of the tpmrm0 device)",
                METRIC_FAMILY_TYPE_STRING,
                .generate = NULL,
        },
        /* Keep those ↑ in sync with tpm2_generate(). */
        {
                METRIC_IO_SYSTEMD_BASIC_PREFIX "Virtualization",
                "Virtualization type",
                METRIC_FAMILY_TYPE_STRING,
                .generate = virtualization_generate,
        },
        {}
};

int vl_method_describe_metrics(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        return metrics_method_describe(metric_family_table, link, parameters, flags, userdata);
}

int vl_method_list_metrics(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        return metrics_method_list(metric_family_table, link, parameters, flags, userdata);
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <fcntl.h>
4	#include <sys/utsname.h>
5
6	#include "sd-device.h"
7	#include "sd-id128.h"
8	#include "sd-json.h"
9	#include "sd-varlink.h"
10
11	#include "alloc-util.h"
12	#include "architecture.h"
13	#include "confidential-virt.h"
14	#include "cpu-set-util.h"
15	#include "env-file.h"
16	#include "errno-util.h"
17	#include "fd-util.h"
18	#include "fileio.h"
19	#include "hostname-setup.h"
20	#include "hostname-util.h"
21	#include "limits-util.h"
22	#include "log.h"
23	#include "metrics.h"
24	#include "os-util.h"
25	#include "report-basic.h"
26	#include "string-util.h"
27	#include "virt.h"
28
UNCOV 29	static int architecture_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 30	assert(mf && mf->name);	×
UNCOV 31	assert(link);	×
32
33	return metric_build_send_string(	×
34	mf,
35	link,
36	/* object= */ NULL,
37	architecture_to_string(uname_architecture()),
38	/* fields= */ NULL);
39	}
40
41	static int boot_id_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 42	sd_id128_t id;	×
43	int r;	×
44
UNCOV 45	assert(mf && mf->name);	×
UNCOV 46	assert(link);	×
47
UNCOV 48	r = sd_id128_get_boot(&id);	×
UNCOV 49	if (r < 0)	×
UNCOV 50	return r;	×
51
52	return metric_build_send_string(	×
53	mf,
54	link,
55	/* object= */ NULL,
56	SD_ID128_TO_STRING(id),	×
57	/* fields= */ NULL);
58	}
59
UNCOV 60	static int hostname_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 61	_cleanup_free_ char *hostname = NULL;	×
62	int r;	×
63
UNCOV 64	assert(mf && mf->name);	×
UNCOV 65	assert(link);	×
66
UNCOV 67	r = gethostname_full(GET_HOSTNAME_ALLOW_LOCALHOST \| GET_HOSTNAME_FALLBACK_DEFAULT, &hostname);	×
UNCOV 68	if (r < 0)	×
69	return r;
70
71	return metric_build_send_string(	×
72	mf,
73	link,
74	/* object= */ NULL,
75	hostname,
76	/* fields= */ NULL);
77	}
78
UNCOV 79	static int kernel_version_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 80	struct utsname u;	×
81
UNCOV 82	assert(mf && mf->name);	×
UNCOV 83	assert(link);	×
84
UNCOV 85	assert_se(uname(&u) >= 0);	×
86
87	return metric_build_send_string(	×
88	mf,
89	link,
90	/* object= */ NULL,
91	u.release,
92	/* fields= */ NULL);
93	}
94
95	static int machine_id_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 96	sd_id128_t id;	×
97	int r;	×
98
UNCOV 99	assert(mf && mf->name);	×
UNCOV 100	assert(link);	×
101
UNCOV 102	r = sd_id128_get_machine(&id);	×
UNCOV 103	if (r < 0)	×
UNCOV 104	return r;	×
105
106	return metric_build_send_string(	×
107	mf,
108	link,
109	/* object= */ NULL,
UNCOV 110	SD_ID128_TO_STRING(id),	×
111	/* fields= */ NULL);
112	}
113
UNCOV 114	static int physical_memory_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 115	assert(mf && mf->name);	×
UNCOV 116	assert(link);	×
117
118	return metric_build_send_unsigned(	×
119	mf,
120	link,
121	/* object= */ NULL,
122	physical_memory(),
123	/* fields= */ NULL);
124	}
125
126	static int cpus_online_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 127	int r;	×
128
UNCOV 129	assert(mf && mf->name);	×
UNCOV 130	assert(link);	×
131
UNCOV 132	unsigned n_cpus;	×
UNCOV 133	r = cpus_online(&n_cpus);	×
UNCOV 134	if (r < 0)	×
UNCOV 135	return r;	×
136
UNCOV 137	return metric_build_send_unsigned(	×
138	mf,
139	link,
140	/* object= */ NULL,
141	n_cpus,
142	/* fields= */ NULL);
143	}
144
145	enum {
146	FIELD_PRETTY_NAME,
147	FIELD_NAME,
148	FIELD_ID,
149	FIELD_CPE_NAME,
150	FIELD_VARIANT_ID,
151	FIELD_VERSION_ID,
152	FIELD_BUILD_ID,
153	FIELD_IMAGE_VERSION,
154	FIELD_IMAGE_ID,
155	FIELD_SUPPORT_END,
156	FIELD_EXPERIMENT,
157	FIELD_SYSEXT_LEVEL,
158	FIELD_CONFEXT_LEVEL,
159	_FIELD_MAX,
160	};
161
UNCOV 162	static int os_release_generate(const MetricFamily mf[static _FIELD_MAX - 1], sd_varlink link, void userdata) {	×
UNCOV 163	char* values[_FIELD_MAX] = {};	×
UNCOV 164	CLEANUP_ELEMENTS(values, free_many_charp);	×
UNCOV 165	int r;	×
166
UNCOV 167	assert(mf && mf->name);	×
UNCOV 168	assert(link);	×
169
UNCOV 170	r = parse_os_release(NULL,	×
171	"PRETTY_NAME", &values[FIELD_PRETTY_NAME],
172	"NAME", &values[FIELD_NAME],
173	"ID", &values[FIELD_ID],
174	"CPE_NAME", &values[FIELD_CPE_NAME],
175	"VARIANT_ID", &values[FIELD_VARIANT_ID],
176	"VERSION_ID", &values[FIELD_VERSION_ID],
177	"BUILD_ID", &values[FIELD_BUILD_ID],
178	"IMAGE_VERSION", &values[FIELD_IMAGE_VERSION],
179	"IMAGE_ID", &values[FIELD_IMAGE_ID],
180	"SUPPORT_END", &values[FIELD_SUPPORT_END],
181	"EXPERIMENT", &values[FIELD_EXPERIMENT],
182	"SYSEXT_LEVEL", &values[FIELD_SYSEXT_LEVEL],
183	"CONFEXT_LEVEL", &values[FIELD_CONFEXT_LEVEL]);
184	if (r < 0) {	×
UNCOV 185	log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,	×
186	"Failed to read os-release file, ignoring: %m");
187	return 0;
188	}
189
UNCOV 190	for (size_t i = 1; i < _FIELD_MAX; i++) {	×
UNCOV 191	const char *v = values[i];	×
UNCOV 192	if (i == FIELD_NAME && values[FIELD_PRETTY_NAME])	×
193	v = values[FIELD_PRETTY_NAME]; /* Prefer PRETTY_NAME to NAME */	×
194
UNCOV 195	if (v) {	×
UNCOV 196	r = metric_build_send_string(	×
UNCOV 197	mf + i - 1,	×
198	link,
199	/* object= */ NULL,
200	v,
201	/* fields= */ NULL);
202	if (r < 0)	×
203	return r;
204	}
205	}
206
207	return 0;
208	}
209
UNCOV 210	static int machine_info_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 211	enum {	×
212	MACHINE_INFO_FIELD_PRETTY_HOSTNAME,
213	MACHINE_INFO_FIELD_DEPLOYMENT,
214	MACHINE_INFO_FIELD_LOCATION,
215	MACHINE_INFO_FIELD_TAGS,
216	_MACHINE_INFO_FIELD_MAX,
217	};
218
UNCOV 219	char* values[_MACHINE_INFO_FIELD_MAX] = {};	×
UNCOV 220	CLEANUP_ELEMENTS(values, free_many_charp);	×
UNCOV 221	int r;	×
222
UNCOV 223	assert(mf && mf->name);	×
UNCOV 224	assert(link);	×
225
UNCOV 226	r = parse_env_file(/* f= */ NULL, etc_machine_info(),	×
227	"PRETTY_HOSTNAME", &values[MACHINE_INFO_FIELD_PRETTY_HOSTNAME],
228	"DEPLOYMENT", &values[MACHINE_INFO_FIELD_DEPLOYMENT],
229	"LOCATION", &values[MACHINE_INFO_FIELD_LOCATION],
230	"TAGS", &values[MACHINE_INFO_FIELD_TAGS]);
UNCOV 231	if (r < 0) {	×
UNCOV 232	log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,	×
233	"Failed to read machine-info file, ignoring: %m");
234	return 0;
235	}
236
UNCOV 237	for (size_t i = 0; i < _MACHINE_INFO_FIELD_MAX; i++) {	×
UNCOV 238	const char *v = values[i];	×
UNCOV 239	if (!v)	×
UNCOV 240	continue;	×
241
UNCOV 242	r = metric_build_send_string(	×
UNCOV 243	mf + i,	×
244	link,
245	/* object= */ NULL,
246	v,
247	/* fields= */ NULL);
UNCOV 248	if (r < 0)	×
249	return r;
250	}
251
252	return 0;
253	}
254
UNCOV 255	static int smbios_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 256	enum {	×
257	SMBIOS_FIELD_SYS_VENDOR,
258	SMBIOS_FIELD_PRODUCT_NAME,
259	SMBIOS_FIELD_PRODUCT_VERSION,
260	SMBIOS_FIELD_PRODUCT_SKU,
261	SMBIOS_FIELD_PRODUCT_FAMILY,
262	SMBIOS_FIELD_PRODUCT_SERIAL,
263	SMBIOS_FIELD_PRODUCT_UUID,
264	SMBIOS_FIELD_BOARD_VENDOR,
265	SMBIOS_FIELD_BOARD_NAME,
266	SMBIOS_FIELD_BOARD_VERSION,
267	SMBIOS_FIELD_BOARD_SERIAL,
268	SMBIOS_FIELD_BOARD_ASSET_TAG,
269	SMBIOS_FIELD_BIOS_VENDOR,
270	SMBIOS_FIELD_BIOS_VERSION,
271	SMBIOS_FIELD_BIOS_DATE,
272	SMBIOS_FIELD_CHASSIS_TYPE,
273	SMBIOS_FIELD_CHASSIS_VENDOR,
274	SMBIOS_FIELD_CHASSIS_SERIAL,
275	SMBIOS_FIELD_CHASSIS_ASSET_TAG,
276	_SMBIOS_FIELD_MAX,
277	};
278
279	/* The sysfs attribute names exposed by the kernel below /sys/class/dmi/id/. The order must match the
280	* SMBIOS_STANDARD_FIELD() entries in the metric family table below. */
UNCOV 281	static const char* const smbios_files[_SMBIOS_FIELD_MAX] = {	×
282	/* SMBIOS Type 1 */
283	[SMBIOS_FIELD_SYS_VENDOR] = "sys_vendor",
284	[SMBIOS_FIELD_PRODUCT_NAME] = "product_name",
285	[SMBIOS_FIELD_PRODUCT_VERSION] = "product_version",
286	[SMBIOS_FIELD_PRODUCT_SKU] = "product_sku",
287	[SMBIOS_FIELD_PRODUCT_FAMILY] = "product_family",
288	[SMBIOS_FIELD_PRODUCT_SERIAL] = "product_serial",
289	[SMBIOS_FIELD_PRODUCT_UUID] = "product_uuid",
290	/* SMBIOS Type 2 */
291	[SMBIOS_FIELD_BOARD_VENDOR] = "board_vendor",
292	[SMBIOS_FIELD_BOARD_NAME] = "board_name",
293	[SMBIOS_FIELD_BOARD_VERSION] = "board_version",
294	[SMBIOS_FIELD_BOARD_SERIAL] = "board_serial",
295	[SMBIOS_FIELD_BOARD_ASSET_TAG] = "board_asset_tag",
296	/* SMBIOS Type 0 */
297	[SMBIOS_FIELD_BIOS_VENDOR] = "bios_vendor",
298	[SMBIOS_FIELD_BIOS_VERSION] = "bios_version",
299	[SMBIOS_FIELD_BIOS_DATE] = "bios_date",
300	/* SMBIOS Type 3 */
301	[SMBIOS_FIELD_CHASSIS_TYPE] = "chassis_type",
302	[SMBIOS_FIELD_CHASSIS_VENDOR] = "chassis_vendor",
303	[SMBIOS_FIELD_CHASSIS_SERIAL] = "chassis_serial",
304	[SMBIOS_FIELD_CHASSIS_ASSET_TAG] = "chassis_asset_tag",
305	};
306
UNCOV 307	int r;	×
308
UNCOV 309	assert(mf && mf->name);	×
UNCOV 310	assert(link);	×
311
312	/* Reports the fundamental SMBIOS/DMI identification fields. Some of these (serial numbers, asset
313	* tags, the system UUID) are privacy sensitive and only readable by root — if we lack the
314	* privileges to read them we simply skip them. */
315
UNCOV 316	_cleanup_close_ int dir_fd = open("/sys/class/dmi/id", O_RDONLY\|O_DIRECTORY\|O_CLOEXEC);	×
UNCOV 317	if (dir_fd < 0) {	×
UNCOV 318	log_full_errno(ERRNO_IS_DEVICE_ABSENT(errno) ? LOG_DEBUG : LOG_WARNING, errno,	×
319	"Failed to open /sys/class/dmi/id/, ignoring: %m");
320	return 0;
321	}
322
UNCOV 323	for (size_t i = 0; i < _SMBIOS_FIELD_MAX; i++) {	×
UNCOV 324	_cleanup_free_ char *buf = NULL;	×
325
UNCOV 326	r = read_virtual_file_at(dir_fd, smbios_files[i], /* max_size= / SIZE_MAX, &buf, / ret_size= */ NULL);	×
UNCOV 327	if (r < 0) {	×
UNCOV 328	log_full_errno(r == -ENOENT \|\| ERRNO_IS_NEG_PRIVILEGE(r) ? LOG_DEBUG : LOG_WARNING, r,	×
329	"Failed to read SMBIOS field '%s', ignoring: %m", smbios_files[i]);
UNCOV 330	continue;	×
331	}
332
UNCOV 333	delete_trailing_chars(buf, NEWLINE);	×
334
UNCOV 335	if (isempty(buf))	×
UNCOV 336	continue;	×
337
UNCOV 338	if (!string_is_safe(buf, STRING_ALLOW_BACKSLASHES\|STRING_ALLOW_QUOTES\|STRING_ALLOW_GLOBS)) {	×
UNCOV 339	log_debug("SMBIOS field '%s' contains unsafe characters, ignoring.", smbios_files[i]);	×
UNCOV 340	continue;	×
341	}
342
UNCOV 343	r = metric_build_send_string(	×
UNCOV 344	mf + i,	×
345	link,
346	/* object= */ NULL,
347	buf,
348	/* fields= */ NULL);
UNCOV 349	if (r < 0)	×
UNCOV 350	return r;	×
351	}
352
353	return 0;
354	}
355
UNCOV 356	static int tpm2_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 357	enum {	×
358	TPM2_FIELD_MANUFACTURER,
359	TPM2_FIELD_VENDOR_STRING,
360	_TPM2_FIELD_MAX,
361	};
362
363	/* The udev properties set by the 'tpm2_id' builtin on the tpmrm device. The order must match the
364	* metric family table entries below. */
UNCOV 365	static const char* const tpm2_properties[_TPM2_FIELD_MAX] = {	×
366	[TPM2_FIELD_MANUFACTURER] = "ID_TPM2_MANUFACTURER",
367	[TPM2_FIELD_VENDOR_STRING] = "ID_TPM2_VENDOR_STRING",
368	};
369
UNCOV 370	int r;	×
371
UNCOV 372	assert(mf && mf->name);	×
UNCOV 373	assert(link);	×
374
UNCOV 375	_cleanup_(sd_device_unrefp) sd_device *dev = NULL;	×
UNCOV 376	r = sd_device_new_from_subsystem_sysname(&dev, "tpmrm", "tpmrm0");	×
UNCOV 377	if (r < 0) {	×
UNCOV 378	log_full_errno(ERRNO_IS_NEG_DEVICE_ABSENT(r) ? LOG_DEBUG : LOG_WARNING, r,	×
379	"Failed to open tpmrm0 device, ignoring: %m");
380	return 0;
381	}
382
UNCOV 383	for (size_t i = 0; i < _TPM2_FIELD_MAX; i++) {	×
UNCOV 384	const char *v;	×
385
UNCOV 386	r = sd_device_get_property_value(dev, tpm2_properties[i], &v);	×
UNCOV 387	if (r < 0) {	×
UNCOV 388	log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,	×
389	"Failed to read TPM2 property '%s', ignoring: %m", tpm2_properties[i]);
UNCOV 390	continue;	×
391	}
392
UNCOV 393	if (isempty(v))	×
UNCOV 394	continue;	×
395
UNCOV 396	r = metric_build_send_string(	×
UNCOV 397	mf + i,	×
398	link,
399	/* object= */ NULL,
400	v,
401	/* fields= */ NULL);
UNCOV 402	if (r < 0)	×
UNCOV 403	return r;	×
404	}
405
406	return 0;
407	}
408
UNCOV 409	static int confidential_virtualization_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 410	assert(mf && mf->name);	×
UNCOV 411	assert(link);	×
412
UNCOV 413	ConfidentialVirtualization cv = detect_confidential_virtualization();	×
UNCOV 414	if (cv < 0)	×
415	return cv;
416
UNCOV 417	return metric_build_send_string(	×
418	mf,
419	link,
420	/* object= */ NULL,
421	confidential_virtualization_to_string(cv),
422	/* fields= */ NULL);
423	}
424
UNCOV 425	static int virtualization_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
UNCOV 426	assert(mf && mf->name);	×
UNCOV 427	assert(link);	×
428
UNCOV 429	Virtualization v = detect_virtualization();	×
UNCOV 430	if (v < 0)	×
431	return v;
432
UNCOV 433	return metric_build_send_string(	×
434	mf,
435	link,
436	/* object= */ NULL,
437	virtualization_to_string(v),
438	/* fields= */ NULL);
439	}
440
441	#define OS_RELEASE_STANDARD_FIELD(name) \
442	{ \
443	METRIC_IO_SYSTEMD_BASIC_PREFIX "OSRelease." name, \
444	"Operating system identification (" name "= field from os-release)", \
445	METRIC_FAMILY_TYPE_STRING, \
446	.generate = NULL, \
447	}
448
449	#define MACHINE_INFO_STANDARD_FIELD(name) \
450	{ \
451	METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineInfo." name, \
452	"Machine identification (" name "= field from machine-info)", \
453	METRIC_FAMILY_TYPE_STRING, \
454	.generate = NULL, \
455	}
456
457	#define SMBIOS_STANDARD_FIELD(name) \
458	{ \
459	METRIC_IO_SYSTEMD_BASIC_PREFIX "SMBIOS." name, \
460	"Firmware/hardware identification (" name " field from SMBIOS/DMI)", \
461	METRIC_FAMILY_TYPE_STRING, \
462	.generate = NULL, \
463	}
464
465	static const MetricFamily metric_family_table[] = {
466	/* Keep entries ordered alphabetically */
467	{
468	METRIC_IO_SYSTEMD_BASIC_PREFIX "Architecture",
469	"CPU architecture",
470	METRIC_FAMILY_TYPE_STRING,
471	.generate = architecture_generate,
472	},
473	{
474	METRIC_IO_SYSTEMD_BASIC_PREFIX "BootID",
475	"Current boot ID",
476	METRIC_FAMILY_TYPE_STRING,
477	.generate = boot_id_generate,
478	},
479	{
480	METRIC_IO_SYSTEMD_BASIC_PREFIX "ConfidentialVirtualization",
481	"Confidential computing technology",
482	METRIC_FAMILY_TYPE_STRING,
483	.generate = confidential_virtualization_generate,
484	},
485	{
486	METRIC_IO_SYSTEMD_BASIC_PREFIX "CPUsOnline",
487	"Number of CPUs currently online",
488	METRIC_FAMILY_TYPE_GAUGE,
489	.generate = cpus_online_generate,
490	},
491	{
492	METRIC_IO_SYSTEMD_BASIC_PREFIX "Hostname",
493	"System hostname",
494	METRIC_FAMILY_TYPE_STRING,
495	.generate = hostname_generate,
496	},
497	{
498	METRIC_IO_SYSTEMD_BASIC_PREFIX "KernelVersion",
499	"Kernel version",
500	METRIC_FAMILY_TYPE_STRING,
501	.generate = kernel_version_generate,
502	},
503	{
504	METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineID",
505	"Machine ID",
506	METRIC_FAMILY_TYPE_STRING,
507	.generate = machine_id_generate,
508	},
509	{
510	METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineInfo.PRETTY_HOSTNAME",
511	"Pretty hostname (PRETTY_HOSTNAME= field from machine-info)",
512	METRIC_FAMILY_TYPE_STRING,
513	.generate = machine_info_generate,
514	},
515	MACHINE_INFO_STANDARD_FIELD("DEPLOYMENT"),
516	MACHINE_INFO_STANDARD_FIELD("LOCATION"),
517	MACHINE_INFO_STANDARD_FIELD("TAGS"),
518	/* Keep those ↑ in sync with machine_info_generate(). */
519	{
520	METRIC_IO_SYSTEMD_BASIC_PREFIX "OSRelease.NAME",
521	"Operating system human-readable name (PRETTY_NAME= or NAME= field from os-release)",
522	METRIC_FAMILY_TYPE_STRING,
523	.generate = os_release_generate,
524	},
525	OS_RELEASE_STANDARD_FIELD("ID"),
526	OS_RELEASE_STANDARD_FIELD("CPE_NAME"),
527	OS_RELEASE_STANDARD_FIELD("VARIANT_ID"),
528	OS_RELEASE_STANDARD_FIELD("VERSION_ID"),
529	OS_RELEASE_STANDARD_FIELD("BUILD_ID"),
530	OS_RELEASE_STANDARD_FIELD("IMAGE_VERSION"),
531	OS_RELEASE_STANDARD_FIELD("IMAGE_ID"),
532	OS_RELEASE_STANDARD_FIELD("SUPPORT_END"),
533	OS_RELEASE_STANDARD_FIELD("EXPERIMENT"),
534	OS_RELEASE_STANDARD_FIELD("SYSEXT_LEVEL"),
535	OS_RELEASE_STANDARD_FIELD("CONFEXT_LEVEL"),
536	/* Keep those ↑ in sync with os_release_generate(). */
537	{
538	METRIC_IO_SYSTEMD_BASIC_PREFIX "PhysicalMemoryBytes",
539	"Installed physical memory in bytes",
540	METRIC_FAMILY_TYPE_GAUGE,
541	.generate = physical_memory_generate,
542	},
543	{
544	/* NB: Here we use the naming of the field as per SMBIOS specification, i.e. undo the weird
545	* renaming that Linux did on the fields. When new fields are added here, please make sure to
546	* check the specification again for naming them. */
547	METRIC_IO_SYSTEMD_BASIC_PREFIX "SMBIOS.SystemManufacturer",
548	"Firmware/hardware identification (SystemManufacturer field from SMBIOS/DMI)",
549	METRIC_FAMILY_TYPE_STRING,
550	.generate = smbios_generate,
551	},
552	SMBIOS_STANDARD_FIELD("SystemProductName"),
553	SMBIOS_STANDARD_FIELD("SystemVersion"),
554	SMBIOS_STANDARD_FIELD("SystemSKUNumber"),
555	SMBIOS_STANDARD_FIELD("SystemFamily"),
556	SMBIOS_STANDARD_FIELD("SystemSerialNumber"),
557	SMBIOS_STANDARD_FIELD("SystemUUID"),
558	SMBIOS_STANDARD_FIELD("BaseBoardManufacturer"),
559	SMBIOS_STANDARD_FIELD("BaseBoardProduct"),
560	SMBIOS_STANDARD_FIELD("BaseBoardVersion"),
561	SMBIOS_STANDARD_FIELD("BaseBoardSerial"),
562	SMBIOS_STANDARD_FIELD("BaseBoardAssetTag"),
563	SMBIOS_STANDARD_FIELD("FirmwareVendor"),
564	SMBIOS_STANDARD_FIELD("FirmwareVersion"),
565	SMBIOS_STANDARD_FIELD("FirmwareReleaseDate"),
566	SMBIOS_STANDARD_FIELD("ChassisType"),
567	SMBIOS_STANDARD_FIELD("ChassisManufacturer"),
568	SMBIOS_STANDARD_FIELD("ChassisSerialNumber"),
569	SMBIOS_STANDARD_FIELD("ChassisAssetTagNumber"),
570	/* Keep those ↑ in sync with smbios_generate(). */
571	{
572	METRIC_IO_SYSTEMD_BASIC_PREFIX "TPM2.Manufacturer",
573	"TPM2 device manufacturer (ID_TPM2_MANUFACTURER property of the tpmrm0 device)",
574	METRIC_FAMILY_TYPE_STRING,
575	.generate = tpm2_generate,
576	},
577	{
578	METRIC_IO_SYSTEMD_BASIC_PREFIX "TPM2.VendorString",
579	"TPM2 device vendor string (ID_TPM2_VENDOR_STRING property of the tpmrm0 device)",
580	METRIC_FAMILY_TYPE_STRING,
581	.generate = NULL,
582	},
583	/* Keep those ↑ in sync with tpm2_generate(). */
584	{
585	METRIC_IO_SYSTEMD_BASIC_PREFIX "Virtualization",
586	"Virtualization type",
587	METRIC_FAMILY_TYPE_STRING,
588	.generate = virtualization_generate,
589	},
590	{}
591	};
592
UNCOV 593	int vl_method_describe_metrics(sd_varlink link, sd_json_variant parameters, sd_varlink_method_flags_t flags, void *userdata) {	×
UNCOV 594	return metrics_method_describe(metric_family_table, link, parameters, flags, userdata);	×
595	}
596
UNCOV 597	int vl_method_list_metrics(sd_varlink link, sd_json_variant parameters, sd_varlink_method_flags_t flags, void *userdata) {	×
UNCOV 598	return metrics_method_list(metric_family_table, link, parameters, flags, userdata);	×
599	}

systemd / systemd / 26546993077

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous