[thirdparty/systemd.git] / src / basic / stat-util.c

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

#include <fcntl.h>
#include <linux/magic.h>
#include <sys/statvfs.h>
#include <unistd.h>

#include "alloc-util.h"
#include "chase.h"
#include "dirent-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "filesystems.h"
#include "fs-util.h"
#include "hash-funcs.h"
#include "log.h"
#include "mountpoint-util.h"
#include "path-util.h"
#include "siphash24.h"
#include "stat-util.h"
#include "string-util.h"
#include "time-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 fd_verify_symlink(int fd) {
        return verify_stat_at(fd, /* path= */ NULL, /* follow= */ false, stat_verify_symlink, /* verify= */ true);
}

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 = getdents64(fd, buf, m);
                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 stat_may_be_dev_null(struct stat *st) {
        assert(st);

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

        return S_ISCHR(st->st_mode);
}

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

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

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 statfs st;

        assert(fd >= 0);

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

        if (st.f_flags & ST_RDONLY)
                return true;

        if (is_network_fs(&st)) {
                /* On NFS, fstatfs() 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));
}

usec_t statx_timestamp_load(const struct statx_timestamp *ts) {
        return timespec_load(&(const struct timespec) { .tv_sec = ts->tv_sec, .tv_nsec = ts->tv_nsec });
}
nsec_t statx_timestamp_load_nsec(const struct statx_timestamp *ts) {
        return timespec_load_nsec(&(const struct timespec) { .tv_sec = ts->tv_sec, .tv_nsec = ts->tv_nsec });
}

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