1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/proc/inode.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 */ 7 8 #include <linux/cache.h> 9 #include <linux/time.h> 10 #include <linux/proc_fs.h> 11 #include <linux/kernel.h> 12 #include <linux/pid_namespace.h> 13 #include <linux/mm.h> 14 #include <linux/string.h> 15 #include <linux/stat.h> 16 #include <linux/completion.h> 17 #include <linux/poll.h> 18 #include <linux/printk.h> 19 #include <linux/file.h> 20 #include <linux/limits.h> 21 #include <linux/init.h> 22 #include <linux/module.h> 23 #include <linux/sysctl.h> 24 #include <linux/seq_file.h> 25 #include <linux/slab.h> 26 #include <linux/mount.h> 27 28 #include <linux/uaccess.h> 29 30 #include "internal.h" 31 32 static void proc_evict_inode(struct inode *inode) 33 { 34 struct proc_dir_entry *de; 35 struct ctl_table_header *head; 36 struct proc_inode *ei = PROC_I(inode); 37 38 truncate_inode_pages_final(&inode->i_data); 39 clear_inode(inode); 40 41 /* Stop tracking associated processes */ 42 if (ei->pid) { 43 proc_pid_evict_inode(ei); 44 ei->pid = NULL; 45 } 46 47 /* Let go of any associated proc directory entry */ 48 de = ei->pde; 49 if (de) { 50 pde_put(de); 51 ei->pde = NULL; 52 } 53 54 head = ei->sysctl; 55 if (head) { 56 RCU_INIT_POINTER(ei->sysctl, NULL); 57 proc_sys_evict_inode(inode, head); 58 } 59 } 60 61 static struct kmem_cache *proc_inode_cachep __ro_after_init; 62 static struct kmem_cache *pde_opener_cache __ro_after_init; 63 64 static struct inode *proc_alloc_inode(struct super_block *sb) 65 { 66 struct proc_inode *ei; 67 68 ei = kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL); 69 if (!ei) 70 return NULL; 71 ei->pid = NULL; 72 ei->fd = 0; 73 ei->op.proc_get_link = NULL; 74 ei->pde = NULL; 75 ei->sysctl = NULL; 76 ei->sysctl_entry = NULL; 77 INIT_HLIST_NODE(&ei->sibling_inodes); 78 ei->ns_ops = NULL; 79 return &ei->vfs_inode; 80 } 81 82 static void proc_free_inode(struct inode *inode) 83 { 84 kmem_cache_free(proc_inode_cachep, PROC_I(inode)); 85 } 86 87 static 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 94 void __init proc_init_kmemcache(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_ACCOUNT| 100 SLAB_PANIC), 101 init_once); 102 pde_opener_cache = 103 kmem_cache_create("pde_opener", sizeof(struct pde_opener), 0, 104 SLAB_ACCOUNT|SLAB_PANIC, NULL); 105 proc_dir_entry_cache = kmem_cache_create_usercopy( 106 "proc_dir_entry", SIZEOF_PDE, 0, SLAB_PANIC, 107 offsetof(struct proc_dir_entry, inline_name), 108 SIZEOF_PDE_INLINE_NAME, NULL); 109 BUILD_BUG_ON(sizeof(struct proc_dir_entry) >= SIZEOF_PDE); 110 } 111 112 void proc_invalidate_siblings_dcache(struct hlist_head *inodes, spinlock_t *lock) 113 { 114 struct inode *inode; 115 struct proc_inode *ei; 116 struct hlist_node *node; 117 struct super_block *old_sb = NULL; 118 119 rcu_read_lock(); 120 for (;;) { 121 struct super_block *sb; 122 node = hlist_first_rcu(inodes); 123 if (!node) 124 break; 125 ei = hlist_entry(node, struct proc_inode, sibling_inodes); 126 spin_lock(lock); 127 hlist_del_init_rcu(&ei->sibling_inodes); 128 spin_unlock(lock); 129 130 inode = &ei->vfs_inode; 131 sb = inode->i_sb; 132 if ((sb != old_sb) && !atomic_inc_not_zero(&sb->s_active)) 133 continue; 134 inode = igrab(inode); 135 rcu_read_unlock(); 136 if (sb != old_sb) { 137 if (old_sb) 138 deactivate_super(old_sb); 139 old_sb = sb; 140 } 141 if (unlikely(!inode)) { 142 rcu_read_lock(); 143 continue; 144 } 145 146 if (S_ISDIR(inode->i_mode)) { 147 struct dentry *dir = d_find_any_alias(inode); 148 if (dir) { 149 d_invalidate(dir); 150 dput(dir); 151 } 152 } else { 153 struct dentry *dentry; 154 while ((dentry = d_find_alias(inode))) { 155 d_invalidate(dentry); 156 dput(dentry); 157 } 158 } 159 iput(inode); 160 161 rcu_read_lock(); 162 } 163 rcu_read_unlock(); 164 if (old_sb) 165 deactivate_super(old_sb); 166 } 167 168 static int proc_show_options(struct seq_file *seq, struct dentry *root) 169 { 170 struct super_block *sb = root->d_sb; 171 struct pid_namespace *pid = sb->s_fs_info; 172 173 if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID)) 174 seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid)); 175 if (pid->hide_pid != HIDEPID_OFF) 176 seq_printf(seq, ",hidepid=%u", pid->hide_pid); 177 178 return 0; 179 } 180 181 const struct super_operations proc_sops = { 182 .alloc_inode = proc_alloc_inode, 183 .free_inode = proc_free_inode, 184 .drop_inode = generic_delete_inode, 185 .evict_inode = proc_evict_inode, 186 .statfs = simple_statfs, 187 .show_options = proc_show_options, 188 }; 189 190 enum {BIAS = -1U<<31}; 191 192 static inline int use_pde(struct proc_dir_entry *pde) 193 { 194 return likely(atomic_inc_unless_negative(&pde->in_use)); 195 } 196 197 static void unuse_pde(struct proc_dir_entry *pde) 198 { 199 if (unlikely(atomic_dec_return(&pde->in_use) == BIAS)) 200 complete(pde->pde_unload_completion); 201 } 202 203 /* pde is locked on entry, unlocked on exit */ 204 static void close_pdeo(struct proc_dir_entry *pde, struct pde_opener *pdeo) 205 __releases(&pde->pde_unload_lock) 206 { 207 /* 208 * close() (proc_reg_release()) can't delete an entry and proceed: 209 * ->release hook needs to be available at the right moment. 210 * 211 * rmmod (remove_proc_entry() et al) can't delete an entry and proceed: 212 * "struct file" needs to be available at the right moment. 213 * 214 * Therefore, first process to enter this function does ->release() and 215 * signals its completion to the other process which does nothing. 216 */ 217 if (pdeo->closing) { 218 /* somebody else is doing that, just wait */ 219 DECLARE_COMPLETION_ONSTACK(c); 220 pdeo->c = &c; 221 spin_unlock(&pde->pde_unload_lock); 222 wait_for_completion(&c); 223 } else { 224 struct file *file; 225 struct completion *c; 226 227 pdeo->closing = true; 228 spin_unlock(&pde->pde_unload_lock); 229 file = pdeo->file; 230 pde->proc_ops->proc_release(file_inode(file), file); 231 spin_lock(&pde->pde_unload_lock); 232 /* After ->release. */ 233 list_del(&pdeo->lh); 234 c = pdeo->c; 235 spin_unlock(&pde->pde_unload_lock); 236 if (unlikely(c)) 237 complete(c); 238 kmem_cache_free(pde_opener_cache, pdeo); 239 } 240 } 241 242 void proc_entry_rundown(struct proc_dir_entry *de) 243 { 244 DECLARE_COMPLETION_ONSTACK(c); 245 /* Wait until all existing callers into module are done. */ 246 de->pde_unload_completion = &c; 247 if (atomic_add_return(BIAS, &de->in_use) != BIAS) 248 wait_for_completion(&c); 249 250 /* ->pde_openers list can't grow from now on. */ 251 252 spin_lock(&de->pde_unload_lock); 253 while (!list_empty(&de->pde_openers)) { 254 struct pde_opener *pdeo; 255 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh); 256 close_pdeo(de, pdeo); 257 spin_lock(&de->pde_unload_lock); 258 } 259 spin_unlock(&de->pde_unload_lock); 260 } 261 262 static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence) 263 { 264 struct proc_dir_entry *pde = PDE(file_inode(file)); 265 loff_t rv = -EINVAL; 266 if (use_pde(pde)) { 267 typeof_member(struct proc_ops, proc_lseek) lseek; 268 269 lseek = pde->proc_ops->proc_lseek; 270 if (!lseek) 271 lseek = default_llseek; 272 rv = lseek(file, offset, whence); 273 unuse_pde(pde); 274 } 275 return rv; 276 } 277 278 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 279 { 280 struct proc_dir_entry *pde = PDE(file_inode(file)); 281 ssize_t rv = -EIO; 282 if (use_pde(pde)) { 283 typeof_member(struct proc_ops, proc_read) read; 284 285 read = pde->proc_ops->proc_read; 286 if (read) 287 rv = read(file, buf, count, ppos); 288 unuse_pde(pde); 289 } 290 return rv; 291 } 292 293 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 294 { 295 struct proc_dir_entry *pde = PDE(file_inode(file)); 296 ssize_t rv = -EIO; 297 if (use_pde(pde)) { 298 typeof_member(struct proc_ops, proc_write) write; 299 300 write = pde->proc_ops->proc_write; 301 if (write) 302 rv = write(file, buf, count, ppos); 303 unuse_pde(pde); 304 } 305 return rv; 306 } 307 308 static __poll_t proc_reg_poll(struct file *file, struct poll_table_struct *pts) 309 { 310 struct proc_dir_entry *pde = PDE(file_inode(file)); 311 __poll_t rv = DEFAULT_POLLMASK; 312 if (use_pde(pde)) { 313 typeof_member(struct proc_ops, proc_poll) poll; 314 315 poll = pde->proc_ops->proc_poll; 316 if (poll) 317 rv = poll(file, pts); 318 unuse_pde(pde); 319 } 320 return rv; 321 } 322 323 static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 324 { 325 struct proc_dir_entry *pde = PDE(file_inode(file)); 326 long rv = -ENOTTY; 327 if (use_pde(pde)) { 328 typeof_member(struct proc_ops, proc_ioctl) ioctl; 329 330 ioctl = pde->proc_ops->proc_ioctl; 331 if (ioctl) 332 rv = ioctl(file, cmd, arg); 333 unuse_pde(pde); 334 } 335 return rv; 336 } 337 338 #ifdef CONFIG_COMPAT 339 static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 340 { 341 struct proc_dir_entry *pde = PDE(file_inode(file)); 342 long rv = -ENOTTY; 343 if (use_pde(pde)) { 344 typeof_member(struct proc_ops, proc_compat_ioctl) compat_ioctl; 345 346 compat_ioctl = pde->proc_ops->proc_compat_ioctl; 347 if (compat_ioctl) 348 rv = compat_ioctl(file, cmd, arg); 349 unuse_pde(pde); 350 } 351 return rv; 352 } 353 #endif 354 355 static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma) 356 { 357 struct proc_dir_entry *pde = PDE(file_inode(file)); 358 int rv = -EIO; 359 if (use_pde(pde)) { 360 typeof_member(struct proc_ops, proc_mmap) mmap; 361 362 mmap = pde->proc_ops->proc_mmap; 363 if (mmap) 364 rv = mmap(file, vma); 365 unuse_pde(pde); 366 } 367 return rv; 368 } 369 370 static unsigned long 371 proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr, 372 unsigned long len, unsigned long pgoff, 373 unsigned long flags) 374 { 375 struct proc_dir_entry *pde = PDE(file_inode(file)); 376 unsigned long rv = -EIO; 377 378 if (use_pde(pde)) { 379 typeof_member(struct proc_ops, proc_get_unmapped_area) get_area; 380 381 get_area = pde->proc_ops->proc_get_unmapped_area; 382 #ifdef CONFIG_MMU 383 if (!get_area) 384 get_area = current->mm->get_unmapped_area; 385 #endif 386 387 if (get_area) 388 rv = get_area(file, orig_addr, len, pgoff, flags); 389 else 390 rv = orig_addr; 391 unuse_pde(pde); 392 } 393 return rv; 394 } 395 396 static int proc_reg_open(struct inode *inode, struct file *file) 397 { 398 struct proc_dir_entry *pde = PDE(inode); 399 int rv = 0; 400 typeof_member(struct proc_ops, proc_open) open; 401 typeof_member(struct proc_ops, proc_release) release; 402 struct pde_opener *pdeo; 403 404 /* 405 * Ensure that 406 * 1) PDE's ->release hook will be called no matter what 407 * either normally by close()/->release, or forcefully by 408 * rmmod/remove_proc_entry. 409 * 410 * 2) rmmod isn't blocked by opening file in /proc and sitting on 411 * the descriptor (including "rmmod foo </proc/foo" scenario). 412 * 413 * Save every "struct file" with custom ->release hook. 414 */ 415 if (!use_pde(pde)) 416 return -ENOENT; 417 418 release = pde->proc_ops->proc_release; 419 if (release) { 420 pdeo = kmem_cache_alloc(pde_opener_cache, GFP_KERNEL); 421 if (!pdeo) { 422 rv = -ENOMEM; 423 goto out_unuse; 424 } 425 } 426 427 open = pde->proc_ops->proc_open; 428 if (open) 429 rv = open(inode, file); 430 431 if (release) { 432 if (rv == 0) { 433 /* To know what to release. */ 434 pdeo->file = file; 435 pdeo->closing = false; 436 pdeo->c = NULL; 437 spin_lock(&pde->pde_unload_lock); 438 list_add(&pdeo->lh, &pde->pde_openers); 439 spin_unlock(&pde->pde_unload_lock); 440 } else 441 kmem_cache_free(pde_opener_cache, pdeo); 442 } 443 444 out_unuse: 445 unuse_pde(pde); 446 return rv; 447 } 448 449 static int proc_reg_release(struct inode *inode, struct file *file) 450 { 451 struct proc_dir_entry *pde = PDE(inode); 452 struct pde_opener *pdeo; 453 spin_lock(&pde->pde_unload_lock); 454 list_for_each_entry(pdeo, &pde->pde_openers, lh) { 455 if (pdeo->file == file) { 456 close_pdeo(pde, pdeo); 457 return 0; 458 } 459 } 460 spin_unlock(&pde->pde_unload_lock); 461 return 0; 462 } 463 464 static const struct file_operations proc_reg_file_ops = { 465 .llseek = proc_reg_llseek, 466 .read = proc_reg_read, 467 .write = proc_reg_write, 468 .poll = proc_reg_poll, 469 .unlocked_ioctl = proc_reg_unlocked_ioctl, 470 #ifdef CONFIG_COMPAT 471 .compat_ioctl = proc_reg_compat_ioctl, 472 #endif 473 .mmap = proc_reg_mmap, 474 .get_unmapped_area = proc_reg_get_unmapped_area, 475 .open = proc_reg_open, 476 .release = proc_reg_release, 477 }; 478 479 #ifdef CONFIG_COMPAT 480 static const struct file_operations proc_reg_file_ops_no_compat = { 481 .llseek = proc_reg_llseek, 482 .read = proc_reg_read, 483 .write = proc_reg_write, 484 .poll = proc_reg_poll, 485 .unlocked_ioctl = proc_reg_unlocked_ioctl, 486 .mmap = proc_reg_mmap, 487 .get_unmapped_area = proc_reg_get_unmapped_area, 488 .open = proc_reg_open, 489 .release = proc_reg_release, 490 }; 491 #endif 492 493 static void proc_put_link(void *p) 494 { 495 unuse_pde(p); 496 } 497 498 static const char *proc_get_link(struct dentry *dentry, 499 struct inode *inode, 500 struct delayed_call *done) 501 { 502 struct proc_dir_entry *pde = PDE(inode); 503 if (!use_pde(pde)) 504 return ERR_PTR(-EINVAL); 505 set_delayed_call(done, proc_put_link, pde); 506 return pde->data; 507 } 508 509 const struct inode_operations proc_link_inode_operations = { 510 .get_link = proc_get_link, 511 }; 512 513 struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de) 514 { 515 struct inode *inode = new_inode_pseudo(sb); 516 517 if (inode) { 518 inode->i_ino = de->low_ino; 519 inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); 520 PROC_I(inode)->pde = de; 521 522 if (is_empty_pde(de)) { 523 make_empty_dir_inode(inode); 524 return inode; 525 } 526 if (de->mode) { 527 inode->i_mode = de->mode; 528 inode->i_uid = de->uid; 529 inode->i_gid = de->gid; 530 } 531 if (de->size) 532 inode->i_size = de->size; 533 if (de->nlink) 534 set_nlink(inode, de->nlink); 535 536 if (S_ISREG(inode->i_mode)) { 537 inode->i_op = de->proc_iops; 538 inode->i_fop = &proc_reg_file_ops; 539 #ifdef CONFIG_COMPAT 540 if (!de->proc_ops->proc_compat_ioctl) { 541 inode->i_fop = &proc_reg_file_ops_no_compat; 542 } 543 #endif 544 } else if (S_ISDIR(inode->i_mode)) { 545 inode->i_op = de->proc_iops; 546 inode->i_fop = de->proc_dir_ops; 547 } else if (S_ISLNK(inode->i_mode)) { 548 inode->i_op = de->proc_iops; 549 inode->i_fop = NULL; 550 } else 551 BUG(); 552 } else 553 pde_put(de); 554 return inode; 555 } 556