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 task_lock(task); 236 nsp = task->nsproxy; 237 if (!nsp || !nsp->mnt_ns) { 238 task_unlock(task); 239 put_task_struct(task); 240 goto err; 241 } 242 ns = nsp->mnt_ns; 243 get_mnt_ns(ns); 244 if (!task->fs) { 245 task_unlock(task); 246 put_task_struct(task); 247 ret = -ENOENT; 248 goto err_put_ns; 249 } 250 get_fs_root(task->fs, &root); 251 task_unlock(task); 252 put_task_struct(task); 253 254 ret = -ENOMEM; 255 p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); 256 if (!p) 257 goto err_put_path; 258 259 file->private_data = &p->m; 260 ret = seq_open(file, &mounts_op); 261 if (ret) 262 goto err_free; 263 264 p->ns = ns; 265 p->root = root; 266 p->m.poll_event = ns->event; 267 p->show = show; 268 p->cached_event = ~0ULL; 269 270 return 0; 271 272 err_free: 273 kfree(p); 274 err_put_path: 275 path_put(&root); 276 err_put_ns: 277 put_mnt_ns(ns); 278 err: 279 return ret; 280 } 281 282 static int mounts_release(struct inode *inode, struct file *file) 283 { 284 struct proc_mounts *p = proc_mounts(file->private_data); 285 path_put(&p->root); 286 put_mnt_ns(p->ns); 287 return seq_release(inode, file); 288 } 289 290 static int mounts_open(struct inode *inode, struct file *file) 291 { 292 return mounts_open_common(inode, file, show_vfsmnt); 293 } 294 295 static int mountinfo_open(struct inode *inode, struct file *file) 296 { 297 return mounts_open_common(inode, file, show_mountinfo); 298 } 299 300 static int mountstats_open(struct inode *inode, struct file *file) 301 { 302 return mounts_open_common(inode, file, show_vfsstat); 303 } 304 305 const struct file_operations proc_mounts_operations = { 306 .open = mounts_open, 307 .read = seq_read, 308 .llseek = seq_lseek, 309 .release = mounts_release, 310 .poll = mounts_poll, 311 }; 312 313 const struct file_operations proc_mountinfo_operations = { 314 .open = mountinfo_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_mountstats_operations = { 322 .open = mountstats_open, 323 .read = seq_read, 324 .llseek = seq_lseek, 325 .release = mounts_release, 326 }; 327