LCOV - code coverage report
Current view: top level - fs - proc_namespace.c (source / functions) Hit Total Coverage
Test: Real Lines: 106 145 73.1 %
Date: 2020-10-17 15:46:43 Functions: 0 12 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14