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/list.h>
  18 #include <linux/mutex.h>
  19 #include <linux/seq_file.h>
  20
  21 #include "sysfs.h"
  22 #include "../kernfs/kernfs-internal.h"
  23
  24 /*
  25  * Determine ktype->sysfs_ops for the given sysfs_dirent.  This function
  26  * must be called while holding an active reference.
  27  */
  28 static const struct sysfs_ops *sysfs_file_ops(struct sysfs_dirent *sd)
  29 {
  30         struct kobject *kobj = sd->s_parent->priv;
  31
  32         if (sd->s_flags & SYSFS_FLAG_LOCKDEP)
  33                 lockdep_assert_held(sd);
  34         return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
  35 }
  36
  37 /*
  38  * Reads on sysfs are handled through seq_file, which takes care of hairy
  39  * details like buffering and seeking.  The following function pipes
  40  * sysfs_ops->show() result through seq_file.
  41  */
  42 static int sysfs_kf_seq_show(struct seq_file *sf, void *v)
  43 {
  44         struct sysfs_open_file *of = sf->private;
  45         struct kobject *kobj = of->sd->s_parent->priv;
  46         const struct sysfs_ops *ops = sysfs_file_ops(of->sd);
  47         ssize_t count;
  48         char *buf;
  49
  50         /* acquire buffer and ensure that it's >= PAGE_SIZE */
  51         count = seq_get_buf(sf, &buf);
  52         if (count < PAGE_SIZE) {
  53                 seq_commit(sf, -1);
  54                 return 0;
  55         }
  56
  57         /*
  58          * Invoke show().  Control may reach here via seq file lseek even
  59          * if @ops->show() isn't implemented.
  60          */
  61         if (ops->show) {
  62                 count = ops->show(kobj, of->sd->priv, buf);
  63                 if (count < 0)
  64                         return count;
  65         }
  66
  67         /*
  68          * The code works fine with PAGE_SIZE return but it's likely to
  69          * indicate truncated result or overflow in normal use cases.
  70          */
  71         if (count >= (ssize_t)PAGE_SIZE) {
  72                 print_symbol("fill_read_buffer: %s returned bad count\n",
  73                         (unsigned long)ops->show);
  74                 /* Try to struggle along */
  75                 count = PAGE_SIZE - 1;
  76         }
  77         seq_commit(sf, count);
  78         return 0;
  79 }
  80
  81 static ssize_t sysfs_kf_bin_read(struct sysfs_open_file *of, char *buf,
  82                                  size_t count, loff_t pos)
  83 {
  84         struct bin_attribute *battr = of->sd->priv;
  85         struct kobject *kobj = of->sd->s_parent->priv;
  86         loff_t size = file_inode(of->file)->i_size;
  87
  88         if (!count)
  89                 return 0;
  90
  91         if (size) {
  92                 if (pos > size)
  93                         return 0;
  94                 if (pos + count > size)
  95                         count = size - pos;
  96         }
  97
  98         if (!battr->read)
  99                 return -EIO;
 100
 101         return battr->read(of->file, kobj, battr, buf, pos, count);
 102 }
 103
 104 /* kernfs write callback for regular sysfs files */
 105 static ssize_t sysfs_kf_write(struct sysfs_open_file *of, char *buf,
 106                               size_t count, loff_t pos)
 107 {
 108         const struct sysfs_ops *ops = sysfs_file_ops(of->sd);
 109         struct kobject *kobj = of->sd->s_parent->priv;
 110
 111         if (!count)
 112                 return 0;
 113
 114         return ops->store(kobj, of->sd->priv, buf, count);
 115 }
 116
 117 /* kernfs write callback for bin sysfs files */
 118 static ssize_t sysfs_kf_bin_write(struct sysfs_open_file *of, char *buf,
 119                                   size_t count, loff_t pos)
 120 {
 121         struct bin_attribute *battr = of->sd->priv;
 122         struct kobject *kobj = of->sd->s_parent->priv;
 123         loff_t size = file_inode(of->file)->i_size;
 124
 125         if (size) {
 126                 if (size <= pos)
 127                         return 0;
 128                 count = min_t(ssize_t, count, size - pos);
 129         }
 130         if (!count)
 131                 return 0;
 132
 133         if (!battr->write)
 134                 return -EIO;
 135
 136         return battr->write(of->file, kobj, battr, buf, pos, count);
 137 }
 138
 139 static int sysfs_kf_bin_mmap(struct sysfs_open_file *of,
 140                              struct vm_area_struct *vma)
 141 {
 142         struct bin_attribute *battr = of->sd->priv;
 143         struct kobject *kobj = of->sd->s_parent->priv;
 144
 145         if (!battr->mmap)
 146                 return -ENODEV;
 147
 148         return battr->mmap(of->file, kobj, battr, vma);
 149 }
 150
 151 void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
 152 {
 153         struct sysfs_dirent *sd = k->sd, *tmp;
 154
 155         if (sd && dir)
 156                 sd = kernfs_find_and_get(sd, dir);
 157         else
 158                 kernfs_get(sd);
 159
 160         if (sd && attr) {
 161                 tmp = kernfs_find_and_get(sd, attr);
 162                 kernfs_put(sd);
 163                 sd = tmp;
 164         }
 165
 166         if (sd) {
 167                 kernfs_notify(sd);
 168                 kernfs_put(sd);
 169         }
 170 }
 171 EXPORT_SYMBOL_GPL(sysfs_notify);
 172
 173 static const struct kernfs_ops sysfs_file_kfops_empty = {
 174 };
 175
 176 static const struct kernfs_ops sysfs_file_kfops_ro = {
 177         .seq_show       = sysfs_kf_seq_show,
 178 };
 179
 180 static const struct kernfs_ops sysfs_file_kfops_wo = {
 181         .write          = sysfs_kf_write,
 182 };
 183
 184 static const struct kernfs_ops sysfs_file_kfops_rw = {
 185         .seq_show       = sysfs_kf_seq_show,
 186         .write          = sysfs_kf_write,
 187 };
 188
 189 static const struct kernfs_ops sysfs_bin_kfops_ro = {
 190         .read           = sysfs_kf_bin_read,
 191 };
 192
 193 static const struct kernfs_ops sysfs_bin_kfops_wo = {
 194         .write          = sysfs_kf_bin_write,
 195 };
 196
 197 static const struct kernfs_ops sysfs_bin_kfops_rw = {
 198         .read           = sysfs_kf_bin_read,
 199         .write          = sysfs_kf_bin_write,
 200         .mmap           = sysfs_kf_bin_mmap,
 201 };
 202
 203 int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
 204                            const struct attribute *attr, bool is_bin,
 205                            umode_t mode, const void *ns)
 206 {
 207         struct lock_class_key *key = NULL;
 208         const struct kernfs_ops *ops;
 209         struct sysfs_dirent *sd;
 210         loff_t size;
 211
 212         if (!is_bin) {
 213                 struct kobject *kobj = dir_sd->priv;
 214                 const struct sysfs_ops *sysfs_ops = kobj->ktype->sysfs_ops;
 215
 216                 /* every kobject with an attribute needs a ktype assigned */
 217                 if (WARN(!sysfs_ops, KERN_ERR
 218                          "missing sysfs attribute operations for kobject: %s\n",
 219                          kobject_name(kobj)))
 220                         return -EINVAL;
 221
 222                 if (sysfs_ops->show && sysfs_ops->store)
 223                         ops = &sysfs_file_kfops_rw;
 224                 else if (sysfs_ops->show)
 225                         ops = &sysfs_file_kfops_ro;
 226                 else if (sysfs_ops->store)
 227                         ops = &sysfs_file_kfops_wo;
 228                 else
 229                         ops = &sysfs_file_kfops_empty;
 230
 231                 size = PAGE_SIZE;
 232         } else {
 233                 struct bin_attribute *battr = (void *)attr;
 234
 235                 if ((battr->read && battr->write) || battr->mmap)
 236                         ops = &sysfs_bin_kfops_rw;
 237                 else if (battr->read)
 238                         ops = &sysfs_bin_kfops_ro;
 239                 else if (battr->write)
 240                         ops = &sysfs_bin_kfops_wo;
 241                 else
 242                         ops = &sysfs_file_kfops_empty;
 243
 244                 size = battr->size;
 245         }
 246
 247 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 248         if (!attr->ignore_lockdep)
 249                 key = attr->key ?: (struct lock_class_key *)&attr->skey;
 250 #endif
 251         sd = kernfs_create_file_ns_key(dir_sd, attr->name, mode, size,
 252                                        ops, (void *)attr, ns, key);
 253         if (IS_ERR(sd)) {
 254                 if (PTR_ERR(sd) == -EEXIST)
 255                         sysfs_warn_dup(dir_sd, attr->name);
 256                 return PTR_ERR(sd);
 257         }
 258         return 0;
 259 }
 260
 261 int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
 262                    bool is_bin)
 263 {
 264         return sysfs_add_file_mode_ns(dir_sd, attr, is_bin, attr->mode, NULL);
 265 }
 266
 267 /**
 268  * sysfs_create_file_ns - create an attribute file for an object with custom ns
 269  * @kobj: object we're creating for
 270  * @attr: attribute descriptor
 271  * @ns: namespace the new file should belong to
 272  */
 273 int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr,
 274                          const void *ns)
 275 {
 276         BUG_ON(!kobj || !kobj->sd || !attr);
 277
 278         return sysfs_add_file_mode_ns(kobj->sd, attr, false, attr->mode, ns);
 279
 280 }
 281 EXPORT_SYMBOL_GPL(sysfs_create_file_ns);
 282
 283 int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
 284 {
 285         int err = 0;
 286         int i;
 287
 288         for (i = 0; ptr[i] && !err; i++)
 289                 err = sysfs_create_file(kobj, ptr[i]);
 290         if (err)
 291                 while (--i >= 0)
 292                         sysfs_remove_file(kobj, ptr[i]);
 293         return err;
 294 }
 295 EXPORT_SYMBOL_GPL(sysfs_create_files);
 296
 297 /**
 298  * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
 299  * @kobj: object we're acting for.
 300  * @attr: attribute descriptor.
 301  * @group: group name.
 302  */
 303 int sysfs_add_file_to_group(struct kobject *kobj,
 304                 const struct attribute *attr, const char *group)
 305 {
 306         struct sysfs_dirent *dir_sd;
 307         int error;
 308
 309         if (group) {
 310                 dir_sd = kernfs_find_and_get(kobj->sd, group);
 311         } else {
 312                 dir_sd = kobj->sd;
 313                 kernfs_get(dir_sd);
 314         }
 315
 316         if (!dir_sd)
 317                 return -ENOENT;
 318
 319         error = sysfs_add_file(dir_sd, attr, false);
 320         kernfs_put(dir_sd);
 321
 322         return error;
 323 }
 324 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
 325
 326 /**
 327  * sysfs_chmod_file - update the modified mode value on an object attribute.
 328  * @kobj: object we're acting for.
 329  * @attr: attribute descriptor.
 330  * @mode: file permissions.
 331  *
 332  */
 333 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
 334                      umode_t mode)
 335 {
 336         struct sysfs_dirent *sd;
 337         struct iattr newattrs;
 338         int rc;
 339
 340         sd = kernfs_find_and_get(kobj->sd, attr->name);
 341         if (!sd)
 342                 return -ENOENT;
 343
 344         newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
 345         newattrs.ia_valid = ATTR_MODE;
 346
 347         rc = kernfs_setattr(sd, &newattrs);
 348
 349         kernfs_put(sd);
 350         return rc;
 351 }
 352 EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 353
 354 /**
 355  * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
 356  * @kobj: object we're acting for
 357  * @attr: attribute descriptor
 358  * @ns: namespace tag of the file to remove
 359  *
 360  * Hash the attribute name and namespace tag and kill the victim.
 361  */
 362 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
 363                           const void *ns)
 364 {
 365         struct sysfs_dirent *dir_sd = kobj->sd;
 366
 367         kernfs_remove_by_name_ns(dir_sd, attr->name, ns);
 368 }
 369 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
 370
 371 void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr)
 372 {
 373         int i;
 374         for (i = 0; ptr[i]; i++)
 375                 sysfs_remove_file(kobj, ptr[i]);
 376 }
 377 EXPORT_SYMBOL_GPL(sysfs_remove_files);
 378
 379 /**
 380  * sysfs_remove_file_from_group - remove an attribute file from a group.
 381  * @kobj: object we're acting for.
 382  * @attr: attribute descriptor.
 383  * @group: group name.
 384  */
 385 void sysfs_remove_file_from_group(struct kobject *kobj,
 386                 const struct attribute *attr, const char *group)
 387 {
 388         struct sysfs_dirent *dir_sd;
 389
 390         if (group) {
 391                 dir_sd = kernfs_find_and_get(kobj->sd, group);
 392         } else {
 393                 dir_sd = kobj->sd;
 394                 kernfs_get(dir_sd);
 395         }
 396
 397         if (dir_sd) {
 398                 kernfs_remove_by_name(dir_sd, attr->name);
 399                 kernfs_put(dir_sd);
 400         }
 401 }
 402 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
 403
 404 /**
 405  *      sysfs_create_bin_file - create binary file for object.
 406  *      @kobj:  object.
 407  *      @attr:  attribute descriptor.
 408  */
 409 int sysfs_create_bin_file(struct kobject *kobj,
 410                           const struct bin_attribute *attr)
 411 {
 412         BUG_ON(!kobj || !kobj->sd || !attr);
 413
 414         return sysfs_add_file(kobj->sd, &attr->attr, true);
 415 }
 416 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
 417
 418 /**
 419  *      sysfs_remove_bin_file - remove binary file for object.
 420  *      @kobj:  object.
 421  *      @attr:  attribute descriptor.
 422  */
 423 void sysfs_remove_bin_file(struct kobject *kobj,
 424                            const struct bin_attribute *attr)
 425 {
 426         kernfs_remove_by_name(kobj->sd, attr->attr.name);
 427 }
 428 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
 429
 430 struct sysfs_schedule_callback_struct {
 431         struct list_head        workq_list;
 432         struct kobject          *kobj;
 433         void                    (*func)(void *);
 434         void                    *data;
 435         struct module           *owner;
 436         struct work_struct      work;
 437 };
 438
 439 static struct workqueue_struct *sysfs_workqueue;
 440 static DEFINE_MUTEX(sysfs_workq_mutex);
 441 static LIST_HEAD(sysfs_workq);
 442 static void sysfs_schedule_callback_work(struct work_struct *work)
 443 {
 444         struct sysfs_schedule_callback_struct *ss = container_of(work,
 445                         struct sysfs_schedule_callback_struct, work);
 446
 447         (ss->func)(ss->data);
 448         kobject_put(ss->kobj);
 449         module_put(ss->owner);
 450         mutex_lock(&sysfs_workq_mutex);
 451         list_del(&ss->workq_list);
 452         mutex_unlock(&sysfs_workq_mutex);
 453         kfree(ss);
 454 }
 455
 456 /**
 457  * sysfs_schedule_callback - helper to schedule a callback for a kobject
 458  * @kobj: object we're acting for.
 459  * @func: callback function to invoke later.
 460  * @data: argument to pass to @func.
 461  * @owner: module owning the callback code
 462  *
 463  * sysfs attribute methods must not unregister themselves or their parent
 464  * kobject (which would amount to the same thing).  Attempts to do so will
 465  * deadlock, since unregistration is mutually exclusive with driver
 466  * callbacks.
 467  *
 468  * Instead methods can call this routine, which will attempt to allocate
 469  * and schedule a workqueue request to call back @func with @data as its
 470  * argument in the workqueue's process context.  @kobj will be pinned
 471  * until @func returns.
 472  *
 473  * Returns 0 if the request was submitted, -ENOMEM if storage could not
 474  * be allocated, -ENODEV if a reference to @owner isn't available,
 475  * -EAGAIN if a callback has already been scheduled for @kobj.
 476  */
 477 int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
 478                 void *data, struct module *owner)
 479 {
 480         struct sysfs_schedule_callback_struct *ss, *tmp;
 481
 482         if (!try_module_get(owner))
 483                 return -ENODEV;
 484
 485         mutex_lock(&sysfs_workq_mutex);
 486         list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
 487                 if (ss->kobj == kobj) {
 488                         module_put(owner);
 489                         mutex_unlock(&sysfs_workq_mutex);
 490                         return -EAGAIN;
 491                 }
 492         mutex_unlock(&sysfs_workq_mutex);
 493
 494         if (sysfs_workqueue == NULL) {
 495                 sysfs_workqueue = create_singlethread_workqueue("sysfsd");
 496                 if (sysfs_workqueue == NULL) {
 497                         module_put(owner);
 498                         return -ENOMEM;
 499                 }
 500         }
 501
 502         ss = kmalloc(sizeof(*ss), GFP_KERNEL);
 503         if (!ss) {
 504                 module_put(owner);
 505                 return -ENOMEM;
 506         }
 507         kobject_get(kobj);
 508         ss->kobj = kobj;
 509         ss->func = func;
 510         ss->data = data;
 511         ss->owner = owner;
 512         INIT_WORK(&ss->work, sysfs_schedule_callback_work);
 513         INIT_LIST_HEAD(&ss->workq_list);
 514         mutex_lock(&sysfs_workq_mutex);
 515         list_add_tail(&ss->workq_list, &sysfs_workq);
 516         mutex_unlock(&sysfs_workq_mutex);
 517         queue_work(sysfs_workqueue, &ss->work);
 518         return 0;
 519 }
 520 EXPORT_SYMBOL_GPL(sysfs_schedule_callback);