1 /* 2 * fs/libfs.c 3 * Library for filesystems writers. 4 */ 5 6 #include <linux/export.h> 7 #include <linux/pagemap.h> 8 #include <linux/slab.h> 9 #include <linux/mount.h> 10 #include <linux/vfs.h> 11 #include <linux/quotaops.h> 12 #include <linux/mutex.h> 13 #include <linux/exportfs.h> 14 #include <linux/writeback.h> 15 #include <linux/buffer_head.h> /* sync_mapping_buffers */ 16 17 #include <asm/uaccess.h> 18 19 #include "internal.h" 20 21 static inline int simple_positive(struct dentry *dentry) 22 { 23 return dentry->d_inode && !d_unhashed(dentry); 24 } 25 26 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry, 27 struct kstat *stat) 28 { 29 struct inode *inode = dentry->d_inode; 30 generic_fillattr(inode, stat); 31 stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9); 32 return 0; 33 } 34 35 int simple_statfs(struct dentry *dentry, struct kstatfs *buf) 36 { 37 buf->f_type = dentry->d_sb->s_magic; 38 buf->f_bsize = PAGE_CACHE_SIZE; 39 buf->f_namelen = NAME_MAX; 40 return 0; 41 } 42 43 /* 44 * Retaining negative dentries for an in-memory filesystem just wastes 45 * memory and lookup time: arrange for them to be deleted immediately. 46 */ 47 static int simple_delete_dentry(const struct dentry *dentry) 48 { 49 return 1; 50 } 51 52 /* 53 * Lookup the data. This is trivial - if the dentry didn't already 54 * exist, we know it is negative. Set d_op to delete negative dentries. 55 */ 56 struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 57 { 58 static const struct dentry_operations simple_dentry_operations = { 59 .d_delete = simple_delete_dentry, 60 }; 61 62 if (dentry->d_name.len > NAME_MAX) 63 return ERR_PTR(-ENAMETOOLONG); 64 d_set_d_op(dentry, &simple_dentry_operations); 65 d_add(dentry, NULL); 66 return NULL; 67 } 68 69 int dcache_dir_open(struct inode *inode, struct file *file) 70 { 71 static struct qstr cursor_name = {.len = 1, .name = "."}; 72 73 file->private_data = d_alloc(file->f_path.dentry, &cursor_name); 74 75 return file->private_data ? 0 : -ENOMEM; 76 } 77 78 int dcache_dir_close(struct inode *inode, struct file *file) 79 { 80 dput(file->private_data); 81 return 0; 82 } 83 84 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin) 85 { 86 struct dentry *dentry = file->f_path.dentry; 87 mutex_lock(&dentry->d_inode->i_mutex); 88 switch (origin) { 89 case 1: 90 offset += file->f_pos; 91 case 0: 92 if (offset >= 0) 93 break; 94 default: 95 mutex_unlock(&dentry->d_inode->i_mutex); 96 return -EINVAL; 97 } 98 if (offset != file->f_pos) { 99 file->f_pos = offset; 100 if (file->f_pos >= 2) { 101 struct list_head *p; 102 struct dentry *cursor = file->private_data; 103 loff_t n = file->f_pos - 2; 104 105 spin_lock(&dentry->d_lock); 106 /* d_lock not required for cursor */ 107 list_del(&cursor->d_u.d_child); 108 p = dentry->d_subdirs.next; 109 while (n && p != &dentry->d_subdirs) { 110 struct dentry *next; 111 next = list_entry(p, struct dentry, d_u.d_child); 112 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED); 113 if (simple_positive(next)) 114 n--; 115 spin_unlock(&next->d_lock); 116 p = p->next; 117 } 118 list_add_tail(&cursor->d_u.d_child, p); 119 spin_unlock(&dentry->d_lock); 120 } 121 } 122 mutex_unlock(&dentry->d_inode->i_mutex); 123 return offset; 124 } 125 126 /* Relationship between i_mode and the DT_xxx types */ 127 static inline unsigned char dt_type(struct inode *inode) 128 { 129 return (inode->i_mode >> 12) & 15; 130 } 131 132 /* 133 * Directory is locked and all positive dentries in it are safe, since 134 * for ramfs-type trees they can't go away without unlink() or rmdir(), 135 * both impossible due to the lock on directory. 136 */ 137 138 int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir) 139 { 140 struct dentry *dentry = filp->f_path.dentry; 141 struct dentry *cursor = filp->private_data; 142 struct list_head *p, *q = &cursor->d_u.d_child; 143 ino_t ino; 144 int i = filp->f_pos; 145 146 switch (i) { 147 case 0: 148 ino = dentry->d_inode->i_ino; 149 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 150 break; 151 filp->f_pos++; 152 i++; 153 /* fallthrough */ 154 case 1: 155 ino = parent_ino(dentry); 156 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 157 break; 158 filp->f_pos++; 159 i++; 160 /* fallthrough */ 161 default: 162 spin_lock(&dentry->d_lock); 163 if (filp->f_pos == 2) 164 list_move(q, &dentry->d_subdirs); 165 166 for (p=q->next; p != &dentry->d_subdirs; p=p->next) { 167 struct dentry *next; 168 next = list_entry(p, struct dentry, d_u.d_child); 169 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED); 170 if (!simple_positive(next)) { 171 spin_unlock(&next->d_lock); 172 continue; 173 } 174 175 spin_unlock(&next->d_lock); 176 spin_unlock(&dentry->d_lock); 177 if (filldir(dirent, next->d_name.name, 178 next->d_name.len, filp->f_pos, 179 next->d_inode->i_ino, 180 dt_type(next->d_inode)) < 0) 181 return 0; 182 spin_lock(&dentry->d_lock); 183 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED); 184 /* next is still alive */ 185 list_move(q, p); 186 spin_unlock(&next->d_lock); 187 p = q; 188 filp->f_pos++; 189 } 190 spin_unlock(&dentry->d_lock); 191 } 192 return 0; 193 } 194 195 ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos) 196 { 197 return -EISDIR; 198 } 199 200 const struct file_operations simple_dir_operations = { 201 .open = dcache_dir_open, 202 .release = dcache_dir_close, 203 .llseek = dcache_dir_lseek, 204 .read = generic_read_dir, 205 .readdir = dcache_readdir, 206 .fsync = noop_fsync, 207 }; 208 209 const struct inode_operations simple_dir_inode_operations = { 210 .lookup = simple_lookup, 211 }; 212 213 static const struct super_operations simple_super_operations = { 214 .statfs = simple_statfs, 215 }; 216 217 /* 218 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that 219 * will never be mountable) 220 */ 221 struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name, 222 const struct super_operations *ops, 223 const struct dentry_operations *dops, unsigned long magic) 224 { 225 struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL); 226 struct dentry *dentry; 227 struct inode *root; 228 struct qstr d_name = {.name = name, .len = strlen(name)}; 229 230 if (IS_ERR(s)) 231 return ERR_CAST(s); 232 233 s->s_flags = MS_NOUSER; 234 s->s_maxbytes = MAX_LFS_FILESIZE; 235 s->s_blocksize = PAGE_SIZE; 236 s->s_blocksize_bits = PAGE_SHIFT; 237 s->s_magic = magic; 238 s->s_op = ops ? ops : &simple_super_operations; 239 s->s_time_gran = 1; 240 root = new_inode(s); 241 if (!root) 242 goto Enomem; 243 /* 244 * since this is the first inode, make it number 1. New inodes created 245 * after this must take care not to collide with it (by passing 246 * max_reserved of 1 to iunique). 247 */ 248 root->i_ino = 1; 249 root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR; 250 root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME; 251 dentry = __d_alloc(s, &d_name); 252 if (!dentry) { 253 iput(root); 254 goto Enomem; 255 } 256 d_instantiate(dentry, root); 257 s->s_root = dentry; 258 s->s_d_op = dops; 259 s->s_flags |= MS_ACTIVE; 260 return dget(s->s_root); 261 262 Enomem: 263 deactivate_locked_super(s); 264 return ERR_PTR(-ENOMEM); 265 } 266 267 int simple_open(struct inode *inode, struct file *file) 268 { 269 if (inode->i_private) 270 file->private_data = inode->i_private; 271 return 0; 272 } 273 274 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 275 { 276 struct inode *inode = old_dentry->d_inode; 277 278 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 279 inc_nlink(inode); 280 ihold(inode); 281 dget(dentry); 282 d_instantiate(dentry, inode); 283 return 0; 284 } 285 286 int simple_empty(struct dentry *dentry) 287 { 288 struct dentry *child; 289 int ret = 0; 290 291 spin_lock(&dentry->d_lock); 292 list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) { 293 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED); 294 if (simple_positive(child)) { 295 spin_unlock(&child->d_lock); 296 goto out; 297 } 298 spin_unlock(&child->d_lock); 299 } 300 ret = 1; 301 out: 302 spin_unlock(&dentry->d_lock); 303 return ret; 304 } 305 306 int simple_unlink(struct inode *dir, struct dentry *dentry) 307 { 308 struct inode *inode = dentry->d_inode; 309 310 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 311 drop_nlink(inode); 312 dput(dentry); 313 return 0; 314 } 315 316 int simple_rmdir(struct inode *dir, struct dentry *dentry) 317 { 318 if (!simple_empty(dentry)) 319 return -ENOTEMPTY; 320 321 drop_nlink(dentry->d_inode); 322 simple_unlink(dir, dentry); 323 drop_nlink(dir); 324 return 0; 325 } 326 327 int simple_rename(struct inode *old_dir, struct dentry *old_dentry, 328 struct inode *new_dir, struct dentry *new_dentry) 329 { 330 struct inode *inode = old_dentry->d_inode; 331 int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode); 332 333 if (!simple_empty(new_dentry)) 334 return -ENOTEMPTY; 335 336 if (new_dentry->d_inode) { 337 simple_unlink(new_dir, new_dentry); 338 if (they_are_dirs) { 339 drop_nlink(new_dentry->d_inode); 340 drop_nlink(old_dir); 341 } 342 } else if (they_are_dirs) { 343 drop_nlink(old_dir); 344 inc_nlink(new_dir); 345 } 346 347 old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime = 348 new_dir->i_mtime = inode->i_ctime = CURRENT_TIME; 349 350 return 0; 351 } 352 353 /** 354 * simple_setattr - setattr for simple filesystem 355 * @dentry: dentry 356 * @iattr: iattr structure 357 * 358 * Returns 0 on success, -error on failure. 359 * 360 * simple_setattr is a simple ->setattr implementation without a proper 361 * implementation of size changes. 362 * 363 * It can either be used for in-memory filesystems or special files 364 * on simple regular filesystems. Anything that needs to change on-disk 365 * or wire state on size changes needs its own setattr method. 366 */ 367 int simple_setattr(struct dentry *dentry, struct iattr *iattr) 368 { 369 struct inode *inode = dentry->d_inode; 370 int error; 371 372 WARN_ON_ONCE(inode->i_op->truncate); 373 374 error = inode_change_ok(inode, iattr); 375 if (error) 376 return error; 377 378 if (iattr->ia_valid & ATTR_SIZE) 379 truncate_setsize(inode, iattr->ia_size); 380 setattr_copy(inode, iattr); 381 mark_inode_dirty(inode); 382 return 0; 383 } 384 EXPORT_SYMBOL(simple_setattr); 385 386 int simple_readpage(struct file *file, struct page *page) 387 { 388 clear_highpage(page); 389 flush_dcache_page(page); 390 SetPageUptodate(page); 391 unlock_page(page); 392 return 0; 393 } 394 395 int simple_write_begin(struct file *file, struct address_space *mapping, 396 loff_t pos, unsigned len, unsigned flags, 397 struct page **pagep, void **fsdata) 398 { 399 struct page *page; 400 pgoff_t index; 401 402 index = pos >> PAGE_CACHE_SHIFT; 403 404 page = grab_cache_page_write_begin(mapping, index, flags); 405 if (!page) 406 return -ENOMEM; 407 408 *pagep = page; 409 410 if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) { 411 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 412 413 zero_user_segments(page, 0, from, from + len, PAGE_CACHE_SIZE); 414 } 415 return 0; 416 } 417 418 /** 419 * simple_write_end - .write_end helper for non-block-device FSes 420 * @available: See .write_end of address_space_operations 421 * @file: " 422 * @mapping: " 423 * @pos: " 424 * @len: " 425 * @copied: " 426 * @page: " 427 * @fsdata: " 428 * 429 * simple_write_end does the minimum needed for updating a page after writing is 430 * done. It has the same API signature as the .write_end of 431 * address_space_operations vector. So it can just be set onto .write_end for 432 * FSes that don't need any other processing. i_mutex is assumed to be held. 433 * Block based filesystems should use generic_write_end(). 434 * NOTE: Even though i_size might get updated by this function, mark_inode_dirty 435 * is not called, so a filesystem that actually does store data in .write_inode 436 * should extend on what's done here with a call to mark_inode_dirty() in the 437 * case that i_size has changed. 438 */ 439 int simple_write_end(struct file *file, struct address_space *mapping, 440 loff_t pos, unsigned len, unsigned copied, 441 struct page *page, void *fsdata) 442 { 443 struct inode *inode = page->mapping->host; 444 loff_t last_pos = pos + copied; 445 446 /* zero the stale part of the page if we did a short copy */ 447 if (copied < len) { 448 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 449 450 zero_user(page, from + copied, len - copied); 451 } 452 453 if (!PageUptodate(page)) 454 SetPageUptodate(page); 455 /* 456 * No need to use i_size_read() here, the i_size 457 * cannot change under us because we hold the i_mutex. 458 */ 459 if (last_pos > inode->i_size) 460 i_size_write(inode, last_pos); 461 462 set_page_dirty(page); 463 unlock_page(page); 464 page_cache_release(page); 465 466 return copied; 467 } 468 469 /* 470 * the inodes created here are not hashed. If you use iunique to generate 471 * unique inode values later for this filesystem, then you must take care 472 * to pass it an appropriate max_reserved value to avoid collisions. 473 */ 474 int simple_fill_super(struct super_block *s, unsigned long magic, 475 struct tree_descr *files) 476 { 477 struct inode *inode; 478 struct dentry *root; 479 struct dentry *dentry; 480 int i; 481 482 s->s_blocksize = PAGE_CACHE_SIZE; 483 s->s_blocksize_bits = PAGE_CACHE_SHIFT; 484 s->s_magic = magic; 485 s->s_op = &simple_super_operations; 486 s->s_time_gran = 1; 487 488 inode = new_inode(s); 489 if (!inode) 490 return -ENOMEM; 491 /* 492 * because the root inode is 1, the files array must not contain an 493 * entry at index 1 494 */ 495 inode->i_ino = 1; 496 inode->i_mode = S_IFDIR | 0755; 497 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 498 inode->i_op = &simple_dir_inode_operations; 499 inode->i_fop = &simple_dir_operations; 500 set_nlink(inode, 2); 501 root = d_make_root(inode); 502 if (!root) 503 return -ENOMEM; 504 for (i = 0; !files->name || files->name[0]; i++, files++) { 505 if (!files->name) 506 continue; 507 508 /* warn if it tries to conflict with the root inode */ 509 if (unlikely(i == 1)) 510 printk(KERN_WARNING "%s: %s passed in a files array" 511 "with an index of 1!\n", __func__, 512 s->s_type->name); 513 514 dentry = d_alloc_name(root, files->name); 515 if (!dentry) 516 goto out; 517 inode = new_inode(s); 518 if (!inode) { 519 dput(dentry); 520 goto out; 521 } 522 inode->i_mode = S_IFREG | files->mode; 523 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 524 inode->i_fop = files->ops; 525 inode->i_ino = i; 526 d_add(dentry, inode); 527 } 528 s->s_root = root; 529 return 0; 530 out: 531 d_genocide(root); 532 dput(root); 533 return -ENOMEM; 534 } 535 536 static DEFINE_SPINLOCK(pin_fs_lock); 537 538 int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count) 539 { 540 struct vfsmount *mnt = NULL; 541 spin_lock(&pin_fs_lock); 542 if (unlikely(!*mount)) { 543 spin_unlock(&pin_fs_lock); 544 mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL); 545 if (IS_ERR(mnt)) 546 return PTR_ERR(mnt); 547 spin_lock(&pin_fs_lock); 548 if (!*mount) 549 *mount = mnt; 550 } 551 mntget(*mount); 552 ++*count; 553 spin_unlock(&pin_fs_lock); 554 mntput(mnt); 555 return 0; 556 } 557 558 void simple_release_fs(struct vfsmount **mount, int *count) 559 { 560 struct vfsmount *mnt; 561 spin_lock(&pin_fs_lock); 562 mnt = *mount; 563 if (!--*count) 564 *mount = NULL; 565 spin_unlock(&pin_fs_lock); 566 mntput(mnt); 567 } 568 569 /** 570 * simple_read_from_buffer - copy data from the buffer to user space 571 * @to: the user space buffer to read to 572 * @count: the maximum number of bytes to read 573 * @ppos: the current position in the buffer 574 * @from: the buffer to read from 575 * @available: the size of the buffer 576 * 577 * The simple_read_from_buffer() function reads up to @count bytes from the 578 * buffer @from at offset @ppos into the user space address starting at @to. 579 * 580 * On success, the number of bytes read is returned and the offset @ppos is 581 * advanced by this number, or negative value is returned on error. 582 **/ 583 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, 584 const void *from, size_t available) 585 { 586 loff_t pos = *ppos; 587 size_t ret; 588 589 if (pos < 0) 590 return -EINVAL; 591 if (pos >= available || !count) 592 return 0; 593 if (count > available - pos) 594 count = available - pos; 595 ret = copy_to_user(to, from + pos, count); 596 if (ret == count) 597 return -EFAULT; 598 count -= ret; 599 *ppos = pos + count; 600 return count; 601 } 602 603 /** 604 * simple_write_to_buffer - copy data from user space to the buffer 605 * @to: the buffer to write to 606 * @available: the size of the buffer 607 * @ppos: the current position in the buffer 608 * @from: the user space buffer to read from 609 * @count: the maximum number of bytes to read 610 * 611 * The simple_write_to_buffer() function reads up to @count bytes from the user 612 * space address starting at @from into the buffer @to at offset @ppos. 613 * 614 * On success, the number of bytes written is returned and the offset @ppos is 615 * advanced by this number, or negative value is returned on error. 616 **/ 617 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, 618 const void __user *from, size_t count) 619 { 620 loff_t pos = *ppos; 621 size_t res; 622 623 if (pos < 0) 624 return -EINVAL; 625 if (pos >= available || !count) 626 return 0; 627 if (count > available - pos) 628 count = available - pos; 629 res = copy_from_user(to + pos, from, count); 630 if (res == count) 631 return -EFAULT; 632 count -= res; 633 *ppos = pos + count; 634 return count; 635 } 636 637 /** 638 * memory_read_from_buffer - copy data from the buffer 639 * @to: the kernel space buffer to read to 640 * @count: the maximum number of bytes to read 641 * @ppos: the current position in the buffer 642 * @from: the buffer to read from 643 * @available: the size of the buffer 644 * 645 * The memory_read_from_buffer() function reads up to @count bytes from the 646 * buffer @from at offset @ppos into the kernel space address starting at @to. 647 * 648 * On success, the number of bytes read is returned and the offset @ppos is 649 * advanced by this number, or negative value is returned on error. 650 **/ 651 ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, 652 const void *from, size_t available) 653 { 654 loff_t pos = *ppos; 655 656 if (pos < 0) 657 return -EINVAL; 658 if (pos >= available) 659 return 0; 660 if (count > available - pos) 661 count = available - pos; 662 memcpy(to, from + pos, count); 663 *ppos = pos + count; 664 665 return count; 666 } 667 668 /* 669 * Transaction based IO. 670 * The file expects a single write which triggers the transaction, and then 671 * possibly a read which collects the result - which is stored in a 672 * file-local buffer. 673 */ 674 675 void simple_transaction_set(struct file *file, size_t n) 676 { 677 struct simple_transaction_argresp *ar = file->private_data; 678 679 BUG_ON(n > SIMPLE_TRANSACTION_LIMIT); 680 681 /* 682 * The barrier ensures that ar->size will really remain zero until 683 * ar->data is ready for reading. 684 */ 685 smp_mb(); 686 ar->size = n; 687 } 688 689 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size) 690 { 691 struct simple_transaction_argresp *ar; 692 static DEFINE_SPINLOCK(simple_transaction_lock); 693 694 if (size > SIMPLE_TRANSACTION_LIMIT - 1) 695 return ERR_PTR(-EFBIG); 696 697 ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL); 698 if (!ar) 699 return ERR_PTR(-ENOMEM); 700 701 spin_lock(&simple_transaction_lock); 702 703 /* only one write allowed per open */ 704 if (file->private_data) { 705 spin_unlock(&simple_transaction_lock); 706 free_page((unsigned long)ar); 707 return ERR_PTR(-EBUSY); 708 } 709 710 file->private_data = ar; 711 712 spin_unlock(&simple_transaction_lock); 713 714 if (copy_from_user(ar->data, buf, size)) 715 return ERR_PTR(-EFAULT); 716 717 return ar->data; 718 } 719 720 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 721 { 722 struct simple_transaction_argresp *ar = file->private_data; 723 724 if (!ar) 725 return 0; 726 return simple_read_from_buffer(buf, size, pos, ar->data, ar->size); 727 } 728 729 int simple_transaction_release(struct inode *inode, struct file *file) 730 { 731 free_page((unsigned long)file->private_data); 732 return 0; 733 } 734 735 /* Simple attribute files */ 736 737 struct simple_attr { 738 int (*get)(void *, u64 *); 739 int (*set)(void *, u64); 740 char get_buf[24]; /* enough to store a u64 and "\n\0" */ 741 char set_buf[24]; 742 void *data; 743 const char *fmt; /* format for read operation */ 744 struct mutex mutex; /* protects access to these buffers */ 745 }; 746 747 /* simple_attr_open is called by an actual attribute open file operation 748 * to set the attribute specific access operations. */ 749 int simple_attr_open(struct inode *inode, struct file *file, 750 int (*get)(void *, u64 *), int (*set)(void *, u64), 751 const char *fmt) 752 { 753 struct simple_attr *attr; 754 755 attr = kmalloc(sizeof(*attr), GFP_KERNEL); 756 if (!attr) 757 return -ENOMEM; 758 759 attr->get = get; 760 attr->set = set; 761 attr->data = inode->i_private; 762 attr->fmt = fmt; 763 mutex_init(&attr->mutex); 764 765 file->private_data = attr; 766 767 return nonseekable_open(inode, file); 768 } 769 770 int simple_attr_release(struct inode *inode, struct file *file) 771 { 772 kfree(file->private_data); 773 return 0; 774 } 775 776 /* read from the buffer that is filled with the get function */ 777 ssize_t simple_attr_read(struct file *file, char __user *buf, 778 size_t len, loff_t *ppos) 779 { 780 struct simple_attr *attr; 781 size_t size; 782 ssize_t ret; 783 784 attr = file->private_data; 785 786 if (!attr->get) 787 return -EACCES; 788 789 ret = mutex_lock_interruptible(&attr->mutex); 790 if (ret) 791 return ret; 792 793 if (*ppos) { /* continued read */ 794 size = strlen(attr->get_buf); 795 } else { /* first read */ 796 u64 val; 797 ret = attr->get(attr->data, &val); 798 if (ret) 799 goto out; 800 801 size = scnprintf(attr->get_buf, sizeof(attr->get_buf), 802 attr->fmt, (unsigned long long)val); 803 } 804 805 ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size); 806 out: 807 mutex_unlock(&attr->mutex); 808 return ret; 809 } 810 811 /* interpret the buffer as a number to call the set function with */ 812 ssize_t simple_attr_write(struct file *file, const char __user *buf, 813 size_t len, loff_t *ppos) 814 { 815 struct simple_attr *attr; 816 u64 val; 817 size_t size; 818 ssize_t ret; 819 820 attr = file->private_data; 821 if (!attr->set) 822 return -EACCES; 823 824 ret = mutex_lock_interruptible(&attr->mutex); 825 if (ret) 826 return ret; 827 828 ret = -EFAULT; 829 size = min(sizeof(attr->set_buf) - 1, len); 830 if (copy_from_user(attr->set_buf, buf, size)) 831 goto out; 832 833 attr->set_buf[size] = '\0'; 834 val = simple_strtoll(attr->set_buf, NULL, 0); 835 ret = attr->set(attr->data, val); 836 if (ret == 0) 837 ret = len; /* on success, claim we got the whole input */ 838 out: 839 mutex_unlock(&attr->mutex); 840 return ret; 841 } 842 843 /** 844 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation 845 * @sb: filesystem to do the file handle conversion on 846 * @fid: file handle to convert 847 * @fh_len: length of the file handle in bytes 848 * @fh_type: type of file handle 849 * @get_inode: filesystem callback to retrieve inode 850 * 851 * This function decodes @fid as long as it has one of the well-known 852 * Linux filehandle types and calls @get_inode on it to retrieve the 853 * inode for the object specified in the file handle. 854 */ 855 struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid, 856 int fh_len, int fh_type, struct inode *(*get_inode) 857 (struct super_block *sb, u64 ino, u32 gen)) 858 { 859 struct inode *inode = NULL; 860 861 if (fh_len < 2) 862 return NULL; 863 864 switch (fh_type) { 865 case FILEID_INO32_GEN: 866 case FILEID_INO32_GEN_PARENT: 867 inode = get_inode(sb, fid->i32.ino, fid->i32.gen); 868 break; 869 } 870 871 return d_obtain_alias(inode); 872 } 873 EXPORT_SYMBOL_GPL(generic_fh_to_dentry); 874 875 /** 876 * generic_fh_to_dentry - generic helper for the fh_to_parent export operation 877 * @sb: filesystem to do the file handle conversion on 878 * @fid: file handle to convert 879 * @fh_len: length of the file handle in bytes 880 * @fh_type: type of file handle 881 * @get_inode: filesystem callback to retrieve inode 882 * 883 * This function decodes @fid as long as it has one of the well-known 884 * Linux filehandle types and calls @get_inode on it to retrieve the 885 * inode for the _parent_ object specified in the file handle if it 886 * is specified in the file handle, or NULL otherwise. 887 */ 888 struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid, 889 int fh_len, int fh_type, struct inode *(*get_inode) 890 (struct super_block *sb, u64 ino, u32 gen)) 891 { 892 struct inode *inode = NULL; 893 894 if (fh_len <= 2) 895 return NULL; 896 897 switch (fh_type) { 898 case FILEID_INO32_GEN_PARENT: 899 inode = get_inode(sb, fid->i32.parent_ino, 900 (fh_len > 3 ? fid->i32.parent_gen : 0)); 901 break; 902 } 903 904 return d_obtain_alias(inode); 905 } 906 EXPORT_SYMBOL_GPL(generic_fh_to_parent); 907 908 /** 909 * generic_file_fsync - generic fsync implementation for simple filesystems 910 * @file: file to synchronize 911 * @datasync: only synchronize essential metadata if true 912 * 913 * This is a generic implementation of the fsync method for simple 914 * filesystems which track all non-inode metadata in the buffers list 915 * hanging off the address_space structure. 916 */ 917 int generic_file_fsync(struct file *file, loff_t start, loff_t end, 918 int datasync) 919 { 920 struct inode *inode = file->f_mapping->host; 921 int err; 922 int ret; 923 924 err = filemap_write_and_wait_range(inode->i_mapping, start, end); 925 if (err) 926 return err; 927 928 mutex_lock(&inode->i_mutex); 929 ret = sync_mapping_buffers(inode->i_mapping); 930 if (!(inode->i_state & I_DIRTY)) 931 goto out; 932 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) 933 goto out; 934 935 err = sync_inode_metadata(inode, 1); 936 if (ret == 0) 937 ret = err; 938 out: 939 mutex_unlock(&inode->i_mutex); 940 return ret; 941 } 942 EXPORT_SYMBOL(generic_file_fsync); 943 944 /** 945 * generic_check_addressable - Check addressability of file system 946 * @blocksize_bits: log of file system block size 947 * @num_blocks: number of blocks in file system 948 * 949 * Determine whether a file system with @num_blocks blocks (and a 950 * block size of 2**@blocksize_bits) is addressable by the sector_t 951 * and page cache of the system. Return 0 if so and -EFBIG otherwise. 952 */ 953 int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks) 954 { 955 u64 last_fs_block = num_blocks - 1; 956 u64 last_fs_page = 957 last_fs_block >> (PAGE_CACHE_SHIFT - blocksize_bits); 958 959 if (unlikely(num_blocks == 0)) 960 return 0; 961 962 if ((blocksize_bits < 9) || (blocksize_bits > PAGE_CACHE_SHIFT)) 963 return -EINVAL; 964 965 if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) || 966 (last_fs_page > (pgoff_t)(~0ULL))) { 967 return -EFBIG; 968 } 969 return 0; 970 } 971 EXPORT_SYMBOL(generic_check_addressable); 972 973 /* 974 * No-op implementation of ->fsync for in-memory filesystems. 975 */ 976 int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync) 977 { 978 return 0; 979 } 980 981 EXPORT_SYMBOL(dcache_dir_close); 982 EXPORT_SYMBOL(dcache_dir_lseek); 983 EXPORT_SYMBOL(dcache_dir_open); 984 EXPORT_SYMBOL(dcache_readdir); 985 EXPORT_SYMBOL(generic_read_dir); 986 EXPORT_SYMBOL(mount_pseudo); 987 EXPORT_SYMBOL(simple_write_begin); 988 EXPORT_SYMBOL(simple_write_end); 989 EXPORT_SYMBOL(simple_dir_inode_operations); 990 EXPORT_SYMBOL(simple_dir_operations); 991 EXPORT_SYMBOL(simple_empty); 992 EXPORT_SYMBOL(simple_fill_super); 993 EXPORT_SYMBOL(simple_getattr); 994 EXPORT_SYMBOL(simple_open); 995 EXPORT_SYMBOL(simple_link); 996 EXPORT_SYMBOL(simple_lookup); 997 EXPORT_SYMBOL(simple_pin_fs); 998 EXPORT_SYMBOL(simple_readpage); 999 EXPORT_SYMBOL(simple_release_fs); 1000 EXPORT_SYMBOL(simple_rename); 1001 EXPORT_SYMBOL(simple_rmdir); 1002 EXPORT_SYMBOL(simple_statfs); 1003 EXPORT_SYMBOL(noop_fsync); 1004 EXPORT_SYMBOL(simple_unlink); 1005 EXPORT_SYMBOL(simple_read_from_buffer); 1006 EXPORT_SYMBOL(simple_write_to_buffer); 1007 EXPORT_SYMBOL(memory_read_from_buffer); 1008 EXPORT_SYMBOL(simple_transaction_set); 1009 EXPORT_SYMBOL(simple_transaction_get); 1010 EXPORT_SYMBOL(simple_transaction_read); 1011 EXPORT_SYMBOL(simple_transaction_release); 1012 EXPORT_SYMBOL_GPL(simple_attr_open); 1013 EXPORT_SYMBOL_GPL(simple_attr_release); 1014 EXPORT_SYMBOL_GPL(simple_attr_read); 1015 EXPORT_SYMBOL_GPL(simple_attr_write); 1016