fs/proc_namespace.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fs/proc_namespace.c - handling of /proc/<pid>/{mounts,mountinfo,mountstats}
   4  *
   5  * In fact, that's a piece of procfs; it's *almost* isolated from
   6  * the rest of fs/proc, but has rather close relationships with
   7  * fs/namespace.c, thus here instead of fs/proc
   8  *
   9  */
  10 #include <linux/mnt_namespace.h>
  11 #include <linux/nsproxy.h>
  12 #include <linux/security.h>
  13 #include <linux/fs_struct.h>
  14 #include <linux/sched/task.h>
  15
  16 #include "proc/internal.h" /* only for get_proc_task() in ->open() */
  17
  18 #include "pnode.h"
  19 #include "internal.h"
  20
  21 static __poll_t mounts_poll(struct file *file, poll_table *wait)
  22 {
  23         struct seq_file *m = file->private_data;
  24         struct proc_mounts *p = m->private;
  25         struct mnt_namespace *ns = p->ns;
  26         __poll_t res = EPOLLIN | EPOLLRDNORM;
  27         int event;
  28
  29         poll_wait(file, &p->ns->poll, wait);
  30
  31         event = READ_ONCE(ns->event);
  32         if (m->poll_event != event) {
  33                 m->poll_event = event;
  34                 res |= EPOLLERR | EPOLLPRI;
  35         }
  36
  37         return res;
  38 }
  39
  40 struct proc_fs_opts {
  41         int flag;
  42         const char *str;
  43 };
  44
  45 static int show_sb_opts(struct seq_file *m, struct super_block *sb)
  46 {
  47         static const struct proc_fs_opts fs_opts[] = {
  48                 { SB_SYNCHRONOUS, ",sync" },
  49                 { SB_DIRSYNC, ",dirsync" },
  50                 { SB_MANDLOCK, ",mand" },
  51                 { SB_LAZYTIME, ",lazytime" },
  52                 { 0, NULL }
  53         };
  54         const struct proc_fs_opts *fs_infop;
  55
  56         for (fs_infop = fs_opts; fs_infop->flag; fs_infop++) {
  57                 if (sb->s_flags & fs_infop->flag)
  58                         seq_puts(m, fs_infop->str);
  59         }
  60
  61         return security_sb_show_options(m, sb);
  62 }
  63
  64 static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)
  65 {
  66         static const struct proc_fs_opts mnt_opts[] = {
  67                 { MNT_NOSUID, ",nosuid" },
  68                 { MNT_NODEV, ",nodev" },
  69                 { MNT_NOEXEC, ",noexec" },
  70                 { MNT_NOATIME, ",noatime" },
  71                 { MNT_NODIRATIME, ",nodiratime" },
  72                 { MNT_RELATIME, ",relatime" },
  73                 { MNT_NOSYMFOLLOW, ",nosymfollow" },
  74                 { 0, NULL }
  75         };
  76         const struct proc_fs_opts *fs_infop;
  77
  78         for (fs_infop = mnt_opts; fs_infop->flag; fs_infop++) {
  79                 if (mnt->mnt_flags & fs_infop->flag)
  80                         seq_puts(m, fs_infop->str);
  81         }
  82 }
  83
  84 static inline void mangle(struct seq_file *m, const char *s)
  85 {
  86         seq_escape(m, s, " \t\n\\");
  87 }
  88
  89 static void show_type(struct seq_file *m, struct super_block *sb)
  90 {
  91         mangle(m, sb->s_type->name);
  92         if (sb->s_subtype) {
  93                 seq_putc(m, '.');
  94                 mangle(m, sb->s_subtype);
  95         }
  96 }
  97
  98 static int show_vfsmnt(struct seq_file *m, struct vfsmount *mnt)
  99 {
 100         struct proc_mounts *p = m->private;
 101         struct mount *r = real_mount(mnt);
 102         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
 103         struct super_block *sb = mnt_path.dentry->d_sb;
 104         int err;
 105
 106         if (sb->s_op->show_devname) {
 107                 err = sb->s_op->show_devname(m, mnt_path.dentry);
 108                 if (err)
 109                         goto out;
 110         } else {
 111                 mangle(m, r->mnt_devname ? r->mnt_devname : "none");
 112         }
 113         seq_putc(m, ' ');
 114         /* mountpoints outside of chroot jail will give SEQ_SKIP on this */
 115         err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
 116         if (err)
 117                 goto out;
 118         seq_putc(m, ' ');
 119         show_type(m, sb);
 120         seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");
 121         err = show_sb_opts(m, sb);
 122         if (err)
 123                 goto out;
 124         show_mnt_opts(m, mnt);
 125         if (sb->s_op->show_options)
 126                 err = sb->s_op->show_options(m, mnt_path.dentry);
 127         seq_puts(m, " 0 0\n");
 128 out:
 129         return err;
 130 }
 131
 132 static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt)
 133 {
 134         struct proc_mounts *p = m->private;
 135         struct mount *r = real_mount(mnt);
 136         struct super_block *sb = mnt->mnt_sb;
 137         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
 138         int err;
 139
 140         seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id,
 141                    MAJOR(sb->s_dev), MINOR(sb->s_dev));
 142         if (sb->s_op->show_path) {
 143                 err = sb->s_op->show_path(m, mnt->mnt_root);
 144                 if (err)
 145                         goto out;
 146         } else {
 147                 seq_dentry(m, mnt->mnt_root, " \t\n\\");
 148         }
 149         seq_putc(m, ' ');
 150
 151         /* mountpoints outside of chroot jail will give SEQ_SKIP on this */
 152         err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
 153         if (err)
 154                 goto out;
 155
 156         seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
 157         show_mnt_opts(m, mnt);
 158
 159         /* Tagged fields ("foo:X" or "bar") */
 160         if (IS_MNT_SHARED(r))
 161                 seq_printf(m, " shared:%i", r->mnt_group_id);
 162         if (IS_MNT_SLAVE(r)) {
 163                 int master = r->mnt_master->mnt_group_id;
 164                 int dom = get_dominating_id(r, &p->root);
 165                 seq_printf(m, " master:%i", master);
 166                 if (dom && dom != master)
 167                         seq_printf(m, " propagate_from:%i", dom);
 168         }
 169         if (IS_MNT_UNBINDABLE(r))
 170                 seq_puts(m, " unbindable");
 171
 172         /* Filesystem specific data */
 173         seq_puts(m, " - ");
 174         show_type(m, sb);
 175         seq_putc(m, ' ');
 176         if (sb->s_op->show_devname) {
 177                 err = sb->s_op->show_devname(m, mnt->mnt_root);
 178                 if (err)
 179                         goto out;
 180         } else {
 181                 mangle(m, r->mnt_devname ? r->mnt_devname : "none");
 182         }
 183         seq_puts(m, sb_rdonly(sb) ? " ro" : " rw");
 184         err = show_sb_opts(m, sb);
 185         if (err)
 186                 goto out;
 187         if (sb->s_op->show_options)
 188                 err = sb->s_op->show_options(m, mnt->mnt_root);
 189         seq_putc(m, '\n');
 190 out:
 191         return err;
 192 }
 193
 194 static int show_vfsstat(struct seq_file *m, struct vfsmount *mnt)
 195 {
 196         struct proc_mounts *p = m->private;
 197         struct mount *r = real_mount(mnt);
 198         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
 199         struct super_block *sb = mnt_path.dentry->d_sb;
 200         int err;
 201
 202         /* device */
 203         if (sb->s_op->show_devname) {
 204                 seq_puts(m, "device ");
 205                 err = sb->s_op->show_devname(m, mnt_path.dentry);
 206                 if (err)
 207                         goto out;
 208         } else {
 209                 if (r->mnt_devname) {
 210                         seq_puts(m, "device ");
 211                         mangle(m, r->mnt_devname);
 212                 } else
 213                         seq_puts(m, "no device");
 214         }
 215
 216         /* mount point */
 217         seq_puts(m, " mounted on ");
 218         /* mountpoints outside of chroot jail will give SEQ_SKIP on this */
 219         err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
 220         if (err)
 221                 goto out;
 222         seq_putc(m, ' ');
 223
 224         /* file system type */
 225         seq_puts(m, "with fstype ");
 226         show_type(m, sb);
 227
 228         /* optional statistics */
 229         if (sb->s_op->show_stats) {
 230                 seq_putc(m, ' ');
 231                 err = sb->s_op->show_stats(m, mnt_path.dentry);
 232         }
 233
 234         seq_putc(m, '\n');
 235 out:
 236         return err;
 237 }
 238
 239 static int mounts_open_common(struct inode *inode, struct file *file,
 240                               int (*show)(struct seq_file *, struct vfsmount *))
 241 {
 242         struct task_struct *task = get_proc_task(inode);
 243         struct nsproxy *nsp;
 244         struct mnt_namespace *ns = NULL;
 245         struct path root;
 246         struct proc_mounts *p;
 247         struct seq_file *m;
 248         int ret = -EINVAL;
 249
 250         if (!task)
 251                 goto err;
 252
 253         task_lock(task);
 254         nsp = task->nsproxy;
 255         if (!nsp || !nsp->mnt_ns) {
 256                 task_unlock(task);
 257                 put_task_struct(task);
 258                 goto err;
 259         }
 260         ns = nsp->mnt_ns;
 261         get_mnt_ns(ns);
 262         if (!task->fs) {
 263                 task_unlock(task);
 264                 put_task_struct(task);
 265                 ret = -ENOENT;
 266                 goto err_put_ns;
 267         }
 268         get_fs_root(task->fs, &root);
 269         task_unlock(task);
 270         put_task_struct(task);
 271
 272         ret = seq_open_private(file, &mounts_op, sizeof(struct proc_mounts));
 273         if (ret)
 274                 goto err_put_path;
 275
 276         m = file->private_data;
 277         m->poll_event = ns->event;
 278
 279         p = m->private;
 280         p->ns = ns;
 281         p->root = root;
 282         p->show = show;
 283         INIT_LIST_HEAD(&p->cursor.mnt_list);
 284         p->cursor.mnt.mnt_flags = MNT_CURSOR;
 285
 286         return 0;
 287
 288  err_put_path:
 289         path_put(&root);
 290  err_put_ns:
 291         put_mnt_ns(ns);
 292  err:
 293         return ret;
 294 }
 295
 296 static int mounts_release(struct inode *inode, struct file *file)
 297 {
 298         struct seq_file *m = file->private_data;
 299         struct proc_mounts *p = m->private;
 300         path_put(&p->root);
 301         mnt_cursor_del(p->ns, &p->cursor);
 302         put_mnt_ns(p->ns);
 303         return seq_release_private(inode, file);
 304 }
 305
 306 static int mounts_open(struct inode *inode, struct file *file)
 307 {
 308         return mounts_open_common(inode, file, show_vfsmnt);
 309 }
 310
 311 static int mountinfo_open(struct inode *inode, struct file *file)
 312 {
 313         return mounts_open_common(inode, file, show_mountinfo);
 314 }
 315
 316 static int mountstats_open(struct inode *inode, struct file *file)
 317 {
 318         return mounts_open_common(inode, file, show_vfsstat);
 319 }
 320
 321 const struct file_operations proc_mounts_operations = {
 322         .open           = mounts_open,
 323         .read_iter      = seq_read_iter,
 324         .splice_read    = generic_file_splice_read,
 325         .llseek         = seq_lseek,
 326         .release        = mounts_release,
 327         .poll           = mounts_poll,
 328 };
 329
 330 const struct file_operations proc_mountinfo_operations = {
 331         .open           = mountinfo_open,
 332         .read_iter      = seq_read_iter,
 333         .splice_read    = generic_file_splice_read,
 334         .llseek         = seq_lseek,
 335         .release        = mounts_release,
 336         .poll           = mounts_poll,
 337 };
 338
 339 const struct file_operations proc_mountstats_operations = {
 340         .open           = mountstats_open,
 341         .read_iter      = seq_read_iter,
 342         .splice_read    = generic_file_splice_read,
 343         .llseek         = seq_lseek,
 344         .release        = mounts_release,
 345 };