fs/sysfs/file.c

   1 /*
   2  * fs/sysfs/file.c - sysfs regular (text) file implementation
   3  *
   4  * Copyright (c) 2001-3 Patrick Mochel
   5  * Copyright (c) 2007 SUSE Linux Products GmbH
   6  * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
   7  *
   8  * This file is released under the GPLv2.
   9  *
  10  * Please see Documentation/filesystems/sysfs.txt for more information.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kobject.h>
  15 #include <linux/kallsyms.h>
  16 #include <linux/slab.h>
  17 #include <linux/fsnotify.h>
  18 #include <linux/namei.h>
  19 #include <linux/poll.h>
  20 #include <linux/list.h>
  21 #include <linux/mutex.h>
  22 #include <linux/limits.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/seq_file.h>
  25 #include <linux/mm.h>
  26
  27 #include "sysfs.h"
  28
  29 /*
  30  * There's one sysfs_open_file for each open file and one sysfs_open_dirent
  31  * for each sysfs_dirent with one or more open files.
  32  *
  33  * sysfs_dirent->s_attr.open points to sysfs_open_dirent.  s_attr.open is
  34  * protected by sysfs_open_dirent_lock.
  35  *
  36  * filp->private_data points to seq_file whose ->private points to
  37  * sysfs_open_file.  sysfs_open_files are chained at
  38  * sysfs_open_dirent->files, which is protected by sysfs_open_file_mutex.
  39  */
  40 static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
  41 static DEFINE_MUTEX(sysfs_open_file_mutex);
  42
  43 struct sysfs_open_dirent {
  44         atomic_t                refcnt;
  45         atomic_t                event;
  46         wait_queue_head_t       poll;
  47         struct list_head        files; /* goes through sysfs_open_file.list */
  48 };
  49
  50 struct sysfs_open_file {
  51         struct sysfs_dirent     *sd;
  52         struct file             *file;
  53         struct mutex            mutex;
  54         int                     event;
  55         struct list_head        list;
  56
  57         bool                    mmapped;
  58         const struct vm_operations_struct *vm_ops;
  59 };
  60
  61 static bool sysfs_is_bin(struct sysfs_dirent *sd)
  62 {
  63         return sysfs_type(sd) == SYSFS_KOBJ_BIN_ATTR;
  64 }
  65
  66 static struct sysfs_open_file *sysfs_of(struct file *file)
  67 {
  68         return ((struct seq_file *)file->private_data)->private;
  69 }
  70
  71 /*
  72  * Determine ktype->sysfs_ops for the given sysfs_dirent.  This function
  73  * must be called while holding an active reference.
  74  */
  75 static const struct sysfs_ops *sysfs_file_ops(struct sysfs_dirent *sd)
  76 {
  77         struct kobject *kobj = sd->s_parent->s_dir.kobj;
  78
  79         if (!sysfs_ignore_lockdep(sd))
  80                 lockdep_assert_held(sd);
  81         return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
  82 }
  83
  84 /*
  85  * Reads on sysfs are handled through seq_file, which takes care of hairy
  86  * details like buffering and seeking.  The following function pipes
  87  * sysfs_ops->show() result through seq_file.
  88  */
  89 static int sysfs_seq_show(struct seq_file *sf, void *v)
  90 {
  91         struct sysfs_open_file *of = sf->private;
  92         struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
  93         const struct sysfs_ops *ops;
  94         char *buf;
  95         ssize_t count;
  96
  97         /* acquire buffer and ensure that it's >= PAGE_SIZE */
  98         count = seq_get_buf(sf, &buf);
  99         if (count < PAGE_SIZE) {
 100                 seq_commit(sf, -1);
 101                 return 0;
 102         }
 103
 104         /*
 105          * Need @of->sd for attr and ops, its parent for kobj.  @of->mutex
 106          * nests outside active ref and is just to ensure that the ops
 107          * aren't called concurrently for the same open file.
 108          */
 109         mutex_lock(&of->mutex);
 110         if (!sysfs_get_active(of->sd)) {
 111                 mutex_unlock(&of->mutex);
 112                 return -ENODEV;
 113         }
 114
 115         of->event = atomic_read(&of->sd->s_attr.open->event);
 116
 117         /*
 118          * Lookup @ops and invoke show().  Control may reach here via seq
 119          * file lseek even if @ops->show() isn't implemented.
 120          */
 121         ops = sysfs_file_ops(of->sd);
 122         if (ops->show)
 123                 count = ops->show(kobj, of->sd->s_attr.attr, buf);
 124         else
 125                 count = 0;
 126
 127         sysfs_put_active(of->sd);
 128         mutex_unlock(&of->mutex);
 129
 130         if (count < 0)
 131                 return count;
 132
 133         /*
 134          * The code works fine with PAGE_SIZE return but it's likely to
 135          * indicate truncated result or overflow in normal use cases.
 136          */
 137         if (count >= (ssize_t)PAGE_SIZE) {
 138                 print_symbol("fill_read_buffer: %s returned bad count\n",
 139                         (unsigned long)ops->show);
 140                 /* Try to struggle along */
 141                 count = PAGE_SIZE - 1;
 142         }
 143         seq_commit(sf, count);
 144         return 0;
 145 }
 146
 147 /*
 148  * Read method for bin files.  As reading a bin file can have side-effects,
 149  * the exact offset and bytes specified in read(2) call should be passed to
 150  * the read callback making it difficult to use seq_file.  Implement
 151  * simplistic custom buffering for bin files.
 152  */
 153 static ssize_t sysfs_bin_read(struct file *file, char __user *userbuf,
 154                               size_t bytes, loff_t *off)
 155 {
 156         struct sysfs_open_file *of = sysfs_of(file);
 157         struct bin_attribute *battr = of->sd->s_attr.bin_attr;
 158         struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
 159         loff_t size = file_inode(file)->i_size;
 160         int count = min_t(size_t, bytes, PAGE_SIZE);
 161         loff_t offs = *off;
 162         char *buf;
 163
 164         if (!bytes)
 165                 return 0;
 166
 167         if (size) {
 168                 if (offs > size)
 169                         return 0;
 170                 if (offs + count > size)
 171                         count = size - offs;
 172         }
 173
 174         buf = kmalloc(count, GFP_KERNEL);
 175         if (!buf)
 176                 return -ENOMEM;
 177
 178         /* need of->sd for battr, its parent for kobj */
 179         mutex_lock(&of->mutex);
 180         if (!sysfs_get_active(of->sd)) {
 181                 count = -ENODEV;
 182                 mutex_unlock(&of->mutex);
 183                 goto out_free;
 184         }
 185
 186         if (battr->read)
 187                 count = battr->read(file, kobj, battr, buf, offs, count);
 188         else
 189                 count = -EIO;
 190
 191         sysfs_put_active(of->sd);
 192         mutex_unlock(&of->mutex);
 193
 194         if (count < 0)
 195                 goto out_free;
 196
 197         if (copy_to_user(userbuf, buf, count)) {
 198                 count = -EFAULT;
 199                 goto out_free;
 200         }
 201
 202         pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
 203
 204         *off = offs + count;
 205
 206  out_free:
 207         kfree(buf);
 208         return count;
 209 }
 210
 211 /**
 212  * flush_write_buffer - push buffer to kobject
 213  * @of: open file
 214  * @buf: data buffer for file
 215  * @off: file offset to write to
 216  * @count: number of bytes
 217  *
 218  * Get the correct pointers for the kobject and the attribute we're dealing
 219  * with, then call the store() method for it with @buf.
 220  */
 221 static int flush_write_buffer(struct sysfs_open_file *of, char *buf, loff_t off,
 222                               size_t count)
 223 {
 224         struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
 225         int rc = 0;
 226
 227         /*
 228          * Need @of->sd for attr and ops, its parent for kobj.  @of->mutex
 229          * nests outside active ref and is just to ensure that the ops
 230          * aren't called concurrently for the same open file.
 231          */
 232         mutex_lock(&of->mutex);
 233         if (!sysfs_get_active(of->sd)) {
 234                 mutex_unlock(&of->mutex);
 235                 return -ENODEV;
 236         }
 237
 238         if (sysfs_is_bin(of->sd)) {
 239                 struct bin_attribute *battr = of->sd->s_attr.bin_attr;
 240
 241                 rc = -EIO;
 242                 if (battr->write)
 243                         rc = battr->write(of->file, kobj, battr, buf, off,
 244                                           count);
 245         } else {
 246                 const struct sysfs_ops *ops = sysfs_file_ops(of->sd);
 247
 248                 rc = ops->store(kobj, of->sd->s_attr.attr, buf, count);
 249         }
 250
 251         sysfs_put_active(of->sd);
 252         mutex_unlock(&of->mutex);
 253
 254         return rc;
 255 }
 256
 257 /**
 258  * sysfs_write_file - write an attribute
 259  * @file: file pointer
 260  * @user_buf: data to write
 261  * @count: number of bytes
 262  * @ppos: starting offset
 263  *
 264  * Copy data in from userland and pass it to the matching
 265  * sysfs_ops->store() by invoking flush_write_buffer().
 266  *
 267  * There is no easy way for us to know if userspace is only doing a partial
 268  * write, so we don't support them. We expect the entire buffer to come on
 269  * the first write.  Hint: if you're writing a value, first read the file,
 270  * modify only the the value you're changing, then write entire buffer
 271  * back.
 272  */
 273 static ssize_t sysfs_write_file(struct file *file, const char __user *user_buf,
 274                                 size_t count, loff_t *ppos)
 275 {
 276         struct sysfs_open_file *of = sysfs_of(file);
 277         ssize_t len = min_t(size_t, count, PAGE_SIZE);
 278         loff_t size = file_inode(file)->i_size;
 279         char *buf;
 280
 281         if (sysfs_is_bin(of->sd) && size) {
 282                 if (size <= *ppos)
 283                         return 0;
 284                 len = min_t(ssize_t, len, size - *ppos);
 285         }
 286
 287         if (!len)
 288                 return 0;
 289
 290         buf = kmalloc(len + 1, GFP_KERNEL);
 291         if (!buf)
 292                 return -ENOMEM;
 293
 294         if (copy_from_user(buf, user_buf, len)) {
 295                 len = -EFAULT;
 296                 goto out_free;
 297         }
 298         buf[len] = '\0';        /* guarantee string termination */
 299
 300         len = flush_write_buffer(of, buf, *ppos, len);
 301         if (len > 0)
 302                 *ppos += len;
 303 out_free:
 304         kfree(buf);
 305         return len;
 306 }
 307
 308 static void sysfs_bin_vma_open(struct vm_area_struct *vma)
 309 {
 310         struct file *file = vma->vm_file;
 311         struct sysfs_open_file *of = sysfs_of(file);
 312
 313         if (!of->vm_ops)
 314                 return;
 315
 316         if (!sysfs_get_active(of->sd))
 317                 return;
 318
 319         if (of->vm_ops->open)
 320                 of->vm_ops->open(vma);
 321
 322         sysfs_put_active(of->sd);
 323 }
 324
 325 static int sysfs_bin_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 326 {
 327         struct file *file = vma->vm_file;
 328         struct sysfs_open_file *of = sysfs_of(file);
 329         int ret;
 330
 331         if (!of->vm_ops)
 332                 return VM_FAULT_SIGBUS;
 333
 334         if (!sysfs_get_active(of->sd))
 335                 return VM_FAULT_SIGBUS;
 336
 337         ret = VM_FAULT_SIGBUS;
 338         if (of->vm_ops->fault)
 339                 ret = of->vm_ops->fault(vma, vmf);
 340
 341         sysfs_put_active(of->sd);
 342         return ret;
 343 }
 344
 345 static int sysfs_bin_page_mkwrite(struct vm_area_struct *vma,
 346                                   struct vm_fault *vmf)
 347 {
 348         struct file *file = vma->vm_file;
 349         struct sysfs_open_file *of = sysfs_of(file);
 350         int ret;
 351
 352         if (!of->vm_ops)
 353                 return VM_FAULT_SIGBUS;
 354
 355         if (!sysfs_get_active(of->sd))
 356                 return VM_FAULT_SIGBUS;
 357
 358         ret = 0;
 359         if (of->vm_ops->page_mkwrite)
 360                 ret = of->vm_ops->page_mkwrite(vma, vmf);
 361         else
 362                 file_update_time(file);
 363
 364         sysfs_put_active(of->sd);
 365         return ret;
 366 }
 367
 368 static int sysfs_bin_access(struct vm_area_struct *vma, unsigned long addr,
 369                             void *buf, int len, int write)
 370 {
 371         struct file *file = vma->vm_file;
 372         struct sysfs_open_file *of = sysfs_of(file);
 373         int ret;
 374
 375         if (!of->vm_ops)
 376                 return -EINVAL;
 377
 378         if (!sysfs_get_active(of->sd))
 379                 return -EINVAL;
 380
 381         ret = -EINVAL;
 382         if (of->vm_ops->access)
 383                 ret = of->vm_ops->access(vma, addr, buf, len, write);
 384
 385         sysfs_put_active(of->sd);
 386         return ret;
 387 }
 388
 389 #ifdef CONFIG_NUMA
 390 static int sysfs_bin_set_policy(struct vm_area_struct *vma,
 391                                 struct mempolicy *new)
 392 {
 393         struct file *file = vma->vm_file;
 394         struct sysfs_open_file *of = sysfs_of(file);
 395         int ret;
 396
 397         if (!of->vm_ops)
 398                 return 0;
 399
 400         if (!sysfs_get_active(of->sd))
 401                 return -EINVAL;
 402
 403         ret = 0;
 404         if (of->vm_ops->set_policy)
 405                 ret = of->vm_ops->set_policy(vma, new);
 406
 407         sysfs_put_active(of->sd);
 408         return ret;
 409 }
 410
 411 static struct mempolicy *sysfs_bin_get_policy(struct vm_area_struct *vma,
 412                                               unsigned long addr)
 413 {
 414         struct file *file = vma->vm_file;
 415         struct sysfs_open_file *of = sysfs_of(file);
 416         struct mempolicy *pol;
 417
 418         if (!of->vm_ops)
 419                 return vma->vm_policy;
 420
 421         if (!sysfs_get_active(of->sd))
 422                 return vma->vm_policy;
 423
 424         pol = vma->vm_policy;
 425         if (of->vm_ops->get_policy)
 426                 pol = of->vm_ops->get_policy(vma, addr);
 427
 428         sysfs_put_active(of->sd);
 429         return pol;
 430 }
 431
 432 static int sysfs_bin_migrate(struct vm_area_struct *vma, const nodemask_t *from,
 433                              const nodemask_t *to, unsigned long flags)
 434 {
 435         struct file *file = vma->vm_file;
 436         struct sysfs_open_file *of = sysfs_of(file);
 437         int ret;
 438
 439         if (!of->vm_ops)
 440                 return 0;
 441
 442         if (!sysfs_get_active(of->sd))
 443                 return 0;
 444
 445         ret = 0;
 446         if (of->vm_ops->migrate)
 447                 ret = of->vm_ops->migrate(vma, from, to, flags);
 448
 449         sysfs_put_active(of->sd);
 450         return ret;
 451 }
 452 #endif
 453
 454 static const struct vm_operations_struct sysfs_bin_vm_ops = {
 455         .open           = sysfs_bin_vma_open,
 456         .fault          = sysfs_bin_fault,
 457         .page_mkwrite   = sysfs_bin_page_mkwrite,
 458         .access         = sysfs_bin_access,
 459 #ifdef CONFIG_NUMA
 460         .set_policy     = sysfs_bin_set_policy,
 461         .get_policy     = sysfs_bin_get_policy,
 462         .migrate        = sysfs_bin_migrate,
 463 #endif
 464 };
 465
 466 static int sysfs_bin_mmap(struct file *file, struct vm_area_struct *vma)
 467 {
 468         struct sysfs_open_file *of = sysfs_of(file);
 469         struct bin_attribute *battr = of->sd->s_attr.bin_attr;
 470         struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
 471         int rc;
 472
 473         mutex_lock(&of->mutex);
 474
 475         /* need of->sd for battr, its parent for kobj */
 476         rc = -ENODEV;
 477         if (!sysfs_get_active(of->sd))
 478                 goto out_unlock;
 479
 480         if (!battr->mmap)
 481                 goto out_put;
 482
 483         rc = battr->mmap(file, kobj, battr, vma);
 484         if (rc)
 485                 goto out_put;
 486
 487         /*
 488          * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
 489          * to satisfy versions of X which crash if the mmap fails: that
 490          * substitutes a new vm_file, and we don't then want bin_vm_ops.
 491          */
 492         if (vma->vm_file != file)
 493                 goto out_put;
 494
 495         rc = -EINVAL;
 496         if (of->mmapped && of->vm_ops != vma->vm_ops)
 497                 goto out_put;
 498
 499         /*
 500          * It is not possible to successfully wrap close.
 501          * So error if someone is trying to use close.
 502          */
 503         rc = -EINVAL;
 504         if (vma->vm_ops && vma->vm_ops->close)
 505                 goto out_put;
 506
 507         rc = 0;
 508         of->mmapped = 1;
 509         of->vm_ops = vma->vm_ops;
 510         vma->vm_ops = &sysfs_bin_vm_ops;
 511 out_put:
 512         sysfs_put_active(of->sd);
 513 out_unlock:
 514         mutex_unlock(&of->mutex);
 515
 516         return rc;
 517 }
 518
 519 /**
 520  *      sysfs_get_open_dirent - get or create sysfs_open_dirent
 521  *      @sd: target sysfs_dirent
 522  *      @of: sysfs_open_file for this instance of open
 523  *
 524  *      If @sd->s_attr.open exists, increment its reference count;
 525  *      otherwise, create one.  @of is chained to the files list.
 526  *
 527  *      LOCKING:
 528  *      Kernel thread context (may sleep).
 529  *
 530  *      RETURNS:
 531  *      0 on success, -errno on failure.
 532  */
 533 static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
 534                                  struct sysfs_open_file *of)
 535 {
 536         struct sysfs_open_dirent *od, *new_od = NULL;
 537
 538  retry:
 539         mutex_lock(&sysfs_open_file_mutex);
 540         spin_lock_irq(&sysfs_open_dirent_lock);
 541
 542         if (!sd->s_attr.open && new_od) {
 543                 sd->s_attr.open = new_od;
 544                 new_od = NULL;
 545         }
 546
 547         od = sd->s_attr.open;
 548         if (od) {
 549                 atomic_inc(&od->refcnt);
 550                 list_add_tail(&of->list, &od->files);
 551         }
 552
 553         spin_unlock_irq(&sysfs_open_dirent_lock);
 554         mutex_unlock(&sysfs_open_file_mutex);
 555
 556         if (od) {
 557                 kfree(new_od);
 558                 return 0;
 559         }
 560
 561         /* not there, initialize a new one and retry */
 562         new_od = kmalloc(sizeof(*new_od), GFP_KERNEL);
 563         if (!new_od)
 564                 return -ENOMEM;
 565
 566         atomic_set(&new_od->refcnt, 0);
 567         atomic_set(&new_od->event, 1);
 568         init_waitqueue_head(&new_od->poll);
 569         INIT_LIST_HEAD(&new_od->files);
 570         goto retry;
 571 }
 572
 573 /**
 574  *      sysfs_put_open_dirent - put sysfs_open_dirent
 575  *      @sd: target sysfs_dirent
 576  *      @of: associated sysfs_open_file
 577  *
 578  *      Put @sd->s_attr.open and unlink @of from the files list.  If
 579  *      reference count reaches zero, disassociate and free it.
 580  *
 581  *      LOCKING:
 582  *      None.
 583  */
 584 static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
 585                                   struct sysfs_open_file *of)
 586 {
 587         struct sysfs_open_dirent *od = sd->s_attr.open;
 588         unsigned long flags;
 589
 590         mutex_lock(&sysfs_open_file_mutex);
 591         spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
 592
 593         if (of)
 594                 list_del(&of->list);
 595
 596         if (atomic_dec_and_test(&od->refcnt))
 597                 sd->s_attr.open = NULL;
 598         else
 599                 od = NULL;
 600
 601         spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
 602         mutex_unlock(&sysfs_open_file_mutex);
 603
 604         kfree(od);
 605 }
 606
 607 static int sysfs_open_file(struct inode *inode, struct file *file)
 608 {
 609         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 610         struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
 611         struct sysfs_open_file *of;
 612         bool has_read, has_write, has_mmap;
 613         int error = -EACCES;
 614
 615         /* need attr_sd for attr and ops, its parent for kobj */
 616         if (!sysfs_get_active(attr_sd))
 617                 return -ENODEV;
 618
 619         if (sysfs_is_bin(attr_sd)) {
 620                 struct bin_attribute *battr = attr_sd->s_attr.bin_attr;
 621
 622                 has_read = battr->read || battr->mmap;
 623                 has_write = battr->write || battr->mmap;
 624                 has_mmap = battr->mmap;
 625         } else {
 626                 const struct sysfs_ops *ops = sysfs_file_ops(attr_sd);
 627
 628                 /* every kobject with an attribute needs a ktype assigned */
 629                 if (WARN(!ops, KERN_ERR
 630                          "missing sysfs attribute operations for kobject: %s\n",
 631                          kobject_name(kobj)))
 632                         goto err_out;
 633
 634                 has_read = ops->show;
 635                 has_write = ops->store;
 636                 has_mmap = false;
 637         }
 638
 639         /* check perms and supported operations */
 640         if ((file->f_mode & FMODE_WRITE) &&
 641             (!(inode->i_mode & S_IWUGO) || !has_write))
 642                 goto err_out;
 643
 644         if ((file->f_mode & FMODE_READ) &&
 645             (!(inode->i_mode & S_IRUGO) || !has_read))
 646                 goto err_out;
 647
 648         /* allocate a sysfs_open_file for the file */
 649         error = -ENOMEM;
 650         of = kzalloc(sizeof(struct sysfs_open_file), GFP_KERNEL);
 651         if (!of)
 652                 goto err_out;
 653
 654         /*
 655          * The following is done to give a different lockdep key to
 656          * @of->mutex for files which implement mmap.  This is a rather
 657          * crude way to avoid false positive lockdep warning around
 658          * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and
 659          * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under
 660          * which mm->mmap_sem nests, while holding @of->mutex.  As each
 661          * open file has a separate mutex, it's okay as long as those don't
 662          * happen on the same file.  At this point, we can't easily give
 663          * each file a separate locking class.  Let's differentiate on
 664          * whether the file has mmap or not for now.
 665          */
 666         if (has_mmap)
 667                 mutex_init(&of->mutex);
 668         else
 669                 mutex_init(&of->mutex);
 670
 671         of->sd = attr_sd;
 672         of->file = file;
 673
 674         /*
 675          * Always instantiate seq_file even if read access doesn't use
 676          * seq_file or is not requested.  This unifies private data access
 677          * and readable regular files are the vast majority anyway.
 678          */
 679         if (sysfs_is_bin(attr_sd))
 680                 error = single_open(file, NULL, of);
 681         else
 682                 error = single_open(file, sysfs_seq_show, of);
 683         if (error)
 684                 goto err_free;
 685
 686         /* seq_file clears PWRITE unconditionally, restore it if WRITE */
 687         if (file->f_mode & FMODE_WRITE)
 688                 file->f_mode |= FMODE_PWRITE;
 689
 690         /* make sure we have open dirent struct */
 691         error = sysfs_get_open_dirent(attr_sd, of);
 692         if (error)
 693                 goto err_close;
 694
 695         /* open succeeded, put active references */
 696         sysfs_put_active(attr_sd);
 697         return 0;
 698
 699 err_close:
 700         single_release(inode, file);
 701 err_free:
 702         kfree(of);
 703 err_out:
 704         sysfs_put_active(attr_sd);
 705         return error;
 706 }
 707
 708 static int sysfs_release(struct inode *inode, struct file *filp)
 709 {
 710         struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
 711         struct sysfs_open_file *of = sysfs_of(filp);
 712
 713         sysfs_put_open_dirent(sd, of);
 714         single_release(inode, filp);
 715         kfree(of);
 716
 717         return 0;
 718 }
 719
 720 void sysfs_unmap_bin_file(struct sysfs_dirent *sd)
 721 {
 722         struct sysfs_open_dirent *od;
 723         struct sysfs_open_file *of;
 724
 725         if (!sysfs_is_bin(sd))
 726                 return;
 727
 728         spin_lock_irq(&sysfs_open_dirent_lock);
 729         od = sd->s_attr.open;
 730         if (od)
 731                 atomic_inc(&od->refcnt);
 732         spin_unlock_irq(&sysfs_open_dirent_lock);
 733         if (!od)
 734                 return;
 735
 736         mutex_lock(&sysfs_open_file_mutex);
 737         list_for_each_entry(of, &od->files, list) {
 738                 struct inode *inode = file_inode(of->file);
 739                 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
 740         }
 741         mutex_unlock(&sysfs_open_file_mutex);
 742
 743         sysfs_put_open_dirent(sd, NULL);
 744 }
 745
 746 /* Sysfs attribute files are pollable.  The idea is that you read
 747  * the content and then you use 'poll' or 'select' to wait for
 748  * the content to change.  When the content changes (assuming the
 749  * manager for the kobject supports notification), poll will
 750  * return POLLERR|POLLPRI, and select will return the fd whether
 751  * it is waiting for read, write, or exceptions.
 752  * Once poll/select indicates that the value has changed, you
 753  * need to close and re-open the file, or seek to 0 and read again.
 754  * Reminder: this only works for attributes which actively support
 755  * it, and it is not possible to test an attribute from userspace
 756  * to see if it supports poll (Neither 'poll' nor 'select' return
 757  * an appropriate error code).  When in doubt, set a suitable timeout value.
 758  */
 759 static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
 760 {
 761         struct sysfs_open_file *of = sysfs_of(filp);
 762         struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
 763         struct sysfs_open_dirent *od = attr_sd->s_attr.open;
 764
 765         /* need parent for the kobj, grab both */
 766         if (!sysfs_get_active(attr_sd))
 767                 goto trigger;
 768
 769         poll_wait(filp, &od->poll, wait);
 770
 771         sysfs_put_active(attr_sd);
 772
 773         if (of->event != atomic_read(&od->event))
 774                 goto trigger;
 775
 776         return DEFAULT_POLLMASK;
 777
 778  trigger:
 779         return DEFAULT_POLLMASK|POLLERR|POLLPRI;
 780 }
 781
 782 void sysfs_notify_dirent(struct sysfs_dirent *sd)
 783 {
 784         struct sysfs_open_dirent *od;
 785         unsigned long flags;
 786
 787         spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
 788
 789         if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
 790                 od = sd->s_attr.open;
 791                 if (od) {
 792                         atomic_inc(&od->event);
 793                         wake_up_interruptible(&od->poll);
 794                 }
 795         }
 796
 797         spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
 798 }
 799 EXPORT_SYMBOL_GPL(sysfs_notify_dirent);
 800
 801 void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
 802 {
 803         struct sysfs_dirent *sd = k->sd;
 804
 805         mutex_lock(&sysfs_mutex);
 806
 807         if (sd && dir)
 808                 sd = sysfs_find_dirent(sd, dir, NULL);
 809         if (sd && attr)
 810                 sd = sysfs_find_dirent(sd, attr, NULL);
 811         if (sd)
 812                 sysfs_notify_dirent(sd);
 813
 814         mutex_unlock(&sysfs_mutex);
 815 }
 816 EXPORT_SYMBOL_GPL(sysfs_notify);
 817
 818 const struct file_operations sysfs_file_operations = {
 819         .read           = seq_read,
 820         .write          = sysfs_write_file,
 821         .llseek         = generic_file_llseek,
 822         .open           = sysfs_open_file,
 823         .release        = sysfs_release,
 824         .poll           = sysfs_poll,
 825 };
 826
 827 const struct file_operations sysfs_bin_operations = {
 828         .read           = sysfs_bin_read,
 829         .write          = sysfs_write_file,
 830         .llseek         = generic_file_llseek,
 831         .mmap           = sysfs_bin_mmap,
 832         .open           = sysfs_open_file,
 833         .release        = sysfs_release,
 834         .poll           = sysfs_poll,
 835 };
 836
 837 int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
 838                            const struct attribute *attr, int type,
 839                            umode_t amode, const void *ns)
 840 {
 841         umode_t mode = (amode & S_IALLUGO) | S_IFREG;
 842         struct sysfs_addrm_cxt acxt;
 843         struct sysfs_dirent *sd;
 844         int rc;
 845
 846         sd = sysfs_new_dirent(attr->name, mode, type);
 847         if (!sd)
 848                 return -ENOMEM;
 849
 850         sd->s_ns = ns;
 851         sd->s_attr.attr = (void *)attr;
 852         sysfs_dirent_init_lockdep(sd);
 853
 854         sysfs_addrm_start(&acxt);
 855         rc = sysfs_add_one(&acxt, sd, dir_sd);
 856         sysfs_addrm_finish(&acxt);
 857
 858         if (rc)
 859                 sysfs_put(sd);
 860
 861         return rc;
 862 }
 863
 864
 865 int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
 866                    int type)
 867 {
 868         return sysfs_add_file_mode_ns(dir_sd, attr, type, attr->mode, NULL);
 869 }
 870
 871 /**
 872  * sysfs_create_file_ns - create an attribute file for an object with custom ns
 873  * @kobj: object we're creating for
 874  * @attr: attribute descriptor
 875  * @ns: namespace the new file should belong to
 876  */
 877 int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr,
 878                          const void *ns)
 879 {
 880         BUG_ON(!kobj || !kobj->sd || !attr);
 881
 882         return sysfs_add_file_mode_ns(kobj->sd, attr, SYSFS_KOBJ_ATTR,
 883                                       attr->mode, ns);
 884
 885 }
 886 EXPORT_SYMBOL_GPL(sysfs_create_file_ns);
 887
 888 int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
 889 {
 890         int err = 0;
 891         int i;
 892
 893         for (i = 0; ptr[i] && !err; i++)
 894                 err = sysfs_create_file(kobj, ptr[i]);
 895         if (err)
 896                 while (--i >= 0)
 897                         sysfs_remove_file(kobj, ptr[i]);
 898         return err;
 899 }
 900 EXPORT_SYMBOL_GPL(sysfs_create_files);
 901
 902 /**
 903  * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
 904  * @kobj: object we're acting for.
 905  * @attr: attribute descriptor.
 906  * @group: group name.
 907  */
 908 int sysfs_add_file_to_group(struct kobject *kobj,
 909                 const struct attribute *attr, const char *group)
 910 {
 911         struct sysfs_dirent *dir_sd;
 912         int error;
 913
 914         if (group)
 915                 dir_sd = sysfs_get_dirent(kobj->sd, group);
 916         else
 917                 dir_sd = sysfs_get(kobj->sd);
 918
 919         if (!dir_sd)
 920                 return -ENOENT;
 921
 922         error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
 923         sysfs_put(dir_sd);
 924
 925         return error;
 926 }
 927 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
 928
 929 /**
 930  * sysfs_chmod_file - update the modified mode value on an object attribute.
 931  * @kobj: object we're acting for.
 932  * @attr: attribute descriptor.
 933  * @mode: file permissions.
 934  *
 935  */
 936 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
 937                      umode_t mode)
 938 {
 939         struct sysfs_dirent *sd;
 940         struct iattr newattrs;
 941         int rc;
 942
 943         mutex_lock(&sysfs_mutex);
 944
 945         rc = -ENOENT;
 946         sd = sysfs_find_dirent(kobj->sd, attr->name, NULL);
 947         if (!sd)
 948                 goto out;
 949
 950         newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
 951         newattrs.ia_valid = ATTR_MODE;
 952         rc = sysfs_sd_setattr(sd, &newattrs);
 953
 954  out:
 955         mutex_unlock(&sysfs_mutex);
 956         return rc;
 957 }
 958 EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 959
 960 /**
 961  * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
 962  * @kobj: object we're acting for
 963  * @attr: attribute descriptor
 964  * @ns: namespace tag of the file to remove
 965  *
 966  * Hash the attribute name and namespace tag and kill the victim.
 967  */
 968 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
 969                           const void *ns)
 970 {
 971         struct sysfs_dirent *dir_sd = kobj->sd;
 972
 973         sysfs_hash_and_remove(dir_sd, attr->name, ns);
 974 }
 975 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
 976
 977 void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr)
 978 {
 979         int i;
 980         for (i = 0; ptr[i]; i++)
 981                 sysfs_remove_file(kobj, ptr[i]);
 982 }
 983 EXPORT_SYMBOL_GPL(sysfs_remove_files);
 984
 985 /**
 986  * sysfs_remove_file_from_group - remove an attribute file from a group.
 987  * @kobj: object we're acting for.
 988  * @attr: attribute descriptor.
 989  * @group: group name.
 990  */
 991 void sysfs_remove_file_from_group(struct kobject *kobj,
 992                 const struct attribute *attr, const char *group)
 993 {
 994         struct sysfs_dirent *dir_sd;
 995
 996         if (group)
 997                 dir_sd = sysfs_get_dirent(kobj->sd, group);
 998         else
 999                 dir_sd = sysfs_get(kobj->sd);
1000         if (dir_sd) {
1001                 sysfs_hash_and_remove(dir_sd, attr->name, NULL);
1002                 sysfs_put(dir_sd);
1003         }
1004 }
1005 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
1006
1007 /**
1008  *      sysfs_create_bin_file - create binary file for object.
1009  *      @kobj:  object.
1010  *      @attr:  attribute descriptor.
1011  */
1012 int sysfs_create_bin_file(struct kobject *kobj,
1013                           const struct bin_attribute *attr)
1014 {
1015         BUG_ON(!kobj || !kobj->sd || !attr);
1016
1017         return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
1018 }
1019 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
1020
1021 /**
1022  *      sysfs_remove_bin_file - remove binary file for object.
1023  *      @kobj:  object.
1024  *      @attr:  attribute descriptor.
1025  */
1026 void sysfs_remove_bin_file(struct kobject *kobj,
1027                            const struct bin_attribute *attr)
1028 {
1029         sysfs_hash_and_remove(kobj->sd, attr->attr.name, NULL);
1030 }
1031 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
1032
1033 struct sysfs_schedule_callback_struct {
1034         struct list_head        workq_list;
1035         struct kobject          *kobj;
1036         void                    (*func)(void *);
1037         void                    *data;
1038         struct module           *owner;
1039         struct work_struct      work;
1040 };
1041
1042 static struct workqueue_struct *sysfs_workqueue;
1043 static DEFINE_MUTEX(sysfs_workq_mutex);
1044 static LIST_HEAD(sysfs_workq);
1045 static void sysfs_schedule_callback_work(struct work_struct *work)
1046 {
1047         struct sysfs_schedule_callback_struct *ss = container_of(work,
1048                         struct sysfs_schedule_callback_struct, work);
1049
1050         (ss->func)(ss->data);
1051         kobject_put(ss->kobj);
1052         module_put(ss->owner);
1053         mutex_lock(&sysfs_workq_mutex);
1054         list_del(&ss->workq_list);
1055         mutex_unlock(&sysfs_workq_mutex);
1056         kfree(ss);
1057 }
1058
1059 /**
1060  * sysfs_schedule_callback - helper to schedule a callback for a kobject
1061  * @kobj: object we're acting for.
1062  * @func: callback function to invoke later.
1063  * @data: argument to pass to @func.
1064  * @owner: module owning the callback code
1065  *
1066  * sysfs attribute methods must not unregister themselves or their parent
1067  * kobject (which would amount to the same thing).  Attempts to do so will
1068  * deadlock, since unregistration is mutually exclusive with driver
1069  * callbacks.
1070  *
1071  * Instead methods can call this routine, which will attempt to allocate
1072  * and schedule a workqueue request to call back @func with @data as its
1073  * argument in the workqueue's process context.  @kobj will be pinned
1074  * until @func returns.
1075  *
1076  * Returns 0 if the request was submitted, -ENOMEM if storage could not
1077  * be allocated, -ENODEV if a reference to @owner isn't available,
1078  * -EAGAIN if a callback has already been scheduled for @kobj.
1079  */
1080 int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
1081                 void *data, struct module *owner)
1082 {
1083         struct sysfs_schedule_callback_struct *ss, *tmp;
1084
1085         if (!try_module_get(owner))
1086                 return -ENODEV;
1087
1088         mutex_lock(&sysfs_workq_mutex);
1089         list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
1090                 if (ss->kobj == kobj) {
1091                         module_put(owner);
1092                         mutex_unlock(&sysfs_workq_mutex);
1093                         return -EAGAIN;
1094                 }
1095         mutex_unlock(&sysfs_workq_mutex);
1096
1097         if (sysfs_workqueue == NULL) {
1098                 sysfs_workqueue = create_singlethread_workqueue("sysfsd");
1099                 if (sysfs_workqueue == NULL) {
1100                         module_put(owner);
1101                         return -ENOMEM;
1102                 }
1103         }
1104
1105         ss = kmalloc(sizeof(*ss), GFP_KERNEL);
1106         if (!ss) {
1107                 module_put(owner);
1108                 return -ENOMEM;
1109         }
1110         kobject_get(kobj);
1111         ss->kobj = kobj;
1112         ss->func = func;
1113         ss->data = data;
1114         ss->owner = owner;
1115         INIT_WORK(&ss->work, sysfs_schedule_callback_work);
1116         INIT_LIST_HEAD(&ss->workq_list);
1117         mutex_lock(&sysfs_workq_mutex);
1118         list_add_tail(&ss->workq_list, &sysfs_workq);
1119         mutex_unlock(&sysfs_workq_mutex);
1120         queue_work(sysfs_workqueue, &ss->work);
1121         return 0;
1122 }
1123 EXPORT_SYMBOL_GPL(sysfs_schedule_callback);