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