14766779411

Committed 30 Apr 2025 04:55PM UTC coverage: 72.225% (-0.06%) from 72.282%

Build # 14766779411

Build Type

push

github

Committed by

web-flow

Commit Message

wait-online: handle varlink connection errors while waiting for DNS (#37283)

Currently, if systemd-networkd-wait-online is started with --dns, and
systemd-resolved is not running, it will exit with an error right away.
Similarly, if systemd-resolved is restarted while waiting for DNS
configuration, systemd-networkd-wait-online will not attempt to
re-connect, and will potentially never see subsequent DNS
configurations.

Improve this by adding socket units for the systemd-resolved varlink
servers, and re-establish the connection in systemd-networkd-wait-online
when we receive `SD_VARLINK_ERROR_DISCONNECTED`.

Coverage Stats

8 of 16 new or added lines in 2 files covered. (50.0%)

5825 existing lines in 217 files now uncovered.

297168 of 411450 relevant lines covered (72.22%)

695892.62 hits per line

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

92.28

/src/basic/stat-util.c

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

#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <sys/statvfs.h>
#include <sys/types.h>
#include <unistd.h>

#include "alloc-util.h"
#include "chase.h"
#include "dirent-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "filesystems.h"
#include "fs-util.h"
#include "hash-funcs.h"
#include "log.h"
#include "macro.h"
#include "missing_fs.h"
#include "missing_magic.h"
#include "mountpoint-util.h"
#include "nulstr-util.h"
#include "parse-util.h"
#include "stat-util.h"
#include "string-util.h"

static int verify_stat_at(
                int fd,
                const char *path,
                bool follow,
                int (*verify_func)(const struct stat *st),
                bool verify) {

        struct stat st;
        int r;

        assert(fd >= 0 || fd == AT_FDCWD);
        assert(!isempty(path) || !follow);
        assert(verify_func);

        if (fstatat(fd, strempty(path), &st,
                    (isempty(path) ? AT_EMPTY_PATH : 0) | (follow ? 0 : AT_SYMLINK_NOFOLLOW)) < 0)
                return -errno;

        r = verify_func(&st);
        return verify ? r : r >= 0;
}

int stat_verify_regular(const struct stat *st) {
        assert(st);

        /* Checks whether the specified stat() structure refers to a regular file. If not returns an
         * appropriate error code. */

        if (S_ISDIR(st->st_mode))
                return -EISDIR;

        if (S_ISLNK(st->st_mode))
                return -ELOOP;

        if (!S_ISREG(st->st_mode))
                return -EBADFD;

        return 0;
}

int verify_regular_at(int fd, const char *path, bool follow) {
        return verify_stat_at(fd, path, follow, stat_verify_regular, true);
}

int fd_verify_regular(int fd) {
        assert(fd >= 0);
        return verify_regular_at(fd, NULL, false);
}

int stat_verify_directory(const struct stat *st) {
        assert(st);

        if (S_ISLNK(st->st_mode))
                return -ELOOP;

        if (!S_ISDIR(st->st_mode))
                return -ENOTDIR;

        return 0;
}

int fd_verify_directory(int fd) {
        assert(fd >= 0);
        return verify_stat_at(fd, NULL, false, stat_verify_directory, true);
}

int is_dir_at(int fd, const char *path, bool follow) {
        return verify_stat_at(fd, path, follow, stat_verify_directory, false);
}

int is_dir(const char *path, bool follow) {
        assert(!isempty(path));
        return is_dir_at(AT_FDCWD, path, follow);
}

int stat_verify_symlink(const struct stat *st) {
        assert(st);

        if (S_ISDIR(st->st_mode))
                return -EISDIR;

        if (!S_ISLNK(st->st_mode))
                return -ENOLINK;

        return 0;
}

int is_symlink(const char *path) {
        assert(!isempty(path));
        return verify_stat_at(AT_FDCWD, path, false, stat_verify_symlink, false);
}

int stat_verify_linked(const struct stat *st) {
        assert(st);

        if (st->st_nlink <= 0)
                return -EIDRM; /* recognizable error. */

        return 0;
}

int fd_verify_linked(int fd) {
        assert(fd >= 0);
        return verify_stat_at(fd, NULL, false, stat_verify_linked, true);
}

int stat_verify_device_node(const struct stat *st) {
        assert(st);

        if (S_ISLNK(st->st_mode))
                return -ELOOP;

        if (S_ISDIR(st->st_mode))
                return -EISDIR;

        if (!S_ISBLK(st->st_mode) && !S_ISCHR(st->st_mode))
                return -ENOTTY;

        return 0;
}

int is_device_node(const char *path) {
        assert(!isempty(path));
        return verify_stat_at(AT_FDCWD, path, false, stat_verify_device_node, false);
}

int dir_is_empty_at(int dir_fd, const char *path, bool ignore_hidden_or_backup) {
        _cleanup_close_ int fd = -EBADF;
        struct dirent *buf;
        size_t m;

        fd = xopenat(dir_fd, path, O_DIRECTORY|O_CLOEXEC);
        if (fd < 0)
                return fd;

        /* Allocate space for at least 3 full dirents, since every dir has at least two entries ("."  +
         * ".."), and only once we have seen if there's a third we know whether the dir is empty or not. If
         * 'ignore_hidden_or_backup' is true we'll allocate a bit more, since we might skip over a bunch of
         * entries that we end up ignoring. */
        m = (ignore_hidden_or_backup ? 16 : 3) * DIRENT_SIZE_MAX;
        buf = alloca(m);

        for (;;) {
                struct dirent *de;
                ssize_t n;

                n = posix_getdents(fd, buf, m, /* flags = */ 0);
                if (n < 0)
                        return -errno;
                if (n == 0)
                        break;

                assert((size_t) n <= m);
                msan_unpoison(buf, n);

                FOREACH_DIRENT_IN_BUFFER(de, buf, n)
                        if (!(ignore_hidden_or_backup ? hidden_or_backup_file(de->d_name) : dot_or_dot_dot(de->d_name)))
                                return 0;
        }

        return 1;
}

bool null_or_empty(struct stat *st) {
        assert(st);

        if (S_ISREG(st->st_mode) && st->st_size <= 0)
                return true;

        /* We don't want to hardcode the major/minor of /dev/null, hence we do a simpler "is this a character
         * device node?" check. */

        if (S_ISCHR(st->st_mode))
                return true;

        return false;
}

int null_or_empty_path_with_root(const char *fn, const char *root) {
        struct stat st;
        int r;

        assert(fn);

        /* A symlink to /dev/null or an empty file?
         * When looking under root_dir, we can't expect /dev/ to be mounted,
         * so let's see if the path is a (possibly dangling) symlink to /dev/null. */

        if (path_equal(path_startswith(fn, root ?: "/"), "dev/null"))
                return true;

        r = chase_and_stat(fn, root, CHASE_PREFIX_ROOT, NULL, &st);
        if (r < 0)
                return r;

        return null_or_empty(&st);
}

int fd_is_read_only_fs(int fd) {
        struct statvfs st;

        assert(fd >= 0);

        if (fstatvfs(fd, &st) < 0)
                return -errno;

        if (st.f_flag & ST_RDONLY)
                return true;

        /* On NFS, fstatvfs() might not reflect whether we can actually write to the remote share. Let's try
         * again with access(W_OK) which is more reliable, at least sometimes. */
        if (access_fd(fd, W_OK) == -EROFS)
                return true;

        return false;
}

int path_is_read_only_fs(const char *path) {
        _cleanup_close_ int fd = -EBADF;

        assert(path);

        fd = open(path, O_CLOEXEC | O_PATH);
        if (fd < 0)
                return -errno;

        return fd_is_read_only_fs(fd);
}

int inode_same_at(int fda, const char *filea, int fdb, const char *fileb, int flags) {
        struct stat sta, stb;
        int r;

        assert(fda >= 0 || fda == AT_FDCWD);
        assert(fdb >= 0 || fdb == AT_FDCWD);
        assert((flags & ~(AT_EMPTY_PATH|AT_SYMLINK_NOFOLLOW|AT_NO_AUTOMOUNT)) == 0);

        /* Refuse an unset filea or fileb early unless AT_EMPTY_PATH is set */
        if ((isempty(filea) || isempty(fileb)) && !FLAGS_SET(flags, AT_EMPTY_PATH))
                return -EINVAL;

        /* Shortcut: comparing the same fd with itself means we can return true */
        if (fda >= 0 && fda == fdb && isempty(filea) && isempty(fileb) && FLAGS_SET(flags, AT_SYMLINK_NOFOLLOW))
                return true;

        _cleanup_close_ int pin_a = -EBADF, pin_b = -EBADF;
        if (!FLAGS_SET(flags, AT_NO_AUTOMOUNT)) {
                /* Let's try to use the name_to_handle_at() AT_HANDLE_FID API to identify identical
                 * inodes. We have to issue multiple calls on the same file for that (first, to acquire the
                 * FID, and then to check if .st_dev is actually the same). Hence let's pin the inode in
                 * between via O_PATH, unless we already have an fd for it. */

                if (!isempty(filea)) {
                        pin_a = openat(fda, filea, O_PATH|O_CLOEXEC|(FLAGS_SET(flags, AT_SYMLINK_NOFOLLOW) ? O_NOFOLLOW : 0));
                        if (pin_a < 0)
                                return -errno;

                        fda = pin_a;
                        filea = NULL;
                        flags |= AT_EMPTY_PATH;
                }

                if (!isempty(fileb)) {
                        pin_b = openat(fdb, fileb, O_PATH|O_CLOEXEC|(FLAGS_SET(flags, AT_SYMLINK_NOFOLLOW) ? O_NOFOLLOW : 0));
                        if (pin_b < 0)
                                return -errno;

                        fdb = pin_b;
                        fileb = NULL;
                        flags |= AT_EMPTY_PATH;
                }

                int ntha_flags = at_flags_normalize_follow(flags) & (AT_EMPTY_PATH|AT_SYMLINK_FOLLOW);
                _cleanup_free_ struct file_handle *ha = NULL, *hb = NULL;
                int mntida = -1, mntidb = -1;

                r = name_to_handle_at_try_fid(
                                fda,
                                filea,
                                &ha,
                                &mntida,
                                ntha_flags);
                if (r < 0) {
                        if (is_name_to_handle_at_fatal_error(r))
                                return r;

                        goto fallback;
                }

                r = name_to_handle_at_try_fid(
                                fdb,
                                fileb,
                                &hb,
                                &mntidb,
                                ntha_flags);
                if (r < 0) {
                        if (is_name_to_handle_at_fatal_error(r))
                                return r;

                        goto fallback;
                }

                /* Now compare the two file handles */
                if (!file_handle_equal(ha, hb))
                        return false;

                /* If the file handles are the same and they come from the same mount ID? Great, then we are
                 * good, they are definitely the same */
                if (mntida == mntidb)
                        return true;

                /* File handles are the same, they are not on the same mount id. This might either be because
                 * they are on two entirely different file systems, that just happen to have the same FIDs
                 * (because they originally where created off the same disk images), or it could be because
                 * they are located on two distinct bind mounts of the same fs. To check that, let's look at
                 * .st_rdev of the inode. We simply reuse the fallback codepath for that, since it checks
                 * exactly that (it checks slightly more, but we don't care.) */
        }

fallback:
        if (fstatat(fda, strempty(filea), &sta, flags) < 0)
                return log_debug_errno(errno, "Cannot stat %s: %m", strna(filea));

        if (fstatat(fdb, strempty(fileb), &stb, flags) < 0)
                return log_debug_errno(errno, "Cannot stat %s: %m", strna(fileb));

        return stat_inode_same(&sta, &stb);
}

bool is_fs_type(const struct statfs *s, statfs_f_type_t magic_value) {
        assert(s);
        assert_cc(sizeof(statfs_f_type_t) >= sizeof(s->f_type));

        return F_TYPE_EQUAL(s->f_type, magic_value);
}

int is_fs_type_at(int dir_fd, const char *path, statfs_f_type_t magic_value) {
        struct statfs s;
        int r;

        r = xstatfsat(dir_fd, path, &s);
        if (r < 0)
                return r;

        return is_fs_type(&s, magic_value);
}

bool is_temporary_fs(const struct statfs *s) {
        return fs_in_group(s, FILESYSTEM_SET_TEMPORARY);
}

bool is_network_fs(const struct statfs *s) {
        return fs_in_group(s, FILESYSTEM_SET_NETWORK);
}

int fd_is_temporary_fs(int fd) {
        struct statfs s;

        if (fstatfs(fd, &s) < 0)
                return -errno;

        return is_temporary_fs(&s);
}

int fd_is_network_fs(int fd) {
        struct statfs s;

        if (fstatfs(fd, &s) < 0)
                return -errno;

        return is_network_fs(&s);
}

int path_is_temporary_fs(const char *path) {
        struct statfs s;

        if (statfs(path, &s) < 0)
                return -errno;

        return is_temporary_fs(&s);
}

int path_is_network_fs(const char *path) {
        struct statfs s;

        if (statfs(path, &s) < 0)
                return -errno;

        return is_network_fs(&s);
}

int proc_mounted(void) {
        int r;

        /* A quick check of procfs is properly mounted */

        r = path_is_fs_type("/proc/", PROC_SUPER_MAGIC);
        if (r == -ENOENT) /* not mounted at all */
                return false;

        return r;
}

bool stat_inode_same(const struct stat *a, const struct stat *b) {

        /* Returns if the specified stat structure references the same (though possibly modified) inode. Does
         * a thorough check, comparing inode nr, backing device and if the inode is still of the same type. */

        return stat_is_set(a) && stat_is_set(b) &&
                ((a->st_mode ^ b->st_mode) & S_IFMT) == 0 &&  /* same inode type */
                a->st_dev == b->st_dev &&
                a->st_ino == b->st_ino;
}

bool stat_inode_unmodified(const struct stat *a, const struct stat *b) {

        /* Returns if the specified stat structures reference the same, unmodified inode. This check tries to
         * be reasonably careful when detecting changes: we check both inode and mtime, to cater for file
         * systems where mtimes are fixed to 0 (think: ostree/nixos type installations). We also check file
         * size, backing device, inode type and if this refers to a device not the major/minor.
         *
         * Note that we don't care if file attributes such as ownership or access mode change, this here is
         * about contents of the file. The purpose here is to detect file contents changes, and nothing
         * else. */

        return stat_inode_same(a, b) &&
                a->st_mtim.tv_sec == b->st_mtim.tv_sec &&
                a->st_mtim.tv_nsec == b->st_mtim.tv_nsec &&
                (!S_ISREG(a->st_mode) || a->st_size == b->st_size) && /* if regular file, compare file size */
                (!(S_ISCHR(a->st_mode) || S_ISBLK(a->st_mode)) || a->st_rdev == b->st_rdev); /* if device node, also compare major/minor, because we can */
}

bool statx_inode_same(const struct statx *a, const struct statx *b) {

        /* Same as stat_inode_same() but for struct statx */

        return statx_is_set(a) && statx_is_set(b) &&
                FLAGS_SET(a->stx_mask, STATX_TYPE|STATX_INO) && FLAGS_SET(b->stx_mask, STATX_TYPE|STATX_INO) &&
                ((a->stx_mode ^ b->stx_mode) & S_IFMT) == 0 &&
                a->stx_dev_major == b->stx_dev_major &&
                a->stx_dev_minor == b->stx_dev_minor &&
                a->stx_ino == b->stx_ino;
}

bool statx_mount_same(const struct statx *a, const struct statx *b) {
        if (!statx_is_set(a) || !statx_is_set(b))
                return false;

        /* if we have the mount ID, that's all we need */
        if (FLAGS_SET(a->stx_mask, STATX_MNT_ID) && FLAGS_SET(b->stx_mask, STATX_MNT_ID))
                return a->stx_mnt_id == b->stx_mnt_id;

        /* Otherwise, major/minor of backing device must match */
        return a->stx_dev_major == b->stx_dev_major &&
                a->stx_dev_minor == b->stx_dev_minor;
}

int xstatfsat(int dir_fd, const char *path, struct statfs *ret) {
        _cleanup_close_ int fd = -EBADF;

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

        if (!isempty(path)) {
                fd = xopenat(dir_fd, path, O_PATH|O_CLOEXEC|O_NOCTTY);
                if (fd < 0)
                        return fd;
                dir_fd = fd;
        }

        return RET_NERRNO(fstatfs(dir_fd, ret));
}

void inode_hash_func(const struct stat *q, struct siphash *state) {
        siphash24_compress_typesafe(q->st_dev, state);
        siphash24_compress_typesafe(q->st_ino, state);
}

int inode_compare_func(const struct stat *a, const struct stat *b) {
        int r;

        r = CMP(a->st_dev, b->st_dev);
        if (r != 0)
                return r;

        return CMP(a->st_ino, b->st_ino);
}

DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(inode_hash_ops, struct stat, inode_hash_func, inode_compare_func, free);

const char* inode_type_to_string(mode_t m) {

        /* Returns a short string for the inode type. We use the same name as the underlying macros for each
         * inode type. */

        switch (m & S_IFMT) {
        case S_IFREG:
                return "reg";
        case S_IFDIR:
                return "dir";
        case S_IFLNK:
                return "lnk";
        case S_IFCHR:
                return "chr";
        case S_IFBLK:
                return "blk";
        case S_IFIFO:
                return "fifo";
        case S_IFSOCK:
                return "sock";
        }

        /* Note anonymous inodes in the kernel will have a zero type. Hence fstat() of an eventfd() will
         * return an .st_mode where we'll return NULL here! */
        return NULL;
}

mode_t inode_type_from_string(const char *s) {
        if (!s)
                return MODE_INVALID;

        if (streq(s, "reg"))
                return S_IFREG;
        if (streq(s, "dir"))
                return S_IFDIR;
        if (streq(s, "lnk"))
                return S_IFLNK;
        if (streq(s, "chr"))
                return S_IFCHR;
        if (streq(s, "blk"))
                return S_IFBLK;
        if (streq(s, "fifo"))
                return S_IFIFO;
        if (streq(s, "sock"))
                return S_IFSOCK;

        return MODE_INVALID;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <errno.h>
4	#include <fcntl.h>
5	#include <sched.h>
6	#include <sys/statvfs.h>
7	#include <sys/types.h>
8	#include <unistd.h>
9
10	#include "alloc-util.h"
11	#include "chase.h"
12	#include "dirent-util.h"
13	#include "errno-util.h"
14	#include "fd-util.h"
15	#include "fileio.h"
16	#include "filesystems.h"
17	#include "fs-util.h"
18	#include "hash-funcs.h"
19	#include "log.h"
20	#include "macro.h"
21	#include "missing_fs.h"
22	#include "missing_magic.h"
23	#include "mountpoint-util.h"
24	#include "nulstr-util.h"
25	#include "parse-util.h"
26	#include "stat-util.h"
27	#include "string-util.h"
28
29	static int verify_stat_at(	2,181,513✔
30	int fd,
31	const char *path,
32	bool follow,
33	int (verify_func)(const struct stat st),
34	bool verify) {
35
36	struct stat st;	2,181,513✔
37	int r;	2,181,513✔
38
39	assert(fd >= 0 \|\| fd == AT_FDCWD);	2,181,513✔
40	assert(!isempty(path) \|\| !follow);	2,181,513✔
41	assert(verify_func);	2,181,513✔
42
43	if (fstatat(fd, strempty(path), &st,	5,188,465✔
44	(isempty(path) ? AT_EMPTY_PATH : 0) \| (follow ? 0 : AT_SYMLINK_NOFOLLOW)) < 0)	2,181,513✔
45	return -errno;	7,649✔
46
47	r = verify_func(&st);	2,173,864✔
48	return verify ? r : r >= 0;	2,173,864✔
49	}
50
51	int stat_verify_regular(const struct stat *st) {	2,580,396✔
52	assert(st);	2,580,396✔
53
54	/* Checks whether the specified stat() structure refers to a regular file. If not returns an
55	* appropriate error code. */
56
57	if (S_ISDIR(st->st_mode))	2,580,396✔
58	return -EISDIR;
59
60	if (S_ISLNK(st->st_mode))	2,578,208✔
61	return -ELOOP;
62
63	if (!S_ISREG(st->st_mode))	2,578,194✔
64	return -EBADFD;	17✔
65
66	return 0;
67	}
68
69	int verify_regular_at(int fd, const char *path, bool follow) {	825,692✔
70	return verify_stat_at(fd, path, follow, stat_verify_regular, true);	825,692✔
71	}
72
73	int fd_verify_regular(int fd) {	825,427✔
74	assert(fd >= 0);	825,427✔
75	return verify_regular_at(fd, NULL, false);	825,427✔
76	}
77
78	int stat_verify_directory(const struct stat *st) {	1,373,975✔
79	assert(st);	1,373,975✔
80
81	if (S_ISLNK(st->st_mode))	1,373,975✔
82	return -ELOOP;
83
84	if (!S_ISDIR(st->st_mode))	1,373,965✔
85	return -ENOTDIR;	8✔
86
87	return 0;
88	}
89
90	int fd_verify_directory(int fd) {	9✔
91	assert(fd >= 0);	9✔
92	return verify_stat_at(fd, NULL, false, stat_verify_directory, true);	9✔
93	}
94
95	int is_dir_at(int fd, const char *path, bool follow) {	1,340,192✔
96	return verify_stat_at(fd, path, follow, stat_verify_directory, false);	1,340,192✔
97	}
98
99	int is_dir(const char *path, bool follow) {	501,415✔
100	assert(!isempty(path));	501,415✔
101	return is_dir_at(AT_FDCWD, path, follow);	501,415✔
102	}
103
104	int stat_verify_symlink(const struct stat *st) {	15,506✔
105	assert(st);	15,506✔
106
107	if (S_ISDIR(st->st_mode))	15,506✔
108	return -EISDIR;
109
110	if (!S_ISLNK(st->st_mode))	15,491✔
111	return -ENOLINK;	428✔
112
113	return 0;
114	}
115
116	int is_symlink(const char *path) {	15,506✔
117	assert(!isempty(path));	15,506✔
118	return verify_stat_at(AT_FDCWD, path, false, stat_verify_symlink, false);	15,506✔
119	}
120
121	int stat_verify_linked(const struct stat *st) {	1,725,994✔
122	assert(st);	1,725,994✔
123
124	if (st->st_nlink <= 0)	1,725,994✔
125	return -EIDRM; /* recognizable error. */	2✔
126
127	return 0;
128	}
129
130	int fd_verify_linked(int fd) {	3✔
131	assert(fd >= 0);	3✔
132	return verify_stat_at(fd, NULL, false, stat_verify_linked, true);	3✔
133	}
134
135	int stat_verify_device_node(const struct stat *st) {	4,592✔
136	assert(st);	4,592✔
137
138	if (S_ISLNK(st->st_mode))	4,592✔
139	return -ELOOP;
140
141	if (S_ISDIR(st->st_mode))	4,592✔
142	return -EISDIR;
143
144	if (!S_ISBLK(st->st_mode) && !S_ISCHR(st->st_mode))	4,489✔
145	return -ENOTTY;	5✔
146
147	return 0;
148	}
149
150	int is_device_node(const char *path) {	111✔
151	assert(!isempty(path));	111✔
152	return verify_stat_at(AT_FDCWD, path, false, stat_verify_device_node, false);	111✔
153	}
154
155	int dir_is_empty_at(int dir_fd, const char *path, bool ignore_hidden_or_backup) {	36,787✔
156	_cleanup_close_ int fd = -EBADF;	36,787✔
157	struct dirent *buf;	36,787✔
158	size_t m;	36,787✔
159
160	fd = xopenat(dir_fd, path, O_DIRECTORY\|O_CLOEXEC);	36,787✔
161	if (fd < 0)	36,787✔
162	return fd;
163
164	/* Allocate space for at least 3 full dirents, since every dir has at least two entries ("." +
165	* ".."), and only once we have seen if there's a third we know whether the dir is empty or not. If
166	* 'ignore_hidden_or_backup' is true we'll allocate a bit more, since we might skip over a bunch of
167	* entries that we end up ignoring. */
168	m = (ignore_hidden_or_backup ? 16 : 3) * DIRENT_SIZE_MAX;	2,180✔
169	buf = alloca(m);	2,180✔
170
171	for (;;) {	3,502✔
172	struct dirent *de;	3,502✔
173	ssize_t n;	3,502✔
174
175	n = posix_getdents(fd, buf, m, /* flags = */ 0);	3,502✔
176	if (n < 0)	3,502✔
177	return -errno;	×
178	if (n == 0)	3,502✔
179	break;
180
181	assert((size_t) n <= m);	2,180✔
182	msan_unpoison(buf, n);	2,180✔
183
184	FOREACH_DIRENT_IN_BUFFER(de, buf, n)	5,876✔
185	if (!(ignore_hidden_or_backup ? hidden_or_backup_file(de->d_name) : dot_or_dot_dot(de->d_name)))	4,554✔
186	return 0;
187	}
188
189	return 1;
190	}
191
192	bool null_or_empty(struct stat *st) {	385,394✔
193	assert(st);	385,394✔
194
195	if (S_ISREG(st->st_mode) && st->st_size <= 0)	385,394✔
196	return true;
197
198	/* We don't want to hardcode the major/minor of /dev/null, hence we do a simpler "is this a character
199	* device node?" check. */
200
201	if (S_ISCHR(st->st_mode))	385,382✔
202	return true;	1,028✔
203
204	return false;
205	}
206
207	int null_or_empty_path_with_root(const char fn, const char root) {	293,139✔
208	struct stat st;	293,139✔
209	int r;	293,139✔
210
211	assert(fn);	293,139✔
212
213	/* A symlink to /dev/null or an empty file?
214	* When looking under root_dir, we can't expect /dev/ to be mounted,
215	* so let's see if the path is a (possibly dangling) symlink to /dev/null. */
216
217	if (path_equal(path_startswith(fn, root ?: "/"), "dev/null"))	586,278✔
218	return true;	293,139✔
219
220	r = chase_and_stat(fn, root, CHASE_PREFIX_ROOT, NULL, &st);	292,977✔
221	if (r < 0)	292,977✔
222	return r;
223
224	return null_or_empty(&st);	292,864✔
225	}
226
227	int fd_is_read_only_fs(int fd) {	1,767✔
228	struct statvfs st;	1,767✔
229
230	assert(fd >= 0);	1,767✔
231
232	if (fstatvfs(fd, &st) < 0)	1,767✔
233	return -errno;	×
234
235	if (st.f_flag & ST_RDONLY)	1,767✔
236	return true;
237
238	/* On NFS, fstatvfs() might not reflect whether we can actually write to the remote share. Let's try
239	* again with access(W_OK) which is more reliable, at least sometimes. */
240	if (access_fd(fd, W_OK) == -EROFS)	1,399✔
241	return true;	×
242
243	return false;
244	}
245
246	int path_is_read_only_fs(const char *path) {	1,496✔
247	_cleanup_close_ int fd = -EBADF;	1,496✔
248
249	assert(path);	1,496✔
250
251	fd = open(path, O_CLOEXEC \| O_PATH);	1,496✔
252	if (fd < 0)	1,496✔
253	return -errno;	146✔
254
255	return fd_is_read_only_fs(fd);	1,350✔
256	}
257
258	int inode_same_at(int fda, const char filea, int fdb, const char fileb, int flags) {	14,150✔
259	struct stat sta, stb;	14,150✔
260	int r;	14,150✔
261
262	assert(fda >= 0 \|\| fda == AT_FDCWD);	14,150✔
263	assert(fdb >= 0 \|\| fdb == AT_FDCWD);	14,150✔
264	assert((flags & ~(AT_EMPTY_PATH\|AT_SYMLINK_NOFOLLOW\|AT_NO_AUTOMOUNT)) == 0);	14,150✔
265
266	/* Refuse an unset filea or fileb early unless AT_EMPTY_PATH is set */
267	if ((isempty(filea) \|\| isempty(fileb)) && !FLAGS_SET(flags, AT_EMPTY_PATH))	28,115✔
268	return -EINVAL;	14,150✔
269
270	/* Shortcut: comparing the same fd with itself means we can return true */
271	if (fda >= 0 && fda == fdb && isempty(filea) && isempty(fileb) && FLAGS_SET(flags, AT_SYMLINK_NOFOLLOW))	14,152✔
272	return true;
273
274	_cleanup_close_ int pin_a = -EBADF, pin_b = -EBADF;	28,299✔
275	if (!FLAGS_SET(flags, AT_NO_AUTOMOUNT)) {	14,149✔
276	/* Let's try to use the name_to_handle_at() AT_HANDLE_FID API to identify identical
277	* inodes. We have to issue multiple calls on the same file for that (first, to acquire the
278	* FID, and then to check if .st_dev is actually the same). Hence let's pin the inode in
279	* between via O_PATH, unless we already have an fd for it. */
280
281	if (!isempty(filea)) {	14,149✔
282	pin_a = openat(fda, filea, O_PATH\|O_CLOEXEC\|(FLAGS_SET(flags, AT_SYMLINK_NOFOLLOW) ? O_NOFOLLOW : 0));	13,965✔
283	if (pin_a < 0)	13,965✔
284	return -errno;	14,047✔
285
286	fda = pin_a;	13,456✔
287	filea = NULL;	13,456✔
288	flags \|= AT_EMPTY_PATH;	13,456✔
289	}
290
291	if (!isempty(fileb)) {	13,640✔
292	pin_b = openat(fdb, fileb, O_PATH\|O_CLOEXEC\|(FLAGS_SET(flags, AT_SYMLINK_NOFOLLOW) ? O_NOFOLLOW : 0));	13,454✔
293	if (pin_b < 0)	13,454✔
294	return -errno;	4✔
295
296	fdb = pin_b;	13,450✔
297	fileb = NULL;	13,450✔
298	flags \|= AT_EMPTY_PATH;	13,450✔
299	}
300
301	int ntha_flags = at_flags_normalize_follow(flags) & (AT_EMPTY_PATH\|AT_SYMLINK_FOLLOW);	13,636✔
302	_cleanup_free_ struct file_handle ha = NULL, hb = NULL;	13,636✔
303	int mntida = -1, mntidb = -1;	13,636✔
304
305	r = name_to_handle_at_try_fid(	13,636✔
306	fda,
307	filea,
308	&ha,
309	&mntida,
310	ntha_flags);
311	if (r < 0) {	13,636✔
312	if (is_name_to_handle_at_fatal_error(r))	×
313	return r;
314
315	goto fallback;	×
316	}
317
318	r = name_to_handle_at_try_fid(	13,636✔
319	fdb,
320	fileb,
321	&hb,
322	&mntidb,
323	ntha_flags);
324	if (r < 0) {	13,636✔
325	if (is_name_to_handle_at_fatal_error(r))	×
326	return r;
327
328	goto fallback;	×
329	}
330
331	/* Now compare the two file handles */
332	if (!file_handle_equal(ha, hb))	13,636✔
333	return false;
334
335	/* If the file handles are the same and they come from the same mount ID? Great, then we are
336	* good, they are definitely the same */
337	if (mntida == mntidb)	13,389✔
338	return true;
339
340	/* File handles are the same, they are not on the same mount id. This might either be because
341	* they are on two entirely different file systems, that just happen to have the same FIDs
342	* (because they originally where created off the same disk images), or it could be because
343	* they are located on two distinct bind mounts of the same fs. To check that, let's look at
344	* .st_rdev of the inode. We simply reuse the fallback codepath for that, since it checks
345	* exactly that (it checks slightly more, but we don't care.) */
346	}
347
348	fallback:	×
349	if (fstatat(fda, strempty(filea), &sta, flags) < 0)	204✔
350	return log_debug_errno(errno, "Cannot stat %s: %m", strna(filea));	×
351
352	if (fstatat(fdb, strempty(fileb), &stb, flags) < 0)	204✔
353	return log_debug_errno(errno, "Cannot stat %s: %m", strna(fileb));	×
354
355	return stat_inode_same(&sta, &stb);	102✔
356	}
357
358	bool is_fs_type(const struct statfs *s, statfs_f_type_t magic_value) {	8,418,383✔
359	assert(s);	8,418,383✔
360	assert_cc(sizeof(statfs_f_type_t) >= sizeof(s->f_type));	8,418,383✔
361
362	return F_TYPE_EQUAL(s->f_type, magic_value);	8,418,383✔
363	}
364
365	int is_fs_type_at(int dir_fd, const char *path, statfs_f_type_t magic_value) {	8,140,399✔
366	struct statfs s;	8,140,399✔
367	int r;	8,140,399✔
368
369	r = xstatfsat(dir_fd, path, &s);	8,140,399✔
370	if (r < 0)	8,140,399✔
371	return r;	8,140,399✔
372
373	return is_fs_type(&s, magic_value);	8,140,398✔
374	}
375
376	bool is_temporary_fs(const struct statfs *s) {	8,313✔
377	return fs_in_group(s, FILESYSTEM_SET_TEMPORARY);	8,313✔
378	}
379
380	bool is_network_fs(const struct statfs *s) {	16,113✔
381	return fs_in_group(s, FILESYSTEM_SET_NETWORK);	16,113✔
382	}
383
384	int fd_is_temporary_fs(int fd) {	143✔
385	struct statfs s;	143✔
386
387	if (fstatfs(fd, &s) < 0)	143✔
388	return -errno;	×
389
390	return is_temporary_fs(&s);	143✔
391	}
392
393	int fd_is_network_fs(int fd) {	16,010✔
394	struct statfs s;	16,010✔
395
396	if (fstatfs(fd, &s) < 0)	16,010✔
397	return -errno;	×
398
399	return is_network_fs(&s);	16,010✔
400	}
401
402	int path_is_temporary_fs(const char *path) {	11✔
403	struct statfs s;	11✔
404
405	if (statfs(path, &s) < 0)	11✔
406	return -errno;	2✔
407
408	return is_temporary_fs(&s);	9✔
409	}
410
411	int path_is_network_fs(const char *path) {	×
412	struct statfs s;	×
413
414	if (statfs(path, &s) < 0)	×
415	return -errno;	×
416
417	return is_network_fs(&s);	×
418	}
419
420	int proc_mounted(void) {	18,552✔
421	int r;	18,552✔
422
423	/* A quick check of procfs is properly mounted */
424
425	r = path_is_fs_type("/proc/", PROC_SUPER_MAGIC);	18,552✔
426	if (r == -ENOENT) /* not mounted at all */	18,552✔
427	return false;	×
428
429	return r;
430	}
431
432	bool stat_inode_same(const struct stat a, const struct stat b) {	1,309,256✔
433
434	/* Returns if the specified stat structure references the same (though possibly modified) inode. Does
435	* a thorough check, comparing inode nr, backing device and if the inode is still of the same type. */
436
437	return stat_is_set(a) && stat_is_set(b) &&	2,616,721✔
438	((a->st_mode ^ b->st_mode) & S_IFMT) == 0 && /* same inode type */	1,273,761✔
439	a->st_dev == b->st_dev &&	2,530,939✔
440	a->st_ino == b->st_ino;	1,221,683✔
441	}
442
443	bool stat_inode_unmodified(const struct stat a, const struct stat b) {	109,153✔
444
445	/* Returns if the specified stat structures reference the same, unmodified inode. This check tries to
446	* be reasonably careful when detecting changes: we check both inode and mtime, to cater for file
447	* systems where mtimes are fixed to 0 (think: ostree/nixos type installations). We also check file
448	* size, backing device, inode type and if this refers to a device not the major/minor.
449	*
450	* Note that we don't care if file attributes such as ownership or access mode change, this here is
451	* about contents of the file. The purpose here is to detect file contents changes, and nothing
452	* else. */
453
454	return stat_inode_same(a, b) &&	109,153✔
455	a->st_mtim.tv_sec == b->st_mtim.tv_sec &&	67,060✔
456	a->st_mtim.tv_nsec == b->st_mtim.tv_nsec &&	66,939✔
457	(!S_ISREG(a->st_mode) \|\| a->st_size == b->st_size) && /* if regular file, compare file size */	176,057✔
458	(!(S_ISCHR(a->st_mode) \|\| S_ISBLK(a->st_mode)) \|\| a->st_rdev == b->st_rdev); /* if device node, also compare major/minor, because we can */	66,904✔
459	}
460
461	bool statx_inode_same(const struct statx a, const struct statx b) {	3,248,812✔
462
463	/* Same as stat_inode_same() but for struct statx */
464
465	return statx_is_set(a) && statx_is_set(b) &&	6,497,624✔
466	FLAGS_SET(a->stx_mask, STATX_TYPE\|STATX_INO) && FLAGS_SET(b->stx_mask, STATX_TYPE\|STATX_INO) &&	3,248,812✔
467	((a->stx_mode ^ b->stx_mode) & S_IFMT) == 0 &&	3,248,812✔
468	a->stx_dev_major == b->stx_dev_major &&	3,248,812✔
469	a->stx_dev_minor == b->stx_dev_minor &&	3,038,512✔
470	a->stx_ino == b->stx_ino;	3,022,621✔
471	}
472
473	bool statx_mount_same(const struct statx a, const struct statx b) {	2,994,567✔
474	if (!statx_is_set(a) \|\| !statx_is_set(b))	5,989,134✔
475	return false;
476
477	/* if we have the mount ID, that's all we need */
478	if (FLAGS_SET(a->stx_mask, STATX_MNT_ID) && FLAGS_SET(b->stx_mask, STATX_MNT_ID))	2,994,567✔
479	return a->stx_mnt_id == b->stx_mnt_id;	2,994,567✔
480
481	/* Otherwise, major/minor of backing device must match */
482	return a->stx_dev_major == b->stx_dev_major &&	×
UNCOV 483	a->stx_dev_minor == b->stx_dev_minor;	×
484	}
485
486	int xstatfsat(int dir_fd, const char path, struct statfs ret) {	8,140,779✔
487	_cleanup_close_ int fd = -EBADF;	8,140,779✔
488
489	assert(dir_fd >= 0 \|\| dir_fd == AT_FDCWD);	8,140,779✔
490	assert(ret);	8,140,779✔
491
492	if (!isempty(path)) {	8,140,779✔
493	fd = xopenat(dir_fd, path, O_PATH\|O_CLOEXEC\|O_NOCTTY);	19,045✔
494	if (fd < 0)	19,045✔
495	return fd;
496	dir_fd = fd;
497	}
498
499	return RET_NERRNO(fstatfs(dir_fd, ret));	8,140,779✔
500	}
501
502	void inode_hash_func(const struct stat q, struct siphash state) {	37,499✔
503	siphash24_compress_typesafe(q->st_dev, state);	37,499✔
504	siphash24_compress_typesafe(q->st_ino, state);	37,499✔
505	}	37,499✔
506
507	int inode_compare_func(const struct stat a, const struct stat b) {	31,511✔
508	int r;	31,511✔
509
510	r = CMP(a->st_dev, b->st_dev);	31,511✔
511	if (r != 0)	26,516✔
512	return r;	5,074✔
513
514	return CMP(a->st_ino, b->st_ino);	26,437✔
515	}
516
517	DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(inode_hash_ops, struct stat, inode_hash_func, inode_compare_func, free);	779✔
518
519	const char* inode_type_to_string(mode_t m) {	7,459✔
520
521	/* Returns a short string for the inode type. We use the same name as the underlying macros for each
522	* inode type. */
523
524	switch (m & S_IFMT) {	7,459✔
525	case S_IFREG:
526	return "reg";
527	case S_IFDIR:	2,929✔
528	return "dir";	2,929✔
529	case S_IFLNK:	1✔
530	return "lnk";	1✔
531	case S_IFCHR:	859✔
532	return "chr";	859✔
533	case S_IFBLK:	415✔
534	return "blk";	415✔
535	case S_IFIFO:	415✔
536	return "fifo";	415✔
537	case S_IFSOCK:	567✔
538	return "sock";	567✔
539	}
540
541	/* Note anonymous inodes in the kernel will have a zero type. Hence fstat() of an eventfd() will
542	* return an .st_mode where we'll return NULL here! */
543	return NULL;	3✔
544	}
545
546	mode_t inode_type_from_string(const char *s) {	13✔
547	if (!s)	13✔
548	return MODE_INVALID;
549
550	if (streq(s, "reg"))	13✔
551	return S_IFREG;
552	if (streq(s, "dir"))	10✔
553	return S_IFDIR;
554	if (streq(s, "lnk"))	7✔
555	return S_IFLNK;
556	if (streq(s, "chr"))	6✔
557	return S_IFCHR;
558	if (streq(s, "blk"))	5✔
559	return S_IFBLK;
560	if (streq(s, "fifo"))	4✔
561	return S_IFIFO;
562	if (streq(s, "sock"))	2✔
563	return S_IFSOCK;	2✔
564
565	return MODE_INVALID;
566	}

systemd / systemd / 14766779411

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