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 proc_mounts *p = proc_mounts(m); 95 struct mount *r = real_mount(mnt); 96 int err = 0; 97 struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt }; 98 struct super_block *sb = mnt_path.dentry->d_sb; 99 100 if (sb->s_op->show_devname) { 101 err = sb->s_op->show_devname(m, mnt_path.dentry); 102 if (err) 103 goto out; 104 } else { 105 mangle(m, r->mnt_devname ? r->mnt_devname : "none"); 106 } 107 seq_putc(m, ' '); 108 /* mountpoints outside of chroot jail will give SEQ_SKIP on this */ 109 err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\"); 110 if (err) 111 goto out; 112 seq_putc(m, ' '); 113 show_type(m, sb); 114 seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw"); 115 err = show_sb_opts(m, sb); 116 if (err) 117 goto out; 118 show_mnt_opts(m, mnt); 119 if (sb->s_op->show_options) 120 err = sb->s_op->show_options(m, mnt_path.dentry); 121 seq_puts(m, " 0 0\n"); 122 out: 123 return err; 124 } 125 126 static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt) 127 { 128 struct proc_mounts *p = proc_mounts(m); 129 struct mount *r = real_mount(mnt); 130 struct super_block *sb = mnt->mnt_sb; 131 struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt }; 132 int err = 0; 133 134 seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id, 135 MAJOR(sb->s_dev), MINOR(sb->s_dev)); 136 if (sb->s_op->show_path) 137 err = sb->s_op->show_path(m, mnt->mnt_root); 138 else 139 seq_dentry(m, mnt->mnt_root, " \t\n\\"); 140 if (err) 141 goto out; 142 seq_putc(m, ' '); 143 144 /* mountpoints outside of chroot jail will give SEQ_SKIP on this */ 145 err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\"); 146 if (err) 147 goto out; 148 149 seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw"); 150 show_mnt_opts(m, mnt); 151 152 /* Tagged fields ("foo:X" or "bar") */ 153 if (IS_MNT_SHARED(r)) 154 seq_printf(m, " shared:%i", r->mnt_group_id); 155 if (IS_MNT_SLAVE(r)) { 156 int master = r->mnt_master->mnt_group_id; 157 int dom = get_dominating_id(r, &p->root); 158 seq_printf(m, " master:%i", master); 159 if (dom && dom != master) 160 seq_printf(m, " propagate_from:%i", dom); 161 } 162 if (IS_MNT_UNBINDABLE(r)) 163 seq_puts(m, " unbindable"); 164 165 /* Filesystem specific data */ 166 seq_puts(m, " - "); 167 show_type(m, sb); 168 seq_putc(m, ' '); 169 if (sb->s_op->show_devname) 170 err = sb->s_op->show_devname(m, mnt->mnt_root); 171 else 172 mangle(m, r->mnt_devname ? r->mnt_devname : "none"); 173 if (err) 174 goto out; 175 seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw"); 176 err = show_sb_opts(m, sb); 177 if (err) 178 goto out; 179 if (sb->s_op->show_options) 180 err = sb->s_op->show_options(m, mnt->mnt_root); 181 seq_putc(m, '\n'); 182 out: 183 return err; 184 } 185 186 static int show_vfsstat(struct seq_file *m, struct vfsmount *mnt) 187 { 188 struct proc_mounts *p = proc_mounts(m); 189 struct mount *r = real_mount(mnt); 190 struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt }; 191 struct super_block *sb = mnt_path.dentry->d_sb; 192 int err = 0; 193 194 /* device */ 195 if (sb->s_op->show_devname) { 196 seq_puts(m, "device "); 197 err = sb->s_op->show_devname(m, mnt_path.dentry); 198 } else { 199 if (r->mnt_devname) { 200 seq_puts(m, "device "); 201 mangle(m, r->mnt_devname); 202 } else 203 seq_puts(m, "no device"); 204 } 205 206 /* mount point */ 207 seq_puts(m, " mounted on "); 208 /* mountpoints outside of chroot jail will give SEQ_SKIP on this */ 209 err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\"); 210 if (err) 211 goto out; 212 seq_putc(m, ' '); 213 214 /* file system type */ 215 seq_puts(m, "with fstype "); 216 show_type(m, sb); 217 218 /* optional statistics */ 219 if (sb->s_op->show_stats) { 220 seq_putc(m, ' '); 221 if (!err) 222 err = sb->s_op->show_stats(m, mnt_path.dentry); 223 } 224 225 seq_putc(m, '\n'); 226 out: 227 return err; 228 } 229 230 static int mounts_open_common(struct inode *inode, struct file *file, 231 int (*show)(struct seq_file *, struct vfsmount *)) 232 { 233 struct task_struct *task = get_proc_task(inode); 234 struct nsproxy *nsp; 235 struct mnt_namespace *ns = NULL; 236 struct path root; 237 struct proc_mounts *p; 238 int ret = -EINVAL; 239 240 if (!task) 241 goto err; 242 243 task_lock(task); 244 nsp = task->nsproxy; 245 if (!nsp || !nsp->mnt_ns) { 246 task_unlock(task); 247 put_task_struct(task); 248 goto err; 249 } 250 ns = nsp->mnt_ns; 251 get_mnt_ns(ns); 252 if (!task->fs) { 253 task_unlock(task); 254 put_task_struct(task); 255 ret = -ENOENT; 256 goto err_put_ns; 257 } 258 get_fs_root(task->fs, &root); 259 task_unlock(task); 260 put_task_struct(task); 261 262 ret = -ENOMEM; 263 p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); 264 if (!p) 265 goto err_put_path; 266 267 file->private_data = &p->m; 268 ret = seq_open(file, &mounts_op); 269 if (ret) 270 goto err_free; 271 272 p->ns = ns; 273 p->root = root; 274 p->m.poll_event = ns->event; 275 p->show = show; 276 p->cached_event = ~0ULL; 277 278 return 0; 279 280 err_free: 281 kfree(p); 282 err_put_path: 283 path_put(&root); 284 err_put_ns: 285 put_mnt_ns(ns); 286 err: 287 return ret; 288 } 289 290 static int mounts_release(struct inode *inode, struct file *file) 291 { 292 struct proc_mounts *p = proc_mounts(file->private_data); 293 path_put(&p->root); 294 put_mnt_ns(p->ns); 295 return seq_release(inode, file); 296 } 297 298 static int mounts_open(struct inode *inode, struct file *file) 299 { 300 return mounts_open_common(inode, file, show_vfsmnt); 301 } 302 303 static int mountinfo_open(struct inode *inode, struct file *file) 304 { 305 return mounts_open_common(inode, file, show_mountinfo); 306 } 307 308 static int mountstats_open(struct inode *inode, struct file *file) 309 { 310 return mounts_open_common(inode, file, show_vfsstat); 311 } 312 313 const struct file_operations proc_mounts_operations = { 314 .open = mounts_open, 315 .read = seq_read, 316 .llseek = seq_lseek, 317 .release = mounts_release, 318 .poll = mounts_poll, 319 }; 320 321 const struct file_operations proc_mountinfo_operations = { 322 .open = mountinfo_open, 323 .read = seq_read, 324 .llseek = seq_lseek, 325 .release = mounts_release, 326 .poll = mounts_poll, 327 }; 328 329 const struct file_operations proc_mountstats_operations = { 330 .open = mountstats_open, 331 .read = seq_read, 332 .llseek = seq_lseek, 333 .release = mounts_release, 334 }; 335