Line data    Source code

       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      588516 : static __poll_t mounts_poll(struct file *file, poll_table *wait)
      22             : {
      23      588516 :         struct seq_file *m = file->private_data;
      24      588516 :         struct proc_mounts *p = m->private;
      25      588516 :         struct mnt_namespace *ns = p->ns;
      26      588516 :         __poll_t res = EPOLLIN | EPOLLRDNORM;
      27      588516 :         int event;
      28             : 
      29      588516 :         poll_wait(file, &p->ns->poll, wait);
      30             : 
      31      589488 :         event = READ_ONCE(ns->event);
      32      589488 :         if (m->poll_event != event) {
      33      297148 :                 m->poll_event = event;
      34      297148 :                 res |= EPOLLERR | EPOLLPRI;
      35             :         }
      36             : 
      37      589488 :         return res;
      38             : }
      39             : 
      40             : struct proc_fs_opts {
      41             :         int flag;
      42             :         const char *str;
      43             : };
      44             : 
      45   910301079 : static int show_sb_opts(struct seq_file *m, struct super_block *sb)
      46             : {
      47   910301079 :         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   910301079 :         const struct proc_fs_opts *fs_infop;
      55             : 
      56  4550320844 :         for (fs_infop = fs_opts; fs_infop->flag; fs_infop++) {
      57  3639048964 :                 if (sb->s_flags & fs_infop->flag)
      58        6816 :                         seq_puts(m, fs_infop->str);
      59             :         }
      60             : 
      61   911271880 :         return security_sb_show_options(m, sb);
      62             : }
      63             : 
      64   911096126 : static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)
      65             : {
      66   911096126 :         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   911096126 :         const struct proc_fs_opts *fs_infop;
      77             : 
      78  7277309169 :         for (fs_infop = mnt_opts; fs_infop->flag; fs_infop++) {
      79  6366024561 :                 if (mnt->mnt_flags & fs_infop->flag)
      80  1435740875 :                         seq_puts(m, fs_infop->str);
      81             :         }
      82             : 
      83   911284608 :         if (is_idmapped_mnt(mnt))
      84        2037 :                 seq_puts(m, ",idmapped");
      85   911255488 : }
      86             : 
      87             : static inline void mangle(struct seq_file *m, const char *s)
      88             : {
      89   838298235 :         seq_escape(m, s, " \t\n\\#");
      90   838733882 : }
      91             : 
      92   911487138 : static void show_type(struct seq_file *m, struct super_block *sb)
      93             : {
      94   911487138 :         mangle(m, sb->s_type->name);
      95   910122367 :         if (sb->s_subtype) {
      96           0 :                 seq_putc(m, '.');
      97           0 :                 mangle(m, sb->s_subtype);
      98             :         }
      99   910122367 : }
     100             : 
     101   855416300 : static int show_vfsmnt(struct seq_file *m, struct vfsmount *mnt)
     102             : {
     103   855416300 :         struct proc_mounts *p = m->private;
     104   855416300 :         struct mount *r = real_mount(mnt);
     105   855416300 :         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
     106   855416300 :         struct super_block *sb = mnt_path.dentry->d_sb;
     107   855416300 :         int err;
     108             : 
     109   855416300 :         if (sb->s_op->show_devname) {
     110    75490090 :                 err = sb->s_op->show_devname(m, mnt_path.dentry);
     111    75546637 :                 if (err)
     112           0 :                         goto out;
     113             :         } else {
     114   779926210 :                 mangle(m, r->mnt_devname ? r->mnt_devname : "none");
     115             :         }
     116   855845079 :         seq_putc(m, ' ');
     117             :         /* mountpoints outside of chroot jail will give SEQ_SKIP on this */
     118   855904227 :         err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
     119   856601108 :         if (err)
     120     9274976 :                 goto out;
     121   847326132 :         seq_putc(m, ' ');
     122   847287508 :         show_type(m, sb);
     123  1201918717 :         seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");
     124   846302572 :         err = show_sb_opts(m, sb);
     125   846973662 :         if (err)
     126           0 :                 goto out;
     127   846973662 :         show_mnt_opts(m, mnt);
     128   847012992 :         if (sb->s_op->show_options)
     129   809882061 :                 err = sb->s_op->show_options(m, mnt_path.dentry);
     130   846794623 :         seq_puts(m, " 0 0\n");
     131   855730238 : out:
     132   855730238 :         return err;
     133             : }
     134             : 
     135    65030462 : static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt)
     136             : {
     137    65030462 :         struct proc_mounts *p = m->private;
     138    65030462 :         struct mount *r = real_mount(mnt);
     139    65030462 :         struct super_block *sb = mnt->mnt_sb;
     140    65030462 :         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
     141    65030462 :         int err;
     142             : 
     143    65030462 :         seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id,
     144    65030462 :                    MAJOR(sb->s_dev), MINOR(sb->s_dev));
     145    64799675 :         if (sb->s_op->show_path) {
     146     7008481 :                 err = sb->s_op->show_path(m, mnt->mnt_root);
     147     7011332 :                 if (err)
     148           0 :                         goto out;
     149             :         } else {
     150    57791194 :                 seq_dentry(m, mnt->mnt_root, " \t\n\\");
     151             :         }
     152    64832827 :         seq_putc(m, ' ');
     153             : 
     154             :         /* mountpoints outside of chroot jail will give SEQ_SKIP on this */
     155    64831378 :         err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
     156    65006670 :         if (err)
     157      682350 :                 goto out;
     158             : 
     159    91062996 :         seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
     160    64288619 :         show_mnt_opts(m, mnt);
     161             : 
     162             :         /* Tagged fields ("foo:X" or "bar") */
     163    64188218 :         if (IS_MNT_SHARED(r))
     164    62449781 :                 seq_printf(m, " shared:%i", r->mnt_group_id);
     165    64245568 :         if (IS_MNT_SLAVE(r)) {
     166     1739656 :                 int master = r->mnt_master->mnt_group_id;
     167     1739656 :                 int dom = get_dominating_id(r, &p->root);
     168     1739621 :                 seq_printf(m, " master:%i", master);
     169     1739611 :                 if (dom && dom != master)
     170           0 :                         seq_printf(m, " propagate_from:%i", dom);
     171             :         }
     172    64245523 :         if (IS_MNT_UNBINDABLE(r))
     173         414 :                 seq_puts(m, " unbindable");
     174             : 
     175             :         /* Filesystem specific data */
     176    64245523 :         seq_puts(m, " - ");
     177    64284382 :         show_type(m, sb);
     178    63882110 :         seq_putc(m, ' ');
     179    63992124 :         if (sb->s_op->show_devname) {
     180     5620099 :                 err = sb->s_op->show_devname(m, mnt->mnt_root);
     181     5655736 :                 if (err)
     182           0 :                         goto out;
     183             :         } else {
     184    58372025 :                 mangle(m, r->mnt_devname ? r->mnt_devname : "none");
     185             :         }
     186   128191033 :         seq_puts(m, sb_rdonly(sb) ? " ro" : " rw");
     187    64073399 :         err = show_sb_opts(m, sb);
     188    64254519 :         if (err)
     189           0 :                 goto out;
     190    64254519 :         if (sb->s_op->show_options)
     191    61440971 :                 err = sb->s_op->show_options(m, mnt->mnt_root);
     192    64011055 :         seq_putc(m, '\n');
     193    64610672 : out:
     194    64610672 :         return err;
     195             : }
     196             : 
     197           0 : static int show_vfsstat(struct seq_file *m, struct vfsmount *mnt)
     198             : {
     199           0 :         struct proc_mounts *p = m->private;
     200           0 :         struct mount *r = real_mount(mnt);
     201           0 :         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
     202           0 :         struct super_block *sb = mnt_path.dentry->d_sb;
     203           0 :         int err;
     204             : 
     205             :         /* device */
     206           0 :         if (sb->s_op->show_devname) {
     207           0 :                 seq_puts(m, "device ");
     208           0 :                 err = sb->s_op->show_devname(m, mnt_path.dentry);
     209           0 :                 if (err)
     210           0 :                         goto out;
     211             :         } else {
     212           0 :                 if (r->mnt_devname) {
     213           0 :                         seq_puts(m, "device ");
     214           0 :                         mangle(m, r->mnt_devname);
     215             :                 } else
     216           0 :                         seq_puts(m, "no device");
     217             :         }
     218             : 
     219             :         /* mount point */
     220           0 :         seq_puts(m, " mounted on ");
     221             :         /* mountpoints outside of chroot jail will give SEQ_SKIP on this */
     222           0 :         err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
     223           0 :         if (err)
     224           0 :                 goto out;
     225           0 :         seq_putc(m, ' ');
     226             : 
     227             :         /* file system type */
     228           0 :         seq_puts(m, "with fstype ");
     229           0 :         show_type(m, sb);
     230             : 
     231             :         /* optional statistics */
     232           0 :         if (sb->s_op->show_stats) {
     233           0 :                 seq_putc(m, ' ');
     234           0 :                 err = sb->s_op->show_stats(m, mnt_path.dentry);
     235             :         }
     236             : 
     237           0 :         seq_putc(m, '\n');
     238           0 : out:
     239           0 :         return err;
     240             : }
     241             : 
     242     9958754 : static int mounts_open_common(struct inode *inode, struct file *file,
     243             :                               int (*show)(struct seq_file *, struct vfsmount *))
     244             : {
     245     9958754 :         struct task_struct *task = get_proc_task(inode);
     246     9981564 :         struct nsproxy *nsp;
     247     9981564 :         struct mnt_namespace *ns = NULL;
     248     9981564 :         struct path root;
     249     9981564 :         struct proc_mounts *p;
     250     9981564 :         struct seq_file *m;
     251     9981564 :         int ret = -EINVAL;
     252             : 
     253     9981564 :         if (!task)
     254           0 :                 goto err;
     255             : 
     256     9981564 :         task_lock(task);
     257     9969342 :         nsp = task->nsproxy;
     258     9969342 :         if (!nsp || !nsp->mnt_ns) {
     259           0 :                 task_unlock(task);
     260           0 :                 put_task_struct(task);
     261           0 :                 goto err;
     262             :         }
     263     9969342 :         ns = nsp->mnt_ns;
     264     9969342 :         get_mnt_ns(ns);
     265     9940956 :         if (!task->fs) {
     266           0 :                 task_unlock(task);
     267           0 :                 put_task_struct(task);
     268           0 :                 ret = -ENOENT;
     269           0 :                 goto err_put_ns;
     270             :         }
     271     9940956 :         get_fs_root(task->fs, &root);
     272     9983918 :         task_unlock(task);
     273     9984368 :         put_task_struct(task);
     274             : 
     275     9972879 :         ret = seq_open_private(file, &mounts_op, sizeof(struct proc_mounts));
     276     9972639 :         if (ret)
     277           0 :                 goto err_put_path;
     278             : 
     279     9972639 :         m = file->private_data;
     280     9972639 :         m->poll_event = ns->event;
     281             : 
     282     9972639 :         p = m->private;
     283     9972639 :         p->ns = ns;
     284     9972639 :         p->root = root;
     285     9972639 :         p->show = show;
     286     9972639 :         INIT_LIST_HEAD(&p->cursor.mnt_list);
     287     9972639 :         p->cursor.mnt.mnt_flags = MNT_CURSOR;
     288             : 
     289     9972639 :         return 0;
     290             : 
     291             :  err_put_path:
     292           0 :         path_put(&root);
     293           0 :  err_put_ns:
     294           0 :         put_mnt_ns(ns);
     295             :  err:
     296             :         return ret;
     297             : }
     298             : 
     299     9946581 : static int mounts_release(struct inode *inode, struct file *file)
     300             : {
     301     9946581 :         struct seq_file *m = file->private_data;
     302     9946581 :         struct proc_mounts *p = m->private;
     303     9946581 :         path_put(&p->root);
     304     9971967 :         mnt_cursor_del(p->ns, &p->cursor);
     305     9984668 :         put_mnt_ns(p->ns);
     306     9946788 :         return seq_release_private(inode, file);
     307             : }
     308             : 
     309     9282278 : static int mounts_open(struct inode *inode, struct file *file)
     310             : {
     311     9282278 :         return mounts_open_common(inode, file, show_vfsmnt);
     312             : }
     313             : 
     314      683433 : static int mountinfo_open(struct inode *inode, struct file *file)
     315             : {
     316      683433 :         return mounts_open_common(inode, file, show_mountinfo);
     317             : }
     318             : 
     319           0 : static int mountstats_open(struct inode *inode, struct file *file)
     320             : {
     321           0 :         return mounts_open_common(inode, file, show_vfsstat);
     322             : }
     323             : 
     324             : const struct file_operations proc_mounts_operations = {
     325             :         .open           = mounts_open,
     326             :         .read_iter      = seq_read_iter,
     327             :         .splice_read    = copy_splice_read,
     328             :         .llseek         = seq_lseek,
     329             :         .release        = mounts_release,
     330             :         .poll           = mounts_poll,
     331             : };
     332             : 
     333             : const struct file_operations proc_mountinfo_operations = {
     334             :         .open           = mountinfo_open,
     335             :         .read_iter      = seq_read_iter,
     336             :         .splice_read    = copy_splice_read,
     337             :         .llseek         = seq_lseek,
     338             :         .release        = mounts_release,
     339             :         .poll           = mounts_poll,
     340             : };
     341             : 
     342             : const struct file_operations proc_mountstats_operations = {
     343             :         .open           = mountstats_open,
     344             :         .read_iter      = seq_read_iter,
     345             :         .splice_read    = copy_splice_read,
     346             :         .llseek         = seq_lseek,
     347             :         .release        = mounts_release,
     348             : };