1 /* 2 * fs/kernfs/file.c - kernfs file implementation 3 * 4 * Copyright (c) 2001-3 Patrick Mochel 5 * Copyright (c) 2007 SUSE Linux Products GmbH 6 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 7 * 8 * This file is released under the GPLv2. 9 */ 10 11 #include <linux/fs.h> 12 #include <linux/seq_file.h> 13 #include <linux/slab.h> 14 #include <linux/poll.h> 15 #include <linux/pagemap.h> 16 #include <linux/sched.h> 17 18 #include "kernfs-internal.h" 19 20 /* 21 * There's one kernfs_open_file for each open file and one kernfs_open_node 22 * for each kernfs_node with one or more open files. 23 * 24 * kernfs_node->attr.open points to kernfs_open_node. attr.open is 25 * protected by kernfs_open_node_lock. 26 * 27 * filp->private_data points to seq_file whose ->private points to 28 * kernfs_open_file. kernfs_open_files are chained at 29 * kernfs_open_node->files, which is protected by kernfs_open_file_mutex. 30 */ 31 static DEFINE_SPINLOCK(kernfs_open_node_lock); 32 static DEFINE_MUTEX(kernfs_open_file_mutex); 33 34 struct kernfs_open_node { 35 atomic_t refcnt; 36 atomic_t event; 37 wait_queue_head_t poll; 38 struct list_head files; /* goes through kernfs_open_file.list */ 39 }; 40 41 static struct kernfs_open_file *kernfs_of(struct file *file) 42 { 43 return ((struct seq_file *)file->private_data)->private; 44 } 45 46 /* 47 * Determine the kernfs_ops for the given kernfs_node. This function must 48 * be called while holding an active reference. 49 */ 50 static const struct kernfs_ops *kernfs_ops(struct kernfs_node *kn) 51 { 52 if (kn->flags & KERNFS_LOCKDEP) 53 lockdep_assert_held(kn); 54 return kn->attr.ops; 55 } 56 57 /* 58 * As kernfs_seq_stop() is also called after kernfs_seq_start() or 59 * kernfs_seq_next() failure, it needs to distinguish whether it's stopping 60 * a seq_file iteration which is fully initialized with an active reference 61 * or an aborted kernfs_seq_start() due to get_active failure. The 62 * position pointer is the only context for each seq_file iteration and 63 * thus the stop condition should be encoded in it. As the return value is 64 * directly visible to userland, ERR_PTR(-ENODEV) is the only acceptable 65 * choice to indicate get_active failure. 66 * 67 * Unfortunately, this is complicated due to the optional custom seq_file 68 * operations which may return ERR_PTR(-ENODEV) too. kernfs_seq_stop() 69 * can't distinguish whether ERR_PTR(-ENODEV) is from get_active failure or 70 * custom seq_file operations and thus can't decide whether put_active 71 * should be performed or not only on ERR_PTR(-ENODEV). 72 * 73 * This is worked around by factoring out the custom seq_stop() and 74 * put_active part into kernfs_seq_stop_active(), skipping it from 75 * kernfs_seq_stop() if ERR_PTR(-ENODEV) while invoking it directly after 76 * custom seq_file operations fail with ERR_PTR(-ENODEV) - this ensures 77 * that kernfs_seq_stop_active() is skipped only after get_active failure. 78 */ 79 static void kernfs_seq_stop_active(struct seq_file *sf, void *v) 80 { 81 struct kernfs_open_file *of = sf->private; 82 const struct kernfs_ops *ops = kernfs_ops(of->kn); 83 84 if (ops->seq_stop) 85 ops->seq_stop(sf, v); 86 kernfs_put_active(of->kn); 87 } 88 89 static void *kernfs_seq_start(struct seq_file *sf, loff_t *ppos) 90 { 91 struct kernfs_open_file *of = sf->private; 92 const struct kernfs_ops *ops; 93 94 /* 95 * @of->mutex nests outside active ref and is just to ensure that 96 * the ops aren't called concurrently for the same open file. 97 */ 98 mutex_lock(&of->mutex); 99 if (!kernfs_get_active(of->kn)) 100 return ERR_PTR(-ENODEV); 101 102 ops = kernfs_ops(of->kn); 103 if (ops->seq_start) { 104 void *next = ops->seq_start(sf, ppos); 105 /* see the comment above kernfs_seq_stop_active() */ 106 if (next == ERR_PTR(-ENODEV)) 107 kernfs_seq_stop_active(sf, next); 108 return next; 109 } else { 110 /* 111 * The same behavior and code as single_open(). Returns 112 * !NULL if pos is at the beginning; otherwise, NULL. 113 */ 114 return NULL + !*ppos; 115 } 116 } 117 118 static void *kernfs_seq_next(struct seq_file *sf, void *v, loff_t *ppos) 119 { 120 struct kernfs_open_file *of = sf->private; 121 const struct kernfs_ops *ops = kernfs_ops(of->kn); 122 123 if (ops->seq_next) { 124 void *next = ops->seq_next(sf, v, ppos); 125 /* see the comment above kernfs_seq_stop_active() */ 126 if (next == ERR_PTR(-ENODEV)) 127 kernfs_seq_stop_active(sf, next); 128 return next; 129 } else { 130 /* 131 * The same behavior and code as single_open(), always 132 * terminate after the initial read. 133 */ 134 ++*ppos; 135 return NULL; 136 } 137 } 138 139 static void kernfs_seq_stop(struct seq_file *sf, void *v) 140 { 141 struct kernfs_open_file *of = sf->private; 142 143 if (v != ERR_PTR(-ENODEV)) 144 kernfs_seq_stop_active(sf, v); 145 mutex_unlock(&of->mutex); 146 } 147 148 static int kernfs_seq_show(struct seq_file *sf, void *v) 149 { 150 struct kernfs_open_file *of = sf->private; 151 152 of->event = atomic_read(&of->kn->attr.open->event); 153 154 return of->kn->attr.ops->seq_show(sf, v); 155 } 156 157 static const struct seq_operations kernfs_seq_ops = { 158 .start = kernfs_seq_start, 159 .next = kernfs_seq_next, 160 .stop = kernfs_seq_stop, 161 .show = kernfs_seq_show, 162 }; 163 164 /* 165 * As reading a bin file can have side-effects, the exact offset and bytes 166 * specified in read(2) call should be passed to the read callback making 167 * it difficult to use seq_file. Implement simplistic custom buffering for 168 * bin files. 169 */ 170 static ssize_t kernfs_file_direct_read(struct kernfs_open_file *of, 171 char __user *user_buf, size_t count, 172 loff_t *ppos) 173 { 174 ssize_t len = min_t(size_t, count, PAGE_SIZE); 175 const struct kernfs_ops *ops; 176 char *buf; 177 178 buf = kmalloc(len, GFP_KERNEL); 179 if (!buf) 180 return -ENOMEM; 181 182 /* 183 * @of->mutex nests outside active ref and is just to ensure that 184 * the ops aren't called concurrently for the same open file. 185 */ 186 mutex_lock(&of->mutex); 187 if (!kernfs_get_active(of->kn)) { 188 len = -ENODEV; 189 mutex_unlock(&of->mutex); 190 goto out_free; 191 } 192 193 ops = kernfs_ops(of->kn); 194 if (ops->read) 195 len = ops->read(of, buf, len, *ppos); 196 else 197 len = -EINVAL; 198 199 kernfs_put_active(of->kn); 200 mutex_unlock(&of->mutex); 201 202 if (len < 0) 203 goto out_free; 204 205 if (copy_to_user(user_buf, buf, len)) { 206 len = -EFAULT; 207 goto out_free; 208 } 209 210 *ppos += len; 211 212 out_free: 213 kfree(buf); 214 return len; 215 } 216 217 /** 218 * kernfs_fop_read - kernfs vfs read callback 219 * @file: file pointer 220 * @user_buf: data to write 221 * @count: number of bytes 222 * @ppos: starting offset 223 */ 224 static ssize_t kernfs_fop_read(struct file *file, char __user *user_buf, 225 size_t count, loff_t *ppos) 226 { 227 struct kernfs_open_file *of = kernfs_of(file); 228 229 if (of->kn->flags & KERNFS_HAS_SEQ_SHOW) 230 return seq_read(file, user_buf, count, ppos); 231 else 232 return kernfs_file_direct_read(of, user_buf, count, ppos); 233 } 234 235 /** 236 * kernfs_fop_write - kernfs vfs write callback 237 * @file: file pointer 238 * @user_buf: data to write 239 * @count: number of bytes 240 * @ppos: starting offset 241 * 242 * Copy data in from userland and pass it to the matching kernfs write 243 * operation. 244 * 245 * There is no easy way for us to know if userspace is only doing a partial 246 * write, so we don't support them. We expect the entire buffer to come on 247 * the first write. Hint: if you're writing a value, first read the file, 248 * modify only the the value you're changing, then write entire buffer 249 * back. 250 */ 251 static ssize_t kernfs_fop_write(struct file *file, const char __user *user_buf, 252 size_t count, loff_t *ppos) 253 { 254 struct kernfs_open_file *of = kernfs_of(file); 255 ssize_t len = min_t(size_t, count, PAGE_SIZE); 256 const struct kernfs_ops *ops; 257 char *buf; 258 259 buf = kmalloc(len + 1, GFP_KERNEL); 260 if (!buf) 261 return -ENOMEM; 262 263 if (copy_from_user(buf, user_buf, len)) { 264 len = -EFAULT; 265 goto out_free; 266 } 267 buf[len] = '\0'; /* guarantee string termination */ 268 269 /* 270 * @of->mutex nests outside active ref and is just to ensure that 271 * the ops aren't called concurrently for the same open file. 272 */ 273 mutex_lock(&of->mutex); 274 if (!kernfs_get_active(of->kn)) { 275 mutex_unlock(&of->mutex); 276 len = -ENODEV; 277 goto out_free; 278 } 279 280 ops = kernfs_ops(of->kn); 281 if (ops->write) 282 len = ops->write(of, buf, len, *ppos); 283 else 284 len = -EINVAL; 285 286 kernfs_put_active(of->kn); 287 mutex_unlock(&of->mutex); 288 289 if (len > 0) 290 *ppos += len; 291 out_free: 292 kfree(buf); 293 return len; 294 } 295 296 static void kernfs_vma_open(struct vm_area_struct *vma) 297 { 298 struct file *file = vma->vm_file; 299 struct kernfs_open_file *of = kernfs_of(file); 300 301 if (!of->vm_ops) 302 return; 303 304 if (!kernfs_get_active(of->kn)) 305 return; 306 307 if (of->vm_ops->open) 308 of->vm_ops->open(vma); 309 310 kernfs_put_active(of->kn); 311 } 312 313 static int kernfs_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 314 { 315 struct file *file = vma->vm_file; 316 struct kernfs_open_file *of = kernfs_of(file); 317 int ret; 318 319 if (!of->vm_ops) 320 return VM_FAULT_SIGBUS; 321 322 if (!kernfs_get_active(of->kn)) 323 return VM_FAULT_SIGBUS; 324 325 ret = VM_FAULT_SIGBUS; 326 if (of->vm_ops->fault) 327 ret = of->vm_ops->fault(vma, vmf); 328 329 kernfs_put_active(of->kn); 330 return ret; 331 } 332 333 static int kernfs_vma_page_mkwrite(struct vm_area_struct *vma, 334 struct vm_fault *vmf) 335 { 336 struct file *file = vma->vm_file; 337 struct kernfs_open_file *of = kernfs_of(file); 338 int ret; 339 340 if (!of->vm_ops) 341 return VM_FAULT_SIGBUS; 342 343 if (!kernfs_get_active(of->kn)) 344 return VM_FAULT_SIGBUS; 345 346 ret = 0; 347 if (of->vm_ops->page_mkwrite) 348 ret = of->vm_ops->page_mkwrite(vma, vmf); 349 else 350 file_update_time(file); 351 352 kernfs_put_active(of->kn); 353 return ret; 354 } 355 356 static int kernfs_vma_access(struct vm_area_struct *vma, unsigned long addr, 357 void *buf, int len, int write) 358 { 359 struct file *file = vma->vm_file; 360 struct kernfs_open_file *of = kernfs_of(file); 361 int ret; 362 363 if (!of->vm_ops) 364 return -EINVAL; 365 366 if (!kernfs_get_active(of->kn)) 367 return -EINVAL; 368 369 ret = -EINVAL; 370 if (of->vm_ops->access) 371 ret = of->vm_ops->access(vma, addr, buf, len, write); 372 373 kernfs_put_active(of->kn); 374 return ret; 375 } 376 377 #ifdef CONFIG_NUMA 378 static int kernfs_vma_set_policy(struct vm_area_struct *vma, 379 struct mempolicy *new) 380 { 381 struct file *file = vma->vm_file; 382 struct kernfs_open_file *of = kernfs_of(file); 383 int ret; 384 385 if (!of->vm_ops) 386 return 0; 387 388 if (!kernfs_get_active(of->kn)) 389 return -EINVAL; 390 391 ret = 0; 392 if (of->vm_ops->set_policy) 393 ret = of->vm_ops->set_policy(vma, new); 394 395 kernfs_put_active(of->kn); 396 return ret; 397 } 398 399 static struct mempolicy *kernfs_vma_get_policy(struct vm_area_struct *vma, 400 unsigned long addr) 401 { 402 struct file *file = vma->vm_file; 403 struct kernfs_open_file *of = kernfs_of(file); 404 struct mempolicy *pol; 405 406 if (!of->vm_ops) 407 return vma->vm_policy; 408 409 if (!kernfs_get_active(of->kn)) 410 return vma->vm_policy; 411 412 pol = vma->vm_policy; 413 if (of->vm_ops->get_policy) 414 pol = of->vm_ops->get_policy(vma, addr); 415 416 kernfs_put_active(of->kn); 417 return pol; 418 } 419 420 static int kernfs_vma_migrate(struct vm_area_struct *vma, 421 const nodemask_t *from, const nodemask_t *to, 422 unsigned long flags) 423 { 424 struct file *file = vma->vm_file; 425 struct kernfs_open_file *of = kernfs_of(file); 426 int ret; 427 428 if (!of->vm_ops) 429 return 0; 430 431 if (!kernfs_get_active(of->kn)) 432 return 0; 433 434 ret = 0; 435 if (of->vm_ops->migrate) 436 ret = of->vm_ops->migrate(vma, from, to, flags); 437 438 kernfs_put_active(of->kn); 439 return ret; 440 } 441 #endif 442 443 static const struct vm_operations_struct kernfs_vm_ops = { 444 .open = kernfs_vma_open, 445 .fault = kernfs_vma_fault, 446 .page_mkwrite = kernfs_vma_page_mkwrite, 447 .access = kernfs_vma_access, 448 #ifdef CONFIG_NUMA 449 .set_policy = kernfs_vma_set_policy, 450 .get_policy = kernfs_vma_get_policy, 451 .migrate = kernfs_vma_migrate, 452 #endif 453 }; 454 455 static int kernfs_fop_mmap(struct file *file, struct vm_area_struct *vma) 456 { 457 struct kernfs_open_file *of = kernfs_of(file); 458 const struct kernfs_ops *ops; 459 int rc; 460 461 /* 462 * mmap path and of->mutex are prone to triggering spurious lockdep 463 * warnings and we don't want to add spurious locking dependency 464 * between the two. Check whether mmap is actually implemented 465 * without grabbing @of->mutex by testing HAS_MMAP flag. See the 466 * comment in kernfs_file_open() for more details. 467 */ 468 if (!(of->kn->flags & KERNFS_HAS_MMAP)) 469 return -ENODEV; 470 471 mutex_lock(&of->mutex); 472 473 rc = -ENODEV; 474 if (!kernfs_get_active(of->kn)) 475 goto out_unlock; 476 477 ops = kernfs_ops(of->kn); 478 rc = ops->mmap(of, vma); 479 480 /* 481 * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup() 482 * to satisfy versions of X which crash if the mmap fails: that 483 * substitutes a new vm_file, and we don't then want bin_vm_ops. 484 */ 485 if (vma->vm_file != file) 486 goto out_put; 487 488 rc = -EINVAL; 489 if (of->mmapped && of->vm_ops != vma->vm_ops) 490 goto out_put; 491 492 /* 493 * It is not possible to successfully wrap close. 494 * So error if someone is trying to use close. 495 */ 496 rc = -EINVAL; 497 if (vma->vm_ops && vma->vm_ops->close) 498 goto out_put; 499 500 rc = 0; 501 of->mmapped = 1; 502 of->vm_ops = vma->vm_ops; 503 vma->vm_ops = &kernfs_vm_ops; 504 out_put: 505 kernfs_put_active(of->kn); 506 out_unlock: 507 mutex_unlock(&of->mutex); 508 509 return rc; 510 } 511 512 /** 513 * kernfs_get_open_node - get or create kernfs_open_node 514 * @kn: target kernfs_node 515 * @of: kernfs_open_file for this instance of open 516 * 517 * If @kn->attr.open exists, increment its reference count; otherwise, 518 * create one. @of is chained to the files list. 519 * 520 * LOCKING: 521 * Kernel thread context (may sleep). 522 * 523 * RETURNS: 524 * 0 on success, -errno on failure. 525 */ 526 static int kernfs_get_open_node(struct kernfs_node *kn, 527 struct kernfs_open_file *of) 528 { 529 struct kernfs_open_node *on, *new_on = NULL; 530 531 retry: 532 mutex_lock(&kernfs_open_file_mutex); 533 spin_lock_irq(&kernfs_open_node_lock); 534 535 if (!kn->attr.open && new_on) { 536 kn->attr.open = new_on; 537 new_on = NULL; 538 } 539 540 on = kn->attr.open; 541 if (on) { 542 atomic_inc(&on->refcnt); 543 list_add_tail(&of->list, &on->files); 544 } 545 546 spin_unlock_irq(&kernfs_open_node_lock); 547 mutex_unlock(&kernfs_open_file_mutex); 548 549 if (on) { 550 kfree(new_on); 551 return 0; 552 } 553 554 /* not there, initialize a new one and retry */ 555 new_on = kmalloc(sizeof(*new_on), GFP_KERNEL); 556 if (!new_on) 557 return -ENOMEM; 558 559 atomic_set(&new_on->refcnt, 0); 560 atomic_set(&new_on->event, 1); 561 init_waitqueue_head(&new_on->poll); 562 INIT_LIST_HEAD(&new_on->files); 563 goto retry; 564 } 565 566 /** 567 * kernfs_put_open_node - put kernfs_open_node 568 * @kn: target kernfs_nodet 569 * @of: associated kernfs_open_file 570 * 571 * Put @kn->attr.open and unlink @of from the files list. If 572 * reference count reaches zero, disassociate and free it. 573 * 574 * LOCKING: 575 * None. 576 */ 577 static void kernfs_put_open_node(struct kernfs_node *kn, 578 struct kernfs_open_file *of) 579 { 580 struct kernfs_open_node *on = kn->attr.open; 581 unsigned long flags; 582 583 mutex_lock(&kernfs_open_file_mutex); 584 spin_lock_irqsave(&kernfs_open_node_lock, flags); 585 586 if (of) 587 list_del(&of->list); 588 589 if (atomic_dec_and_test(&on->refcnt)) 590 kn->attr.open = NULL; 591 else 592 on = NULL; 593 594 spin_unlock_irqrestore(&kernfs_open_node_lock, flags); 595 mutex_unlock(&kernfs_open_file_mutex); 596 597 kfree(on); 598 } 599 600 static int kernfs_fop_open(struct inode *inode, struct file *file) 601 { 602 struct kernfs_node *kn = file->f_path.dentry->d_fsdata; 603 const struct kernfs_ops *ops; 604 struct kernfs_open_file *of; 605 bool has_read, has_write, has_mmap; 606 int error = -EACCES; 607 608 if (!kernfs_get_active(kn)) 609 return -ENODEV; 610 611 ops = kernfs_ops(kn); 612 613 has_read = ops->seq_show || ops->read || ops->mmap; 614 has_write = ops->write || ops->mmap; 615 has_mmap = ops->mmap; 616 617 /* check perms and supported operations */ 618 if ((file->f_mode & FMODE_WRITE) && 619 (!(inode->i_mode & S_IWUGO) || !has_write)) 620 goto err_out; 621 622 if ((file->f_mode & FMODE_READ) && 623 (!(inode->i_mode & S_IRUGO) || !has_read)) 624 goto err_out; 625 626 /* allocate a kernfs_open_file for the file */ 627 error = -ENOMEM; 628 of = kzalloc(sizeof(struct kernfs_open_file), GFP_KERNEL); 629 if (!of) 630 goto err_out; 631 632 /* 633 * The following is done to give a different lockdep key to 634 * @of->mutex for files which implement mmap. This is a rather 635 * crude way to avoid false positive lockdep warning around 636 * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and 637 * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under 638 * which mm->mmap_sem nests, while holding @of->mutex. As each 639 * open file has a separate mutex, it's okay as long as those don't 640 * happen on the same file. At this point, we can't easily give 641 * each file a separate locking class. Let's differentiate on 642 * whether the file has mmap or not for now. 643 * 644 * Both paths of the branch look the same. They're supposed to 645 * look that way and give @of->mutex different static lockdep keys. 646 */ 647 if (has_mmap) 648 mutex_init(&of->mutex); 649 else 650 mutex_init(&of->mutex); 651 652 of->kn = kn; 653 of->file = file; 654 655 /* 656 * Always instantiate seq_file even if read access doesn't use 657 * seq_file or is not requested. This unifies private data access 658 * and readable regular files are the vast majority anyway. 659 */ 660 if (ops->seq_show) 661 error = seq_open(file, &kernfs_seq_ops); 662 else 663 error = seq_open(file, NULL); 664 if (error) 665 goto err_free; 666 667 ((struct seq_file *)file->private_data)->private = of; 668 669 /* seq_file clears PWRITE unconditionally, restore it if WRITE */ 670 if (file->f_mode & FMODE_WRITE) 671 file->f_mode |= FMODE_PWRITE; 672 673 /* make sure we have open node struct */ 674 error = kernfs_get_open_node(kn, of); 675 if (error) 676 goto err_close; 677 678 /* open succeeded, put active references */ 679 kernfs_put_active(kn); 680 return 0; 681 682 err_close: 683 seq_release(inode, file); 684 err_free: 685 kfree(of); 686 err_out: 687 kernfs_put_active(kn); 688 return error; 689 } 690 691 static int kernfs_fop_release(struct inode *inode, struct file *filp) 692 { 693 struct kernfs_node *kn = filp->f_path.dentry->d_fsdata; 694 struct kernfs_open_file *of = kernfs_of(filp); 695 696 kernfs_put_open_node(kn, of); 697 seq_release(inode, filp); 698 kfree(of); 699 700 return 0; 701 } 702 703 void kernfs_unmap_bin_file(struct kernfs_node *kn) 704 { 705 struct kernfs_open_node *on; 706 struct kernfs_open_file *of; 707 708 if (!(kn->flags & KERNFS_HAS_MMAP)) 709 return; 710 711 spin_lock_irq(&kernfs_open_node_lock); 712 on = kn->attr.open; 713 if (on) 714 atomic_inc(&on->refcnt); 715 spin_unlock_irq(&kernfs_open_node_lock); 716 if (!on) 717 return; 718 719 mutex_lock(&kernfs_open_file_mutex); 720 list_for_each_entry(of, &on->files, list) { 721 struct inode *inode = file_inode(of->file); 722 unmap_mapping_range(inode->i_mapping, 0, 0, 1); 723 } 724 mutex_unlock(&kernfs_open_file_mutex); 725 726 kernfs_put_open_node(kn, NULL); 727 } 728 729 /* 730 * Kernfs attribute files are pollable. The idea is that you read 731 * the content and then you use 'poll' or 'select' to wait for 732 * the content to change. When the content changes (assuming the 733 * manager for the kobject supports notification), poll will 734 * return POLLERR|POLLPRI, and select will return the fd whether 735 * it is waiting for read, write, or exceptions. 736 * Once poll/select indicates that the value has changed, you 737 * need to close and re-open the file, or seek to 0 and read again. 738 * Reminder: this only works for attributes which actively support 739 * it, and it is not possible to test an attribute from userspace 740 * to see if it supports poll (Neither 'poll' nor 'select' return 741 * an appropriate error code). When in doubt, set a suitable timeout value. 742 */ 743 static unsigned int kernfs_fop_poll(struct file *filp, poll_table *wait) 744 { 745 struct kernfs_open_file *of = kernfs_of(filp); 746 struct kernfs_node *kn = filp->f_path.dentry->d_fsdata; 747 struct kernfs_open_node *on = kn->attr.open; 748 749 /* need parent for the kobj, grab both */ 750 if (!kernfs_get_active(kn)) 751 goto trigger; 752 753 poll_wait(filp, &on->poll, wait); 754 755 kernfs_put_active(kn); 756 757 if (of->event != atomic_read(&on->event)) 758 goto trigger; 759 760 return DEFAULT_POLLMASK; 761 762 trigger: 763 return DEFAULT_POLLMASK|POLLERR|POLLPRI; 764 } 765 766 /** 767 * kernfs_notify - notify a kernfs file 768 * @kn: file to notify 769 * 770 * Notify @kn such that poll(2) on @kn wakes up. 771 */ 772 void kernfs_notify(struct kernfs_node *kn) 773 { 774 struct kernfs_open_node *on; 775 unsigned long flags; 776 777 spin_lock_irqsave(&kernfs_open_node_lock, flags); 778 779 if (!WARN_ON(kernfs_type(kn) != KERNFS_FILE)) { 780 on = kn->attr.open; 781 if (on) { 782 atomic_inc(&on->event); 783 wake_up_interruptible(&on->poll); 784 } 785 } 786 787 spin_unlock_irqrestore(&kernfs_open_node_lock, flags); 788 } 789 EXPORT_SYMBOL_GPL(kernfs_notify); 790 791 const struct file_operations kernfs_file_fops = { 792 .read = kernfs_fop_read, 793 .write = kernfs_fop_write, 794 .llseek = generic_file_llseek, 795 .mmap = kernfs_fop_mmap, 796 .open = kernfs_fop_open, 797 .release = kernfs_fop_release, 798 .poll = kernfs_fop_poll, 799 }; 800 801 /** 802 * __kernfs_create_file - kernfs internal function to create a file 803 * @parent: directory to create the file in 804 * @name: name of the file 805 * @mode: mode of the file 806 * @size: size of the file 807 * @ops: kernfs operations for the file 808 * @priv: private data for the file 809 * @ns: optional namespace tag of the file 810 * @static_name: don't copy file name 811 * @key: lockdep key for the file's active_ref, %NULL to disable lockdep 812 * 813 * Returns the created node on success, ERR_PTR() value on error. 814 */ 815 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent, 816 const char *name, 817 umode_t mode, loff_t size, 818 const struct kernfs_ops *ops, 819 void *priv, const void *ns, 820 bool name_is_static, 821 struct lock_class_key *key) 822 { 823 struct kernfs_addrm_cxt acxt; 824 struct kernfs_node *kn; 825 unsigned flags; 826 int rc; 827 828 flags = KERNFS_FILE; 829 if (name_is_static) 830 flags |= KERNFS_STATIC_NAME; 831 832 kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG, flags); 833 if (!kn) 834 return ERR_PTR(-ENOMEM); 835 836 kn->attr.ops = ops; 837 kn->attr.size = size; 838 kn->ns = ns; 839 kn->priv = priv; 840 841 #ifdef CONFIG_DEBUG_LOCK_ALLOC 842 if (key) { 843 lockdep_init_map(&kn->dep_map, "s_active", key, 0); 844 kn->flags |= KERNFS_LOCKDEP; 845 } 846 #endif 847 848 /* 849 * kn->attr.ops is accesible only while holding active ref. We 850 * need to know whether some ops are implemented outside active 851 * ref. Cache their existence in flags. 852 */ 853 if (ops->seq_show) 854 kn->flags |= KERNFS_HAS_SEQ_SHOW; 855 if (ops->mmap) 856 kn->flags |= KERNFS_HAS_MMAP; 857 858 kernfs_addrm_start(&acxt); 859 rc = kernfs_add_one(&acxt, kn); 860 kernfs_addrm_finish(&acxt); 861 862 if (rc) { 863 kernfs_put(kn); 864 return ERR_PTR(rc); 865 } 866 return kn; 867 } 868