Pileus Git - ~andy/linux/blob - fs/kernfs/file.c

   1 /*
   2  * fs/kernfs/file.c - kernfs file implementation
   3  *
   4  * Copyright (c) 2001-3 Patrick Mochel
   5  * Copyright (c) 2007 SUSE Linux Products GmbH
   6  * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
   7  *
   8  * This file is released under the GPLv2.
   9  */
  10
  11 #include <linux/fs.h>
  12 #include <linux/seq_file.h>
  13 #include <linux/slab.h>
  14 #include <linux/poll.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/sched.h>
  17
  18 #include "kernfs-internal.h"
  19
  20 /*
  21  * There's one kernfs_open_file for each open file and one kernfs_open_node
  22  * for each kernfs_node with one or more open files.
  23  *
  24  * kernfs_node->attr.open points to kernfs_open_node.  attr.open is
  25  * protected by kernfs_open_node_lock.
  26  *
  27  * filp->private_data points to seq_file whose ->private points to
  28  * kernfs_open_file.  kernfs_open_files are chained at
  29  * kernfs_open_node->files, which is protected by kernfs_open_file_mutex.
  30  */
  31 static DEFINE_SPINLOCK(kernfs_open_node_lock);
  32 static DEFINE_MUTEX(kernfs_open_file_mutex);
  33
  34 struct kernfs_open_node {
  35         atomic_t                refcnt;
  36         atomic_t                event;
  37         wait_queue_head_t       poll;
  38         struct list_head        files; /* goes through kernfs_open_file.list */
  39 };
  40
  41 static struct kernfs_open_file *kernfs_of(struct file *file)
  42 {
  43         return ((struct seq_file *)file->private_data)->private;
  44 }
  45
  46 /*
  47  * Determine the kernfs_ops for the given kernfs_node.  This function must
  48  * be called while holding an active reference.
  49  */
  50 static const struct kernfs_ops *kernfs_ops(struct kernfs_node *kn)
  51 {
  52         if (kn->flags & KERNFS_LOCKDEP)
  53                 lockdep_assert_held(kn);
  54         return kn->attr.ops;
  55 }
  56
  57 /*
  58  * As kernfs_seq_stop() is also called after kernfs_seq_start() or
  59  * kernfs_seq_next() failure, it needs to distinguish whether it's stopping
  60  * a seq_file iteration which is fully initialized with an active reference
  61  * or an aborted kernfs_seq_start() due to get_active failure.  The
  62  * position pointer is the only context for each seq_file iteration and
  63  * thus the stop condition should be encoded in it.  As the return value is
  64  * directly visible to userland, ERR_PTR(-ENODEV) is the only acceptable
  65  * choice to indicate get_active failure.
  66  *
  67  * Unfortunately, this is complicated due to the optional custom seq_file
  68  * operations which may return ERR_PTR(-ENODEV) too.  kernfs_seq_stop()
  69  * can't distinguish whether ERR_PTR(-ENODEV) is from get_active failure or
  70  * custom seq_file operations and thus can't decide whether put_active
  71  * should be performed or not only on ERR_PTR(-ENODEV).
  72  *
  73  * This is worked around by factoring out the custom seq_stop() and
  74  * put_active part into kernfs_seq_stop_active(), skipping it from
  75  * kernfs_seq_stop() if ERR_PTR(-ENODEV) while invoking it directly after
  76  * custom seq_file operations fail with ERR_PTR(-ENODEV) - this ensures
  77  * that kernfs_seq_stop_active() is skipped only after get_active failure.
  78  */
  79 static void kernfs_seq_stop_active(struct seq_file *sf, void *v)
  80 {
  81         struct kernfs_open_file *of = sf->private;
  82         const struct kernfs_ops *ops = kernfs_ops(of->kn);
  83
  84         if (ops->seq_stop)
  85                 ops->seq_stop(sf, v);
  86         kernfs_put_active(of->kn);
  87 }
  88
  89 static void *kernfs_seq_start(struct seq_file *sf, loff_t *ppos)
  90 {
  91         struct kernfs_open_file *of = sf->private;
  92         const struct kernfs_ops *ops;
  93
  94         /*
  95          * @of->mutex nests outside active ref and is just to ensure that
  96          * the ops aren't called concurrently for the same open file.
  97          */
  98         mutex_lock(&of->mutex);
  99         if (!kernfs_get_active(of->kn))
 100                 return ERR_PTR(-ENODEV);
 101
 102         ops = kernfs_ops(of->kn);
 103         if (ops->seq_start) {
 104                 void *next = ops->seq_start(sf, ppos);
 105                 /* see the comment above kernfs_seq_stop_active() */
 106                 if (next == ERR_PTR(-ENODEV))
 107                         kernfs_seq_stop_active(sf, next);
 108                 return next;
 109         } else {
 110                 /*
 111                  * The same behavior and code as single_open().  Returns
 112                  * !NULL if pos is at the beginning; otherwise, NULL.
 113                  */
 114                 return NULL + !*ppos;
 115         }
 116 }
 117
 118 static void *kernfs_seq_next(struct seq_file *sf, void *v, loff_t *ppos)
 119 {
 120         struct kernfs_open_file *of = sf->private;
 121         const struct kernfs_ops *ops = kernfs_ops(of->kn);
 122
 123         if (ops->seq_next) {
 124                 void *next = ops->seq_next(sf, v, ppos);
 125                 /* see the comment above kernfs_seq_stop_active() */
 126                 if (next == ERR_PTR(-ENODEV))
 127                         kernfs_seq_stop_active(sf, next);
 128                 return next;
 129         } else {
 130                 /*
 131                  * The same behavior and code as single_open(), always
 132                  * terminate after the initial read.
 133                  */
 134                 ++*ppos;
 135                 return NULL;
 136         }
 137 }
 138
 139 static void kernfs_seq_stop(struct seq_file *sf, void *v)
 140 {
 141         struct kernfs_open_file *of = sf->private;
 142
 143         if (v != ERR_PTR(-ENODEV))
 144                 kernfs_seq_stop_active(sf, v);
 145         mutex_unlock(&of->mutex);
 146 }
 147
 148 static int kernfs_seq_show(struct seq_file *sf, void *v)
 149 {
 150         struct kernfs_open_file *of = sf->private;
 151
 152         of->event = atomic_read(&of->kn->attr.open->event);
 153
 154         return of->kn->attr.ops->seq_show(sf, v);
 155 }
 156
 157 static const struct seq_operations kernfs_seq_ops = {
 158         .start = kernfs_seq_start,
 159         .next = kernfs_seq_next,
 160         .stop = kernfs_seq_stop,
 161         .show = kernfs_seq_show,
 162 };
 163
 164 /*
 165  * As reading a bin file can have side-effects, the exact offset and bytes
 166  * specified in read(2) call should be passed to the read callback making
 167  * it difficult to use seq_file.  Implement simplistic custom buffering for
 168  * bin files.
 169  */
 170 static ssize_t kernfs_file_direct_read(struct kernfs_open_file *of,
 171                                        char __user *user_buf, size_t count,
 172                                        loff_t *ppos)
 173 {
 174         ssize_t len = min_t(size_t, count, PAGE_SIZE);
 175         const struct kernfs_ops *ops;
 176         char *buf;
 177
 178         buf = kmalloc(len, GFP_KERNEL);
 179         if (!buf)
 180                 return -ENOMEM;
 181
 182         /*
 183          * @of->mutex nests outside active ref and is just to ensure that
 184          * the ops aren't called concurrently for the same open file.
 185          */
 186         mutex_lock(&of->mutex);
 187         if (!kernfs_get_active(of->kn)) {
 188                 len = -ENODEV;
 189                 mutex_unlock(&of->mutex);
 190                 goto out_free;
 191         }
 192
 193         ops = kernfs_ops(of->kn);
 194         if (ops->read)
 195                 len = ops->read(of, buf, len, *ppos);
 196         else
 197                 len = -EINVAL;
 198
 199         kernfs_put_active(of->kn);
 200         mutex_unlock(&of->mutex);
 201
 202         if (len < 0)
 203                 goto out_free;
 204
 205         if (copy_to_user(user_buf, buf, len)) {
 206                 len = -EFAULT;
 207                 goto out_free;
 208         }
 209
 210         *ppos += len;
 211
 212  out_free:
 213         kfree(buf);
 214         return len;
 215 }
 216
 217 /**
 218  * kernfs_fop_read - kernfs vfs read callback
 219  * @file: file pointer
 220  * @user_buf: data to write
 221  * @count: number of bytes
 222  * @ppos: starting offset
 223  */
 224 static ssize_t kernfs_fop_read(struct file *file, char __user *user_buf,
 225                                size_t count, loff_t *ppos)
 226 {
 227         struct kernfs_open_file *of = kernfs_of(file);
 228
 229         if (of->kn->flags & KERNFS_HAS_SEQ_SHOW)
 230                 return seq_read(file, user_buf, count, ppos);
 231         else
 232                 return kernfs_file_direct_read(of, user_buf, count, ppos);
 233 }
 234
 235 /**
 236  * kernfs_fop_write - kernfs vfs write callback
 237  * @file: file pointer
 238  * @user_buf: data to write
 239  * @count: number of bytes
 240  * @ppos: starting offset
 241  *
 242  * Copy data in from userland and pass it to the matching kernfs write
 243  * operation.
 244  *
 245  * There is no easy way for us to know if userspace is only doing a partial
 246  * write, so we don't support them. We expect the entire buffer to come on
 247  * the first write.  Hint: if you're writing a value, first read the file,
 248  * modify only the the value you're changing, then write entire buffer
 249  * back.
 250  */
 251 static ssize_t kernfs_fop_write(struct file *file, const char __user *user_buf,
 252                                 size_t count, loff_t *ppos)
 253 {
 254         struct kernfs_open_file *of = kernfs_of(file);
 255         ssize_t len = min_t(size_t, count, PAGE_SIZE);
 256         const struct kernfs_ops *ops;
 257         char *buf;
 258
 259         buf = kmalloc(len + 1, GFP_KERNEL);
 260         if (!buf)
 261                 return -ENOMEM;
 262
 263         if (copy_from_user(buf, user_buf, len)) {
 264                 len = -EFAULT;
 265                 goto out_free;
 266         }
 267         buf[len] = '\0';        /* guarantee string termination */
 268
 269         /*
 270          * @of->mutex nests outside active ref and is just to ensure that
 271          * the ops aren't called concurrently for the same open file.
 272          */
 273         mutex_lock(&of->mutex);
 274         if (!kernfs_get_active(of->kn)) {
 275                 mutex_unlock(&of->mutex);
 276                 len = -ENODEV;
 277                 goto out_free;
 278         }
 279
 280         ops = kernfs_ops(of->kn);
 281         if (ops->write)
 282                 len = ops->write(of, buf, len, *ppos);
 283         else
 284                 len = -EINVAL;
 285
 286         kernfs_put_active(of->kn);
 287         mutex_unlock(&of->mutex);
 288
 289         if (len > 0)
 290                 *ppos += len;
 291 out_free:
 292         kfree(buf);
 293         return len;
 294 }
 295
 296 static void kernfs_vma_open(struct vm_area_struct *vma)
 297 {
 298         struct file *file = vma->vm_file;
 299         struct kernfs_open_file *of = kernfs_of(file);
 300
 301         if (!of->vm_ops)
 302                 return;
 303
 304         if (!kernfs_get_active(of->kn))
 305                 return;
 306
 307         if (of->vm_ops->open)
 308                 of->vm_ops->open(vma);
 309
 310         kernfs_put_active(of->kn);
 311 }
 312
 313 static int kernfs_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 314 {
 315         struct file *file = vma->vm_file;
 316         struct kernfs_open_file *of = kernfs_of(file);
 317         int ret;
 318
 319         if (!of->vm_ops)
 320                 return VM_FAULT_SIGBUS;
 321
 322         if (!kernfs_get_active(of->kn))
 323                 return VM_FAULT_SIGBUS;
 324
 325         ret = VM_FAULT_SIGBUS;
 326         if (of->vm_ops->fault)
 327                 ret = of->vm_ops->fault(vma, vmf);
 328
 329         kernfs_put_active(of->kn);
 330         return ret;
 331 }
 332
 333 static int kernfs_vma_page_mkwrite(struct vm_area_struct *vma,
 334                                    struct vm_fault *vmf)
 335 {
 336         struct file *file = vma->vm_file;
 337         struct kernfs_open_file *of = kernfs_of(file);
 338         int ret;
 339
 340         if (!of->vm_ops)
 341                 return VM_FAULT_SIGBUS;
 342
 343         if (!kernfs_get_active(of->kn))
 344                 return VM_FAULT_SIGBUS;
 345
 346         ret = 0;
 347         if (of->vm_ops->page_mkwrite)
 348                 ret = of->vm_ops->page_mkwrite(vma, vmf);
 349         else
 350                 file_update_time(file);
 351
 352         kernfs_put_active(of->kn);
 353         return ret;
 354 }
 355
 356 static int kernfs_vma_access(struct vm_area_struct *vma, unsigned long addr,
 357                              void *buf, int len, int write)
 358 {
 359         struct file *file = vma->vm_file;
 360         struct kernfs_open_file *of = kernfs_of(file);
 361         int ret;
 362
 363         if (!of->vm_ops)
 364                 return -EINVAL;
 365
 366         if (!kernfs_get_active(of->kn))
 367                 return -EINVAL;
 368
 369         ret = -EINVAL;
 370         if (of->vm_ops->access)
 371                 ret = of->vm_ops->access(vma, addr, buf, len, write);
 372
 373         kernfs_put_active(of->kn);
 374         return ret;
 375 }
 376
 377 #ifdef CONFIG_NUMA
 378 static int kernfs_vma_set_policy(struct vm_area_struct *vma,
 379                                  struct mempolicy *new)
 380 {
 381         struct file *file = vma->vm_file;
 382         struct kernfs_open_file *of = kernfs_of(file);
 383         int ret;
 384
 385         if (!of->vm_ops)
 386                 return 0;
 387
 388         if (!kernfs_get_active(of->kn))
 389                 return -EINVAL;
 390
 391         ret = 0;
 392         if (of->vm_ops->set_policy)
 393                 ret = of->vm_ops->set_policy(vma, new);
 394
 395         kernfs_put_active(of->kn);
 396         return ret;
 397 }
 398
 399 static struct mempolicy *kernfs_vma_get_policy(struct vm_area_struct *vma,
 400                                                unsigned long addr)
 401 {
 402         struct file *file = vma->vm_file;
 403         struct kernfs_open_file *of = kernfs_of(file);
 404         struct mempolicy *pol;
 405
 406         if (!of->vm_ops)
 407                 return vma->vm_policy;
 408
 409         if (!kernfs_get_active(of->kn))
 410                 return vma->vm_policy;
 411
 412         pol = vma->vm_policy;
 413         if (of->vm_ops->get_policy)
 414                 pol = of->vm_ops->get_policy(vma, addr);
 415
 416         kernfs_put_active(of->kn);
 417         return pol;
 418 }
 419
 420 static int kernfs_vma_migrate(struct vm_area_struct *vma,
 421                               const nodemask_t *from, const nodemask_t *to,
 422                               unsigned long flags)
 423 {
 424         struct file *file = vma->vm_file;
 425         struct kernfs_open_file *of = kernfs_of(file);
 426         int ret;
 427
 428         if (!of->vm_ops)
 429                 return 0;
 430
 431         if (!kernfs_get_active(of->kn))
 432                 return 0;
 433
 434         ret = 0;
 435         if (of->vm_ops->migrate)
 436                 ret = of->vm_ops->migrate(vma, from, to, flags);
 437
 438         kernfs_put_active(of->kn);
 439         return ret;
 440 }
 441 #endif
 442
 443 static const struct vm_operations_struct kernfs_vm_ops = {
 444         .open           = kernfs_vma_open,
 445         .fault          = kernfs_vma_fault,
 446         .page_mkwrite   = kernfs_vma_page_mkwrite,
 447         .access         = kernfs_vma_access,
 448 #ifdef CONFIG_NUMA
 449         .set_policy     = kernfs_vma_set_policy,
 450         .get_policy     = kernfs_vma_get_policy,
 451         .migrate        = kernfs_vma_migrate,
 452 #endif
 453 };
 454
 455 static int kernfs_fop_mmap(struct file *file, struct vm_area_struct *vma)
 456 {
 457         struct kernfs_open_file *of = kernfs_of(file);
 458         const struct kernfs_ops *ops;
 459         int rc;
 460
 461         /*
 462          * mmap path and of->mutex are prone to triggering spurious lockdep
 463          * warnings and we don't want to add spurious locking dependency
 464          * between the two.  Check whether mmap is actually implemented
 465          * without grabbing @of->mutex by testing HAS_MMAP flag.  See the
 466          * comment in kernfs_file_open() for more details.
 467          */
 468         if (!(of->kn->flags & KERNFS_HAS_MMAP))
 469                 return -ENODEV;
 470
 471         mutex_lock(&of->mutex);
 472
 473         rc = -ENODEV;
 474         if (!kernfs_get_active(of->kn))
 475                 goto out_unlock;
 476
 477         ops = kernfs_ops(of->kn);
 478         rc = ops->mmap(of, vma);
 479
 480         /*
 481          * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
 482          * to satisfy versions of X which crash if the mmap fails: that
 483          * substitutes a new vm_file, and we don't then want bin_vm_ops.
 484          */
 485         if (vma->vm_file != file)
 486                 goto out_put;
 487
 488         rc = -EINVAL;
 489         if (of->mmapped && of->vm_ops != vma->vm_ops)
 490                 goto out_put;
 491
 492         /*
 493          * It is not possible to successfully wrap close.
 494          * So error if someone is trying to use close.
 495          */
 496         rc = -EINVAL;
 497         if (vma->vm_ops && vma->vm_ops->close)
 498                 goto out_put;
 499
 500         rc = 0;
 501         of->mmapped = 1;
 502         of->vm_ops = vma->vm_ops;
 503         vma->vm_ops = &kernfs_vm_ops;
 504 out_put:
 505         kernfs_put_active(of->kn);
 506 out_unlock:
 507         mutex_unlock(&of->mutex);
 508
 509         return rc;
 510 }
 511
 512 /**
 513  *      kernfs_get_open_node - get or create kernfs_open_node
 514  *      @kn: target kernfs_node
 515  *      @of: kernfs_open_file for this instance of open
 516  *
 517  *      If @kn->attr.open exists, increment its reference count; otherwise,
 518  *      create one.  @of is chained to the files list.
 519  *
 520  *      LOCKING:
 521  *      Kernel thread context (may sleep).
 522  *
 523  *      RETURNS:
 524  *      0 on success, -errno on failure.
 525  */
 526 static int kernfs_get_open_node(struct kernfs_node *kn,
 527                                 struct kernfs_open_file *of)
 528 {
 529         struct kernfs_open_node *on, *new_on = NULL;
 530
 531  retry:
 532         mutex_lock(&kernfs_open_file_mutex);
 533         spin_lock_irq(&kernfs_open_node_lock);
 534
 535         if (!kn->attr.open && new_on) {
 536                 kn->attr.open = new_on;
 537                 new_on = NULL;
 538         }
 539
 540         on = kn->attr.open;
 541         if (on) {
 542                 atomic_inc(&on->refcnt);
 543                 list_add_tail(&of->list, &on->files);
 544         }
 545
 546         spin_unlock_irq(&kernfs_open_node_lock);
 547         mutex_unlock(&kernfs_open_file_mutex);
 548
 549         if (on) {
 550                 kfree(new_on);
 551                 return 0;
 552         }
 553
 554         /* not there, initialize a new one and retry */
 555         new_on = kmalloc(sizeof(*new_on), GFP_KERNEL);
 556         if (!new_on)
 557                 return -ENOMEM;
 558
 559         atomic_set(&new_on->refcnt, 0);
 560         atomic_set(&new_on->event, 1);
 561         init_waitqueue_head(&new_on->poll);
 562         INIT_LIST_HEAD(&new_on->files);
 563         goto retry;
 564 }
 565
 566 /**
 567  *      kernfs_put_open_node - put kernfs_open_node
 568  *      @kn: target kernfs_nodet
 569  *      @of: associated kernfs_open_file
 570  *
 571  *      Put @kn->attr.open and unlink @of from the files list.  If
 572  *      reference count reaches zero, disassociate and free it.
 573  *
 574  *      LOCKING:
 575  *      None.
 576  */
 577 static void kernfs_put_open_node(struct kernfs_node *kn,
 578                                  struct kernfs_open_file *of)
 579 {
 580         struct kernfs_open_node *on = kn->attr.open;
 581         unsigned long flags;
 582
 583         mutex_lock(&kernfs_open_file_mutex);
 584         spin_lock_irqsave(&kernfs_open_node_lock, flags);
 585
 586         if (of)
 587                 list_del(&of->list);
 588
 589         if (atomic_dec_and_test(&on->refcnt))
 590                 kn->attr.open = NULL;
 591         else
 592                 on = NULL;
 593
 594         spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
 595         mutex_unlock(&kernfs_open_file_mutex);
 596
 597         kfree(on);
 598 }
 599
 600 static int kernfs_fop_open(struct inode *inode, struct file *file)
 601 {
 602         struct kernfs_node *kn = file->f_path.dentry->d_fsdata;
 603         const struct kernfs_ops *ops;
 604         struct kernfs_open_file *of;
 605         bool has_read, has_write, has_mmap;
 606         int error = -EACCES;
 607
 608         if (!kernfs_get_active(kn))
 609                 return -ENODEV;
 610
 611         ops = kernfs_ops(kn);
 612
 613         has_read = ops->seq_show || ops->read || ops->mmap;
 614         has_write = ops->write || ops->mmap;
 615         has_mmap = ops->mmap;
 616
 617         /* check perms and supported operations */
 618         if ((file->f_mode & FMODE_WRITE) &&
 619             (!(inode->i_mode & S_IWUGO) || !has_write))
 620                 goto err_out;
 621
 622         if ((file->f_mode & FMODE_READ) &&
 623             (!(inode->i_mode & S_IRUGO) || !has_read))
 624                 goto err_out;
 625
 626         /* allocate a kernfs_open_file for the file */
 627         error = -ENOMEM;
 628         of = kzalloc(sizeof(struct kernfs_open_file), GFP_KERNEL);
 629         if (!of)
 630                 goto err_out;
 631
 632         /*
 633          * The following is done to give a different lockdep key to
 634          * @of->mutex for files which implement mmap.  This is a rather
 635          * crude way to avoid false positive lockdep warning around
 636          * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and
 637          * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under
 638          * which mm->mmap_sem nests, while holding @of->mutex.  As each
 639          * open file has a separate mutex, it's okay as long as those don't
 640          * happen on the same file.  At this point, we can't easily give
 641          * each file a separate locking class.  Let's differentiate on
 642          * whether the file has mmap or not for now.
 643          *
 644          * Both paths of the branch look the same.  They're supposed to
 645          * look that way and give @of->mutex different static lockdep keys.
 646          */
 647         if (has_mmap)
 648                 mutex_init(&of->mutex);
 649         else
 650                 mutex_init(&of->mutex);
 651
 652         of->kn = kn;
 653         of->file = file;
 654
 655         /*
 656          * Always instantiate seq_file even if read access doesn't use
 657          * seq_file or is not requested.  This unifies private data access
 658          * and readable regular files are the vast majority anyway.
 659          */
 660         if (ops->seq_show)
 661                 error = seq_open(file, &kernfs_seq_ops);
 662         else
 663                 error = seq_open(file, NULL);
 664         if (error)
 665                 goto err_free;
 666
 667         ((struct seq_file *)file->private_data)->private = of;
 668
 669         /* seq_file clears PWRITE unconditionally, restore it if WRITE */
 670         if (file->f_mode & FMODE_WRITE)
 671                 file->f_mode |= FMODE_PWRITE;
 672
 673         /* make sure we have open node struct */
 674         error = kernfs_get_open_node(kn, of);
 675         if (error)
 676                 goto err_close;
 677
 678         /* open succeeded, put active references */
 679         kernfs_put_active(kn);
 680         return 0;
 681
 682 err_close:
 683         seq_release(inode, file);
 684 err_free:
 685         kfree(of);
 686 err_out:
 687         kernfs_put_active(kn);
 688         return error;
 689 }
 690
 691 static int kernfs_fop_release(struct inode *inode, struct file *filp)
 692 {
 693         struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
 694         struct kernfs_open_file *of = kernfs_of(filp);
 695
 696         kernfs_put_open_node(kn, of);
 697         seq_release(inode, filp);
 698         kfree(of);
 699
 700         return 0;
 701 }
 702
 703 void kernfs_unmap_bin_file(struct kernfs_node *kn)
 704 {
 705         struct kernfs_open_node *on;
 706         struct kernfs_open_file *of;
 707
 708         if (!(kn->flags & KERNFS_HAS_MMAP))
 709                 return;
 710
 711         spin_lock_irq(&kernfs_open_node_lock);
 712         on = kn->attr.open;
 713         if (on)
 714                 atomic_inc(&on->refcnt);
 715         spin_unlock_irq(&kernfs_open_node_lock);
 716         if (!on)
 717                 return;
 718
 719         mutex_lock(&kernfs_open_file_mutex);
 720         list_for_each_entry(of, &on->files, list) {
 721                 struct inode *inode = file_inode(of->file);
 722                 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
 723         }
 724         mutex_unlock(&kernfs_open_file_mutex);
 725
 726         kernfs_put_open_node(kn, NULL);
 727 }
 728
 729 /*
 730  * Kernfs attribute files are pollable.  The idea is that you read
 731  * the content and then you use 'poll' or 'select' to wait for
 732  * the content to change.  When the content changes (assuming the
 733  * manager for the kobject supports notification), poll will
 734  * return POLLERR|POLLPRI, and select will return the fd whether
 735  * it is waiting for read, write, or exceptions.
 736  * Once poll/select indicates that the value has changed, you
 737  * need to close and re-open the file, or seek to 0 and read again.
 738  * Reminder: this only works for attributes which actively support
 739  * it, and it is not possible to test an attribute from userspace
 740  * to see if it supports poll (Neither 'poll' nor 'select' return
 741  * an appropriate error code).  When in doubt, set a suitable timeout value.
 742  */
 743 static unsigned int kernfs_fop_poll(struct file *filp, poll_table *wait)
 744 {
 745         struct kernfs_open_file *of = kernfs_of(filp);
 746         struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
 747         struct kernfs_open_node *on = kn->attr.open;
 748
 749         /* need parent for the kobj, grab both */
 750         if (!kernfs_get_active(kn))
 751                 goto trigger;
 752
 753         poll_wait(filp, &on->poll, wait);
 754
 755         kernfs_put_active(kn);
 756
 757         if (of->event != atomic_read(&on->event))
 758                 goto trigger;
 759
 760         return DEFAULT_POLLMASK;
 761
 762  trigger:
 763         return DEFAULT_POLLMASK|POLLERR|POLLPRI;
 764 }
 765
 766 /**
 767  * kernfs_notify - notify a kernfs file
 768  * @kn: file to notify
 769  *
 770  * Notify @kn such that poll(2) on @kn wakes up.
 771  */
 772 void kernfs_notify(struct kernfs_node *kn)
 773 {
 774         struct kernfs_open_node *on;
 775         unsigned long flags;
 776
 777         spin_lock_irqsave(&kernfs_open_node_lock, flags);
 778
 779         if (!WARN_ON(kernfs_type(kn) != KERNFS_FILE)) {
 780                 on = kn->attr.open;
 781                 if (on) {
 782                         atomic_inc(&on->event);
 783                         wake_up_interruptible(&on->poll);
 784                 }
 785         }
 786
 787         spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
 788 }
 789 EXPORT_SYMBOL_GPL(kernfs_notify);
 790
 791 const struct file_operations kernfs_file_fops = {
 792         .read           = kernfs_fop_read,
 793         .write          = kernfs_fop_write,
 794         .llseek         = generic_file_llseek,
 795         .mmap           = kernfs_fop_mmap,
 796         .open           = kernfs_fop_open,
 797         .release        = kernfs_fop_release,
 798         .poll           = kernfs_fop_poll,
 799 };
 800
 801 /**
 802  * __kernfs_create_file - kernfs internal function to create a file
 803  * @parent: directory to create the file in
 804  * @name: name of the file
 805  * @mode: mode of the file
 806  * @size: size of the file
 807  * @ops: kernfs operations for the file
 808  * @priv: private data for the file
 809  * @ns: optional namespace tag of the file
 810  * @static_name: don't copy file name
 811  * @key: lockdep key for the file's active_ref, %NULL to disable lockdep
 812  *
 813  * Returns the created node on success, ERR_PTR() value on error.
 814  */
 815 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
 816                                          const char *name,
 817                                          umode_t mode, loff_t size,
 818                                          const struct kernfs_ops *ops,
 819                                          void *priv, const void *ns,
 820                                          bool name_is_static,
 821                                          struct lock_class_key *key)
 822 {
 823         struct kernfs_addrm_cxt acxt;
 824         struct kernfs_node *kn;
 825         unsigned flags;
 826         int rc;
 827
 828         flags = KERNFS_FILE;
 829         if (name_is_static)
 830                 flags |= KERNFS_STATIC_NAME;
 831
 832         kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG, flags);
 833         if (!kn)
 834                 return ERR_PTR(-ENOMEM);
 835
 836         kn->attr.ops = ops;
 837         kn->attr.size = size;
 838         kn->ns = ns;
 839         kn->priv = priv;
 840
 841 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 842         if (key) {
 843                 lockdep_init_map(&kn->dep_map, "s_active", key, 0);
 844                 kn->flags |= KERNFS_LOCKDEP;
 845         }
 846 #endif
 847
 848         /*
 849          * kn->attr.ops is accesible only while holding active ref.  We
 850          * need to know whether some ops are implemented outside active
 851          * ref.  Cache their existence in flags.
 852          */
 853         if (ops->seq_show)
 854                 kn->flags |= KERNFS_HAS_SEQ_SHOW;
 855         if (ops->mmap)
 856                 kn->flags |= KERNFS_HAS_MMAP;
 857
 858         kernfs_addrm_start(&acxt);
 859         rc = kernfs_add_one(&acxt, kn);
 860         kernfs_addrm_finish(&acxt);
 861
 862         if (rc) {
 863                 kernfs_put(kn);
 864                 return ERR_PTR(rc);
 865         }
 866         return kn;
 867 }