15232239991

Committed 24 May 2025 08:01PM UTC coverage: 72.053% (-0.02%) from 72.07%

Build # 15232239991

Build Type

push

github

Committed by

web-flow

Commit Message

docs: add man pages for sd_device_enumerator_[new,ref,unref,unrefp] (#37586)

For #20929.

Coverage Stats

299160 of 415197 relevant lines covered (72.05%)

703671.29 hits per line

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

0.0

/src/shared/kernel-image.c

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

#include "alloc-util.h"
#include "env-file.h"
#include "fd-util.h"
#include "kernel-image.h"
#include "log.h"
#include "pe-binary.h"
#include "string-table.h"
#include "string-util.h"

#define PE_SECTION_READ_MAX (16U*1024U)

static const char * const kernel_image_type_table[_KERNEL_IMAGE_TYPE_MAX] = {
        [KERNEL_IMAGE_TYPE_UNKNOWN] = "unknown",
        [KERNEL_IMAGE_TYPE_UKI]     = "uki",
        [KERNEL_IMAGE_TYPE_ADDON]   = "addon",
        [KERNEL_IMAGE_TYPE_PE]      = "pe",
};

DEFINE_STRING_TABLE_LOOKUP_TO_STRING(kernel_image_type, KernelImageType);

static int uki_read_pretty_name(
                int fd,
                const PeHeader *pe_header,
                const IMAGE_SECTION_HEADER *sections,
                char **ret) {

        _cleanup_free_ char *pname = NULL, *name = NULL;
        _cleanup_fclose_ FILE *f = NULL;
        _cleanup_free_ void *osrel = NULL;
        size_t osrel_size;
        int r;

        assert(fd >= 0);
        assert(pe_header);
        assert(sections || le16toh(pe_header->pe.NumberOfSections) == 0);
        assert(ret);

        r = pe_read_section_data_by_name(
                        fd,
                        pe_header,
                        sections,
                        ".osrel",
                        /* max_size=*/ PE_SECTION_READ_MAX,
                        &osrel,
                        &osrel_size);
        if (r == -ENXIO) { /* Section not found */
                *ret = NULL;
                return 0;
        }

        f = fmemopen(osrel, osrel_size, "r");
        if (!f)
                return log_error_errno(errno, "Failed to open embedded os-release file: %m");

        r = parse_env_file(
                        f, NULL,
                        "PRETTY_NAME", &pname,
                        "NAME",        &name);
        if (r < 0)
                return log_error_errno(r, "Failed to parse embedded os-release file: %m");

        /* follow the same logic as os_release_pretty_name() */
        if (!isempty(pname))
                *ret = TAKE_PTR(pname);
        else if (!isempty(name))
                *ret = TAKE_PTR(name);
        else {
                char *n = strdup("Linux");
                if (!n)
                        return log_oom();

                *ret = n;
        }

        return 0;
}

static int inspect_uki(
                int fd,
                const PeHeader *pe_header,
                const IMAGE_SECTION_HEADER *sections,
                char **ret_cmdline,
                char **ret_uname,
                char **ret_pretty_name) {

        _cleanup_free_ char *cmdline = NULL, *uname = NULL, *pname = NULL;
        int r;

        assert(fd >= 0);
        assert(sections || le16toh(pe_header->pe.NumberOfSections) == 0);

        if (ret_cmdline) {
                r = pe_read_section_data_by_name(fd, pe_header, sections, ".cmdline", PE_SECTION_READ_MAX, (void**) &cmdline, NULL);
                if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */
                        return r;
        }

        if (ret_uname) {
                r = pe_read_section_data_by_name(fd, pe_header, sections, ".uname", PE_SECTION_READ_MAX, (void**) &uname, NULL);
                if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */
                        return r;
        }

        if (ret_pretty_name) {
                r = uki_read_pretty_name(fd, pe_header, sections, &pname);
                if (r < 0)
                        return r;
        }

        if (ret_cmdline)
                *ret_cmdline = TAKE_PTR(cmdline);
        if (ret_uname)
                *ret_uname = TAKE_PTR(uname);
        if (ret_pretty_name)
                *ret_pretty_name = TAKE_PTR(pname);

        return 0;
}

int inspect_kernel(
                int dir_fd,
                const char *filename,
                KernelImageType *ret_type,
                char **ret_cmdline,
                char **ret_uname,
                char **ret_pretty_name) {

        _cleanup_free_ IMAGE_SECTION_HEADER *sections = NULL;
        _cleanup_free_ IMAGE_DOS_HEADER *dos_header = NULL;
        KernelImageType t = KERNEL_IMAGE_TYPE_UNKNOWN;
        _cleanup_free_ PeHeader *pe_header = NULL;
        _cleanup_close_ int fd = -EBADF;
        int r;

        assert(dir_fd >= 0 || dir_fd == AT_FDCWD);
        assert(filename);

        fd = openat(dir_fd, filename, O_RDONLY|O_CLOEXEC);
        if (fd < 0)
                return log_error_errno(errno, "Failed to open kernel image file '%s': %m", filename);

        r = pe_load_headers(fd, &dos_header, &pe_header);
        if (r == -EBADMSG) /* not a valid PE file */
                goto not_uki;
        if (r < 0)
                return log_error_errno(r, "Failed to parse kernel image file '%s': %m", filename);

        r = pe_load_sections(fd, dos_header, pe_header, &sections);
        if (r == -EBADMSG) /* not a valid PE file */
                goto not_uki;
        if (r < 0)
                return log_error_errno(r, "Failed to load PE sections from kernel image file '%s': %m", filename);

        if (pe_is_uki(pe_header, sections)) {
                r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, ret_pretty_name);
                if (r < 0)
                        return r;

                t = KERNEL_IMAGE_TYPE_UKI;
                goto done;
        } else if (pe_is_addon(pe_header, sections)) {
                r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, /* ret_pretty_name= */ NULL);
                if (r < 0)
                        return r;

                if (ret_pretty_name)
                        *ret_pretty_name = NULL;

                t = KERNEL_IMAGE_TYPE_ADDON;
                goto done;
        } else
                t = KERNEL_IMAGE_TYPE_PE;

