fs/proc/inode.c

   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         return inode;
 491
 492 out_ino:
 493         module_put(de->owner);
 494 out_mod:
 495         return NULL;
 496 }
 497
 498 int proc_fill_super(struct super_block *s)
 499 {
 500         struct inode * root_inode;
 501
 502         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
 503         s->s_blocksize = 1024;
 504         s->s_blocksize_bits = 10;
 505         s->s_magic = PROC_SUPER_MAGIC;
 506         s->s_op = &proc_sops;
 507         s->s_time_gran = 1;
 508
 509         de_get(&proc_root);
 510         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
 511         if (!root_inode)
 512                 goto out_no_root;
 513         root_inode->i_uid = 0;
 514         root_inode->i_gid = 0;
 515         s->s_root = d_alloc_root(root_inode);
 516         if (!s->s_root)
 517                 goto out_no_root;
 518         return 0;
 519
 520 out_no_root:
 521         printk("proc_read_super: get root inode failed\n");
 522         iput(root_inode);
 523         de_put(&proc_root);
 524         return -ENOMEM;
 525 }