377 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * linux/fs/proc/root.c4 *5 * Copyright (C) 1991, 1992 Linus Torvalds6 *7 * proc root directory handling functions8 */9#include <linux/errno.h>10#include <linux/time.h>11#include <linux/proc_fs.h>12#include <linux/stat.h>13#include <linux/init.h>14#include <linux/sched.h>15#include <linux/sched/stat.h>16#include <linux/module.h>17#include <linux/bitops.h>18#include <linux/user_namespace.h>19#include <linux/fs_context.h>20#include <linux/mount.h>21#include <linux/pid_namespace.h>22#include <linux/fs_parser.h>23#include <linux/cred.h>24#include <linux/magic.h>25#include <linux/slab.h>26 27#include "internal.h"28 29struct proc_fs_context {30 struct pid_namespace *pid_ns;31 unsigned int mask;32 enum proc_hidepid hidepid;33 int gid;34 enum proc_pidonly pidonly;35};36 37enum proc_param {38 Opt_gid,39 Opt_hidepid,40 Opt_subset,41};42 43static const struct fs_parameter_spec proc_fs_parameters[] = {44 fsparam_u32("gid", Opt_gid),45 fsparam_string("hidepid", Opt_hidepid),46 fsparam_string("subset", Opt_subset),47 {}48};49 50static inline int valid_hidepid(unsigned int value)51{52 return (value == HIDEPID_OFF ||53 value == HIDEPID_NO_ACCESS ||54 value == HIDEPID_INVISIBLE ||55 value == HIDEPID_NOT_PTRACEABLE);56}57 58static int proc_parse_hidepid_param(struct fs_context *fc, struct fs_parameter *param)59{60 struct proc_fs_context *ctx = fc->fs_private;61 struct fs_parameter_spec hidepid_u32_spec = fsparam_u32("hidepid", Opt_hidepid);62 struct fs_parse_result result;63 int base = (unsigned long)hidepid_u32_spec.data;64 65 if (param->type != fs_value_is_string)66 return invalf(fc, "proc: unexpected type of hidepid value\n");67 68 if (!kstrtouint(param->string, base, &result.uint_32)) {69 if (!valid_hidepid(result.uint_32))70 return invalf(fc, "proc: unknown value of hidepid - %s\n", param->string);71 ctx->hidepid = result.uint_32;72 return 0;73 }74 75 if (!strcmp(param->string, "off"))76 ctx->hidepid = HIDEPID_OFF;77 else if (!strcmp(param->string, "noaccess"))78 ctx->hidepid = HIDEPID_NO_ACCESS;79 else if (!strcmp(param->string, "invisible"))80 ctx->hidepid = HIDEPID_INVISIBLE;81 else if (!strcmp(param->string, "ptraceable"))82 ctx->hidepid = HIDEPID_NOT_PTRACEABLE;83 else84 return invalf(fc, "proc: unknown value of hidepid - %s\n", param->string);85 86 return 0;87}88 89static int proc_parse_subset_param(struct fs_context *fc, char *value)90{91 struct proc_fs_context *ctx = fc->fs_private;92 93 while (value) {94 char *ptr = strchr(value, ',');95 96 if (ptr != NULL)97 *ptr++ = '\0';98 99 if (*value != '\0') {100 if (!strcmp(value, "pid")) {101 ctx->pidonly = PROC_PIDONLY_ON;102 } else {103 return invalf(fc, "proc: unsupported subset option - %s\n", value);104 }105 }106 value = ptr;107 }108 109 return 0;110}111 112static int proc_parse_param(struct fs_context *fc, struct fs_parameter *param)113{114 struct proc_fs_context *ctx = fc->fs_private;115 struct fs_parse_result result;116 int opt;117 118 opt = fs_parse(fc, proc_fs_parameters, param, &result);119 if (opt < 0)120 return opt;121 122 switch (opt) {123 case Opt_gid:124 ctx->gid = result.uint_32;125 break;126 127 case Opt_hidepid:128 if (proc_parse_hidepid_param(fc, param))129 return -EINVAL;130 break;131 132 case Opt_subset:133 if (proc_parse_subset_param(fc, param->string) < 0)134 return -EINVAL;135 break;136 137 default:138 return -EINVAL;139 }140 141 ctx->mask |= 1 << opt;142 return 0;143}144 145static void proc_apply_options(struct proc_fs_info *fs_info,146 struct fs_context *fc,147 struct user_namespace *user_ns)148{149 struct proc_fs_context *ctx = fc->fs_private;150 151 if (ctx->mask & (1 << Opt_gid))152 fs_info->pid_gid = make_kgid(user_ns, ctx->gid);153 if (ctx->mask & (1 << Opt_hidepid))154 fs_info->hide_pid = ctx->hidepid;155 if (ctx->mask & (1 << Opt_subset))156 fs_info->pidonly = ctx->pidonly;157}158 159static int proc_fill_super(struct super_block *s, struct fs_context *fc)160{161 struct proc_fs_context *ctx = fc->fs_private;162 struct inode *root_inode;163 struct proc_fs_info *fs_info;164 int ret;165 166 fs_info = kzalloc(sizeof(*fs_info), GFP_KERNEL);167 if (!fs_info)168 return -ENOMEM;169 170 fs_info->pid_ns = get_pid_ns(ctx->pid_ns);171 proc_apply_options(fs_info, fc, current_user_ns());172 173 /* User space would break if executables or devices appear on proc */174 s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;175 s->s_flags |= SB_NODIRATIME | SB_NOSUID | SB_NOEXEC;176 s->s_blocksize = 1024;177 s->s_blocksize_bits = 10;178 s->s_magic = PROC_SUPER_MAGIC;179 s->s_op = &proc_sops;180 s->s_time_gran = 1;181 s->s_fs_info = fs_info;182 183 /*184 * procfs isn't actually a stacking filesystem; however, there is185 * too much magic going on inside it to permit stacking things on186 * top of it187 */188 s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;189 190 /* procfs dentries and inodes don't require IO to create */191 s->s_shrink->seeks = 0;192 193 pde_get(&proc_root);194 root_inode = proc_get_inode(s, &proc_root);195 if (!root_inode) {196 pr_err("proc_fill_super: get root inode failed\n");197 return -ENOMEM;198 }199 200 s->s_root = d_make_root(root_inode);201 if (!s->s_root) {202 pr_err("proc_fill_super: allocate dentry failed\n");203 return -ENOMEM;204 }205 206 ret = proc_setup_self(s);207 if (ret) {208 return ret;209 }210 return proc_setup_thread_self(s);211}212 213static int proc_reconfigure(struct fs_context *fc)214{215 struct super_block *sb = fc->root->d_sb;216 struct proc_fs_info *fs_info = proc_sb_info(sb);217 218 sync_filesystem(sb);219 220 proc_apply_options(fs_info, fc, current_user_ns());221 return 0;222}223 224static HWJS_SUSPENDS int proc_get_tree(struct fs_context *fc)225{226 return get_tree_nodev(fc, proc_fill_super);227}228 229static void proc_fs_context_free(struct fs_context *fc)230{231 struct proc_fs_context *ctx = fc->fs_private;232 233 put_pid_ns(ctx->pid_ns);234 kfree(ctx);235}236 237static const struct fs_context_operations proc_fs_context_ops = {238 .free = proc_fs_context_free,239 .parse_param = proc_parse_param,240 .get_tree = proc_get_tree,241 .reconfigure = proc_reconfigure,242};243 244static int proc_init_fs_context(struct fs_context *fc)245{246 struct proc_fs_context *ctx;247 248 ctx = kzalloc(sizeof(struct proc_fs_context), GFP_KERNEL);249 if (!ctx)250 return -ENOMEM;251 252 ctx->pid_ns = get_pid_ns(task_active_pid_ns(current));253 put_user_ns(fc->user_ns);254 fc->user_ns = get_user_ns(ctx->pid_ns->user_ns);255 fc->fs_private = ctx;256 fc->ops = &proc_fs_context_ops;257 return 0;258}259 260static HWJS_SUSPENDS void proc_kill_sb(struct super_block *sb)261{262 struct proc_fs_info *fs_info = proc_sb_info(sb);263 264 if (!fs_info) {265 kill_anon_super(sb);266 return;267 }268 269 dput(fs_info->proc_self);270 dput(fs_info->proc_thread_self);271 272 kill_anon_super(sb);273 put_pid_ns(fs_info->pid_ns);274 kfree_rcu(fs_info, rcu);275}276 277static struct file_system_type proc_fs_type = {278 .name = "proc",279 .init_fs_context = proc_init_fs_context,280 .parameters = proc_fs_parameters,281 .kill_sb = proc_kill_sb,282 .fs_flags = FS_USERNS_MOUNT | FS_DISALLOW_NOTIFY_PERM,283};284 285void __init proc_root_init(void)286{287 proc_init_kmemcache();288 set_proc_pid_nlink();289 proc_self_init();290 proc_thread_self_init();291 proc_symlink("mounts", NULL, "self/mounts");292 293 proc_net_init();294 proc_mkdir("fs", NULL);295 proc_mkdir("driver", NULL);296 proc_create_mount_point("fs/nfsd"); /* somewhere for the nfsd filesystem to be mounted */297#if defined(CONFIG_SUN_OPENPROMFS) || defined(CONFIG_SUN_OPENPROMFS_MODULE)298 /* just give it a mountpoint */299 proc_create_mount_point("openprom");300#endif301 proc_tty_init();302 proc_mkdir("bus", NULL);303 proc_sys_init();304 305 /*306 * Last things last. It is not like userspace processes eager307 * to open /proc files exist at this point but register last308 * anyway.309 */310 register_filesystem(&proc_fs_type);311}312 313static int proc_root_getattr(struct mnt_idmap *idmap,314 const struct path *path, struct kstat *stat,315 u32 request_mask, unsigned int query_flags)316{317 generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(path->dentry),318 stat);319 stat->nlink = proc_root.nlink + nr_processes();320 return 0;321}322 323static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, unsigned int flags)324{325 if (!proc_pid_lookup(dentry, flags))326 return NULL;327 328 return proc_lookup(dir, dentry, flags);329}330 331static HWJS_SUSPENDS int proc_root_readdir(struct file *file, struct dir_context *ctx)332{333 if (ctx->pos < FIRST_PROCESS_ENTRY) {334 int error = proc_readdir(file, ctx);335 if (unlikely(error <= 0))336 return error;337 ctx->pos = FIRST_PROCESS_ENTRY;338 }339 340 return proc_pid_readdir(file, ctx);341}342 343/*344 * The root /proc directory is special, as it has the345 * <pid> directories. Thus we don't use the generic346 * directory handling functions for that..347 */348static const struct file_operations proc_root_operations = {349 .read = generic_read_dir,350 .iterate_shared = proc_root_readdir,351 .llseek = generic_file_llseek,352};353 354/*355 * proc root can do almost nothing..356 */357static const struct inode_operations proc_root_inode_operations = {358 .lookup = proc_root_lookup,359 .getattr = proc_root_getattr,360};361 362/*363 * This is the root "inode" in the /proc tree..364 */365struct proc_dir_entry proc_root = {366 .low_ino = PROC_ROOT_INO, 367 .namelen = 5, 368 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 369 .nlink = 2, 370 .refcnt = REFCOUNT_INIT(1),371 .proc_iops = &proc_root_inode_operations, 372 .proc_dir_ops = &proc_root_operations,373 .parent = &proc_root,374 .subdir = RB_ROOT,375 .name = "/proc",376};377