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