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