Pileus Git - ~andy/linux/blob - 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;
 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         } else {
 625                 const struct sysfs_ops *ops = sysfs_file_ops(attr_sd);
 626
 627                 /* every kobject with an attribute needs a ktype assigned */
 628                 if (WARN(!ops, KERN_ERR
 629                          "missing sysfs attribute operations for kobject: %s\n",
 630                          kobject_name(kobj)))
 631                         goto err_out;
 632
 633                 has_read = ops->show;
 634                 has_write = ops->store;
 635         }
 636
 637         /* check perms and supported operations */
 638         if ((file->f_mode & FMODE_WRITE) &&
 639             (!(inode->i_mode & S_IWUGO) || !has_write))
 640                 goto err_out;
 641
 642         if ((file->f_mode & FMODE_READ) &&
 643             (!(inode->i_mode & S_IRUGO) || !has_read))
 644                 goto err_out;
 645
 646         /* allocate a sysfs_open_file for the file */
 647         error = -ENOMEM;
 648         of = kzalloc(sizeof(struct sysfs_open_file), GFP_KERNEL);
 649         if (!of)
 650                 goto err_out;
 651
 652         /*
 653          * The following is done to give a different lockdep key to
 654          * @of->mutex for files which implement mmap.  This is a rather
 655          * crude way to avoid false positive lockdep warning around
 656          * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and
 657          * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under
 658          * which mm->mmap_sem nests, while holding @of->mutex.  As each
 659          * open file has a separate mutex, it's okay as long as those don't
 660          * happen on the same file.  At this point, we can't easily give
 661          * each file a separate locking class.  Let's differentiate on
 662          * whether the file is bin or not for now.
 663          */
 664         if (sysfs_is_bin(attr_sd))
 665                 mutex_init(&of->mutex);
 666         else
 667                 mutex_init(&of->mutex);
 668
 669         of->sd = attr_sd;
 670         of->file = file;
 671
 672         /*
 673          * Always instantiate seq_file even if read access doesn't use
 674          * seq_file or is not requested.  This unifies private data access
 675          * and readable regular files are the vast majority anyway.
 676          */
 677         if (sysfs_is_bin(attr_sd))
 678                 error = single_open(file, NULL, of);
 679         else
 680                 error = single_open(file, sysfs_seq_show, of);
 681         if (error)
 682                 goto err_free;
 683
 684         /* seq_file clears PWRITE unconditionally, restore it if WRITE */
 685         if (file->f_mode & FMODE_WRITE)
 686                 file->f_mode |= FMODE_PWRITE;
 687
 688         /* make sure we have open dirent struct */
 689         error = sysfs_get_open_dirent(attr_sd, of);
 690         if (error)
 691                 goto err_close;
 692
 693         /* open succeeded, put active references */
 694         sysfs_put_active(attr_sd);
 695         return 0;
 696
 697 err_close:
 698         single_release(inode, file);
 699 err_free:
 700         kfree(of);
 701 err_out:
 702         sysfs_put_active(attr_sd);
 703         return error;
 704 }
 705
 706 static int sysfs_release(struct inode *inode, struct file *filp)
 707 {
 708         struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
 709         struct sysfs_open_file *of = sysfs_of(filp);
 710
 711         sysfs_put_open_dirent(sd, of);
 712         single_release(inode, filp);
 713         kfree(of);
 714
 715         return 0;
 716 }
 717
 718 void sysfs_unmap_bin_file(struct sysfs_dirent *sd)
 719 {
 720         struct sysfs_open_dirent *od;
 721         struct sysfs_open_file *of;
 722
 723         if (!sysfs_is_bin(sd))
 724                 return;
 725
 726         spin_lock_irq(&sysfs_open_dirent_lock);
 727         od = sd->s_attr.open;
 728         if (od)
 729                 atomic_inc(&od->refcnt);
 730         spin_unlock_irq(&sysfs_open_dirent_lock);
 731         if (!od)
 732                 return;
 733
 734         mutex_lock(&sysfs_open_file_mutex);
 735         list_for_each_entry(of, &od->files, list) {
 736                 struct inode *inode = file_inode(of->file);
 737                 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
 738         }
 739         mutex_unlock(&sysfs_open_file_mutex);
 740
 741         sysfs_put_open_dirent(sd, NULL);
 742 }
 743
 744 /* Sysfs attribute files are pollable.  The idea is that you read
 745  * the content and then you use 'poll' or 'select' to wait for
 746  * the content to change.  When the content changes (assuming the
 747  * manager for the kobject supports notification), poll will
 748  * return POLLERR|POLLPRI, and select will return the fd whether
 749  * it is waiting for read, write, or exceptions.
 750  * Once poll/select indicates that the value has changed, you
 751  * need to close and re-open the file, or seek to 0 and read again.
 752  * Reminder: this only works for attributes which actively support
 753  * it, and it is not possible to test an attribute from userspace
 754  * to see if it supports poll (Neither 'poll' nor 'select' return
 755  * an appropriate error code).  When in doubt, set a suitable timeout value.
 756  */
 757 static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
 758 {
 759         struct sysfs_open_file *of = sysfs_of(filp);
 760         struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
 761         struct sysfs_open_dirent *od = attr_sd->s_attr.open;
 762
 763         /* need parent for the kobj, grab both */
 764         if (!sysfs_get_active(attr_sd))
 765                 goto trigger;
 766
 767         poll_wait(filp, &od->poll, wait);
 768
 769         sysfs_put_active(attr_sd);
 770
 771         if (of->event != atomic_read(&od->event))
 772                 goto trigger;
 773
 774         return DEFAULT_POLLMASK;
 775
 776  trigger:
 777         return DEFAULT_POLLMASK|POLLERR|POLLPRI;
 778 }
 779
 780 void sysfs_notify_dirent(struct sysfs_dirent *sd)
 781 {
 782         struct sysfs_open_dirent *od;
 783         unsigned long flags;
 784
 785         spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
 786
 787         if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
 788                 od = sd->s_attr.open;
 789                 if (od) {
 790                         atomic_inc(&od->event);
 791                         wake_up_interruptible(&od->poll);
 792                 }
 793         }
 794
 795         spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
 796 }
 797 EXPORT_SYMBOL_GPL(sysfs_notify_dirent);
 798
 799 void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
 800 {
 801         struct sysfs_dirent *sd = k->sd;
 802
 803         mutex_lock(&sysfs_mutex);
 804
 805         if (sd && dir)
 806                 sd = sysfs_find_dirent(sd, dir, NULL);
 807         if (sd && attr)
 808                 sd = sysfs_find_dirent(sd, attr, NULL);
 809         if (sd)
 810                 sysfs_notify_dirent(sd);
 811
 812         mutex_unlock(&sysfs_mutex);
 813 }
 814 EXPORT_SYMBOL_GPL(sysfs_notify);
 815
 816 const struct file_operations sysfs_file_operations = {
 817         .read           = seq_read,
 818         .write          = sysfs_write_file,
 819         .llseek         = generic_file_llseek,
 820         .open           = sysfs_open_file,
 821         .release        = sysfs_release,
 822         .poll           = sysfs_poll,
 823 };
 824
 825 const struct file_operations sysfs_bin_operations = {
 826         .read           = sysfs_bin_read,
 827         .write          = sysfs_write_file,
 828         .llseek         = generic_file_llseek,
 829         .mmap           = sysfs_bin_mmap,
 830         .open           = sysfs_open_file,
 831         .release        = sysfs_release,
 832         .poll           = sysfs_poll,
 833 };
 834
 835 int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
 836                            const struct attribute *attr, int type,
 837                            umode_t amode, const void *ns)
 838 {
 839         umode_t mode = (amode & S_IALLUGO) | S_IFREG;
 840         struct sysfs_addrm_cxt acxt;
 841         struct sysfs_dirent *sd;
 842         int rc;
 843
 844         sd = sysfs_new_dirent(attr->name, mode, type);
 845         if (!sd)
 846                 return -ENOMEM;
 847
 848         sd->s_ns = ns;
 849         sd->s_attr.attr = (void *)attr;
 850         sysfs_dirent_init_lockdep(sd);
 851
 852         sysfs_addrm_start(&acxt);
 853         rc = sysfs_add_one(&acxt, sd, dir_sd);
 854         sysfs_addrm_finish(&acxt);
 855
 856         if (rc)
 857                 sysfs_put(sd);
 858
 859         return rc;
 860 }
 861
 862
 863 int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
 864                    int type)
 865 {
 866         return sysfs_add_file_mode_ns(dir_sd, attr, type, attr->mode, NULL);
 867 }
 868
 869 /**
 870  * sysfs_create_file_ns - create an attribute file for an object with custom ns
 871  * @kobj: object we're creating for
 872  * @attr: attribute descriptor
 873  * @ns: namespace the new file should belong to
 874  */
 875 int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr,
 876                          const void *ns)
 877 {
 878         BUG_ON(!kobj || !kobj->sd || !attr);
 879
 880         return sysfs_add_file_mode_ns(kobj->sd, attr, SYSFS_KOBJ_ATTR,
 881                                       attr->mode, ns);
 882
 883 }
 884 EXPORT_SYMBOL_GPL(sysfs_create_file_ns);
 885
 886 int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
 887 {
 888         int err = 0;
 889         int i;
 890
 891         for (i = 0; ptr[i] && !err; i++)
 892                 err = sysfs_create_file(kobj, ptr[i]);
 893         if (err)
 894                 while (--i >= 0)
 895                         sysfs_remove_file(kobj, ptr[i]);
 896         return err;
 897 }
 898 EXPORT_SYMBOL_GPL(sysfs_create_files);
 899
 900 /**
 901  * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
 902  * @kobj: object we're acting for.
 903  * @attr: attribute descriptor.
 904  * @group: group name.
 905  */
 906 int sysfs_add_file_to_group(struct kobject *kobj,
 907                 const struct attribute *attr, const char *group)
 908 {
 909         struct sysfs_dirent *dir_sd;
 910         int error;
 911
 912         if (group)
 913                 dir_sd = sysfs_get_dirent(kobj->sd, group);
 914         else
 915                 dir_sd = sysfs_get(kobj->sd);
 916
 917         if (!dir_sd)
 918                 return -ENOENT;
 919
 920         error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
 921         sysfs_put(dir_sd);
 922
 923         return error;
 924 }
 925 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
 926
 927 /**
 928  * sysfs_chmod_file - update the modified mode value on an object attribute.
 929  * @kobj: object we're acting for.
 930  * @attr: attribute descriptor.
 931  * @mode: file permissions.
 932  *
 933  */
 934 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
 935                      umode_t mode)
 936 {
 937         struct sysfs_dirent *sd;
 938         struct iattr newattrs;
 939         int rc;
 940
 941         mutex_lock(&sysfs_mutex);
 942
 943         rc = -ENOENT;
 944         sd = sysfs_find_dirent(kobj->sd, attr->name, NULL);
 945         if (!sd)
 946                 goto out;
 947
 948         newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
 949         newattrs.ia_valid = ATTR_MODE;
 950         rc = sysfs_sd_setattr(sd, &newattrs);
 951
 952  out:
 953         mutex_unlock(&sysfs_mutex);
 954         return rc;
 955 }
 956 EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 957
 958 /**
 959  * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
 960  * @kobj: object we're acting for
 961  * @attr: attribute descriptor
 962  * @ns: namespace tag of the file to remove
 963  *
 964  * Hash the attribute name and namespace tag and kill the victim.
 965  */
 966 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
 967                           const void *ns)
 968 {
 969         struct sysfs_dirent *dir_sd = kobj->sd;
 970
 971         sysfs_hash_and_remove(dir_sd, attr->name, ns);
 972 }
 973 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
 974
 975 void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr)
 976 {
 977         int i;
 978         for (i = 0; ptr[i]; i++)
 979                 sysfs_remove_file(kobj, ptr[i]);
 980 }
 981 EXPORT_SYMBOL_GPL(sysfs_remove_files);
 982
 983 /**
 984  * sysfs_remove_file_from_group - remove an attribute file from a group.
 985  * @kobj: object we're acting for.
 986  * @attr: attribute descriptor.
 987  * @group: group name.
 988  */
 989 void sysfs_remove_file_from_group(struct kobject *kobj,
 990                 const struct attribute *attr, const char *group)
 991 {
 992         struct sysfs_dirent *dir_sd;
 993
 994         if (group)
 995                 dir_sd = sysfs_get_dirent(kobj->sd, group);
 996         else
 997                 dir_sd = sysfs_get(kobj->sd);
 998         if (dir_sd) {
 999                 sysfs_hash_and_remove(dir_sd, attr->name, NULL);
1000                 sysfs_put(dir_sd);
1001         }
1002 }
1003 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
1004
1005 /**
1006  *      sysfs_create_bin_file - create binary file for object.
1007  *      @kobj:  object.
1008  *      @attr:  attribute descriptor.
1009  */
1010 int sysfs_create_bin_file(struct kobject *kobj,
1011                           const struct bin_attribute *attr)
1012 {
1013         BUG_ON(!kobj || !kobj->sd || !attr);
1014
1015         return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
1016 }
1017 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
1018
1019 /**
1020  *      sysfs_remove_bin_file - remove binary file for object.
1021  *      @kobj:  object.
1022  *      @attr:  attribute descriptor.
1023  */
1024 void sysfs_remove_bin_file(struct kobject *kobj,
1025                            const struct bin_attribute *attr)
1026 {
1027         sysfs_hash_and_remove(kobj->sd, attr->attr.name, NULL);
1028 }
1029 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
1030
1031 struct sysfs_schedule_callback_struct {
1032         struct list_head        workq_list;
1033         struct kobject          *kobj;
1034         void                    (*func)(void *);
1035         void                    *data;
1036         struct module           *owner;
1037         struct work_struct      work;
1038 };
1039
1040 static struct workqueue_struct *sysfs_workqueue;
1041 static DEFINE_MUTEX(sysfs_workq_mutex);
1042 static LIST_HEAD(sysfs_workq);
1043 static void sysfs_schedule_callback_work(struct work_struct *work)
1044 {
1045         struct sysfs_schedule_callback_struct *ss = container_of(work,
1046                         struct sysfs_schedule_callback_struct, work);
1047
1048         (ss->func)(ss->data);
1049         kobject_put(ss->kobj);
1050         module_put(ss->owner);
1051         mutex_lock(&sysfs_workq_mutex);
1052         list_del(&ss->workq_list);
1053         mutex_unlock(&sysfs_workq_mutex);
1054         kfree(ss);
1055 }
1056
1057 /**
1058  * sysfs_schedule_callback - helper to schedule a callback for a kobject
1059  * @kobj: object we're acting for.
1060  * @func: callback function to invoke later.
1061  * @data: argument to pass to @func.
1062  * @owner: module owning the callback code
1063  *
1064  * sysfs attribute methods must not unregister themselves or their parent
1065  * kobject (which would amount to the same thing).  Attempts to do so will
1066  * deadlock, since unregistration is mutually exclusive with driver
1067  * callbacks.
1068  *
1069  * Instead methods can call this routine, which will attempt to allocate
1070  * and schedule a workqueue request to call back @func with @data as its
1071  * argument in the workqueue's process context.  @kobj will be pinned
1072  * until @func returns.
1073  *
1074  * Returns 0 if the request was submitted, -ENOMEM if storage could not
1075  * be allocated, -ENODEV if a reference to @owner isn't available,
1076  * -EAGAIN if a callback has already been scheduled for @kobj.
1077  */
1078 int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
1079                 void *data, struct module *owner)
1080 {
1081         struct sysfs_schedule_callback_struct *ss, *tmp;
1082
1083         if (!try_module_get(owner))
1084                 return -ENODEV;
1085
1086         mutex_lock(&sysfs_workq_mutex);
1087         list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
1088                 if (ss->kobj == kobj) {
1089                         module_put(owner);
1090                         mutex_unlock(&sysfs_workq_mutex);
1091                         return -EAGAIN;
1092                 }
1093         mutex_unlock(&sysfs_workq_mutex);
1094
1095         if (sysfs_workqueue == NULL) {
1096                 sysfs_workqueue = create_singlethread_workqueue("sysfsd");
1097                 if (sysfs_workqueue == NULL) {
1098                         module_put(owner);
1099                         return -ENOMEM;
1100                 }
1101         }
1102
1103         ss = kmalloc(sizeof(*ss), GFP_KERNEL);
1104         if (!ss) {
1105                 module_put(owner);
1106                 return -ENOMEM;
1107         }
1108         kobject_get(kobj);
1109         ss->kobj = kobj;
1110         ss->func = func;
1111         ss->data = data;
1112         ss->owner = owner;
1113         INIT_WORK(&ss->work, sysfs_schedule_callback_work);
1114         INIT_LIST_HEAD(&ss->workq_list);
1115         mutex_lock(&sysfs_workq_mutex);
1116         list_add_tail(&ss->workq_list, &sysfs_workq);
1117         mutex_unlock(&sysfs_workq_mutex);
1118         queue_work(sysfs_workqueue, &ss->work);
1119         return 0;
1120 }
1121 EXPORT_SYMBOL_GPL(sysfs_schedule_callback);