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
  21 #include <asm/system.h>
  22 #include <asm/uaccess.h>
  23
  24 #include "internal.h"
  25
  26 struct proc_dir_entry *de_get(struct proc_dir_entry *de)
  27 {
  28         atomic_inc(&de->count);
  29         return de;
  30 }
  31
  32 /*
  33  * Decrements the use count and checks for deferred deletion.
  34  */
  35 void de_put(struct proc_dir_entry *de)
  36 {
  37         lock_kernel();
  38         if (!atomic_read(&de->count)) {
  39                 printk("de_put: entry %s already free!\n", de->name);
  40                 unlock_kernel();
  41                 return;
  42         }
  43
  44         if (atomic_dec_and_test(&de->count))
  45                 free_proc_entry(de);
  46         unlock_kernel();
  47 }
  48
  49 /*
  50  * Decrement the use count of the proc_dir_entry.
  51  */
  52 static void proc_delete_inode(struct inode *inode)
  53 {
  54         struct proc_dir_entry *de;
  55
  56         truncate_inode_pages(&inode->i_data, 0);
  57
  58         /* Stop tracking associated processes */
  59         put_pid(PROC_I(inode)->pid);
  60
  61         /* Let go of any associated proc directory entry */
  62         de = PROC_I(inode)->pde;
  63         if (de) {
  64                 if (de->owner)
  65                         module_put(de->owner);
  66                 de_put(de);
  67         }
  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         inode = &ei->vfs_inode;
  88         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  89         return inode;
  90 }
  91
  92 static void proc_destroy_inode(struct inode *inode)
  93 {
  94         kmem_cache_free(proc_inode_cachep, PROC_I(inode));
  95 }
  96
  97 static void init_once(struct kmem_cache * cachep, void *foo)
  98 {
  99         struct proc_inode *ei = (struct proc_inode *) foo;
 100
 101         inode_init_once(&ei->vfs_inode);
 102 }
 103
 104 int __init proc_init_inodecache(void)
 105 {
 106         proc_inode_cachep = kmem_cache_create("proc_inode_cache",
 107                                              sizeof(struct proc_inode),
 108                                              0, (SLAB_RECLAIM_ACCOUNT|
 109                                                 SLAB_MEM_SPREAD|SLAB_PANIC),
 110                                              init_once);
 111         return 0;
 112 }
 113
 114 static int proc_remount(struct super_block *sb, int *flags, char *data)
 115 {
 116         *flags |= MS_NODIRATIME;
 117         return 0;
 118 }
 119
 120 static const struct super_operations proc_sops = {
 121         .alloc_inode    = proc_alloc_inode,
 122         .destroy_inode  = proc_destroy_inode,
 123         .drop_inode     = generic_delete_inode,
 124         .delete_inode   = proc_delete_inode,
 125         .statfs         = simple_statfs,
 126         .remount_fs     = proc_remount,
 127 };
 128
 129 static void pde_users_dec(struct proc_dir_entry *pde)
 130 {
 131         spin_lock(&pde->pde_unload_lock);
 132         pde->pde_users--;
 133         if (pde->pde_unload_completion && pde->pde_users == 0)
 134                 complete(pde->pde_unload_completion);
 135         spin_unlock(&pde->pde_unload_lock);
 136 }
 137
 138 static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
 139 {
 140         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 141         loff_t rv = -EINVAL;
 142         loff_t (*llseek)(struct file *, loff_t, int);
 143
 144         spin_lock(&pde->pde_unload_lock);
 145         /*
 146          * remove_proc_entry() is going to delete PDE (as part of module
 147          * cleanup sequence). No new callers into module allowed.
 148          */
 149         if (!pde->proc_fops) {
 150                 spin_unlock(&pde->pde_unload_lock);
 151                 return rv;
 152         }
 153         /*
 154          * Bump refcount so that remove_proc_entry will wail for ->llseek to
 155          * complete.
 156          */
 157         pde->pde_users++;
 158         /*
 159          * Save function pointer under lock, to protect against ->proc_fops
 160          * NULL'ifying right after ->pde_unload_lock is dropped.
 161          */
 162         llseek = pde->proc_fops->llseek;
 163         spin_unlock(&pde->pde_unload_lock);
 164
 165         if (!llseek)
 166                 llseek = default_llseek;
 167         rv = llseek(file, offset, whence);
 168
 169         pde_users_dec(pde);
 170         return rv;
 171 }
 172
 173 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 174 {
 175         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 176         ssize_t rv = -EIO;
 177         ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
 178
 179         spin_lock(&pde->pde_unload_lock);
 180         if (!pde->proc_fops) {
 181                 spin_unlock(&pde->pde_unload_lock);
 182                 return rv;
 183         }
 184         pde->pde_users++;
 185         read = pde->proc_fops->read;
 186         spin_unlock(&pde->pde_unload_lock);
 187
 188         if (read)
 189                 rv = read(file, buf, count, ppos);
 190
 191         pde_users_dec(pde);
 192         return rv;
 193 }
 194
 195 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 196 {
 197         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 198         ssize_t rv = -EIO;
 199         ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
 200
 201         spin_lock(&pde->pde_unload_lock);
 202         if (!pde->proc_fops) {
 203                 spin_unlock(&pde->pde_unload_lock);
 204                 return rv;
 205         }
 206         pde->pde_users++;
 207         write = pde->proc_fops->write;
 208         spin_unlock(&pde->pde_unload_lock);
 209
 210         if (write)
 211                 rv = write(file, buf, count, ppos);
 212
 213         pde_users_dec(pde);
 214         return rv;
 215 }
 216
 217 static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
 218 {
 219         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 220         unsigned int rv = DEFAULT_POLLMASK;
 221         unsigned int (*poll)(struct file *, struct poll_table_struct *);
 222
 223         spin_lock(&pde->pde_unload_lock);
 224         if (!pde->proc_fops) {
 225                 spin_unlock(&pde->pde_unload_lock);
 226                 return rv;
 227         }
 228         pde->pde_users++;
 229         poll = pde->proc_fops->poll;
 230         spin_unlock(&pde->pde_unload_lock);
 231
 232         if (poll)
 233                 rv = poll(file, pts);
 234
 235         pde_users_dec(pde);
 236         return rv;
 237 }
 238
 239 static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 240 {
 241         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 242         long rv = -ENOTTY;
 243         long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
 244         int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
 245
 246         spin_lock(&pde->pde_unload_lock);
 247         if (!pde->proc_fops) {
 248                 spin_unlock(&pde->pde_unload_lock);
 249                 return rv;
 250         }
 251         pde->pde_users++;
 252         unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
 253         ioctl = pde->proc_fops->ioctl;
 254         spin_unlock(&pde->pde_unload_lock);
 255
 256         if (unlocked_ioctl) {
 257                 rv = unlocked_ioctl(file, cmd, arg);
 258                 if (rv == -ENOIOCTLCMD)
 259                         rv = -EINVAL;
 260         } else if (ioctl) {
 261                 lock_kernel();
 262                 rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
 263                 unlock_kernel();
 264         }
 265
 266         pde_users_dec(pde);
 267         return rv;
 268 }
 269
 270 #ifdef CONFIG_COMPAT
 271 static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 272 {
 273         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 274         long rv = -ENOTTY;
 275         long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
 276
 277         spin_lock(&pde->pde_unload_lock);
 278         if (!pde->proc_fops) {
 279                 spin_unlock(&pde->pde_unload_lock);
 280                 return rv;
 281         }
 282         pde->pde_users++;
 283         compat_ioctl = pde->proc_fops->compat_ioctl;
 284         spin_unlock(&pde->pde_unload_lock);
 285
 286         if (compat_ioctl)
 287                 rv = compat_ioctl(file, cmd, arg);
 288
 289         pde_users_dec(pde);
 290         return rv;
 291 }
 292 #endif
 293
 294 static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
 295 {
 296         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 297         int rv = -EIO;
 298         int (*mmap)(struct file *, struct vm_area_struct *);
 299
 300         spin_lock(&pde->pde_unload_lock);
 301         if (!pde->proc_fops) {
 302                 spin_unlock(&pde->pde_unload_lock);
 303                 return rv;
 304         }
 305         pde->pde_users++;
 306         mmap = pde->proc_fops->mmap;
 307         spin_unlock(&pde->pde_unload_lock);
 308
 309         if (mmap)
 310                 rv = mmap(file, vma);
 311
 312         pde_users_dec(pde);
 313         return rv;
 314 }
 315
 316 static int proc_reg_open(struct inode *inode, struct file *file)
 317 {
 318         struct proc_dir_entry *pde = PDE(inode);
 319         int rv = 0;
 320         int (*open)(struct inode *, struct file *);
 321
 322         spin_lock(&pde->pde_unload_lock);
 323         if (!pde->proc_fops) {
 324                 spin_unlock(&pde->pde_unload_lock);
 325                 return rv;
 326         }
 327         pde->pde_users++;
 328         open = pde->proc_fops->open;
 329         spin_unlock(&pde->pde_unload_lock);
 330
 331         if (open)
 332                 rv = open(inode, file);
 333
 334         pde_users_dec(pde);
 335         return rv;
 336 }
 337
 338 static int proc_reg_release(struct inode *inode, struct file *file)
 339 {
 340         struct proc_dir_entry *pde = PDE(inode);
 341         int rv = 0;
 342         int (*release)(struct inode *, struct file *);
 343
 344         spin_lock(&pde->pde_unload_lock);
 345         if (!pde->proc_fops) {
 346                 spin_unlock(&pde->pde_unload_lock);
 347                 return rv;
 348         }
 349         pde->pde_users++;
 350         release = pde->proc_fops->release;
 351         spin_unlock(&pde->pde_unload_lock);
 352
 353         if (release)
 354                 rv = release(inode, file);
 355
 356         pde_users_dec(pde);
 357         return rv;
 358 }
 359
 360 static const struct file_operations proc_reg_file_ops = {
 361         .llseek         = proc_reg_llseek,
 362         .read           = proc_reg_read,
 363         .write          = proc_reg_write,
 364         .poll           = proc_reg_poll,
 365         .unlocked_ioctl = proc_reg_unlocked_ioctl,
 366 #ifdef CONFIG_COMPAT
 367         .compat_ioctl   = proc_reg_compat_ioctl,
 368 #endif
 369         .mmap           = proc_reg_mmap,
 370         .open           = proc_reg_open,
 371         .release        = proc_reg_release,
 372 };
 373
 374 #ifdef CONFIG_COMPAT
 375 static const struct file_operations proc_reg_file_ops_no_compat = {
 376         .llseek         = proc_reg_llseek,
 377         .read           = proc_reg_read,
 378         .write          = proc_reg_write,
 379         .poll           = proc_reg_poll,
 380         .unlocked_ioctl = proc_reg_unlocked_ioctl,
 381         .mmap           = proc_reg_mmap,
 382         .open           = proc_reg_open,
 383         .release        = proc_reg_release,
 384 };
 385 #endif
 386
 387 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
 388                                 struct proc_dir_entry *de)
 389 {
 390         struct inode * inode;
 391
 392         if (!try_module_get(de->owner))
 393                 goto out_mod;
 394
 395         inode = iget_locked(sb, ino);
 396         if (!inode)
 397                 goto out_ino;
 398         if (inode->i_state & I_NEW) {
 399                 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 400                 PROC_I(inode)->fd = 0;
 401                 PROC_I(inode)->pde = de;
 402
 403                 if (de->mode) {
 404                         inode->i_mode = de->mode;
 405                         inode->i_uid = de->uid;
 406                         inode->i_gid = de->gid;
 407                 }
 408                 if (de->size)
 409                         inode->i_size = de->size;
 410                 if (de->nlink)
 411                         inode->i_nlink = de->nlink;
 412                 if (de->proc_iops)
 413                         inode->i_op = de->proc_iops;
 414                 if (de->proc_fops) {
 415                         if (S_ISREG(inode->i_mode)) {
 416 #ifdef CONFIG_COMPAT
 417                                 if (!de->proc_fops->compat_ioctl)
 418                                         inode->i_fop =
 419                                                 &proc_reg_file_ops_no_compat;
 420                                 else
 421 #endif
 422                                         inode->i_fop = &proc_reg_file_ops;
 423                         } else {
 424                                 inode->i_fop = de->proc_fops;
 425                         }
 426                 }
 427                 unlock_new_inode(inode);
 428         } else
 429                module_put(de->owner);
 430         return inode;
 431
 432 out_ino:
 433         module_put(de->owner);
 434 out_mod:
 435         return NULL;
 436 }
 437
 438 int proc_fill_super(struct super_block *s)
 439 {
 440         struct inode * root_inode;
 441
 442         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
 443         s->s_blocksize = 1024;
 444         s->s_blocksize_bits = 10;
 445         s->s_magic = PROC_SUPER_MAGIC;
 446         s->s_op = &proc_sops;
 447         s->s_time_gran = 1;
 448
 449         de_get(&proc_root);
 450         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
 451         if (!root_inode)
 452                 goto out_no_root;
 453         root_inode->i_uid = 0;
 454         root_inode->i_gid = 0;
 455         s->s_root = d_alloc_root(root_inode);
 456         if (!s->s_root)
 457                 goto out_no_root;
 458         return 0;
 459
 460 out_no_root:
 461         printk("proc_read_super: get root inode failed\n");
 462         iput(root_inode);
 463         de_put(&proc_root);
 464         return -ENOMEM;
 465 }