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 }; 346