1/* 2 * linux/fs/proc/inode.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7#include <linux/time.h> 8#include <linux/proc_fs.h> 9#include <linux/kernel.h> 10#include <linux/pid_namespace.h> 11#include <linux/mm.h> 12#include <linux/string.h> 13#include <linux/stat.h> 14#include <linux/completion.h> 15#include <linux/poll.h> 16#include <linux/printk.h> 17#include <linux/file.h> 18#include <linux/limits.h> 19#include <linux/init.h> 20#include <linux/module.h> 21#include <linux/sysctl.h> 22#include <linux/seq_file.h> 23#include <linux/slab.h> 24#include <linux/mount.h> 25#include <linux/magic.h> 26#include <linux/namei.h> 27 28#include <asm/uaccess.h> 29 30#include "internal.h" 31 32static void proc_evict_inode(struct inode *inode) 33{ 34 struct proc_dir_entry *de; 35 struct ctl_table_header *head; 36 37 truncate_inode_pages_final(&inode->i_data); 38 clear_inode(inode); 39 40 /* Stop tracking associated processes */ 41 put_pid(PROC_I(inode)->pid); 42 43 /* Let go of any associated proc directory entry */ 44 de = PDE(inode); 45 if (de) 46 pde_put(de); 47 head = PROC_I(inode)->sysctl; 48 if (head) { 49 RCU_INIT_POINTER(PROC_I(inode)->sysctl, NULL); 50 sysctl_head_put(head); 51 } 52} 53 54static struct kmem_cache * proc_inode_cachep; 55 56static struct inode *proc_alloc_inode(struct super_block *sb) 57{ 58 struct proc_inode *ei; 59 struct inode *inode; 60 61 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL); 62 if (!ei) 63 return NULL; 64 ei->pid = NULL; 65 ei->fd = 0; 66 ei->op.proc_get_link = NULL; 67 ei->pde = NULL; 68 ei->sysctl = NULL; 69 ei->sysctl_entry = NULL; 70 ei->ns_ops = NULL; 71 inode = &ei->vfs_inode; 72 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 73 return inode; 74} 75 76static void proc_i_callback(struct rcu_head *head) 77{ 78 struct inode *inode = container_of(head, struct inode, i_rcu); 79 kmem_cache_free(proc_inode_cachep, PROC_I(inode)); 80} 81 82static void proc_destroy_inode(struct inode *inode) 83{ 84 call_rcu(&inode->i_rcu, proc_i_callback); 85} 86 87static void init_once(void *foo) 88{ 89 struct proc_inode *ei = (struct proc_inode *) foo; 90 91 inode_init_once(&ei->vfs_inode); 92} 93 94void __init proc_init_inodecache(void) 95{ 96 proc_inode_cachep = kmem_cache_create("proc_inode_cache", 97 sizeof(struct proc_inode), 98 0, (SLAB_RECLAIM_ACCOUNT| 99 SLAB_MEM_SPREAD|SLAB_PANIC), 100 init_once); 101} 102 103static int proc_show_options(struct seq_file *seq, struct dentry *root) 104{ 105 struct super_block *sb = root->d_sb; 106 struct pid_namespace *pid = sb->s_fs_info; 107 108 if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID)) 109 seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid)); 110 if (pid->hide_pid != 0) 111 seq_printf(seq, ",hidepid=%u", pid->hide_pid); 112 113 return 0; 114} 115 116static const struct super_operations proc_sops = { 117 .alloc_inode = proc_alloc_inode, 118 .destroy_inode = proc_destroy_inode, 119 .drop_inode = generic_delete_inode, 120 .evict_inode = proc_evict_inode, 121 .statfs = simple_statfs, 122 .remount_fs = proc_remount, 123 .show_options = proc_show_options, 124}; 125 126enum {BIAS = -1U<<31}; 127 128static inline int use_pde(struct proc_dir_entry *pde) 129{ 130 return atomic_inc_unless_negative(&pde->in_use); 131} 132 133static void unuse_pde(struct proc_dir_entry *pde) 134{ 135 if (atomic_dec_return(&pde->in_use) == BIAS) 136 complete(pde->pde_unload_completion); 137} 138 139/* pde is locked */ 140static void close_pdeo(struct proc_dir_entry *pde, struct pde_opener *pdeo) 141{ 142 if (pdeo->closing) { 143 /* somebody else is doing that, just wait */ 144 DECLARE_COMPLETION_ONSTACK(c); 145 pdeo->c = &c; 146 spin_unlock(&pde->pde_unload_lock); 147 wait_for_completion(&c); 148 spin_lock(&pde->pde_unload_lock); 149 } else { 150 struct file *file; 151 pdeo->closing = 1; 152 spin_unlock(&pde->pde_unload_lock); 153 file = pdeo->file; 154 pde->proc_fops->release(file_inode(file), file); 155 spin_lock(&pde->pde_unload_lock); 156 list_del_init(&pdeo->lh); 157 if (pdeo->c) 158 complete(pdeo->c); 159 kfree(pdeo); 160 } 161} 162 163void proc_entry_rundown(struct proc_dir_entry *de) 164{ 165 DECLARE_COMPLETION_ONSTACK(c); 166 /* Wait until all existing callers into module are done. */ 167 de->pde_unload_completion = &c; 168 if (atomic_add_return(BIAS, &de->in_use) != BIAS) 169 wait_for_completion(&c); 170 171 spin_lock(&de->pde_unload_lock); 172 while (!list_empty(&de->pde_openers)) { 173 struct pde_opener *pdeo; 174 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh); 175 close_pdeo(de, pdeo); 176 } 177 spin_unlock(&de->pde_unload_lock); 178} 179 180static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence) 181{ 182 struct proc_dir_entry *pde = PDE(file_inode(file)); 183 loff_t rv = -EINVAL; 184 if (use_pde(pde)) { 185 loff_t (*llseek)(struct file *, loff_t, int); 186 llseek = pde->proc_fops->llseek; 187 if (!llseek) 188 llseek = default_llseek; 189 rv = llseek(file, offset, whence); 190 unuse_pde(pde); 191 } 192 return rv; 193} 194 195static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 196{ 197 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *); 198 struct proc_dir_entry *pde = PDE(file_inode(file)); 199 ssize_t rv = -EIO; 200 if (use_pde(pde)) { 201 read = pde->proc_fops->read; 202 if (read) 203 rv = read(file, buf, count, ppos); 204 unuse_pde(pde); 205 } 206 return rv; 207} 208 209static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 210{ 211 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *); 212 struct proc_dir_entry *pde = PDE(file_inode(file)); 213 ssize_t rv = -EIO; 214 if (use_pde(pde)) { 215 write = pde->proc_fops->write; 216 if (write) 217 rv = write(file, buf, count, ppos); 218 unuse_pde(pde); 219 } 220 return rv; 221} 222 223static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts) 224{ 225 struct proc_dir_entry *pde = PDE(file_inode(file)); 226 unsigned int rv = DEFAULT_POLLMASK; 227 unsigned int (*poll)(struct file *, struct poll_table_struct *); 228 if (use_pde(pde)) { 229 poll = pde->proc_fops->poll; 230 if (poll) 231 rv = poll(file, pts); 232 unuse_pde(pde); 233 } 234 return rv; 235} 236 237static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 238{ 239 struct proc_dir_entry *pde = PDE(file_inode(file)); 240 long rv = -ENOTTY; 241 long (*ioctl)(struct file *, unsigned int, unsigned long); 242 if (use_pde(pde)) { 243 ioctl = pde->proc_fops->unlocked_ioctl; 244 if (ioctl) 245 rv = ioctl(file, cmd, arg); 246 unuse_pde(pde); 247 } 248 return rv; 249} 250 251#ifdef CONFIG_COMPAT 252static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 253{ 254 struct proc_dir_entry *pde = PDE(file_inode(file)); 255 long rv = -ENOTTY; 256 long (*compat_ioctl)(struct file *, unsigned int, unsigned long); 257 if (use_pde(pde)) { 258 compat_ioctl = pde->proc_fops->compat_ioctl; 259 if (compat_ioctl) 260 rv = compat_ioctl(file, cmd, arg); 261 unuse_pde(pde); 262 } 263 return rv; 264} 265#endif 266 267static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma) 268{ 269 struct proc_dir_entry *pde = PDE(file_inode(file)); 270 int rv = -EIO; 271 int (*mmap)(struct file *, struct vm_area_struct *); 272 if (use_pde(pde)) { 273 mmap = pde->proc_fops->mmap; 274 if (mmap) 275 rv = mmap(file, vma); 276 unuse_pde(pde); 277 } 278 return rv; 279} 280 281static unsigned long 282proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr, 283 unsigned long len, unsigned long pgoff, 284 unsigned long flags) 285{ 286 struct proc_dir_entry *pde = PDE(file_inode(file)); 287 unsigned long rv = -EIO; 288 289 if (use_pde(pde)) { 290 typeof(proc_reg_get_unmapped_area) *get_area; 291 292 get_area = pde->proc_fops->get_unmapped_area; 293#ifdef CONFIG_MMU 294 if (!get_area) 295 get_area = current->mm->get_unmapped_area; 296#endif 297 298 if (get_area) 299 rv = get_area(file, orig_addr, len, pgoff, flags); 300 else 301 rv = orig_addr; 302 unuse_pde(pde); 303 } 304 return rv; 305} 306 307static int proc_reg_open(struct inode *inode, struct file *file) 308{ 309 struct proc_dir_entry *pde = PDE(inode); 310 int rv = 0; 311 int (*open)(struct inode *, struct file *); 312 int (*release)(struct inode *, struct file *); 313 struct pde_opener *pdeo; 314 315 /* 316 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry 317 * sequence. ->release won't be called because ->proc_fops will be 318 * cleared. Depending on complexity of ->release, consequences vary. 319 * 320 * We can't wait for mercy when close will be done for real, it's 321 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release 322 * by hand in remove_proc_entry(). For this, save opener's credentials 323 * for later. 324 */ 325 pdeo = kzalloc(sizeof(struct pde_opener), GFP_KERNEL); 326 if (!pdeo) 327 return -ENOMEM; 328 329 if (!use_pde(pde)) { 330 kfree(pdeo); 331 return -ENOENT; 332 } 333 open = pde->proc_fops->open; 334 release = pde->proc_fops->release; 335 336 if (open) 337 rv = open(inode, file); 338 339 if (rv == 0 && release) { 340 /* To know what to release. */ 341 pdeo->file = file; 342 /* Strictly for "too late" ->release in proc_reg_release(). */ 343 spin_lock(&pde->pde_unload_lock); 344 list_add(&pdeo->lh, &pde->pde_openers); 345 spin_unlock(&pde->pde_unload_lock); 346 } else 347 kfree(pdeo); 348 349 unuse_pde(pde); 350 return rv; 351} 352 353static int proc_reg_release(struct inode *inode, struct file *file) 354{ 355 struct proc_dir_entry *pde = PDE(inode); 356 struct pde_opener *pdeo; 357 spin_lock(&pde->pde_unload_lock); 358 list_for_each_entry(pdeo, &pde->pde_openers, lh) { 359 if (pdeo->file == file) { 360 close_pdeo(pde, pdeo); 361 break; 362 } 363 } 364 spin_unlock(&pde->pde_unload_lock); 365 return 0; 366} 367 368static const struct file_operations proc_reg_file_ops = { 369 .llseek = proc_reg_llseek, 370 .read = proc_reg_read, 371 .write = proc_reg_write, 372 .poll = proc_reg_poll, 373 .unlocked_ioctl = proc_reg_unlocked_ioctl, 374#ifdef CONFIG_COMPAT 375 .compat_ioctl = proc_reg_compat_ioctl, 376#endif 377 .mmap = proc_reg_mmap, 378 .get_unmapped_area = proc_reg_get_unmapped_area, 379 .open = proc_reg_open, 380 .release = proc_reg_release, 381}; 382 383#ifdef CONFIG_COMPAT 384static const struct file_operations proc_reg_file_ops_no_compat = { 385 .llseek = proc_reg_llseek, 386 .read = proc_reg_read, 387 .write = proc_reg_write, 388 .poll = proc_reg_poll, 389 .unlocked_ioctl = proc_reg_unlocked_ioctl, 390 .mmap = proc_reg_mmap, 391 .get_unmapped_area = proc_reg_get_unmapped_area, 392 .open = proc_reg_open, 393 .release = proc_reg_release, 394}; 395#endif 396 397static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd) 398{ 399 struct proc_dir_entry *pde = PDE(d_inode(dentry)); 400 if (unlikely(!use_pde(pde))) 401 return ERR_PTR(-EINVAL); 402 nd_set_link(nd, pde->data); 403 return pde; 404} 405 406static void proc_put_link(struct dentry *dentry, struct nameidata *nd, void *p) 407{ 408 unuse_pde(p); 409} 410 411const struct inode_operations proc_link_inode_operations = { 412 .readlink = generic_readlink, 413 .follow_link = proc_follow_link, 414 .put_link = proc_put_link, 415}; 416 417struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de) 418{ 419 struct inode *inode = new_inode_pseudo(sb); 420 421 if (inode) { 422 inode->i_ino = de->low_ino; 423 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 424 PROC_I(inode)->pde = de; 425 426 if (is_empty_pde(de)) { 427 make_empty_dir_inode(inode); 428 return inode; 429 } 430 if (de->mode) { 431 inode->i_mode = de->mode; 432 inode->i_uid = de->uid; 433 inode->i_gid = de->gid; 434 } 435 if (de->size) 436 inode->i_size = de->size; 437 if (de->nlink) 438 set_nlink(inode, de->nlink); 439 WARN_ON(!de->proc_iops); 440 inode->i_op = de->proc_iops; 441 if (de->proc_fops) { 442 if (S_ISREG(inode->i_mode)) { 443#ifdef CONFIG_COMPAT 444 if (!de->proc_fops->compat_ioctl) 445 inode->i_fop = 446 &proc_reg_file_ops_no_compat; 447 else 448#endif 449 inode->i_fop = &proc_reg_file_ops; 450 } else { 451 inode->i_fop = de->proc_fops; 452 } 453 } 454 } else 455 pde_put(de); 456 return inode; 457} 458 459int proc_fill_super(struct super_block *s) 460{ 461 struct inode *root_inode; 462 int ret; 463 464 s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC; 465 s->s_blocksize = 1024; 466 s->s_blocksize_bits = 10; 467 s->s_magic = PROC_SUPER_MAGIC; 468 s->s_op = &proc_sops; 469 s->s_time_gran = 1; 470 471 pde_get(&proc_root); 472 root_inode = proc_get_inode(s, &proc_root); 473 if (!root_inode) { 474 pr_err("proc_fill_super: get root inode failed\n"); 475 return -ENOMEM; 476 } 477 478 s->s_root = d_make_root(root_inode); 479 if (!s->s_root) { 480 pr_err("proc_fill_super: allocate dentry failed\n"); 481 return -ENOMEM; 482 } 483 484 ret = proc_setup_self(s); 485 if (ret) { 486 return ret; 487 } 488 return proc_setup_thread_self(s); 489} 490