1 /* 2 * linux/fs/proc/root.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * proc root directory handling functions 7 */ 8 9 #include <asm/uaccess.h> 10 11 #include <linux/errno.h> 12 #include <linux/time.h> 13 #include <linux/proc_fs.h> 14 #include <linux/stat.h> 15 #include <linux/init.h> 16 #include <linux/sched.h> 17 #include <linux/module.h> 18 #include <linux/bitops.h> 19 #include <linux/mount.h> 20 #include <linux/pid_namespace.h> 21 #include <linux/parser.h> 22 23 #include "internal.h" 24 25 static int proc_test_super(struct super_block *sb, void *data) 26 { 27 return sb->s_fs_info == data; 28 } 29 30 static int proc_set_super(struct super_block *sb, void *data) 31 { 32 int err = set_anon_super(sb, NULL); 33 if (!err) { 34 struct pid_namespace *ns = (struct pid_namespace *)data; 35 sb->s_fs_info = get_pid_ns(ns); 36 } 37 return err; 38 } 39 40 enum { 41 Opt_gid, Opt_hidepid, Opt_err, 42 }; 43 44 static const match_table_t tokens = { 45 {Opt_hidepid, "hidepid=%u"}, 46 {Opt_gid, "gid=%u"}, 47 {Opt_err, NULL}, 48 }; 49 50 static int proc_parse_options(char *options, struct pid_namespace *pid) 51 { 52 char *p; 53 substring_t args[MAX_OPT_ARGS]; 54 int option; 55 56 if (!options) 57 return 1; 58 59 while ((p = strsep(&options, ",")) != NULL) { 60 int token; 61 if (!*p) 62 continue; 63 64 args[0].to = args[0].from = NULL; 65 token = match_token(p, tokens, args); 66 switch (token) { 67 case Opt_gid: 68 if (match_int(&args[0], &option)) 69 return 0; 70 pid->pid_gid = make_kgid(current_user_ns(), option); 71 break; 72 case Opt_hidepid: 73 if (match_int(&args[0], &option)) 74 return 0; 75 if (option < 0 || option > 2) { 76 pr_err("proc: hidepid value must be between 0 and 2.\n"); 77 return 0; 78 } 79 pid->hide_pid = option; 80 break; 81 default: 82 pr_err("proc: unrecognized mount option \"%s\" " 83 "or missing value\n", p); 84 return 0; 85 } 86 } 87 88 return 1; 89 } 90 91 int proc_remount(struct super_block *sb, int *flags, char *data) 92 { 93 struct pid_namespace *pid = sb->s_fs_info; 94 return !proc_parse_options(data, pid); 95 } 96 97 static struct dentry *proc_mount(struct file_system_type *fs_type, 98 int flags, const char *dev_name, void *data) 99 { 100 int err; 101 struct super_block *sb; 102 struct pid_namespace *ns; 103 char *options; 104 105 if (flags & MS_KERNMOUNT) { 106 ns = (struct pid_namespace *)data; 107 options = NULL; 108 } else { 109 ns = task_active_pid_ns(current); 110 options = data; 111 } 112 113 sb = sget(fs_type, proc_test_super, proc_set_super, flags, ns); 114 if (IS_ERR(sb)) 115 return ERR_CAST(sb); 116 117 if (!proc_parse_options(options, ns)) { 118 deactivate_locked_super(sb); 119 return ERR_PTR(-EINVAL); 120 } 121 122 if (!sb->s_root) { 123 err = proc_fill_super(sb); 124 if (err) { 125 deactivate_locked_super(sb); 126 return ERR_PTR(err); 127 } 128 129 sb->s_flags |= MS_ACTIVE; 130 } 131 132 return dget(sb->s_root); 133 } 134 135 static void proc_kill_sb(struct super_block *sb) 136 { 137 struct pid_namespace *ns; 138 139 ns = (struct pid_namespace *)sb->s_fs_info; 140 kill_anon_super(sb); 141 put_pid_ns(ns); 142 } 143 144 static struct file_system_type proc_fs_type = { 145 .name = "proc", 146 .mount = proc_mount, 147 .kill_sb = proc_kill_sb, 148 .fs_flags = FS_USERNS_MOUNT, 149 }; 150 151 void __init proc_root_init(void) 152 { 153 int err; 154 155 proc_init_inodecache(); 156 err = register_filesystem(&proc_fs_type); 157 if (err) 158 return; 159 160 proc_self_init(); 161 proc_symlink("mounts", NULL, "self/mounts"); 162 163 proc_net_init(); 164 165 #ifdef CONFIG_SYSVIPC 166 proc_mkdir("sysvipc", NULL); 167 #endif 168 proc_mkdir("fs", NULL); 169 proc_mkdir("driver", NULL); 170 proc_mkdir("fs/nfsd", NULL); /* somewhere for the nfsd filesystem to be mounted */ 171 #if defined(CONFIG_SUN_OPENPROMFS) || defined(CONFIG_SUN_OPENPROMFS_MODULE) 172 /* just give it a mountpoint */ 173 proc_mkdir("openprom", NULL); 174 #endif 175 proc_tty_init(); 176 #ifdef CONFIG_PROC_DEVICETREE 177 proc_device_tree_init(); 178 #endif 179 proc_mkdir("bus", NULL); 180 proc_sys_init(); 181 } 182 183 static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat 184 ) 185 { 186 generic_fillattr(dentry->d_inode, stat); 187 stat->nlink = proc_root.nlink + nr_processes(); 188 return 0; 189 } 190 191 static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, unsigned int flags) 192 { 193 if (!proc_lookup(dir, dentry, flags)) 194 return NULL; 195 196 return proc_pid_lookup(dir, dentry, flags); 197 } 198 199 static int proc_root_readdir(struct file * filp, 200 void * dirent, filldir_t filldir) 201 { 202 unsigned int nr = filp->f_pos; 203 int ret; 204 205 if (nr < FIRST_PROCESS_ENTRY) { 206 int error = proc_readdir(filp, dirent, filldir); 207 if (error <= 0) 208 return error; 209 filp->f_pos = FIRST_PROCESS_ENTRY; 210 } 211 212 ret = proc_pid_readdir(filp, dirent, filldir); 213 return ret; 214 } 215 216 /* 217 * The root /proc directory is special, as it has the 218 * <pid> directories. Thus we don't use the generic 219 * directory handling functions for that.. 220 */ 221 static const struct file_operations proc_root_operations = { 222 .read = generic_read_dir, 223 .readdir = proc_root_readdir, 224 .llseek = default_llseek, 225 }; 226 227 /* 228 * proc root can do almost nothing.. 229 */ 230 static const struct inode_operations proc_root_inode_operations = { 231 .lookup = proc_root_lookup, 232 .getattr = proc_root_getattr, 233 }; 234 235 /* 236 * This is the root "inode" in the /proc tree.. 237 */ 238 struct proc_dir_entry proc_root = { 239 .low_ino = PROC_ROOT_INO, 240 .namelen = 5, 241 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 242 .nlink = 2, 243 .count = ATOMIC_INIT(1), 244 .proc_iops = &proc_root_inode_operations, 245 .proc_fops = &proc_root_operations, 246 .parent = &proc_root, 247 .name = "/proc", 248 }; 249 250 int pid_ns_prepare_proc(struct pid_namespace *ns) 251 { 252 struct vfsmount *mnt; 253 254 mnt = kern_mount_data(&proc_fs_type, ns); 255 if (IS_ERR(mnt)) 256 return PTR_ERR(mnt); 257 258 ns->proc_mnt = mnt; 259 return 0; 260 } 261 262 void pid_ns_release_proc(struct pid_namespace *ns) 263 { 264 kern_unmount(ns->proc_mnt); 265 } 266