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