mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-12 13:34:10 +08:00
9d9539db86
As Linus suggested this enables pidfs unconditionally. A key property to retain is the ability to compare pidfds by inode number (cf. [1]). That's extremely helpful just as comparing namespace file descriptors by inode number is. They are used in a variety of scenarios where they need to be compared, e.g., when receiving a pidfd via SO_PEERPIDFD from a socket to trivially authenticate a the sender and various other use-cases. For 64bit systems this is pretty trivial to do. For 32bit it's slightly more annoying as we discussed but we simply add a dumb ida based allocator that gets used on 32bit. This gives the same guarantees about inode numbers on 64bit without any overflow risk. Practically, we'll never run into overflow issues because we're constrained by the number of processes that can exist on 32bit and by the number of open files that can exist on a 32bit system. On 64bit none of this matters and things are very simple. If 32bit also needs the uniqueness guarantee they can simply parse the contents of /proc/<pid>/fd/<nr>. The uniqueness guarantees have a variety of use-cases. One of the most obvious ones is that they will make pidfiles (or "pidfdfiles", I guess) reliable as the unique identifier can be placed into there that won't be reycled. Also a frequent request. Note, I took the chance and simplified path_from_stashed() even further. Instead of passing the inode number explicitly to path_from_stashed() we let the filesystem handle that internally. So path_from_stashed() ends up even simpler than it is now. This is also a good solution allowing the cleanup code to be clean and consistent between 32bit and 64bit. The cleanup path in prepare_anon_dentry() is also switched around so we put the inode before the dentry allocation. This means we only have to call the cleanup handler for the filesystem's inode data once and can rely ->evict_inode() otherwise. Aside from having to have a bit of extra code for 32bit it actually ends up a nice cleanup for path_from_stashed() imho. Tested on both 32 and 64bit including error injection. Link: https://github.com/systemd/systemd/pull/31713 [1] Link: https://lore.kernel.org/r/20240312-dingo-sehnlich-b3ecc35c6de7@brauner Signed-off-by: Christian Brauner <brauner@kernel.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
247 lines
5.6 KiB
C
247 lines
5.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <linux/mount.h>
|
|
#include <linux/pseudo_fs.h>
|
|
#include <linux/file.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/proc_ns.h>
|
|
#include <linux/magic.h>
|
|
#include <linux/ktime.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/user_namespace.h>
|
|
#include <linux/nsfs.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include "internal.h"
|
|
|
|
static struct vfsmount *nsfs_mnt;
|
|
|
|
static long ns_ioctl(struct file *filp, unsigned int ioctl,
|
|
unsigned long arg);
|
|
static const struct file_operations ns_file_operations = {
|
|
.llseek = no_llseek,
|
|
.unlocked_ioctl = ns_ioctl,
|
|
.compat_ioctl = compat_ptr_ioctl,
|
|
};
|
|
|
|
static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
|
|
{
|
|
struct inode *inode = d_inode(dentry);
|
|
struct ns_common *ns = inode->i_private;
|
|
const struct proc_ns_operations *ns_ops = ns->ops;
|
|
|
|
return dynamic_dname(buffer, buflen, "%s:[%lu]",
|
|
ns_ops->name, inode->i_ino);
|
|
}
|
|
|
|
const struct dentry_operations ns_dentry_operations = {
|
|
.d_delete = always_delete_dentry,
|
|
.d_dname = ns_dname,
|
|
.d_prune = stashed_dentry_prune,
|
|
};
|
|
|
|
static void nsfs_evict(struct inode *inode)
|
|
{
|
|
struct ns_common *ns = inode->i_private;
|
|
clear_inode(inode);
|
|
ns->ops->put(ns);
|
|
}
|
|
|
|
int ns_get_path_cb(struct path *path, ns_get_path_helper_t *ns_get_cb,
|
|
void *private_data)
|
|
{
|
|
struct ns_common *ns;
|
|
|
|
ns = ns_get_cb(private_data);
|
|
if (!ns)
|
|
return -ENOENT;
|
|
|
|
return path_from_stashed(&ns->stashed, nsfs_mnt, ns, path);
|
|
}
|
|
|
|
struct ns_get_path_task_args {
|
|
const struct proc_ns_operations *ns_ops;
|
|
struct task_struct *task;
|
|
};
|
|
|
|
static struct ns_common *ns_get_path_task(void *private_data)
|
|
{
|
|
struct ns_get_path_task_args *args = private_data;
|
|
|
|
return args->ns_ops->get(args->task);
|
|
}
|
|
|
|
int ns_get_path(struct path *path, struct task_struct *task,
|
|
const struct proc_ns_operations *ns_ops)
|
|
{
|
|
struct ns_get_path_task_args args = {
|
|
.ns_ops = ns_ops,
|
|
.task = task,
|
|
};
|
|
|
|
return ns_get_path_cb(path, ns_get_path_task, &args);
|
|
}
|
|
|
|
int open_related_ns(struct ns_common *ns,
|
|
struct ns_common *(*get_ns)(struct ns_common *ns))
|
|
{
|
|
struct path path = {};
|
|
struct ns_common *relative;
|
|
struct file *f;
|
|
int err;
|
|
int fd;
|
|
|
|
fd = get_unused_fd_flags(O_CLOEXEC);
|
|
if (fd < 0)
|
|
return fd;
|
|
|
|
relative = get_ns(ns);
|
|
if (IS_ERR(relative)) {
|
|
put_unused_fd(fd);
|
|
return PTR_ERR(relative);
|
|
}
|
|
|
|
err = path_from_stashed(&relative->stashed, nsfs_mnt, relative, &path);
|
|
if (err < 0) {
|
|
put_unused_fd(fd);
|
|
return err;
|
|
}
|
|
|
|
f = dentry_open(&path, O_RDONLY, current_cred());
|
|
path_put(&path);
|
|
if (IS_ERR(f)) {
|
|
put_unused_fd(fd);
|
|
fd = PTR_ERR(f);
|
|
} else
|
|
fd_install(fd, f);
|
|
|
|
return fd;
|
|
}
|
|
EXPORT_SYMBOL_GPL(open_related_ns);
|
|
|
|
static long ns_ioctl(struct file *filp, unsigned int ioctl,
|
|
unsigned long arg)
|
|
{
|
|
struct user_namespace *user_ns;
|
|
struct ns_common *ns = get_proc_ns(file_inode(filp));
|
|
uid_t __user *argp;
|
|
uid_t uid;
|
|
|
|
switch (ioctl) {
|
|
case NS_GET_USERNS:
|
|
return open_related_ns(ns, ns_get_owner);
|
|
case NS_GET_PARENT:
|
|
if (!ns->ops->get_parent)
|
|
return -EINVAL;
|
|
return open_related_ns(ns, ns->ops->get_parent);
|
|
case NS_GET_NSTYPE:
|
|
return ns->ops->type;
|
|
case NS_GET_OWNER_UID:
|
|
if (ns->ops->type != CLONE_NEWUSER)
|
|
return -EINVAL;
|
|
user_ns = container_of(ns, struct user_namespace, ns);
|
|
argp = (uid_t __user *) arg;
|
|
uid = from_kuid_munged(current_user_ns(), user_ns->owner);
|
|
return put_user(uid, argp);
|
|
default:
|
|
return -ENOTTY;
|
|
}
|
|
}
|
|
|
|
int ns_get_name(char *buf, size_t size, struct task_struct *task,
|
|
const struct proc_ns_operations *ns_ops)
|
|
{
|
|
struct ns_common *ns;
|
|
int res = -ENOENT;
|
|
const char *name;
|
|
ns = ns_ops->get(task);
|
|
if (ns) {
|
|
name = ns_ops->real_ns_name ? : ns_ops->name;
|
|
res = snprintf(buf, size, "%s:[%u]", name, ns->inum);
|
|
ns_ops->put(ns);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
bool proc_ns_file(const struct file *file)
|
|
{
|
|
return file->f_op == &ns_file_operations;
|
|
}
|
|
|
|
/**
|
|
* ns_match() - Returns true if current namespace matches dev/ino provided.
|
|
* @ns: current namespace
|
|
* @dev: dev_t from nsfs that will be matched against current nsfs
|
|
* @ino: ino_t from nsfs that will be matched against current nsfs
|
|
*
|
|
* Return: true if dev and ino matches the current nsfs.
|
|
*/
|
|
bool ns_match(const struct ns_common *ns, dev_t dev, ino_t ino)
|
|
{
|
|
return (ns->inum == ino) && (nsfs_mnt->mnt_sb->s_dev == dev);
|
|
}
|
|
|
|
|
|
static int nsfs_show_path(struct seq_file *seq, struct dentry *dentry)
|
|
{
|
|
struct inode *inode = d_inode(dentry);
|
|
const struct ns_common *ns = inode->i_private;
|
|
const struct proc_ns_operations *ns_ops = ns->ops;
|
|
|
|
seq_printf(seq, "%s:[%lu]", ns_ops->name, inode->i_ino);
|
|
return 0;
|
|
}
|
|
|
|
static const struct super_operations nsfs_ops = {
|
|
.statfs = simple_statfs,
|
|
.evict_inode = nsfs_evict,
|
|
.show_path = nsfs_show_path,
|
|
};
|
|
|
|
static int nsfs_init_inode(struct inode *inode, void *data)
|
|
{
|
|
struct ns_common *ns = data;
|
|
|
|
inode->i_private = data;
|
|
inode->i_mode |= S_IRUGO;
|
|
inode->i_fop = &ns_file_operations;
|
|
inode->i_ino = ns->inum;
|
|
return 0;
|
|
}
|
|
|
|
static void nsfs_put_data(void *data)
|
|
{
|
|
struct ns_common *ns = data;
|
|
ns->ops->put(ns);
|
|
}
|
|
|
|
static const struct stashed_operations nsfs_stashed_ops = {
|
|
.init_inode = nsfs_init_inode,
|
|
.put_data = nsfs_put_data,
|
|
};
|
|
|
|
static int nsfs_init_fs_context(struct fs_context *fc)
|
|
{
|
|
struct pseudo_fs_context *ctx = init_pseudo(fc, NSFS_MAGIC);
|
|
if (!ctx)
|
|
return -ENOMEM;
|
|
ctx->ops = &nsfs_ops;
|
|
ctx->dops = &ns_dentry_operations;
|
|
fc->s_fs_info = (void *)&nsfs_stashed_ops;
|
|
return 0;
|
|
}
|
|
|
|
static struct file_system_type nsfs = {
|
|
.name = "nsfs",
|
|
.init_fs_context = nsfs_init_fs_context,
|
|
.kill_sb = kill_anon_super,
|
|
};
|
|
|
|
void __init nsfs_init(void)
|
|
{
|
|
nsfs_mnt = kern_mount(&nsfs);
|
|
if (IS_ERR(nsfs_mnt))
|
|
panic("can't set nsfs up\n");
|
|
nsfs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
|
|
}
|