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 <asm/uaccess.h> 24 25 #include "sysfs.h" 26 27 /* 28 * There's one sysfs_buffer for each open file and one 29 * sysfs_open_dirent for each sysfs_dirent with one or more open 30 * files. 31 * 32 * filp->private_data points to sysfs_buffer and 33 * sysfs_dirent->s_attr.open points to sysfs_open_dirent. s_attr.open 34 * is protected by sysfs_open_dirent_lock. 35 */ 36 static DEFINE_SPINLOCK(sysfs_open_dirent_lock); 37 38 struct sysfs_open_dirent { 39 atomic_t refcnt; 40 atomic_t event; 41 wait_queue_head_t poll; 42 struct list_head buffers; /* goes through sysfs_buffer.list */ 43 }; 44 45 struct sysfs_buffer { 46 size_t count; 47 loff_t pos; 48 char * page; 49 const struct sysfs_ops * ops; 50 struct mutex mutex; 51 int needs_read_fill; 52 int event; 53 struct list_head list; 54 }; 55 56 /** 57 * fill_read_buffer - allocate and fill buffer from object. 58 * @dentry: dentry pointer. 59 * @buffer: data buffer for file. 60 * 61 * Allocate @buffer->page, if it hasn't been already, then call the 62 * kobject's show() method to fill the buffer with this attribute's 63 * data. 64 * This is called only once, on the file's first read unless an error 65 * is returned. 66 */ 67 static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer) 68 { 69 struct sysfs_dirent *attr_sd = dentry->d_fsdata; 70 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj; 71 const struct sysfs_ops * ops = buffer->ops; 72 int ret = 0; 73 ssize_t count; 74 75 if (!buffer->page) 76 buffer->page = (char *) get_zeroed_page(GFP_KERNEL); 77 if (!buffer->page) 78 return -ENOMEM; 79 80 /* need attr_sd for attr and ops, its parent for kobj */ 81 if (!sysfs_get_active(attr_sd)) 82 return -ENODEV; 83 84 buffer->event = atomic_read(&attr_sd->s_attr.open->event); 85 count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page); 86 87 sysfs_put_active(attr_sd); 88 89 /* 90 * The code works fine with PAGE_SIZE return but it's likely to 91 * indicate truncated result or overflow in normal use cases. 92 */ 93 if (count >= (ssize_t)PAGE_SIZE) { 94 print_symbol("fill_read_buffer: %s returned bad count\n", 95 (unsigned long)ops->show); 96 /* Try to struggle along */ 97 count = PAGE_SIZE - 1; 98 } 99 if (count >= 0) { 100 buffer->needs_read_fill = 0; 101 buffer->count = count; 102 } else { 103 ret = count; 104 } 105 return ret; 106 } 107 108 /** 109 * sysfs_read_file - read an attribute. 110 * @file: file pointer. 111 * @buf: buffer to fill. 112 * @count: number of bytes to read. 113 * @ppos: starting offset in file. 114 * 115 * Userspace wants to read an attribute file. The attribute descriptor 116 * is in the file's ->d_fsdata. The target object is in the directory's 117 * ->d_fsdata. 118 * 119 * We call fill_read_buffer() to allocate and fill the buffer from the 120 * object's show() method exactly once (if the read is happening from 121 * the beginning of the file). That should fill the entire buffer with 122 * all the data the object has to offer for that attribute. 123 * We then call flush_read_buffer() to copy the buffer to userspace 124 * in the increments specified. 125 */ 126 127 static ssize_t 128 sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos) 129 { 130 struct sysfs_buffer * buffer = file->private_data; 131 ssize_t retval = 0; 132 133 mutex_lock(&buffer->mutex); 134 if (buffer->needs_read_fill || *ppos == 0) { 135 retval = fill_read_buffer(file->f_path.dentry,buffer); 136 if (retval) 137 goto out; 138 } 139 pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n", 140 __func__, count, *ppos, buffer->page); 141 retval = simple_read_from_buffer(buf, count, ppos, buffer->page, 142 buffer->count); 143 out: 144 mutex_unlock(&buffer->mutex); 145 return retval; 146 } 147 148 /** 149 * fill_write_buffer - copy buffer from userspace. 150 * @buffer: data buffer for file. 151 * @buf: data from user. 152 * @count: number of bytes in @userbuf. 153 * 154 * Allocate @buffer->page if it hasn't been already, then 155 * copy the user-supplied buffer into it. 156 */ 157 158 static int 159 fill_write_buffer(struct sysfs_buffer * buffer, const char __user * buf, size_t count) 160 { 161 int error; 162 163 if (!buffer->page) 164 buffer->page = (char *)get_zeroed_page(GFP_KERNEL); 165 if (!buffer->page) 166 return -ENOMEM; 167 168 if (count >= PAGE_SIZE) 169 count = PAGE_SIZE - 1; 170 error = copy_from_user(buffer->page,buf,count); 171 buffer->needs_read_fill = 1; 172 /* if buf is assumed to contain a string, terminate it by \0, 173 so e.g. sscanf() can scan the string easily */ 174 buffer->page[count] = 0; 175 return error ? -EFAULT : count; 176 } 177 178 179 /** 180 * flush_write_buffer - push buffer to kobject. 181 * @dentry: dentry to the attribute 182 * @buffer: data buffer for file. 183 * @count: number of bytes 184 * 185 * Get the correct pointers for the kobject and the attribute we're 186 * dealing with, then call the store() method for the attribute, 187 * passing the buffer that we acquired in fill_write_buffer(). 188 */ 189 190 static int 191 flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count) 192 { 193 struct sysfs_dirent *attr_sd = dentry->d_fsdata; 194 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj; 195 const struct sysfs_ops * ops = buffer->ops; 196 int rc; 197 198 /* need attr_sd for attr and ops, its parent for kobj */ 199 if (!sysfs_get_active(attr_sd)) 200 return -ENODEV; 201 202 rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count); 203 204 sysfs_put_active(attr_sd); 205 206 return rc; 207 } 208 209 210 /** 211 * sysfs_write_file - write an attribute. 212 * @file: file pointer 213 * @buf: data to write 214 * @count: number of bytes 215 * @ppos: starting offset 216 * 217 * Similar to sysfs_read_file(), though working in the opposite direction. 218 * We allocate and fill the data from the user in fill_write_buffer(), 219 * then push it to the kobject in flush_write_buffer(). 220 * There is no easy way for us to know if userspace is only doing a partial 221 * write, so we don't support them. We expect the entire buffer to come 222 * on the first write. 223 * Hint: if you're writing a value, first read the file, modify only the 224 * the value you're changing, then write entire buffer back. 225 */ 226 227 static ssize_t 228 sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 229 { 230 struct sysfs_buffer * buffer = file->private_data; 231 ssize_t len; 232 233 mutex_lock(&buffer->mutex); 234 len = fill_write_buffer(buffer, buf, count); 235 if (len > 0) 236 len = flush_write_buffer(file->f_path.dentry, buffer, len); 237 if (len > 0) 238 *ppos += len; 239 mutex_unlock(&buffer->mutex); 240 return len; 241 } 242 243 /** 244 * sysfs_get_open_dirent - get or create sysfs_open_dirent 245 * @sd: target sysfs_dirent 246 * @buffer: sysfs_buffer for this instance of open 247 * 248 * If @sd->s_attr.open exists, increment its reference count; 249 * otherwise, create one. @buffer is chained to the buffers 250 * list. 251 * 252 * LOCKING: 253 * Kernel thread context (may sleep). 254 * 255 * RETURNS: 256 * 0 on success, -errno on failure. 257 */ 258 static int sysfs_get_open_dirent(struct sysfs_dirent *sd, 259 struct sysfs_buffer *buffer) 260 { 261 struct sysfs_open_dirent *od, *new_od = NULL; 262 263 retry: 264 spin_lock_irq(&sysfs_open_dirent_lock); 265 266 if (!sd->s_attr.open && new_od) { 267 sd->s_attr.open = new_od; 268 new_od = NULL; 269 } 270 271 od = sd->s_attr.open; 272 if (od) { 273 atomic_inc(&od->refcnt); 274 list_add_tail(&buffer->list, &od->buffers); 275 } 276 277 spin_unlock_irq(&sysfs_open_dirent_lock); 278 279 if (od) { 280 kfree(new_od); 281 return 0; 282 } 283 284 /* not there, initialize a new one and retry */ 285 new_od = kmalloc(sizeof(*new_od), GFP_KERNEL); 286 if (!new_od) 287 return -ENOMEM; 288 289 atomic_set(&new_od->refcnt, 0); 290 atomic_set(&new_od->event, 1); 291 init_waitqueue_head(&new_od->poll); 292 INIT_LIST_HEAD(&new_od->buffers); 293 goto retry; 294 } 295 296 /** 297 * sysfs_put_open_dirent - put sysfs_open_dirent 298 * @sd: target sysfs_dirent 299 * @buffer: associated sysfs_buffer 300 * 301 * Put @sd->s_attr.open and unlink @buffer from the buffers list. 302 * If reference count reaches zero, disassociate and free it. 303 * 304 * LOCKING: 305 * None. 306 */ 307 static void sysfs_put_open_dirent(struct sysfs_dirent *sd, 308 struct sysfs_buffer *buffer) 309 { 310 struct sysfs_open_dirent *od = sd->s_attr.open; 311 unsigned long flags; 312 313 spin_lock_irqsave(&sysfs_open_dirent_lock, flags); 314 315 list_del(&buffer->list); 316 if (atomic_dec_and_test(&od->refcnt)) 317 sd->s_attr.open = NULL; 318 else 319 od = NULL; 320 321 spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags); 322 323 kfree(od); 324 } 325 326 static int sysfs_open_file(struct inode *inode, struct file *file) 327 { 328 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata; 329 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj; 330 struct sysfs_buffer *buffer; 331 const struct sysfs_ops *ops; 332 int error = -EACCES; 333 334 /* need attr_sd for attr and ops, its parent for kobj */ 335 if (!sysfs_get_active(attr_sd)) 336 return -ENODEV; 337 338 /* every kobject with an attribute needs a ktype assigned */ 339 if (kobj->ktype && kobj->ktype->sysfs_ops) 340 ops = kobj->ktype->sysfs_ops; 341 else { 342 WARN(1, KERN_ERR "missing sysfs attribute operations for " 343 "kobject: %s\n", kobject_name(kobj)); 344 goto err_out; 345 } 346 347 /* File needs write support. 348 * The inode's perms must say it's ok, 349 * and we must have a store method. 350 */ 351 if (file->f_mode & FMODE_WRITE) { 352 if (!(inode->i_mode & S_IWUGO) || !ops->store) 353 goto err_out; 354 } 355 356 /* File needs read support. 357 * The inode's perms must say it's ok, and we there 358 * must be a show method for it. 359 */ 360 if (file->f_mode & FMODE_READ) { 361 if (!(inode->i_mode & S_IRUGO) || !ops->show) 362 goto err_out; 363 } 364 365 /* No error? Great, allocate a buffer for the file, and store it 366 * it in file->private_data for easy access. 367 */ 368 error = -ENOMEM; 369 buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL); 370 if (!buffer) 371 goto err_out; 372 373 mutex_init(&buffer->mutex); 374 buffer->needs_read_fill = 1; 375 buffer->ops = ops; 376 file->private_data = buffer; 377 378 /* make sure we have open dirent struct */ 379 error = sysfs_get_open_dirent(attr_sd, buffer); 380 if (error) 381 goto err_free; 382 383 /* open succeeded, put active references */ 384 sysfs_put_active(attr_sd); 385 return 0; 386 387 err_free: 388 kfree(buffer); 389 err_out: 390 sysfs_put_active(attr_sd); 391 return error; 392 } 393 394 static int sysfs_release(struct inode *inode, struct file *filp) 395 { 396 struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata; 397 struct sysfs_buffer *buffer = filp->private_data; 398 399 sysfs_put_open_dirent(sd, buffer); 400 401 if (buffer->page) 402 free_page((unsigned long)buffer->page); 403 kfree(buffer); 404 405 return 0; 406 } 407 408 /* Sysfs attribute files are pollable. The idea is that you read 409 * the content and then you use 'poll' or 'select' to wait for 410 * the content to change. When the content changes (assuming the 411 * manager for the kobject supports notification), poll will 412 * return POLLERR|POLLPRI, and select will return the fd whether 413 * it is waiting for read, write, or exceptions. 414 * Once poll/select indicates that the value has changed, you 415 * need to close and re-open the file, or seek to 0 and read again. 416 * Reminder: this only works for attributes which actively support 417 * it, and it is not possible to test an attribute from userspace 418 * to see if it supports poll (Neither 'poll' nor 'select' return 419 * an appropriate error code). When in doubt, set a suitable timeout value. 420 */ 421 static unsigned int sysfs_poll(struct file *filp, poll_table *wait) 422 { 423 struct sysfs_buffer * buffer = filp->private_data; 424 struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata; 425 struct sysfs_open_dirent *od = attr_sd->s_attr.open; 426 427 /* need parent for the kobj, grab both */ 428 if (!sysfs_get_active(attr_sd)) 429 goto trigger; 430 431 poll_wait(filp, &od->poll, wait); 432 433 sysfs_put_active(attr_sd); 434 435 if (buffer->event != atomic_read(&od->event)) 436 goto trigger; 437 438 return DEFAULT_POLLMASK; 439 440 trigger: 441 buffer->needs_read_fill = 1; 442 return DEFAULT_POLLMASK|POLLERR|POLLPRI; 443 } 444 445 void sysfs_notify_dirent(struct sysfs_dirent *sd) 446 { 447 struct sysfs_open_dirent *od; 448 unsigned long flags; 449 450 spin_lock_irqsave(&sysfs_open_dirent_lock, flags); 451 452 od = sd->s_attr.open; 453 if (od) { 454 atomic_inc(&od->event); 455 wake_up_interruptible(&od->poll); 456 } 457 458 spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags); 459 } 460 EXPORT_SYMBOL_GPL(sysfs_notify_dirent); 461 462 void sysfs_notify(struct kobject *k, const char *dir, const char *attr) 463 { 464 struct sysfs_dirent *sd = k->sd; 465 466 mutex_lock(&sysfs_mutex); 467 468 if (sd && dir) 469 /* Only directories are tagged, so no need to pass 470 * a tag explicitly. 471 */ 472 sd = sysfs_find_dirent(sd, NULL, dir); 473 if (sd && attr) 474 sd = sysfs_find_dirent(sd, NULL, attr); 475 if (sd) 476 sysfs_notify_dirent(sd); 477 478 mutex_unlock(&sysfs_mutex); 479 } 480 EXPORT_SYMBOL_GPL(sysfs_notify); 481 482 const struct file_operations sysfs_file_operations = { 483 .read = sysfs_read_file, 484 .write = sysfs_write_file, 485 .llseek = generic_file_llseek, 486 .open = sysfs_open_file, 487 .release = sysfs_release, 488 .poll = sysfs_poll, 489 }; 490 491 int sysfs_add_file_mode(struct sysfs_dirent *dir_sd, 492 const struct attribute *attr, int type, mode_t amode) 493 { 494 umode_t mode = (amode & S_IALLUGO) | S_IFREG; 495 struct sysfs_addrm_cxt acxt; 496 struct sysfs_dirent *sd; 497 int rc; 498 499 sd = sysfs_new_dirent(attr->name, mode, type); 500 if (!sd) 501 return -ENOMEM; 502 sd->s_attr.attr = (void *)attr; 503 sysfs_dirent_init_lockdep(sd); 504 505 sysfs_addrm_start(&acxt, dir_sd); 506 rc = sysfs_add_one(&acxt, sd); 507 sysfs_addrm_finish(&acxt); 508 509 if (rc) 510 sysfs_put(sd); 511 512 return rc; 513 } 514 515 516 int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr, 517 int type) 518 { 519 return sysfs_add_file_mode(dir_sd, attr, type, attr->mode); 520 } 521 522 523 /** 524 * sysfs_create_file - create an attribute file for an object. 525 * @kobj: object we're creating for. 526 * @attr: attribute descriptor. 527 */ 528 529 int sysfs_create_file(struct kobject * kobj, const struct attribute * attr) 530 { 531 BUG_ON(!kobj || !kobj->sd || !attr); 532 533 return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR); 534 535 } 536 537 int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr) 538 { 539 int err = 0; 540 int i; 541 542 for (i = 0; ptr[i] && !err; i++) 543 err = sysfs_create_file(kobj, ptr[i]); 544 if (err) 545 while (--i >= 0) 546 sysfs_remove_file(kobj, ptr[i]); 547 return err; 548 } 549 550 /** 551 * sysfs_add_file_to_group - add an attribute file to a pre-existing group. 552 * @kobj: object we're acting for. 553 * @attr: attribute descriptor. 554 * @group: group name. 555 */ 556 int sysfs_add_file_to_group(struct kobject *kobj, 557 const struct attribute *attr, const char *group) 558 { 559 struct sysfs_dirent *dir_sd; 560 int error; 561 562 if (group) 563 dir_sd = sysfs_get_dirent(kobj->sd, NULL, group); 564 else 565 dir_sd = sysfs_get(kobj->sd); 566 567 if (!dir_sd) 568 return -ENOENT; 569 570 error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR); 571 sysfs_put(dir_sd); 572 573 return error; 574 } 575 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group); 576 577 /** 578 * sysfs_chmod_file - update the modified mode value on an object attribute. 579 * @kobj: object we're acting for. 580 * @attr: attribute descriptor. 581 * @mode: file permissions. 582 * 583 */ 584 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr, 585 mode_t mode) 586 { 587 struct sysfs_dirent *sd; 588 struct iattr newattrs; 589 int rc; 590 591 mutex_lock(&sysfs_mutex); 592 593 rc = -ENOENT; 594 sd = sysfs_find_dirent(kobj->sd, NULL, attr->name); 595 if (!sd) 596 goto out; 597 598 newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO); 599 newattrs.ia_valid = ATTR_MODE; 600 rc = sysfs_sd_setattr(sd, &newattrs); 601 602 out: 603 mutex_unlock(&sysfs_mutex); 604 return rc; 605 } 606 EXPORT_SYMBOL_GPL(sysfs_chmod_file); 607 608 609 /** 610 * sysfs_remove_file - remove an object attribute. 611 * @kobj: object we're acting for. 612 * @attr: attribute descriptor. 613 * 614 * Hash the attribute name and kill the victim. 615 */ 616 617 void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr) 618 { 619 sysfs_hash_and_remove(kobj->sd, NULL, attr->name); 620 } 621 622 void sysfs_remove_files(struct kobject * kobj, const struct attribute **ptr) 623 { 624 int i; 625 for (i = 0; ptr[i]; i++) 626 sysfs_remove_file(kobj, ptr[i]); 627 } 628 629 /** 630 * sysfs_remove_file_from_group - remove an attribute file from a group. 631 * @kobj: object we're acting for. 632 * @attr: attribute descriptor. 633 * @group: group name. 634 */ 635 void sysfs_remove_file_from_group(struct kobject *kobj, 636 const struct attribute *attr, const char *group) 637 { 638 struct sysfs_dirent *dir_sd; 639 640 if (group) 641 dir_sd = sysfs_get_dirent(kobj->sd, NULL, group); 642 else 643 dir_sd = sysfs_get(kobj->sd); 644 if (dir_sd) { 645 sysfs_hash_and_remove(dir_sd, NULL, attr->name); 646 sysfs_put(dir_sd); 647 } 648 } 649 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group); 650 651 struct sysfs_schedule_callback_struct { 652 struct list_head workq_list; 653 struct kobject *kobj; 654 void (*func)(void *); 655 void *data; 656 struct module *owner; 657 struct work_struct work; 658 }; 659 660 static struct workqueue_struct *sysfs_workqueue; 661 static DEFINE_MUTEX(sysfs_workq_mutex); 662 static LIST_HEAD(sysfs_workq); 663 static void sysfs_schedule_callback_work(struct work_struct *work) 664 { 665 struct sysfs_schedule_callback_struct *ss = container_of(work, 666 struct sysfs_schedule_callback_struct, work); 667 668 (ss->func)(ss->data); 669 kobject_put(ss->kobj); 670 module_put(ss->owner); 671 mutex_lock(&sysfs_workq_mutex); 672 list_del(&ss->workq_list); 673 mutex_unlock(&sysfs_workq_mutex); 674 kfree(ss); 675 } 676 677 /** 678 * sysfs_schedule_callback - helper to schedule a callback for a kobject 679 * @kobj: object we're acting for. 680 * @func: callback function to invoke later. 681 * @data: argument to pass to @func. 682 * @owner: module owning the callback code 683 * 684 * sysfs attribute methods must not unregister themselves or their parent 685 * kobject (which would amount to the same thing). Attempts to do so will 686 * deadlock, since unregistration is mutually exclusive with driver 687 * callbacks. 688 * 689 * Instead methods can call this routine, which will attempt to allocate 690 * and schedule a workqueue request to call back @func with @data as its 691 * argument in the workqueue's process context. @kobj will be pinned 692 * until @func returns. 693 * 694 * Returns 0 if the request was submitted, -ENOMEM if storage could not 695 * be allocated, -ENODEV if a reference to @owner isn't available, 696 * -EAGAIN if a callback has already been scheduled for @kobj. 697 */ 698 int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *), 699 void *data, struct module *owner) 700 { 701 struct sysfs_schedule_callback_struct *ss, *tmp; 702 703 if (!try_module_get(owner)) 704 return -ENODEV; 705 706 mutex_lock(&sysfs_workq_mutex); 707 list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list) 708 if (ss->kobj == kobj) { 709 module_put(owner); 710 mutex_unlock(&sysfs_workq_mutex); 711 return -EAGAIN; 712 } 713 mutex_unlock(&sysfs_workq_mutex); 714 715 if (sysfs_workqueue == NULL) { 716 sysfs_workqueue = create_singlethread_workqueue("sysfsd"); 717 if (sysfs_workqueue == NULL) { 718 module_put(owner); 719 return -ENOMEM; 720 } 721 } 722 723 ss = kmalloc(sizeof(*ss), GFP_KERNEL); 724 if (!ss) { 725 module_put(owner); 726 return -ENOMEM; 727 } 728 kobject_get(kobj); 729 ss->kobj = kobj; 730 ss->func = func; 731 ss->data = data; 732 ss->owner = owner; 733 INIT_WORK(&ss->work, sysfs_schedule_callback_work); 734 INIT_LIST_HEAD(&ss->workq_list); 735 mutex_lock(&sysfs_workq_mutex); 736 list_add_tail(&ss->workq_list, &sysfs_workq); 737 mutex_unlock(&sysfs_workq_mutex); 738 queue_work(sysfs_workqueue, &ss->work); 739 return 0; 740 } 741 EXPORT_SYMBOL_GPL(sysfs_schedule_callback); 742 743 744 EXPORT_SYMBOL_GPL(sysfs_create_file); 745 EXPORT_SYMBOL_GPL(sysfs_remove_file); 746 EXPORT_SYMBOL_GPL(sysfs_remove_files); 747 EXPORT_SYMBOL_GPL(sysfs_create_files); 748