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/mm.h> 11 #include <linux/string.h> 12 #include <linux/stat.h> 13 #include <linux/completion.h> 14 #include <linux/poll.h> 15 #include <linux/file.h> 16 #include <linux/limits.h> 17 #include <linux/init.h> 18 #include <linux/module.h> 19 #include <linux/smp_lock.h> 20 #include <linux/sysctl.h> 21 22 #include <asm/system.h> 23 #include <asm/uaccess.h> 24 25 #include "internal.h" 26 27 struct proc_dir_entry *de_get(struct proc_dir_entry *de) 28 { 29 atomic_inc(&de->count); 30 return de; 31 } 32 33 /* 34 * Decrements the use count and checks for deferred deletion. 35 */ 36 void de_put(struct proc_dir_entry *de) 37 { 38 if (!atomic_read(&de->count)) { 39 printk("de_put: entry %s already free!\n", de->name); 40 return; 41 } 42 43 if (atomic_dec_and_test(&de->count)) 44 free_proc_entry(de); 45 } 46 47 /* 48 * Decrement the use count of the proc_dir_entry. 49 */ 50 static void proc_delete_inode(struct inode *inode) 51 { 52 struct proc_dir_entry *de; 53 54 truncate_inode_pages(&inode->i_data, 0); 55 56 /* Stop tracking associated processes */ 57 put_pid(PROC_I(inode)->pid); 58 59 /* Let go of any associated proc directory entry */ 60 de = PROC_I(inode)->pde; 61 if (de) { 62 if (de->owner) 63 module_put(de->owner); 64 de_put(de); 65 } 66 if (PROC_I(inode)->sysctl) 67 sysctl_head_put(PROC_I(inode)->sysctl); 68 clear_inode(inode); 69 } 70 71 struct vfsmount *proc_mnt; 72 73 static struct kmem_cache * proc_inode_cachep; 74 75 static struct inode *proc_alloc_inode(struct super_block *sb) 76 { 77 struct proc_inode *ei; 78 struct inode *inode; 79 80 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL); 81 if (!ei) 82 return NULL; 83 ei->pid = NULL; 84 ei->fd = 0; 85 ei->op.proc_get_link = NULL; 86 ei->pde = NULL; 87 ei->sysctl = NULL; 88 ei->sysctl_entry = NULL; 89 inode = &ei->vfs_inode; 90 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 91 return inode; 92 } 93 94 static void proc_destroy_inode(struct inode *inode) 95 { 96 kmem_cache_free(proc_inode_cachep, PROC_I(inode)); 97 } 98 99 static void init_once(void *foo) 100 { 101 struct proc_inode *ei = (struct proc_inode *) foo; 102 103 inode_init_once(&ei->vfs_inode); 104 } 105 106 void __init proc_init_inodecache(void) 107 { 108 proc_inode_cachep = kmem_cache_create("proc_inode_cache", 109 sizeof(struct proc_inode), 110 0, (SLAB_RECLAIM_ACCOUNT| 111 SLAB_MEM_SPREAD|SLAB_PANIC), 112 init_once); 113 } 114 115 static const struct super_operations proc_sops = { 116 .alloc_inode = proc_alloc_inode, 117 .destroy_inode = proc_destroy_inode, 118 .drop_inode = generic_delete_inode, 119 .delete_inode = proc_delete_inode, 120 .statfs = simple_statfs, 121 }; 122 123 static void __pde_users_dec(struct proc_dir_entry *pde) 124 { 125 pde->pde_users--; 126 if (pde->pde_unload_completion && pde->pde_users == 0) 127 complete(pde->pde_unload_completion); 128 } 129 130 static void pde_users_dec(struct proc_dir_entry *pde) 131 { 132 spin_lock(&pde->pde_unload_lock); 133 __pde_users_dec(pde); 134 spin_unlock(&pde->pde_unload_lock); 135 } 136 137 static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence) 138 { 139 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 140 loff_t rv = -EINVAL; 141 loff_t (*llseek)(struct file *, loff_t, int); 142 143 spin_lock(&pde->pde_unload_lock); 144 /* 145 * remove_proc_entry() is going to delete PDE (as part of module 146 * cleanup sequence). No new callers into module allowed. 147 */ 148 if (!pde->proc_fops) { 149 spin_unlock(&pde->pde_unload_lock); 150 return rv; 151 } 152 /* 153 * Bump refcount so that remove_proc_entry will wail for ->llseek to 154 * complete. 155 */ 156 pde->pde_users++; 157 /* 158 * Save function pointer under lock, to protect against ->proc_fops 159 * NULL'ifying right after ->pde_unload_lock is dropped. 160 */ 161 llseek = pde->proc_fops->llseek; 162 spin_unlock(&pde->pde_unload_lock); 163 164 if (!llseek) 165 llseek = default_llseek; 166 rv = llseek(file, offset, whence); 167 168 pde_users_dec(pde); 169 return rv; 170 } 171 172 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 173 { 174 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 175 ssize_t rv = -EIO; 176 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *); 177 178 spin_lock(&pde->pde_unload_lock); 179 if (!pde->proc_fops) { 180 spin_unlock(&pde->pde_unload_lock); 181 return rv; 182 } 183 pde->pde_users++; 184 read = pde->proc_fops->read; 185 spin_unlock(&pde->pde_unload_lock); 186 187 if (read) 188 rv = read(file, buf, count, ppos); 189 190 pde_users_dec(pde); 191 return rv; 192 } 193 194 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 195 { 196 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 197 ssize_t rv = -EIO; 198 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *); 199 200 spin_lock(&pde->pde_unload_lock); 201 if (!pde->proc_fops) { 202 spin_unlock(&pde->pde_unload_lock); 203 return rv; 204 } 205 pde->pde_users++; 206 write = pde->proc_fops->write; 207 spin_unlock(&pde->pde_unload_lock); 208 209 if (write) 210 rv = write(file, buf, count, ppos); 211 212 pde_users_dec(pde); 213 return rv; 214 } 215 216 static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts) 217 { 218 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 219 unsigned int rv = DEFAULT_POLLMASK; 220 unsigned int (*poll)(struct file *, struct poll_table_struct *); 221 222 spin_lock(&pde->pde_unload_lock); 223 if (!pde->proc_fops) { 224 spin_unlock(&pde->pde_unload_lock); 225 return rv; 226 } 227 pde->pde_users++; 228 poll = pde->proc_fops->poll; 229 spin_unlock(&pde->pde_unload_lock); 230 231 if (poll) 232 rv = poll(file, pts); 233 234 pde_users_dec(pde); 235 return rv; 236 } 237 238 static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 239 { 240 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 241 long rv = -ENOTTY; 242 long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long); 243 int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long); 244 245 spin_lock(&pde->pde_unload_lock); 246 if (!pde->proc_fops) { 247 spin_unlock(&pde->pde_unload_lock); 248 return rv; 249 } 250 pde->pde_users++; 251 unlocked_ioctl = pde->proc_fops->unlocked_ioctl; 252 ioctl = pde->proc_fops->ioctl; 253 spin_unlock(&pde->pde_unload_lock); 254 255 if (unlocked_ioctl) { 256 rv = unlocked_ioctl(file, cmd, arg); 257 if (rv == -ENOIOCTLCMD) 258 rv = -EINVAL; 259 } else if (ioctl) { 260 lock_kernel(); 261 rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg); 262 unlock_kernel(); 263 } 264 265 pde_users_dec(pde); 266 return rv; 267 } 268 269 #ifdef CONFIG_COMPAT 270 static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 271 { 272 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 273 long rv = -ENOTTY; 274 long (*compat_ioctl)(struct file *, unsigned int, unsigned long); 275 276 spin_lock(&pde->pde_unload_lock); 277 if (!pde->proc_fops) { 278 spin_unlock(&pde->pde_unload_lock); 279 return rv; 280 } 281 pde->pde_users++; 282 compat_ioctl = pde->proc_fops->compat_ioctl; 283 spin_unlock(&pde->pde_unload_lock); 284 285 if (compat_ioctl) 286 rv = compat_ioctl(file, cmd, arg); 287 288 pde_users_dec(pde); 289 return rv; 290 } 291 #endif 292 293 static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma) 294 { 295 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 296 int rv = -EIO; 297 int (*mmap)(struct file *, struct vm_area_struct *); 298 299 spin_lock(&pde->pde_unload_lock); 300 if (!pde->proc_fops) { 301 spin_unlock(&pde->pde_unload_lock); 302 return rv; 303 } 304 pde->pde_users++; 305 mmap = pde->proc_fops->mmap; 306 spin_unlock(&pde->pde_unload_lock); 307 308 if (mmap) 309 rv = mmap(file, vma); 310 311 pde_users_dec(pde); 312 return rv; 313 } 314 315 static int proc_reg_open(struct inode *inode, struct file *file) 316 { 317 struct proc_dir_entry *pde = PDE(inode); 318 int rv = 0; 319 int (*open)(struct inode *, struct file *); 320 int (*release)(struct inode *, struct file *); 321 struct pde_opener *pdeo; 322 323 /* 324 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry 325 * sequence. ->release won't be called because ->proc_fops will be 326 * cleared. Depending on complexity of ->release, consequences vary. 327 * 328 * We can't wait for mercy when close will be done for real, it's 329 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release 330 * by hand in remove_proc_entry(). For this, save opener's credentials 331 * for later. 332 */ 333 pdeo = kmalloc(sizeof(struct pde_opener), GFP_KERNEL); 334 if (!pdeo) 335 return -ENOMEM; 336 337 spin_lock(&pde->pde_unload_lock); 338 if (!pde->proc_fops) { 339 spin_unlock(&pde->pde_unload_lock); 340 kfree(pdeo); 341 return -EINVAL; 342 } 343 pde->pde_users++; 344 open = pde->proc_fops->open; 345 release = pde->proc_fops->release; 346 spin_unlock(&pde->pde_unload_lock); 347 348 if (open) 349 rv = open(inode, file); 350 351 spin_lock(&pde->pde_unload_lock); 352 if (rv == 0 && release) { 353 /* To know what to release. */ 354 pdeo->inode = inode; 355 pdeo->file = file; 356 /* Strictly for "too late" ->release in proc_reg_release(). */ 357 pdeo->release = release; 358 list_add(&pdeo->lh, &pde->pde_openers); 359 } else 360 kfree(pdeo); 361 __pde_users_dec(pde); 362 spin_unlock(&pde->pde_unload_lock); 363 return rv; 364 } 365 366 static struct pde_opener *find_pde_opener(struct proc_dir_entry *pde, 367 struct inode *inode, struct file *file) 368 { 369 struct pde_opener *pdeo; 370 371 list_for_each_entry(pdeo, &pde->pde_openers, lh) { 372 if (pdeo->inode == inode && pdeo->file == file) 373 return pdeo; 374 } 375 return NULL; 376 } 377 378 static int proc_reg_release(struct inode *inode, struct file *file) 379 { 380 struct proc_dir_entry *pde = PDE(inode); 381 int rv = 0; 382 int (*release)(struct inode *, struct file *); 383 struct pde_opener *pdeo; 384 385 spin_lock(&pde->pde_unload_lock); 386 pdeo = find_pde_opener(pde, inode, file); 387 if (!pde->proc_fops) { 388 /* 389 * Can't simply exit, __fput() will think that everything is OK, 390 * and move on to freeing struct file. remove_proc_entry() will 391 * find slacker in opener's list and will try to do non-trivial 392 * things with struct file. Therefore, remove opener from list. 393 * 394 * But if opener is removed from list, who will ->release it? 395 */ 396 if (pdeo) { 397 list_del(&pdeo->lh); 398 spin_unlock(&pde->pde_unload_lock); 399 rv = pdeo->release(inode, file); 400 kfree(pdeo); 401 } else 402 spin_unlock(&pde->pde_unload_lock); 403 return rv; 404 } 405 pde->pde_users++; 406 release = pde->proc_fops->release; 407 if (pdeo) { 408 list_del(&pdeo->lh); 409 kfree(pdeo); 410 } 411 spin_unlock(&pde->pde_unload_lock); 412 413 if (release) 414 rv = release(inode, file); 415 416 pde_users_dec(pde); 417 return rv; 418 } 419 420 static const struct file_operations proc_reg_file_ops = { 421 .llseek = proc_reg_llseek, 422 .read = proc_reg_read, 423 .write = proc_reg_write, 424 .poll = proc_reg_poll, 425 .unlocked_ioctl = proc_reg_unlocked_ioctl, 426 #ifdef CONFIG_COMPAT 427 .compat_ioctl = proc_reg_compat_ioctl, 428 #endif 429 .mmap = proc_reg_mmap, 430 .open = proc_reg_open, 431 .release = proc_reg_release, 432 }; 433 434 #ifdef CONFIG_COMPAT 435 static const struct file_operations proc_reg_file_ops_no_compat = { 436 .llseek = proc_reg_llseek, 437 .read = proc_reg_read, 438 .write = proc_reg_write, 439 .poll = proc_reg_poll, 440 .unlocked_ioctl = proc_reg_unlocked_ioctl, 441 .mmap = proc_reg_mmap, 442 .open = proc_reg_open, 443 .release = proc_reg_release, 444 }; 445 #endif 446 447 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino, 448 struct proc_dir_entry *de) 449 { 450 struct inode * inode; 451 452 if (!try_module_get(de->owner)) 453 goto out_mod; 454 455 inode = iget_locked(sb, ino); 456 if (!inode) 457 goto out_ino; 458 if (inode->i_state & I_NEW) { 459 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 460 PROC_I(inode)->fd = 0; 461 PROC_I(inode)->pde = de; 462 463 if (de->mode) { 464 inode->i_mode = de->mode; 465 inode->i_uid = de->uid; 466 inode->i_gid = de->gid; 467 } 468 if (de->size) 469 inode->i_size = de->size; 470 if (de->nlink) 471 inode->i_nlink = de->nlink; 472 if (de->proc_iops) 473 inode->i_op = de->proc_iops; 474 if (de->proc_fops) { 475 if (S_ISREG(inode->i_mode)) { 476 #ifdef CONFIG_COMPAT 477 if (!de->proc_fops->compat_ioctl) 478 inode->i_fop = 479 &proc_reg_file_ops_no_compat; 480 else 481 #endif 482 inode->i_fop = &proc_reg_file_ops; 483 } else { 484 inode->i_fop = de->proc_fops; 485 } 486 } 487 unlock_new_inode(inode); 488 } else { 489 module_put(de->owner); 490 de_put(de); 491 } 492 return inode; 493 494 out_ino: 495 module_put(de->owner); 496 out_mod: 497 return NULL; 498 } 499 500 int proc_fill_super(struct super_block *s) 501 { 502 struct inode * root_inode; 503 504 s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC; 505 s->s_blocksize = 1024; 506 s->s_blocksize_bits = 10; 507 s->s_magic = PROC_SUPER_MAGIC; 508 s->s_op = &proc_sops; 509 s->s_time_gran = 1; 510 511 de_get(&proc_root); 512 root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root); 513 if (!root_inode) 514 goto out_no_root; 515 root_inode->i_uid = 0; 516 root_inode->i_gid = 0; 517 s->s_root = d_alloc_root(root_inode); 518 if (!s->s_root) 519 goto out_no_root; 520 return 0; 521 522 out_no_root: 523 printk("proc_read_super: get root inode failed\n"); 524 iput(root_inode); 525 de_put(&proc_root); 526 return -ENOMEM; 527 } 528