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