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