not_uki:
        if (ret_cmdline)
                *ret_cmdline = NULL;
        if (ret_uname)
                *ret_uname = NULL;
        if (ret_pretty_name)
                *ret_pretty_name = NULL;

done:
        if (ret_type)
                *ret_type = t;

        return 0;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "alloc-util.h"
4	#include "env-file.h"
5	#include "fd-util.h"
6	#include "kernel-image.h"
7	#include "log.h"
8	#include "pe-binary.h"
9	#include "string-table.h"
10	#include "string-util.h"
11
12	#define PE_SECTION_READ_MAX (16U*1024U)
13
14	static const char * const kernel_image_type_table[_KERNEL_IMAGE_TYPE_MAX] = {
15	[KERNEL_IMAGE_TYPE_UNKNOWN] = "unknown",
16	[KERNEL_IMAGE_TYPE_UKI] = "uki",
17	[KERNEL_IMAGE_TYPE_ADDON] = "addon",
18	[KERNEL_IMAGE_TYPE_PE] = "pe",
19	};
20
21	DEFINE_STRING_TABLE_LOOKUP_TO_STRING(kernel_image_type, KernelImageType);	×
22
23	static int uki_read_pretty_name(	×
24	int fd,
25	const PeHeader *pe_header,
26	const IMAGE_SECTION_HEADER *sections,
27	char **ret) {
28
29	_cleanup_free_ char pname = NULL, name = NULL;	×
30	_cleanup_fclose_ FILE *f = NULL;	×
31	_cleanup_free_ void *osrel = NULL;	×
32	size_t osrel_size;	×
33	int r;	×
34
35	assert(fd >= 0);	×
36	assert(pe_header);	×
37	assert(sections \|\| le16toh(pe_header->pe.NumberOfSections) == 0);	×
38	assert(ret);	×
39
40	r = pe_read_section_data_by_name(	×
41	fd,
42	pe_header,
43	sections,
44	".osrel",
45	/* max_size=*/ PE_SECTION_READ_MAX,
46	&osrel,
47	&osrel_size);
48	if (r == -ENXIO) { /* Section not found */	×
49	*ret = NULL;	×
50	return 0;	×
51	}
52
53	f = fmemopen(osrel, osrel_size, "r");	×
54	if (!f)	×
55	return log_error_errno(errno, "Failed to open embedded os-release file: %m");	×
56
57	r = parse_env_file(	×
58	f, NULL,
59	"PRETTY_NAME", &pname,
60	"NAME", &name);
61	if (r < 0)	×
62	return log_error_errno(r, "Failed to parse embedded os-release file: %m");	×
63
64	/* follow the same logic as os_release_pretty_name() */
65	if (!isempty(pname))	×
66	*ret = TAKE_PTR(pname);	×
67	else if (!isempty(name))	×
68	*ret = TAKE_PTR(name);	×
69	else {
70	char *n = strdup("Linux");	×
71	if (!n)	×
72	return log_oom();	×
73
74	*ret = n;	×
75	}
76
77	return 0;
78	}
79
80	static int inspect_uki(	×
81	int fd,
82	const PeHeader *pe_header,
83	const IMAGE_SECTION_HEADER *sections,
84	char **ret_cmdline,
85	char **ret_uname,
86	char **ret_pretty_name) {
87
88	_cleanup_free_ char cmdline = NULL, uname = NULL, *pname = NULL;	×
89	int r;	×
90
91	assert(fd >= 0);	×
92	assert(sections \|\| le16toh(pe_header->pe.NumberOfSections) == 0);	×
93
94	if (ret_cmdline) {	×
95	r = pe_read_section_data_by_name(fd, pe_header, sections, ".cmdline", PE_SECTION_READ_MAX, (void**) &cmdline, NULL);	×
96	if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */	×
97	return r;
98	}
99
100	if (ret_uname) {	×
101	r = pe_read_section_data_by_name(fd, pe_header, sections, ".uname", PE_SECTION_READ_MAX, (void**) &uname, NULL);	×
102	if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */	×
103	return r;
104	}
105
106	if (ret_pretty_name) {	×
107	r = uki_read_pretty_name(fd, pe_header, sections, &pname);	×
108	if (r < 0)	×
109	return r;
110	}
111
112	if (ret_cmdline)	×
113	*ret_cmdline = TAKE_PTR(cmdline);	×
114	if (ret_uname)	×
115	*ret_uname = TAKE_PTR(uname);	×
116	if (ret_pretty_name)	×
117	*ret_pretty_name = TAKE_PTR(pname);	×
118
119	return 0;
120	}
121
122	int inspect_kernel(	×
123	int dir_fd,
124	const char *filename,
125	KernelImageType *ret_type,
126	char **ret_cmdline,
127	char **ret_uname,
128	char **ret_pretty_name) {
129
130	_cleanup_free_ IMAGE_SECTION_HEADER *sections = NULL;	×
131	_cleanup_free_ IMAGE_DOS_HEADER *dos_header = NULL;	×
132	KernelImageType t = KERNEL_IMAGE_TYPE_UNKNOWN;	×
133	_cleanup_free_ PeHeader *pe_header = NULL;	×
134	_cleanup_close_ int fd = -EBADF;	×
135	int r;	×
136
137	assert(dir_fd >= 0 \|\| dir_fd == AT_FDCWD);	×
138	assert(filename);	×
139
140	fd = openat(dir_fd, filename, O_RDONLY\|O_CLOEXEC);	×
141	if (fd < 0)	×
142	return log_error_errno(errno, "Failed to open kernel image file '%s': %m", filename);	×
143
144	r = pe_load_headers(fd, &dos_header, &pe_header);	×
145	if (r == -EBADMSG) /* not a valid PE file */	×
146	goto not_uki;	×
147	if (r < 0)	×
148	return log_error_errno(r, "Failed to parse kernel image file '%s': %m", filename);	×
149
150	r = pe_load_sections(fd, dos_header, pe_header, &sections);	×
151	if (r == -EBADMSG) /* not a valid PE file */	×
152	goto not_uki;	×
153	if (r < 0)	×
154	return log_error_errno(r, "Failed to load PE sections from kernel image file '%s': %m", filename);	×
155
156	if (pe_is_uki(pe_header, sections)) {	×
157	r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, ret_pretty_name);	×
158	if (r < 0)	×
159	return r;
160
161	t = KERNEL_IMAGE_TYPE_UKI;	×
162	goto done;	×
163	} else if (pe_is_addon(pe_header, sections)) {	×
164	r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, /* ret_pretty_name= */ NULL);	×
165	if (r < 0)	×
166	return r;
167
168	if (ret_pretty_name)	×
169	*ret_pretty_name = NULL;	×
170
171	t = KERNEL_IMAGE_TYPE_ADDON;	×
172	goto done;	×
173	} else
174	t = KERNEL_IMAGE_TYPE_PE;
175
176	not_uki:	×
177	if (ret_cmdline)	×
178	*ret_cmdline = NULL;	×
179	if (ret_uname)	×
180	*ret_uname = NULL;	×
181	if (ret_pretty_name)	×
182	*ret_pretty_name = NULL;	×
183
184	done:	×
185	if (ret_type)	×
186	*ret_type = t;	×
187
188	return 0;
189	}

systemd / systemd / 15232239991

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