fs/proc/root.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/proc/root.c
   4  *
   5  *  Copyright (C) 1991, 1992 Linus Torvalds
   6  *
   7  *  proc root directory handling functions
   8  */
   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
  29 struct 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
  37 enum proc_param {
  38         Opt_gid,
  39         Opt_hidepid,
  40         Opt_subset,
  41 };
  42
  43 static 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
  50 static 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
  58 static 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         else
  84                 return invalf(fc, "proc: unknown value of hidepid - %s\n", param->string);
  85
  86         return 0;
  87 }
  88
  89 static 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
 112 static 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
 145 static 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
 159 static 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 is
 185          * too much magic going on inside it to permit stacking things on
 186          * top of it
 187          */
 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
 213 static 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
 224 static int proc_get_tree(struct fs_context *fc)
 225 {
 226         return get_tree_nodev(fc, proc_fill_super);
 227 }
 228
 229 static 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
 237 static 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
 244 static 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
 260 static 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(fs_info);
 275 }
 276
 277 static 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
 285 void __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 #endif
 301         proc_tty_init();
 302         proc_mkdir("bus", NULL);
 303         proc_sys_init();
 304
 305         /*
 306          * Last things last. It is not like userspace processes eager
 307          * to open /proc files exist at this point but register last
 308          * anyway.
 309          */
 310         register_filesystem(&proc_fs_type);
 311 }
 312
 313 static int proc_root_getattr(struct user_namespace *mnt_userns,
 314                              const struct path *path, struct kstat *stat,
 315                              u32 request_mask, unsigned int query_flags)
 316 {
 317         generic_fillattr(&init_user_ns, d_inode(path->dentry), stat);
 318         stat->nlink = proc_root.nlink + nr_processes();
 319         return 0;
 320 }
 321
 322 static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, unsigned int flags)
 323 {
 324         if (!proc_pid_lookup(dentry, flags))
 325                 return NULL;
 326
 327         return proc_lookup(dir, dentry, flags);
 328 }
 329
 330 static int proc_root_readdir(struct file *file, struct dir_context *ctx)
 331 {
 332         if (ctx->pos < FIRST_PROCESS_ENTRY) {
 333                 int error = proc_readdir(file, ctx);
 334                 if (unlikely(error <= 0))
 335                         return error;
 336                 ctx->pos = FIRST_PROCESS_ENTRY;
 337         }
 338
 339         return proc_pid_readdir(file, ctx);
 340 }
 341
 342 /*
 343  * The root /proc directory is special, as it has the
 344  * <pid> directories. Thus we don't use the generic
 345  * directory handling functions for that..
 346  */
 347 static const struct file_operations proc_root_operations = {
 348         .read            = generic_read_dir,
 349         .iterate_shared  = proc_root_readdir,
 350         .llseek         = generic_file_llseek,
 351 };
 352
 353 /*
 354  * proc root can do almost nothing..
 355  */
 356 static const struct inode_operations proc_root_inode_operations = {
 357         .lookup         = proc_root_lookup,
 358         .getattr        = proc_root_getattr,
 359 };
 360
 361 /*
 362  * This is the root "inode" in the /proc tree..
 363  */
 364 struct proc_dir_entry proc_root = {
 365         .low_ino        = PROC_ROOT_INO,
 366         .namelen        = 5,
 367         .mode           = S_IFDIR | S_IRUGO | S_IXUGO,
 368         .nlink          = 2,
 369         .refcnt         = REFCOUNT_INIT(1),
 370         .proc_iops      = &proc_root_inode_operations,
 371         .proc_dir_ops   = &proc_root_operations,
 372         .parent         = &proc_root,
 373         .subdir         = RB_ROOT,
 374         .name           = "/proc",
 375 };