25893429527

Committed 14 May 2026 09:08PM UTC coverage: 72.364% (-0.2%) from 72.584%

Build # 25893429527

Build Type

push

github

Committed by

bluca

Commit Message

ci: switch SUSE mkosi mirror to cdn.o.o

The cdn mirror is preferred by SUSE for clouds/CIs. There have been issues with some
mirrors, which fail to download from GHA quite often lately, so hopefully this will
make it reliable again.

Coverage Stats

328159 of 453485 relevant lines covered (72.36%)

1405869.02 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 <sys/utsname.h>

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

#include "alloc-util.h"
#include "architecture.h"
#include "cpu-set-util.h"
#include "hostname-setup.h"
#include "limits-util.h"
#include "log.h"
#include "metrics.h"
#include "os-util.h"
#include "report-basic.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 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,                                       \
        }

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 "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 "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,
        },
        {
                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 <sys/utsname.h>
4
5	#include "sd-id128.h"
6	#include "sd-json.h"
7	#include "sd-varlink.h"
8
9	#include "alloc-util.h"
10	#include "architecture.h"
11	#include "cpu-set-util.h"
12	#include "hostname-setup.h"
13	#include "limits-util.h"
14	#include "log.h"
15	#include "metrics.h"
16	#include "os-util.h"
17	#include "report-basic.h"
18	#include "virt.h"
19
20	static int architecture_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
21	assert(mf && mf->name);	×
22	assert(link);	×
23
24	return metric_build_send_string(	×
25	mf,
26	link,
27	/* object= */ NULL,
28	architecture_to_string(uname_architecture()),
29	/* fields= */ NULL);
30	}
31
32	static int boot_id_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
33	sd_id128_t id;	×
34	int r;	×
35
36	assert(mf && mf->name);	×
37	assert(link);	×
38
39	r = sd_id128_get_boot(&id);	×
40	if (r < 0)	×
41	return r;	×
42
43	return metric_build_send_string(	×
44	mf,
45	link,
46	/* object= */ NULL,
47	SD_ID128_TO_STRING(id),	×
48	/* fields= */ NULL);
49	}
50
51	static int hostname_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
52	_cleanup_free_ char *hostname = NULL;	×
53	int r;	×
54
55	assert(mf && mf->name);	×
56	assert(link);	×
57
58	r = gethostname_full(GET_HOSTNAME_ALLOW_LOCALHOST \| GET_HOSTNAME_FALLBACK_DEFAULT, &hostname);	×
59	if (r < 0)	×
60	return r;
61
62	return metric_build_send_string(	×
63	mf,
64	link,
65	/* object= */ NULL,
66	hostname,
67	/* fields= */ NULL);
68	}
69
70	static int kernel_version_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
71	struct utsname u;	×
72
73	assert(mf && mf->name);	×
74	assert(link);	×
75
76	assert_se(uname(&u) >= 0);	×
77
78	return metric_build_send_string(	×
79	mf,
80	link,
81	/* object= */ NULL,
82	u.release,
83	/* fields= */ NULL);
84	}
85
86	static int machine_id_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
87	sd_id128_t id;	×
88	int r;	×
89
90	assert(mf && mf->name);	×
91	assert(link);	×
92
93	r = sd_id128_get_machine(&id);	×
94	if (r < 0)	×
95	return r;	×
96
97	return metric_build_send_string(	×
98	mf,
99	link,
100	/* object= */ NULL,
101	SD_ID128_TO_STRING(id),	×
102	/* fields= */ NULL);
103	}
104
105	static int physical_memory_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
106	assert(mf && mf->name);	×
107	assert(link);	×
108
109	return metric_build_send_unsigned(	×
110	mf,
111	link,
112	/* object= */ NULL,
113	physical_memory(),
114	/* fields= */ NULL);
115	}
116
117	static int cpus_online_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
118	int r;	×
119
120	assert(mf && mf->name);	×
121	assert(link);	×
122
123	unsigned n_cpus;	×
124	r = cpus_online(&n_cpus);	×
125	if (r < 0)	×
126	return r;	×
127
128	return metric_build_send_unsigned(	×
129	mf,
130	link,
131	/* object= */ NULL,
132	n_cpus,
133	/* fields= */ NULL);
134	}
135
136	enum {
137	FIELD_PRETTY_NAME,
138	FIELD_NAME,
139	FIELD_ID,
140	FIELD_CPE_NAME,
141	FIELD_VARIANT_ID,
142	FIELD_VERSION_ID,
143	FIELD_BUILD_ID,
144	FIELD_IMAGE_VERSION,
145	FIELD_IMAGE_ID,
146	FIELD_SUPPORT_END,
147	FIELD_EXPERIMENT,
148	FIELD_SYSEXT_LEVEL,
149	FIELD_CONFEXT_LEVEL,
150	_FIELD_MAX,
151	};
152
153	static int os_release_generate(const MetricFamily mf[static _FIELD_MAX - 1], sd_varlink link, void userdata) {	×
154	char* values[_FIELD_MAX] = {};	×
155	CLEANUP_ELEMENTS(values, free_many_charp);	×
156	int r;	×
157
158	assert(mf && mf->name);	×
159	assert(link);	×
160
161	r = parse_os_release(NULL,	×
162	"PRETTY_NAME", &values[FIELD_PRETTY_NAME],
163	"NAME", &values[FIELD_NAME],
164	"ID", &values[FIELD_ID],
165	"CPE_NAME", &values[FIELD_CPE_NAME],
166	"VARIANT_ID", &values[FIELD_VARIANT_ID],
167	"VERSION_ID", &values[FIELD_VERSION_ID],
168	"BUILD_ID", &values[FIELD_BUILD_ID],
169	"IMAGE_VERSION", &values[FIELD_IMAGE_VERSION],
170	"IMAGE_ID", &values[FIELD_IMAGE_ID],
171	"SUPPORT_END", &values[FIELD_SUPPORT_END],
172	"EXPERIMENT", &values[FIELD_EXPERIMENT],
173	"SYSEXT_LEVEL", &values[FIELD_SYSEXT_LEVEL],
174	"CONFEXT_LEVEL", &values[FIELD_CONFEXT_LEVEL]);
175	if (r < 0) {	×
176	log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,	×
177	"Failed to read os-release file, ignoring: %m");
178	return 0;
179	}
180
181	for (size_t i = 1; i < _FIELD_MAX; i++) {	×
182	const char *v = values[i];	×
183	if (i == FIELD_NAME && values[FIELD_PRETTY_NAME])	×
184	v = values[FIELD_PRETTY_NAME]; /* Prefer PRETTY_NAME to NAME */	×
185
186	if (v) {	×
187	r = metric_build_send_string(	×
188	mf + i - 1,	×
189	link,
190	/* object= */ NULL,
191	v,
192	/* fields= */ NULL);
193	if (r < 0)	×
194	return r;
195	}
196	}
197
198	return 0;
199	}
200
201	static int virtualization_generate(const MetricFamily mf, sd_varlink link, void *userdata) {	×
202	assert(mf && mf->name);	×
203	assert(link);	×
204
205	Virtualization v = detect_virtualization();	×
206	if (v < 0)	×
207	return v;
208
209	return metric_build_send_string(	×
210	mf,
211	link,
212	/* object= */ NULL,
213	virtualization_to_string(v),
214	/* fields= */ NULL);
215	}
216
217	#define OS_RELEASE_STANDARD_FIELD(name) \
218	{ \
219	METRIC_IO_SYSTEMD_BASIC_PREFIX "OSRelease." name, \
220	"Operating system identification (" name "= field from os-release)", \
221	METRIC_FAMILY_TYPE_STRING, \
222	.generate = NULL, \
223	}
224
225	static const MetricFamily metric_family_table[] = {
226	/* Keep entries ordered alphabetically */
227	{
228	METRIC_IO_SYSTEMD_BASIC_PREFIX "Architecture",
229	"CPU architecture",
230	METRIC_FAMILY_TYPE_STRING,
231	.generate = architecture_generate,
232	},
233	{
234	METRIC_IO_SYSTEMD_BASIC_PREFIX "BootID",
235	"Current boot ID",
236	METRIC_FAMILY_TYPE_STRING,
237	.generate = boot_id_generate,
238	},
239	{
240	METRIC_IO_SYSTEMD_BASIC_PREFIX "CPUsOnline",
241	"Number of CPUs currently online",
242	METRIC_FAMILY_TYPE_GAUGE,
243	.generate = cpus_online_generate,
244	},
245	{
246	METRIC_IO_SYSTEMD_BASIC_PREFIX "Hostname",
247	"System hostname",
248	METRIC_FAMILY_TYPE_STRING,
249	.generate = hostname_generate,
250	},
251	{
252	METRIC_IO_SYSTEMD_BASIC_PREFIX "KernelVersion",
253	"Kernel version",
254	METRIC_FAMILY_TYPE_STRING,
255	.generate = kernel_version_generate,
256	},
257	{
258	METRIC_IO_SYSTEMD_BASIC_PREFIX "MachineID",
259	"Machine ID",
260	METRIC_FAMILY_TYPE_STRING,
261	.generate = machine_id_generate,
262	},
263	{
264	METRIC_IO_SYSTEMD_BASIC_PREFIX "OSRelease.NAME",
265	"Operating system human-readable name (PRETTY_NAME= or NAME= field from os-release)",
266	METRIC_FAMILY_TYPE_STRING,
267	.generate = os_release_generate,
268	},
269	OS_RELEASE_STANDARD_FIELD("ID"),
270	OS_RELEASE_STANDARD_FIELD("CPE_NAME"),
271	OS_RELEASE_STANDARD_FIELD("VARIANT_ID"),
272	OS_RELEASE_STANDARD_FIELD("VERSION_ID"),
273	OS_RELEASE_STANDARD_FIELD("BUILD_ID"),
274	OS_RELEASE_STANDARD_FIELD("IMAGE_VERSION"),
275	OS_RELEASE_STANDARD_FIELD("IMAGE_ID"),
276	OS_RELEASE_STANDARD_FIELD("SUPPORT_END"),
277	OS_RELEASE_STANDARD_FIELD("EXPERIMENT"),
278	OS_RELEASE_STANDARD_FIELD("SYSEXT_LEVEL"),
279	OS_RELEASE_STANDARD_FIELD("CONFEXT_LEVEL"),
280	/* Keep those ↑ in sync with os_release_generate(). */
281	{
282	METRIC_IO_SYSTEMD_BASIC_PREFIX "PhysicalMemoryBytes",
283	"Installed physical memory in bytes",
284	METRIC_FAMILY_TYPE_GAUGE,
285	.generate = physical_memory_generate,
286	},
287	{
288	METRIC_IO_SYSTEMD_BASIC_PREFIX "Virtualization",
289	"Virtualization type",
290	METRIC_FAMILY_TYPE_STRING,
291	.generate = virtualization_generate,
292	},
293	{}
294	};
295
296	int vl_method_describe_metrics(sd_varlink link, sd_json_variant parameters, sd_varlink_method_flags_t flags, void *userdata) {	×
297	return metrics_method_describe(metric_family_table, link, parameters, flags, userdata);	×
298	}
299
300	int vl_method_list_metrics(sd_varlink link, sd_json_variant parameters, sd_varlink_method_flags_t flags, void *userdata) {	×
301	return metrics_method_list(metric_family_table, link, parameters, flags, userdata);	×
302	}

systemd / systemd / 25893429527

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