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_bin_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_bin_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_bin_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         rc = -EINVAL;
 481         if (!battr->mmap)
 482                 goto out_put;
 483
 484         rc = battr->mmap(file, kobj, battr, vma);
 485         if (rc)
 486                 goto out_put;
 487
 488         /*
 489          * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
 490          * to satisfy versions of X which crash if the mmap fails: that
 491          * substitutes a new vm_file, and we don't then want bin_vm_ops.
 492          */
 493         if (vma->vm_file != file)
 494                 goto out_put;
 495
 496         rc = -EINVAL;
 497         if (of->mmapped && of->vm_ops != vma->vm_ops)
 498                 goto out_put;
 499
 500         /*
 501          * It is not possible to successfully wrap close.
 502          * So error if someone is trying to use close.
 503          */
 504         rc = -EINVAL;
 505         if (vma->vm_ops && vma->vm_ops->close)
 506                 goto out_put;
 507
 508         rc = 0;
 509         of->mmapped = 1;
 510         of->vm_ops = vma->vm_ops;
 511         vma->vm_ops = &sysfs_bin_vm_ops;
 512 out_put:
 513         sysfs_put_active(of->sd);
 514 out_unlock:
 515         mutex_unlock(&of->mutex);
 516
 517         return rc;
 518 }
 519
 520 /**
 521  *      sysfs_get_open_dirent - get or create sysfs_open_dirent
 522  *      @sd: target sysfs_dirent
 523  *      @of: sysfs_open_file for this instance of open
 524  *
 525  *      If @sd->s_attr.open exists, increment its reference count;
 526  *      otherwise, create one.  @of is chained to the files list.
 527  *
 528  *      LOCKING:
 529  *      Kernel thread context (may sleep).
 530  *
 531  *      RETURNS:
 532  *      0 on success, -errno on failure.
 533  */
 534 static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
 535                                  struct sysfs_open_file *of)
 536 {
 537         struct sysfs_open_dirent *od, *new_od = NULL;
 538
 539  retry:
 540         mutex_lock(&sysfs_open_file_mutex);
 541         spin_lock_irq(&sysfs_open_dirent_lock);
 542
 543         if (!sd->s_attr.open && new_od) {
 544                 sd->s_attr.open = new_od;
 545                 new_od = NULL;
 546         }
 547
 548         od = sd->s_attr.open;
 549         if (od) {
 550                 atomic_inc(&od->refcnt);
 551                 list_add_tail(&of->list, &od->files);
 552         }
 553
 554         spin_unlock_irq(&sysfs_open_dirent_lock);
 555         mutex_unlock(&sysfs_open_file_mutex);
 556
 557         if (od) {
 558                 kfree(new_od);
 559                 return 0;
 560         }
 561
 562         /* not there, initialize a new one and retry */
 563         new_od = kmalloc(sizeof(*new_od), GFP_KERNEL);
 564         if (!new_od)
 565                 return -ENOMEM;
 566
 567         atomic_set(&new_od->refcnt, 0);
 568         atomic_set(&new_od->event, 1);
 569         init_waitqueue_head(&new_od->poll);
 570         INIT_LIST_HEAD(&new_od->files);
 571         goto retry;
 572 }
 573
 574 /**
 575  *      sysfs_put_open_dirent - put sysfs_open_dirent
 576  *      @sd: target sysfs_dirent
 577  *      @of: associated sysfs_open_file
 578  *
 579  *      Put @sd->s_attr.open and unlink @of from the files list.  If
 580  *      reference count reaches zero, disassociate and free it.
 581  *
 582  *      LOCKING:
 583  *      None.
 584  */
 585 static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
 586                                   struct sysfs_open_file *of)
 587 {
 588         struct sysfs_open_dirent *od = sd->s_attr.open;
 589         unsigned long flags;
 590
 591         mutex_lock(&sysfs_open_file_mutex);
 592         spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
 593
 594         if (of)
 595                 list_del(&of->list);
 596
 597         if (atomic_dec_and_test(&od->refcnt))
 598                 sd->s_attr.open = NULL;
 599         else
 600                 od = NULL;
 601
 602         spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
 603         mutex_unlock(&sysfs_open_file_mutex);
 604
 605         kfree(od);
 606 }
 607
 608 static int sysfs_open_file(struct inode *inode, struct file *file)
 609 {
 610         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 611         struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
 612         struct sysfs_open_file *of;
 613         bool has_read, has_write;
 614         int error = -EACCES;
 615
 616         /* need attr_sd for attr and ops, its parent for kobj */
 617         if (!sysfs_get_active(attr_sd))
 618                 return -ENODEV;
 619
 620         if (sysfs_is_bin(attr_sd)) {
 621                 struct bin_attribute *battr = attr_sd->s_bin_attr.bin_attr;
 622
 623                 has_read = battr->read || battr->mmap;
 624                 has_write = battr->write || 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         }
 637
 638         /* check perms and supported operations */
 639         if ((file->f_mode & FMODE_WRITE) &&
 640             (!(inode->i_mode & S_IWUGO) || !has_write))
 641                 goto err_out;
 642
 643         if ((file->f_mode & FMODE_READ) &&
 644             (!(inode->i_mode & S_IRUGO) || !has_read))
 645                 goto err_out;
 646
 647         /* allocate a sysfs_open_file for the file */
 648         error = -ENOMEM;
 649         of = kzalloc(sizeof(struct sysfs_open_file), GFP_KERNEL);
 650         if (!of)
 651                 goto err_out;
 652
 653         mutex_init(&of->mutex);
 654         of->sd = attr_sd;
 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 (sysfs_is_bin(attr_sd))
 663                 error = single_open(file, NULL, of);
 664         else
 665                 error = single_open(file, sysfs_seq_show, of);
 666         if (error)
 667                 goto err_free;
 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 dirent struct */
 674         error = sysfs_get_open_dirent(attr_sd, of);
 675         if (error)
 676                 goto err_close;
 677
 678         /* open succeeded, put active references */
 679         sysfs_put_active(attr_sd);
 680         return 0;
 681
 682 err_close:
 683         single_release(inode, file);
 684 err_free:
 685         kfree(of);
 686 err_out:
 687         sysfs_put_active(attr_sd);
 688         return error;
 689 }
 690
 691 static int sysfs_release(struct inode *inode, struct file *filp)
 692 {
 693         struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
 694         struct sysfs_open_file *of = sysfs_of(filp);
 695
 696         sysfs_put_open_dirent(sd, of);
 697         single_release(inode, filp);
 698         kfree(of);
 699
 700         return 0;
 701 }
 702
 703 void sysfs_unmap_bin_file(struct sysfs_dirent *sd)
 704 {
 705         struct sysfs_open_dirent *od;
 706         struct sysfs_open_file *of;
 707
 708         if (!sysfs_is_bin(sd))
 709                 return;
 710
 711         spin_lock_irq(&sysfs_open_dirent_lock);
 712         od = sd->s_attr.open;
 713         if (od)
 714                 atomic_inc(&od->refcnt);
 715         spin_unlock_irq(&sysfs_open_dirent_lock);
 716         if (!od)
 717                 return;
 718
 719         mutex_lock(&sysfs_open_file_mutex);
 720         list_for_each_entry(of, &od->files, list) {
 721                 struct inode *inode = file_inode(of->file);
 722                 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
 723         }
 724         mutex_unlock(&sysfs_open_file_mutex);
 725
 726         sysfs_put_open_dirent(sd, NULL);
 727 }
 728
 729 /* Sysfs attribute files are pollable.  The idea is that you read
 730  * the content and then you use 'poll' or 'select' to wait for
 731  * the content to change.  When the content changes (assuming the
 732  * manager for the kobject supports notification), poll will
 733  * return POLLERR|POLLPRI, and select will return the fd whether
 734  * it is waiting for read, write, or exceptions.
 735  * Once poll/select indicates that the value has changed, you
 736  * need to close and re-open the file, or seek to 0 and read again.
 737  * Reminder: this only works for attributes which actively support
 738  * it, and it is not possible to test an attribute from userspace
 739  * to see if it supports poll (Neither 'poll' nor 'select' return
 740  * an appropriate error code).  When in doubt, set a suitable timeout value.
 741  */
 742 static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
 743 {
 744         struct sysfs_open_file *of = sysfs_of(filp);
 745         struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
 746         struct sysfs_open_dirent *od = attr_sd->s_attr.open;
 747
 748         /* need parent for the kobj, grab both */
 749         if (!sysfs_get_active(attr_sd))
 750                 goto trigger;
 751
 752         poll_wait(filp, &od->poll, wait);
 753
 754         sysfs_put_active(attr_sd);
 755
 756         if (of->event != atomic_read(&od->event))
 757                 goto trigger;
 758
 759         return DEFAULT_POLLMASK;
 760
 761  trigger:
 762         return DEFAULT_POLLMASK|POLLERR|POLLPRI;
 763 }
 764
 765 void sysfs_notify_dirent(struct sysfs_dirent *sd)
 766 {
 767         struct sysfs_open_dirent *od;
 768         unsigned long flags;
 769
 770         spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
 771
 772         if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
 773                 od = sd->s_attr.open;
 774                 if (od) {
 775                         atomic_inc(&od->event);
 776                         wake_up_interruptible(&od->poll);
 777                 }
 778         }
 779
 780         spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
 781 }
 782 EXPORT_SYMBOL_GPL(sysfs_notify_dirent);
 783
 784 void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
 785 {
 786         struct sysfs_dirent *sd = k->sd;
 787
 788         mutex_lock(&sysfs_mutex);
 789
 790         if (sd && dir)
 791                 sd = sysfs_find_dirent(sd, dir, NULL);
 792         if (sd && attr)
 793                 sd = sysfs_find_dirent(sd, attr, NULL);
 794         if (sd)
 795                 sysfs_notify_dirent(sd);
 796
 797         mutex_unlock(&sysfs_mutex);
 798 }
 799 EXPORT_SYMBOL_GPL(sysfs_notify);
 800
 801 const struct file_operations sysfs_file_operations = {
 802         .read           = seq_read,
 803         .write          = sysfs_write_file,
 804         .llseek         = seq_lseek,
 805         .open           = sysfs_open_file,
 806         .release        = sysfs_release,
 807         .poll           = sysfs_poll,
 808 };
 809
 810 const struct file_operations sysfs_bin_operations = {
 811         .read           = sysfs_bin_read,
 812         .write          = sysfs_write_file,
 813         .llseek         = generic_file_llseek,
 814         .mmap           = sysfs_bin_mmap,
 815         .open           = sysfs_open_file,
 816         .release        = sysfs_release,
 817         .poll           = sysfs_poll,
 818 };
 819
 820 int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
 821                            const struct attribute *attr, int type,
 822                            umode_t amode, const void *ns)
 823 {
 824         umode_t mode = (amode & S_IALLUGO) | S_IFREG;
 825         struct sysfs_addrm_cxt acxt;
 826         struct sysfs_dirent *sd;
 827         int rc;
 828
 829         sd = sysfs_new_dirent(attr->name, mode, type);
 830         if (!sd)
 831                 return -ENOMEM;
 832
 833         sd->s_ns = ns;
 834         sd->s_attr.attr = (void *)attr;
 835         sysfs_dirent_init_lockdep(sd);
 836
 837         sysfs_addrm_start(&acxt);
 838         rc = sysfs_add_one(&acxt, sd, dir_sd);
 839         sysfs_addrm_finish(&acxt);
 840
 841         if (rc)
 842                 sysfs_put(sd);
 843
 844         return rc;
 845 }
 846
 847
 848 int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
 849                    int type)
 850 {
 851         return sysfs_add_file_mode_ns(dir_sd, attr, type, attr->mode, NULL);
 852 }
 853
 854 /**
 855  * sysfs_create_file_ns - create an attribute file for an object with custom ns
 856  * @kobj: object we're creating for
 857  * @attr: attribute descriptor
 858  * @ns: namespace the new file should belong to
 859  */
 860 int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr,
 861                          const void *ns)
 862 {
 863         BUG_ON(!kobj || !kobj->sd || !attr);
 864
 865         return sysfs_add_file_mode_ns(kobj->sd, attr, SYSFS_KOBJ_ATTR,
 866                                       attr->mode, ns);
 867
 868 }
 869 EXPORT_SYMBOL_GPL(sysfs_create_file_ns);
 870
 871 int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
 872 {
 873         int err = 0;
 874         int i;
 875
 876         for (i = 0; ptr[i] && !err; i++)
 877                 err = sysfs_create_file(kobj, ptr[i]);
 878         if (err)
 879                 while (--i >= 0)
 880                         sysfs_remove_file(kobj, ptr[i]);
 881         return err;
 882 }
 883 EXPORT_SYMBOL_GPL(sysfs_create_files);
 884
 885 /**
 886  * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
 887  * @kobj: object we're acting for.
 888  * @attr: attribute descriptor.
 889  * @group: group name.
 890  */
 891 int sysfs_add_file_to_group(struct kobject *kobj,
 892                 const struct attribute *attr, const char *group)
 893 {
 894         struct sysfs_dirent *dir_sd;
 895         int error;
 896
 897         if (group)
 898                 dir_sd = sysfs_get_dirent(kobj->sd, group);
 899         else
 900                 dir_sd = sysfs_get(kobj->sd);
 901
 902         if (!dir_sd)
 903                 return -ENOENT;
 904
 905         error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
 906         sysfs_put(dir_sd);
 907
 908         return error;
 909 }
 910 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
 911
 912 /**
 913  * sysfs_chmod_file - update the modified mode value on an object attribute.
 914  * @kobj: object we're acting for.
 915  * @attr: attribute descriptor.
 916  * @mode: file permissions.
 917  *
 918  */
 919 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
 920                      umode_t mode)
 921 {
 922         struct sysfs_dirent *sd;
 923         struct iattr newattrs;
 924         int rc;
 925
 926         mutex_lock(&sysfs_mutex);
 927
 928         rc = -ENOENT;
 929         sd = sysfs_find_dirent(kobj->sd, attr->name, NULL);
 930         if (!sd)
 931                 goto out;
 932
 933         newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
 934         newattrs.ia_valid = ATTR_MODE;
 935         rc = sysfs_sd_setattr(sd, &newattrs);
 936
 937  out:
 938         mutex_unlock(&sysfs_mutex);
 939         return rc;
 940 }
 941 EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 942
 943 /**
 944  * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
 945  * @kobj: object we're acting for
 946  * @attr: attribute descriptor
 947  * @ns: namespace tag of the file to remove
 948  *
 949  * Hash the attribute name and namespace tag and kill the victim.
 950  */
 951 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
 952                           const void *ns)
 953 {
 954         struct sysfs_dirent *dir_sd = kobj->sd;
 955
 956         sysfs_hash_and_remove(dir_sd, attr->name, ns);
 957 }
 958 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
 959
 960 void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr)
 961 {
 962         int i;
 963         for (i = 0; ptr[i]; i++)
 964                 sysfs_remove_file(kobj, ptr[i]);
 965 }
 966 EXPORT_SYMBOL_GPL(sysfs_remove_files);
 967
 968 /**
 969  * sysfs_remove_file_from_group - remove an attribute file from a group.
 970  * @kobj: object we're acting for.
 971  * @attr: attribute descriptor.
 972  * @group: group name.
 973  */
 974 void sysfs_remove_file_from_group(struct kobject *kobj,
 975                 const struct attribute *attr, const char *group)
 976 {
 977         struct sysfs_dirent *dir_sd;
 978
 979         if (group)
 980                 dir_sd = sysfs_get_dirent(kobj->sd, group);
 981         else
 982                 dir_sd = sysfs_get(kobj->sd);
 983         if (dir_sd) {
 984                 sysfs_hash_and_remove(dir_sd, attr->name, NULL);
 985                 sysfs_put(dir_sd);
 986         }
 987 }
 988 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
 989
 990 /**
 991  *      sysfs_create_bin_file - create binary file for object.
 992  *      @kobj:  object.
 993  *      @attr:  attribute descriptor.
 994  */
 995 int sysfs_create_bin_file(struct kobject *kobj,
 996                           const struct bin_attribute *attr)
 997 {
 998         BUG_ON(!kobj || !kobj->sd || !attr);
 999
1000         return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
1001 }
1002 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
1003
1004 /**
1005  *      sysfs_remove_bin_file - remove binary file for object.
1006  *      @kobj:  object.
1007  *      @attr:  attribute descriptor.
1008  */
1009 void sysfs_remove_bin_file(struct kobject *kobj,
1010                            const struct bin_attribute *attr)
1011 {
1012         sysfs_hash_and_remove(kobj->sd, attr->attr.name, NULL);
1013 }
1014 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
1015
1016 struct sysfs_schedule_callback_struct {
1017         struct list_head        workq_list;
1018         struct kobject          *kobj;
1019         void                    (*func)(void *);
1020         void                    *data;
1021         struct module           *owner;
1022         struct work_struct      work;
1023 };
1024
1025 static struct workqueue_struct *sysfs_workqueue;
1026 static DEFINE_MUTEX(sysfs_workq_mutex);
1027 static LIST_HEAD(sysfs_workq);
1028 static void sysfs_schedule_callback_work(struct work_struct *work)
1029 {
1030         struct sysfs_schedule_callback_struct *ss = container_of(work,
1031                         struct sysfs_schedule_callback_struct, work);
1032
1033         (ss->func)(ss->data);
1034         kobject_put(ss->kobj);
1035         module_put(ss->owner);
1036         mutex_lock(&sysfs_workq_mutex);
1037         list_del(&ss->workq_list);
1038         mutex_unlock(&sysfs_workq_mutex);
1039         kfree(ss);
1040 }
1041
1042 /**
1043  * sysfs_schedule_callback - helper to schedule a callback for a kobject
1044  * @kobj: object we're acting for.
1045  * @func: callback function to invoke later.
1046  * @data: argument to pass to @func.
1047  * @owner: module owning the callback code
1048  *
1049  * sysfs attribute methods must not unregister themselves or their parent
1050  * kobject (which would amount to the same thing).  Attempts to do so will
1051  * deadlock, since unregistration is mutually exclusive with driver
1052  * callbacks.
1053  *
1054  * Instead methods can call this routine, which will attempt to allocate
1055  * and schedule a workqueue request to call back @func with @data as its
1056  * argument in the workqueue's process context.  @kobj will be pinned
1057  * until @func returns.
1058  *
1059  * Returns 0 if the request was submitted, -ENOMEM if storage could not
1060  * be allocated, -ENODEV if a reference to @owner isn't available,
1061  * -EAGAIN if a callback has already been scheduled for @kobj.
1062  */
1063 int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
1064                 void *data, struct module *owner)
1065 {
1066         struct sysfs_schedule_callback_struct *ss, *tmp;
1067
1068         if (!try_module_get(owner))
1069                 return -ENODEV;
1070
1071         mutex_lock(&sysfs_workq_mutex);
1072         list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
1073                 if (ss->kobj == kobj) {
1074                         module_put(owner);
1075                         mutex_unlock(&sysfs_workq_mutex);
1076                         return -EAGAIN;
1077                 }
1078         mutex_unlock(&sysfs_workq_mutex);
1079
1080         if (sysfs_workqueue == NULL) {
1081                 sysfs_workqueue = create_singlethread_workqueue("sysfsd");
1082                 if (sysfs_workqueue == NULL) {
1083                         module_put(owner);
1084                         return -ENOMEM;
1085                 }
1086         }
1087
1088         ss = kmalloc(sizeof(*ss), GFP_KERNEL);
1089         if (!ss) {
1090                 module_put(owner);
1091                 return -ENOMEM;
1092         }
1093         kobject_get(kobj);
1094         ss->kobj = kobj;
1095         ss->func = func;
1096         ss->data = data;
1097         ss->owner = owner;
1098         INIT_WORK(&ss->work, sysfs_schedule_callback_work);
1099         INIT_LIST_HEAD(&ss->workq_list);
1100         mutex_lock(&sysfs_workq_mutex);
1101         list_add_tail(&ss->workq_list, &sysfs_workq);
1102         mutex_unlock(&sysfs_workq_mutex);
1103         queue_work(sysfs_workqueue, &ss->work);
1104         return 0;
1105 }
1106 EXPORT_SYMBOL_GPL(sysfs_schedule_callback);