18578253386

Committed 16 Oct 2025 06:50PM UTC coverage: 72.363% (+0.3%) from 72.072%

Build # 18578253386

Build Type

push

github

Committed by

web-flow

Commit Message

core/mount: properly handle REMOUNTING_* states in mount_stop() (#39269)

Run Details

5 of 9 new or added lines in 1 file covered. (55.56%)

3694 existing lines in 74 files now uncovered.

304611 of 420946 relevant lines covered (72.36%)

1092905.84 hits per line

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

94.92

/src/shared/securebits-util.c

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

#include <stdio.h>

#include "alloc-util.h"
#include "extract-word.h"
#include "securebits-util.h"
#include "string-util.h"
#include "strv.h"

static inline const char* secure_bit_to_string(int i) {
        /* match a single bit */

        switch (i) {
                case SECURE_KEEP_CAPS:
                        return "keep-caps";
                case SECURE_KEEP_CAPS_LOCKED:
                        return "keep-caps-locked";
                case SECURE_NO_SETUID_FIXUP:
                        return "no-setuid-fixup";
                case SECURE_NO_SETUID_FIXUP_LOCKED:
                        return "no-setuid-fixup-locked";
                case SECURE_NOROOT:
                        return "noroot";
                case SECURE_NOROOT_LOCKED:
                        return "noroot-locked";
                default:
                        assert_not_reached();
        }
}

int secure_bits_to_string_alloc(int i, char **ret) {
        _cleanup_strv_free_ char **sv = NULL;
        _cleanup_free_ char *joined = NULL;
        int r;

        assert(ret);

        r = secure_bits_to_strv(i, &sv);
        if (r < 0)
                return r;

        joined = strv_join(sv, " ");
        if (!joined)
                return -ENOMEM;

        *ret = TAKE_PTR(joined);
        return 0;
}

int secure_bits_to_strv(int i, char ***ret) {
        _cleanup_strv_free_ char **sv = NULL;
        static const int bits[] = {
                SECURE_KEEP_CAPS,
                SECURE_KEEP_CAPS_LOCKED,
                SECURE_NO_SETUID_FIXUP,
                SECURE_NO_SETUID_FIXUP_LOCKED,
                SECURE_NOROOT,
                SECURE_NOROOT_LOCKED,
        };
        int r;

        assert(ret);

        FOREACH_ELEMENT(bit, bits) {
                if (i & (1 << *bit)) {
                        r = strv_extend(&sv, secure_bit_to_string(*bit));
                        if (r < 0)
                                return r;
                }
        }

        *ret = TAKE_PTR(sv);
        return 0;
}

int secure_bits_from_string(const char *s) {
        int secure_bits = 0;
        const char *p;
        int r;

        for (p = s;;) {
                _cleanup_free_ char *word = NULL;

                r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
                if (r == -ENOMEM)
                        return r;
                if (r <= 0)
                        break;

                if (streq(word, "keep-caps"))
                        secure_bits |= 1 << SECURE_KEEP_CAPS;
                else if (streq(word, "keep-caps-locked"))
                        secure_bits |= 1 << SECURE_KEEP_CAPS_LOCKED;
                else if (streq(word, "no-setuid-fixup"))
                        secure_bits |= 1 << SECURE_NO_SETUID_FIXUP;
                else if (streq(word, "no-setuid-fixup-locked"))
                        secure_bits |= 1 << SECURE_NO_SETUID_FIXUP_LOCKED;
                else if (streq(word, "noroot"))
                        secure_bits |= 1 << SECURE_NOROOT;
                else if (streq(word, "noroot-locked"))
                        secure_bits |= 1 << SECURE_NOROOT_LOCKED;
        }

        return secure_bits;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <stdio.h>
4
5	#include "alloc-util.h"
6	#include "extract-word.h"
7	#include "securebits-util.h"
8	#include "string-util.h"
9	#include "strv.h"
10
11	static inline const char* secure_bit_to_string(int i) {	32✔
12	/* match a single bit */
13
14	switch (i) {	32✔
15	case SECURE_KEEP_CAPS:
16	return "keep-caps";
17	case SECURE_KEEP_CAPS_LOCKED:	5✔
18	return "keep-caps-locked";	5✔
19	case SECURE_NO_SETUID_FIXUP:	4✔
20	return "no-setuid-fixup";	4✔
21	case SECURE_NO_SETUID_FIXUP_LOCKED:	4✔
22	return "no-setuid-fixup-locked";	4✔
23	case SECURE_NOROOT:	7✔
24	return "noroot";	7✔
25	case SECURE_NOROOT_LOCKED:	4✔
26	return "noroot-locked";	4✔
UNCOV 27	default:	×
UNCOV 28	assert_not_reached();	×
29	}
30	}
31
32	int secure_bits_to_string_alloc(int i, char **ret) {	14✔
33	_cleanup_strv_free_ char **sv = NULL;	28✔
34	_cleanup_free_ char *joined = NULL;	14✔
35	int r;	14✔
36
37	assert(ret);	14✔
38
39	r = secure_bits_to_strv(i, &sv);	14✔
40	if (r < 0)	14✔
41	return r;
42
43	joined = strv_join(sv, " ");	14✔
44	if (!joined)	14✔
45	return -ENOMEM;
46
47	*ret = TAKE_PTR(joined);	14✔
48	return 0;	14✔
49	}
50
51	int secure_bits_to_strv(int i, char ***ret) {	66✔
52	_cleanup_strv_free_ char **sv = NULL;	66✔
53	static const int bits[] = {	66✔
54	SECURE_KEEP_CAPS,
55	SECURE_KEEP_CAPS_LOCKED,
56	SECURE_NO_SETUID_FIXUP,
57	SECURE_NO_SETUID_FIXUP_LOCKED,
58	SECURE_NOROOT,
59	SECURE_NOROOT_LOCKED,
60	};
61	int r;	66✔
62
63	assert(ret);	66✔
64
65	FOREACH_ELEMENT(bit, bits) {	462✔
66	if (i & (1 << *bit)) {	396✔
67	r = strv_extend(&sv, secure_bit_to_string(*bit));	32✔
68	if (r < 0)	32✔
69	return r;
70	}
71	}
72
73	*ret = TAKE_PTR(sv);	66✔
74	return 0;	66✔
75	}
76
77	int secure_bits_from_string(const char *s) {	18✔
78	int secure_bits = 0;	18✔
79	const char *p;	18✔
80	int r;	18✔
81
82	for (p = s;;) {	18✔
83	_cleanup_free_ char *word = NULL;	34✔
84
85	r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);	52✔
86	if (r == -ENOMEM)	52✔
UNCOV 87	return r;	×
88	if (r <= 0)	52✔
89	break;
90
91	if (streq(word, "keep-caps"))	34✔
92	secure_bits \|= 1 << SECURE_KEEP_CAPS;	9✔
93	else if (streq(word, "keep-caps-locked"))	25✔
94	secure_bits \|= 1 << SECURE_KEEP_CAPS_LOCKED;	3✔
95	else if (streq(word, "no-setuid-fixup"))	22✔
96	secure_bits \|= 1 << SECURE_NO_SETUID_FIXUP;	3✔
97	else if (streq(word, "no-setuid-fixup-locked"))	19✔
98	secure_bits \|= 1 << SECURE_NO_SETUID_FIXUP_LOCKED;	2✔
99	else if (streq(word, "noroot"))	17✔
100	secure_bits \|= 1 << SECURE_NOROOT;	6✔
101	else if (streq(word, "noroot-locked"))	11✔
102	secure_bits \|= 1 << SECURE_NOROOT_LOCKED;	2✔
103	}
104
105	return secure_bits;	18✔
106	}

systemd / systemd / 18578253386

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