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         if (rc)
 480                 goto out_put;
 481
 482         /*
 483          * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
 484          * to satisfy versions of X which crash if the mmap fails: that
 485          * substitutes a new vm_file, and we don't then want bin_vm_ops.
 486          */
 487         if (vma->vm_file != file)
 488                 goto out_put;
 489
 490         rc = -EINVAL;
 491         if (of->mmapped && of->vm_ops != vma->vm_ops)
 492                 goto out_put;
 493
 494         /*
 495          * It is not possible to successfully wrap close.
 496          * So error if someone is trying to use close.
 497          */
 498         rc = -EINVAL;
 499         if (vma->vm_ops && vma->vm_ops->close)
 500                 goto out_put;
 501
 502         rc = 0;
 503         of->mmapped = 1;
 504         of->vm_ops = vma->vm_ops;
 505         vma->vm_ops = &kernfs_vm_ops;
 506 out_put:
 507         kernfs_put_active(of->kn);
 508 out_unlock:
 509         mutex_unlock(&of->mutex);
 510
 511         return rc;
 512 }
 513
 514 /**
 515  *      kernfs_get_open_node - get or create kernfs_open_node
 516  *      @kn: target kernfs_node
 517  *      @of: kernfs_open_file for this instance of open
 518  *
 519  *      If @kn->attr.open exists, increment its reference count; otherwise,
 520  *      create one.  @of is chained to the files list.
 521  *
 522  *      LOCKING:
 523  *      Kernel thread context (may sleep).
 524  *
 525  *      RETURNS:
 526  *      0 on success, -errno on failure.
 527  */
 528 static int kernfs_get_open_node(struct kernfs_node *kn,
 529                                 struct kernfs_open_file *of)
 530 {
 531         struct kernfs_open_node *on, *new_on = NULL;
 532
 533  retry:
 534         mutex_lock(&kernfs_open_file_mutex);
 535         spin_lock_irq(&kernfs_open_node_lock);
 536
 537         if (!kn->attr.open && new_on) {
 538                 kn->attr.open = new_on;
 539                 new_on = NULL;
 540         }
 541
 542         on = kn->attr.open;
 543         if (on) {
 544                 atomic_inc(&on->refcnt);
 545                 list_add_tail(&of->list, &on->files);
 546         }
 547
 548         spin_unlock_irq(&kernfs_open_node_lock);
 549         mutex_unlock(&kernfs_open_file_mutex);
 550
 551         if (on) {
 552                 kfree(new_on);
 553                 return 0;
 554         }
 555
 556         /* not there, initialize a new one and retry */
 557         new_on = kmalloc(sizeof(*new_on), GFP_KERNEL);
 558         if (!new_on)
 559                 return -ENOMEM;
 560
 561         atomic_set(&new_on->refcnt, 0);
 562         atomic_set(&new_on->event, 1);
 563         init_waitqueue_head(&new_on->poll);
 564         INIT_LIST_HEAD(&new_on->files);
 565         goto retry;
 566 }
 567
 568 /**
 569  *      kernfs_put_open_node - put kernfs_open_node
 570  *      @kn: target kernfs_nodet
 571  *      @of: associated kernfs_open_file
 572  *
 573  *      Put @kn->attr.open and unlink @of from the files list.  If
 574  *      reference count reaches zero, disassociate and free it.
 575  *
 576  *      LOCKING:
 577  *      None.
 578  */
 579 static void kernfs_put_open_node(struct kernfs_node *kn,
 580                                  struct kernfs_open_file *of)
 581 {
 582         struct kernfs_open_node *on = kn->attr.open;
 583         unsigned long flags;
 584
 585         mutex_lock(&kernfs_open_file_mutex);
 586         spin_lock_irqsave(&kernfs_open_node_lock, flags);
 587
 588         if (of)
 589                 list_del(&of->list);
 590
 591         if (atomic_dec_and_test(&on->refcnt))
 592                 kn->attr.open = NULL;
 593         else
 594                 on = NULL;
 595
 596         spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
 597         mutex_unlock(&kernfs_open_file_mutex);
 598
 599         kfree(on);
 600 }
 601
 602 static int kernfs_fop_open(struct inode *inode, struct file *file)
 603 {
 604         struct kernfs_node *kn = file->f_path.dentry->d_fsdata;
 605         const struct kernfs_ops *ops;
 606         struct kernfs_open_file *of;
 607         bool has_read, has_write, has_mmap;
 608         int error = -EACCES;
 609
 610         if (!kernfs_get_active(kn))
 611                 return -ENODEV;
 612
 613         ops = kernfs_ops(kn);
 614
 615         has_read = ops->seq_show || ops->read || ops->mmap;
 616         has_write = ops->write || ops->mmap;
 617         has_mmap = ops->mmap;
 618
 619         /* check perms and supported operations */
 620         if ((file->f_mode & FMODE_WRITE) &&
 621             (!(inode->i_mode & S_IWUGO) || !has_write))
 622                 goto err_out;
 623
 624         if ((file->f_mode & FMODE_READ) &&
 625             (!(inode->i_mode & S_IRUGO) || !has_read))
 626                 goto err_out;
 627
 628         /* allocate a kernfs_open_file for the file */
 629         error = -ENOMEM;
 630         of = kzalloc(sizeof(struct kernfs_open_file), GFP_KERNEL);
 631         if (!of)
 632                 goto err_out;
 633
 634         /*
 635          * The following is done to give a different lockdep key to
 636          * @of->mutex for files which implement mmap.  This is a rather
 637          * crude way to avoid false positive lockdep warning around
 638          * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and
 639          * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under
 640          * which mm->mmap_sem nests, while holding @of->mutex.  As each
 641          * open file has a separate mutex, it's okay as long as those don't
 642          * happen on the same file.  At this point, we can't easily give
 643          * each file a separate locking class.  Let's differentiate on
 644          * whether the file has mmap or not for now.
 645          *
 646          * Both paths of the branch look the same.  They're supposed to
 647          * look that way and give @of->mutex different static lockdep keys.
 648          */
 649         if (has_mmap)
 650                 mutex_init(&of->mutex);
 651         else
 652                 mutex_init(&of->mutex);
 653
 654         of->kn = kn;
 655         of->file = file;
 656
 657         /*
 658          * Always instantiate seq_file even if read access doesn't use
 659          * seq_file or is not requested.  This unifies private data access
 660          * and readable regular files are the vast majority anyway.
 661          */
 662         if (ops->seq_show)
 663                 error = seq_open(file, &kernfs_seq_ops);
 664         else
 665                 error = seq_open(file, NULL);
 666         if (error)
 667                 goto err_free;
 668
 669         ((struct seq_file *)file->private_data)->private = of;
 670
 671         /* seq_file clears PWRITE unconditionally, restore it if WRITE */
 672         if (file->f_mode & FMODE_WRITE)
 673                 file->f_mode |= FMODE_PWRITE;
 674
 675         /* make sure we have open node struct */
 676         error = kernfs_get_open_node(kn, of);
 677         if (error)
 678                 goto err_close;
 679
 680         /* open succeeded, put active references */
 681         kernfs_put_active(kn);
 682         return 0;
 683
 684 err_close:
 685         seq_release(inode, file);
 686 err_free:
 687         kfree(of);
 688 err_out:
 689         kernfs_put_active(kn);
 690         return error;
 691 }
 692
 693 static int kernfs_fop_release(struct inode *inode, struct file *filp)
 694 {
 695         struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
 696         struct kernfs_open_file *of = kernfs_of(filp);
 697
 698         kernfs_put_open_node(kn, of);
 699         seq_release(inode, filp);
 700         kfree(of);
 701
 702         return 0;
 703 }
 704
 705 void kernfs_unmap_bin_file(struct kernfs_node *kn)
 706 {
 707         struct kernfs_open_node *on;
 708         struct kernfs_open_file *of;
 709
 710         if (!(kn->flags & KERNFS_HAS_MMAP))
 711                 return;
 712
 713         spin_lock_irq(&kernfs_open_node_lock);
 714         on = kn->attr.open;
 715         if (on)
 716                 atomic_inc(&on->refcnt);
 717         spin_unlock_irq(&kernfs_open_node_lock);
 718         if (!on)
 719                 return;
 720
 721         mutex_lock(&kernfs_open_file_mutex);
 722         list_for_each_entry(of, &on->files, list) {
 723                 struct inode *inode = file_inode(of->file);
 724                 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
 725         }
 726         mutex_unlock(&kernfs_open_file_mutex);
 727
 728         kernfs_put_open_node(kn, NULL);
 729 }
 730
 731 /*
 732  * Kernfs attribute files are pollable.  The idea is that you read
 733  * the content and then you use 'poll' or 'select' to wait for
 734  * the content to change.  When the content changes (assuming the
 735  * manager for the kobject supports notification), poll will
 736  * return POLLERR|POLLPRI, and select will return the fd whether
 737  * it is waiting for read, write, or exceptions.
 738  * Once poll/select indicates that the value has changed, you
 739  * need to close and re-open the file, or seek to 0 and read again.
 740  * Reminder: this only works for attributes which actively support
 741  * it, and it is not possible to test an attribute from userspace
 742  * to see if it supports poll (Neither 'poll' nor 'select' return
 743  * an appropriate error code).  When in doubt, set a suitable timeout value.
 744  */
 745 static unsigned int kernfs_fop_poll(struct file *filp, poll_table *wait)
 746 {
 747         struct kernfs_open_file *of = kernfs_of(filp);
 748         struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
 749         struct kernfs_open_node *on = kn->attr.open;
 750
 751         /* need parent for the kobj, grab both */
 752         if (!kernfs_get_active(kn))
 753                 goto trigger;
 754
 755         poll_wait(filp, &on->poll, wait);
 756
 757         kernfs_put_active(kn);
 758
 759         if (of->event != atomic_read(&on->event))
 760                 goto trigger;
 761
 762         return DEFAULT_POLLMASK;
 763
 764  trigger:
 765         return DEFAULT_POLLMASK|POLLERR|POLLPRI;
 766 }
 767
 768 /**
 769  * kernfs_notify - notify a kernfs file
 770  * @kn: file to notify
 771  *
 772  * Notify @kn such that poll(2) on @kn wakes up.
 773  */
 774 void kernfs_notify(struct kernfs_node *kn)
 775 {
 776         struct kernfs_open_node *on;
 777         unsigned long flags;
 778
 779         spin_lock_irqsave(&kernfs_open_node_lock, flags);
 780
 781         if (!WARN_ON(kernfs_type(kn) != KERNFS_FILE)) {
 782                 on = kn->attr.open;
 783                 if (on) {
 784                         atomic_inc(&on->event);
 785                         wake_up_interruptible(&on->poll);
 786                 }
 787         }
 788
 789         spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
 790 }
 791 EXPORT_SYMBOL_GPL(kernfs_notify);
 792
 793 const struct file_operations kernfs_file_fops = {
 794         .read           = kernfs_fop_read,
 795         .write          = kernfs_fop_write,
 796         .llseek         = generic_file_llseek,
 797         .mmap           = kernfs_fop_mmap,
 798         .open           = kernfs_fop_open,
 799         .release        = kernfs_fop_release,
 800         .poll           = kernfs_fop_poll,
 801 };
 802
 803 /**
 804  * __kernfs_create_file - kernfs internal function to create a file
 805  * @parent: directory to create the file in
 806  * @name: name of the file
 807  * @mode: mode of the file
 808  * @size: size of the file
 809  * @ops: kernfs operations for the file
 810  * @priv: private data for the file
 811  * @ns: optional namespace tag of the file
 812  * @static_name: don't copy file name
 813  * @key: lockdep key for the file's active_ref, %NULL to disable lockdep
 814  *
 815  * Returns the created node on success, ERR_PTR() value on error.
 816  */
 817 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
 818                                          const char *name,
 819                                          umode_t mode, loff_t size,
 820                                          const struct kernfs_ops *ops,
 821                                          void *priv, const void *ns,
 822                                          bool name_is_static,
 823                                          struct lock_class_key *key)
 824 {
 825         struct kernfs_addrm_cxt acxt;
 826         struct kernfs_node *kn;
 827         unsigned flags;
 828         int rc;
 829
 830         flags = KERNFS_FILE;
 831         if (name_is_static)
 832                 flags |= KERNFS_STATIC_NAME;
 833
 834         kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG, flags);
 835         if (!kn)
 836                 return ERR_PTR(-ENOMEM);
 837
 838         kn->attr.ops = ops;
 839         kn->attr.size = size;
 840         kn->ns = ns;
 841         kn->priv = priv;
 842
 843 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 844         if (key) {
 845                 lockdep_init_map(&kn->dep_map, "s_active", key, 0);
 846                 kn->flags |= KERNFS_LOCKDEP;
 847         }
 848 #endif
 849
 850         /*
 851          * kn->attr.ops is accesible only while holding active ref.  We
 852          * need to know whether some ops are implemented outside active
 853          * ref.  Cache their existence in flags.
 854          */
 855         if (ops->seq_show)
 856                 kn->flags |= KERNFS_HAS_SEQ_SHOW;
 857         if (ops->mmap)
 858                 kn->flags |= KERNFS_HAS_MMAP;
 859
 860         kernfs_addrm_start(&acxt);
 861         rc = kernfs_add_one(&acxt, kn);
 862         kernfs_addrm_finish(&acxt);
 863
 864         if (rc) {
 865                 kernfs_put(kn);
 866                 return ERR_PTR(rc);
 867         }
 868         return kn;
 869 }