fs/nsfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/mount.h>
   3 #include <linux/pseudo_fs.h>
   4 #include <linux/file.h>
   5 #include <linux/fs.h>
   6 #include <linux/proc_fs.h>
   7 #include <linux/proc_ns.h>
   8 #include <linux/magic.h>
   9 #include <linux/ktime.h>
  10 #include <linux/seq_file.h>
  11 #include <linux/pid_namespace.h>
  12 #include <linux/user_namespace.h>
  13 #include <linux/nsfs.h>
  14 #include <linux/uaccess.h>
  15
  16 #include "mount.h"
  17 #include "internal.h"
  18
  19 static struct vfsmount *nsfs_mnt;
  20
  21 static long ns_ioctl(struct file *filp, unsigned int ioctl,
  22                         unsigned long arg);
  23 static const struct file_operations ns_file_operations = {
  24         .llseek         = no_llseek,
  25         .unlocked_ioctl = ns_ioctl,
  26         .compat_ioctl   = compat_ptr_ioctl,
  27 };
  28
  29 static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
  30 {
  31         struct inode *inode = d_inode(dentry);
  32         struct ns_common *ns = inode->i_private;
  33         const struct proc_ns_operations *ns_ops = ns->ops;
  34
  35         return dynamic_dname(buffer, buflen, "%s:[%lu]",
  36                 ns_ops->name, inode->i_ino);
  37 }
  38
  39 const struct dentry_operations ns_dentry_operations = {
  40         .d_delete       = always_delete_dentry,
  41         .d_dname        = ns_dname,
  42         .d_prune        = stashed_dentry_prune,
  43 };
  44
  45 static void nsfs_evict(struct inode *inode)
  46 {
  47         struct ns_common *ns = inode->i_private;
  48         clear_inode(inode);
  49         ns->ops->put(ns);
  50 }
  51
  52 int ns_get_path_cb(struct path *path, ns_get_path_helper_t *ns_get_cb,
  53                      void *private_data)
  54 {
  55         struct ns_common *ns;
  56
  57         ns = ns_get_cb(private_data);
  58         if (!ns)
  59                 return -ENOENT;
  60
  61         return path_from_stashed(&ns->stashed, nsfs_mnt, ns, path);
  62 }
  63
  64 struct ns_get_path_task_args {
  65         const struct proc_ns_operations *ns_ops;
  66         struct task_struct *task;
  67 };
  68
  69 static struct ns_common *ns_get_path_task(void *private_data)
  70 {
  71         struct ns_get_path_task_args *args = private_data;
  72
  73         return args->ns_ops->get(args->task);
  74 }
  75
  76 int ns_get_path(struct path *path, struct task_struct *task,
  77                   const struct proc_ns_operations *ns_ops)
  78 {
  79         struct ns_get_path_task_args args = {
  80                 .ns_ops = ns_ops,
  81                 .task   = task,
  82         };
  83
  84         return ns_get_path_cb(path, ns_get_path_task, &args);
  85 }
  86
  87 /**
  88  * open_namespace - open a namespace
  89  * @ns: the namespace to open
  90  *
  91  * This will consume a reference to @ns indendent of success or failure.
  92  *
  93  * Return: A file descriptor on success or a negative error code on failure.
  94  */
  95 int open_namespace(struct ns_common *ns)
  96 {
  97         struct path path __free(path_put) = {};
  98         struct file *f;
  99         int err;
 100
 101         /* call first to consume reference */
 102         err = path_from_stashed(&ns->stashed, nsfs_mnt, ns, &path);
 103         if (err < 0)
 104                 return err;
 105
 106         CLASS(get_unused_fd, fd)(O_CLOEXEC);
 107         if (fd < 0)
 108                 return fd;
 109
 110         f = dentry_open(&path, O_RDONLY, current_cred());
 111         if (IS_ERR(f))
 112                 return PTR_ERR(f);
 113
 114         fd_install(fd, f);
 115         return take_fd(fd);
 116 }
 117
 118 int open_related_ns(struct ns_common *ns,
 119                    struct ns_common *(*get_ns)(struct ns_common *ns))
 120 {
 121         struct ns_common *relative;
 122
 123         relative = get_ns(ns);
 124         if (IS_ERR(relative))
 125                 return PTR_ERR(relative);
 126
 127         return open_namespace(relative);
 128 }
 129 EXPORT_SYMBOL_GPL(open_related_ns);
 130
 131 static long ns_ioctl(struct file *filp, unsigned int ioctl,
 132                         unsigned long arg)
 133 {
 134         struct user_namespace *user_ns;
 135         struct pid_namespace *pid_ns;
 136         struct task_struct *tsk;
 137         struct ns_common *ns = get_proc_ns(file_inode(filp));
 138         uid_t __user *argp;
 139         uid_t uid;
 140         int ret;
 141
 142         switch (ioctl) {
 143         case NS_GET_USERNS:
 144                 return open_related_ns(ns, ns_get_owner);
 145         case NS_GET_PARENT:
 146                 if (!ns->ops->get_parent)
 147                         return -EINVAL;
 148                 return open_related_ns(ns, ns->ops->get_parent);
 149         case NS_GET_NSTYPE:
 150                 return ns->ops->type;
 151         case NS_GET_OWNER_UID:
 152                 if (ns->ops->type != CLONE_NEWUSER)
 153                         return -EINVAL;
 154                 user_ns = container_of(ns, struct user_namespace, ns);
 155                 argp = (uid_t __user *) arg;
 156                 uid = from_kuid_munged(current_user_ns(), user_ns->owner);
 157                 return put_user(uid, argp);
 158         case NS_GET_MNTNS_ID: {
 159                 struct mnt_namespace *mnt_ns;
 160                 __u64 __user *idp;
 161                 __u64 id;
 162
 163                 if (ns->ops->type != CLONE_NEWNS)
 164                         return -EINVAL;
 165
 166                 mnt_ns = container_of(ns, struct mnt_namespace, ns);
 167                 idp = (__u64 __user *)arg;
 168                 id = mnt_ns->seq;
 169                 return put_user(id, idp);
 170         }
 171         case NS_GET_PID_FROM_PIDNS:
 172                 fallthrough;
 173         case NS_GET_TGID_FROM_PIDNS:
 174                 fallthrough;
 175         case NS_GET_PID_IN_PIDNS:
 176                 fallthrough;
 177         case NS_GET_TGID_IN_PIDNS: {
 178                 if (ns->ops->type != CLONE_NEWPID)
 179                         return -EINVAL;
 180
 181                 ret = -ESRCH;
 182                 pid_ns = container_of(ns, struct pid_namespace, ns);
 183
 184                 guard(rcu)();
 185
 186                 if (ioctl == NS_GET_PID_IN_PIDNS ||
 187                     ioctl == NS_GET_TGID_IN_PIDNS)
 188                         tsk = find_task_by_vpid(arg);
 189                 else
 190                         tsk = find_task_by_pid_ns(arg, pid_ns);
 191                 if (!tsk)
 192                         break;
 193
 194                 switch (ioctl) {
 195                 case NS_GET_PID_FROM_PIDNS:
 196                         ret = task_pid_vnr(tsk);
 197                         break;
 198                 case NS_GET_TGID_FROM_PIDNS:
 199                         ret = task_tgid_vnr(tsk);
 200                         break;
 201                 case NS_GET_PID_IN_PIDNS:
 202                         ret = task_pid_nr_ns(tsk, pid_ns);
 203                         break;
 204                 case NS_GET_TGID_IN_PIDNS:
 205                         ret = task_tgid_nr_ns(tsk, pid_ns);
 206                         break;
 207                 default:
 208                         ret = 0;
 209                         break;
 210                 }
 211
 212                 if (!ret)
 213                         ret = -ESRCH;
 214                 break;
 215         }
 216         default:
 217                 ret = -ENOTTY;
 218         }
 219
 220         return ret;
 221 }
 222
 223 int ns_get_name(char *buf, size_t size, struct task_struct *task,
 224                         const struct proc_ns_operations *ns_ops)
 225 {
 226         struct ns_common *ns;
 227         int res = -ENOENT;
 228         const char *name;
 229         ns = ns_ops->get(task);
 230         if (ns) {
 231                 name = ns_ops->real_ns_name ? : ns_ops->name;
 232                 res = snprintf(buf, size, "%s:[%u]", name, ns->inum);
 233                 ns_ops->put(ns);
 234         }
 235         return res;
 236 }
 237
 238 bool proc_ns_file(const struct file *file)
 239 {
 240         return file->f_op == &ns_file_operations;
 241 }
 242
 243 /**
 244  * ns_match() - Returns true if current namespace matches dev/ino provided.
 245  * @ns: current namespace
 246  * @dev: dev_t from nsfs that will be matched against current nsfs
 247  * @ino: ino_t from nsfs that will be matched against current nsfs
 248  *
 249  * Return: true if dev and ino matches the current nsfs.
 250  */
 251 bool ns_match(const struct ns_common *ns, dev_t dev, ino_t ino)
 252 {
 253         return (ns->inum == ino) && (nsfs_mnt->mnt_sb->s_dev == dev);
 254 }
 255
 256
 257 static int nsfs_show_path(struct seq_file *seq, struct dentry *dentry)
 258 {
 259         struct inode *inode = d_inode(dentry);
 260         const struct ns_common *ns = inode->i_private;
 261         const struct proc_ns_operations *ns_ops = ns->ops;
 262
 263         seq_printf(seq, "%s:[%lu]", ns_ops->name, inode->i_ino);
 264         return 0;
 265 }
 266
 267 static const struct super_operations nsfs_ops = {
 268         .statfs = simple_statfs,
 269         .evict_inode = nsfs_evict,
 270         .show_path = nsfs_show_path,
 271 };
 272
 273 static int nsfs_init_inode(struct inode *inode, void *data)
 274 {
 275         struct ns_common *ns = data;
 276
 277         inode->i_private = data;
 278         inode->i_mode |= S_IRUGO;
 279         inode->i_fop = &ns_file_operations;
 280         inode->i_ino = ns->inum;
 281         return 0;
 282 }
 283
 284 static void nsfs_put_data(void *data)
 285 {
 286         struct ns_common *ns = data;
 287         ns->ops->put(ns);
 288 }
 289
 290 static const struct stashed_operations nsfs_stashed_ops = {
 291         .init_inode = nsfs_init_inode,
 292         .put_data = nsfs_put_data,
 293 };
 294
 295 static int nsfs_init_fs_context(struct fs_context *fc)
 296 {
 297         struct pseudo_fs_context *ctx = init_pseudo(fc, NSFS_MAGIC);
 298         if (!ctx)
 299                 return -ENOMEM;
 300         ctx->ops = &nsfs_ops;
 301         ctx->dops = &ns_dentry_operations;
 302         fc->s_fs_info = (void *)&nsfs_stashed_ops;
 303         return 0;
 304 }
 305
 306 static struct file_system_type nsfs = {
 307         .name = "nsfs",
 308         .init_fs_context = nsfs_init_fs_context,
 309         .kill_sb = kill_anon_super,
 310 };
 311
 312 void __init nsfs_init(void)
 313 {
 314         nsfs_mnt = kern_mount(&nsfs);
 315         if (IS_ERR(nsfs_mnt))
 316                 panic("can't set nsfs up\n");
 317         nsfs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
 318 }