1 /* 2 * fs/libfs.c 3 * Library for filesystems writers. 4 */ 5 6 #include <linux/module.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> 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_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 268 { 269 struct inode *inode = old_dentry->d_inode; 270 271 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 272 inc_nlink(inode); 273 ihold(inode); 274 dget(dentry); 275 d_instantiate(dentry, inode); 276 return 0; 277 } 278 279 int simple_empty(struct dentry *dentry) 280 { 281 struct dentry *child; 282 int ret = 0; 283 284 spin_lock(&dentry->d_lock); 285 list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) { 286 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED); 287 if (simple_positive(child)) { 288 spin_unlock(&child->d_lock); 289 goto out; 290 } 291 spin_unlock(&child->d_lock); 292 } 293 ret = 1; 294 out: 295 spin_unlock(&dentry->d_lock); 296 return ret; 297 } 298 299 int simple_unlink(struct inode *dir, struct dentry *dentry) 300 { 301 struct inode *inode = dentry->d_inode; 302 303 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 304 drop_nlink(inode); 305 dput(dentry); 306 return 0; 307 } 308 309 int simple_rmdir(struct inode *dir, struct dentry *dentry) 310 { 311 if (!simple_empty(dentry)) 312 return -ENOTEMPTY; 313 314 drop_nlink(dentry->d_inode); 315 simple_unlink(dir, dentry); 316 drop_nlink(dir); 317 return 0; 318 } 319 320 int simple_rename(struct inode *old_dir, struct dentry *old_dentry, 321 struct inode *new_dir, struct dentry *new_dentry) 322 { 323 struct inode *inode = old_dentry->d_inode; 324 int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode); 325 326 if (!simple_empty(new_dentry)) 327 return -ENOTEMPTY; 328 329 if (new_dentry->d_inode) { 330 simple_unlink(new_dir, new_dentry); 331 if (they_are_dirs) { 332 drop_nlink(new_dentry->d_inode); 333 drop_nlink(old_dir); 334 } 335 } else if (they_are_dirs) { 336 drop_nlink(old_dir); 337 inc_nlink(new_dir); 338 } 339 340 old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime = 341 new_dir->i_mtime = inode->i_ctime = CURRENT_TIME; 342 343 return 0; 344 } 345 346 /** 347 * simple_setattr - setattr for simple filesystem 348 * @dentry: dentry 349 * @iattr: iattr structure 350 * 351 * Returns 0 on success, -error on failure. 352 * 353 * simple_setattr is a simple ->setattr implementation without a proper 354 * implementation of size changes. 355 * 356 * It can either be used for in-memory filesystems or special files 357 * on simple regular filesystems. Anything that needs to change on-disk 358 * or wire state on size changes needs its own setattr method. 359 */ 360 int simple_setattr(struct dentry *dentry, struct iattr *iattr) 361 { 362 struct inode *inode = dentry->d_inode; 363 int error; 364 365 WARN_ON_ONCE(inode->i_op->truncate); 366 367 error = inode_change_ok(inode, iattr); 368 if (error) 369 return error; 370 371 if (iattr->ia_valid & ATTR_SIZE) 372 truncate_setsize(inode, iattr->ia_size); 373 setattr_copy(inode, iattr); 374 mark_inode_dirty(inode); 375 return 0; 376 } 377 EXPORT_SYMBOL(simple_setattr); 378 379 int simple_readpage(struct file *file, struct page *page) 380 { 381 clear_highpage(page); 382 flush_dcache_page(page); 383 SetPageUptodate(page); 384 unlock_page(page); 385 return 0; 386 } 387 388 int simple_write_begin(struct file *file, struct address_space *mapping, 389 loff_t pos, unsigned len, unsigned flags, 390 struct page **pagep, void **fsdata) 391 { 392 struct page *page; 393 pgoff_t index; 394 395 index = pos >> PAGE_CACHE_SHIFT; 396 397 page = grab_cache_page_write_begin(mapping, index, flags); 398 if (!page) 399 return -ENOMEM; 400 401 *pagep = page; 402 403 if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) { 404 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 405 406 zero_user_segments(page, 0, from, from + len, PAGE_CACHE_SIZE); 407 } 408 return 0; 409 } 410 411 /** 412 * simple_write_end - .write_end helper for non-block-device FSes 413 * @available: See .write_end of address_space_operations 414 * @file: " 415 * @mapping: " 416 * @pos: " 417 * @len: " 418 * @copied: " 419 * @page: " 420 * @fsdata: " 421 * 422 * simple_write_end does the minimum needed for updating a page after writing is 423 * done. It has the same API signature as the .write_end of 424 * address_space_operations vector. So it can just be set onto .write_end for 425 * FSes that don't need any other processing. i_mutex is assumed to be held. 426 * Block based filesystems should use generic_write_end(). 427 * NOTE: Even though i_size might get updated by this function, mark_inode_dirty 428 * is not called, so a filesystem that actually does store data in .write_inode 429 * should extend on what's done here with a call to mark_inode_dirty() in the 430 * case that i_size has changed. 431 */ 432 int simple_write_end(struct file *file, struct address_space *mapping, 433 loff_t pos, unsigned len, unsigned copied, 434 struct page *page, void *fsdata) 435 { 436 struct inode *inode = page->mapping->host; 437 loff_t last_pos = pos + copied; 438 439 /* zero the stale part of the page if we did a short copy */ 440 if (copied < len) { 441 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 442 443 zero_user(page, from + copied, len - copied); 444 } 445 446 if (!PageUptodate(page)) 447 SetPageUptodate(page); 448 /* 449 * No need to use i_size_read() here, the i_size 450 * cannot change under us because we hold the i_mutex. 451 */ 452 if (last_pos > inode->i_size) 453 i_size_write(inode, last_pos); 454 455 set_page_dirty(page); 456 unlock_page(page); 457 page_cache_release(page); 458 459 return copied; 460 } 461 462 /* 463 * the inodes created here are not hashed. If you use iunique to generate 464 * unique inode values later for this filesystem, then you must take care 465 * to pass it an appropriate max_reserved value to avoid collisions. 466 */ 467 int simple_fill_super(struct super_block *s, unsigned long magic, 468 struct tree_descr *files) 469 { 470 struct inode *inode; 471 struct dentry *root; 472 struct dentry *dentry; 473 int i; 474 475 s->s_blocksize = PAGE_CACHE_SIZE; 476 s->s_blocksize_bits = PAGE_CACHE_SHIFT; 477 s->s_magic = magic; 478 s->s_op = &simple_super_operations; 479 s->s_time_gran = 1; 480 481 inode = new_inode(s); 482 if (!inode) 483 return -ENOMEM; 484 /* 485 * because the root inode is 1, the files array must not contain an 486 * entry at index 1 487 */ 488 inode->i_ino = 1; 489 inode->i_mode = S_IFDIR | 0755; 490 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 491 inode->i_op = &simple_dir_inode_operations; 492 inode->i_fop = &simple_dir_operations; 493 inode->i_nlink = 2; 494 root = d_alloc_root(inode); 495 if (!root) { 496 iput(inode); 497 return -ENOMEM; 498 } 499 for (i = 0; !files->name || files->name[0]; i++, files++) { 500 if (!files->name) 501 continue; 502 503 /* warn if it tries to conflict with the root inode */ 504 if (unlikely(i == 1)) 505 printk(KERN_WARNING "%s: %s passed in a files array" 506 "with an index of 1!\n", __func__, 507 s->s_type->name); 508 509 dentry = d_alloc_name(root, files->name); 510 if (!dentry) 511 goto out; 512 inode = new_inode(s); 513 if (!inode) 514 goto out; 515 inode->i_mode = S_IFREG | files->mode; 516 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 517 inode->i_fop = files->ops; 518 inode->i_ino = i; 519 d_add(dentry, inode); 520 } 521 s->s_root = root; 522 return 0; 523 out: 524 d_genocide(root); 525 dput(root); 526 return -ENOMEM; 527 } 528 529 static DEFINE_SPINLOCK(pin_fs_lock); 530 531 int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count) 532 { 533 struct vfsmount *mnt = NULL; 534 spin_lock(&pin_fs_lock); 535 if (unlikely(!*mount)) { 536 spin_unlock(&pin_fs_lock); 537 mnt = vfs_kern_mount(type, 0, type->name, NULL); 538 if (IS_ERR(mnt)) 539 return PTR_ERR(mnt); 540 spin_lock(&pin_fs_lock); 541 if (!*mount) 542 *mount = mnt; 543 } 544 mntget(*mount); 545 ++*count; 546 spin_unlock(&pin_fs_lock); 547 mntput(mnt); 548 return 0; 549 } 550 551 void simple_release_fs(struct vfsmount **mount, int *count) 552 { 553 struct vfsmount *mnt; 554 spin_lock(&pin_fs_lock); 555 mnt = *mount; 556 if (!--*count) 557 *mount = NULL; 558 spin_unlock(&pin_fs_lock); 559 mntput(mnt); 560 } 561 562 /** 563 * simple_read_from_buffer - copy data from the buffer to user space 564 * @to: the user space buffer to read to 565 * @count: the maximum number of bytes to read 566 * @ppos: the current position in the buffer 567 * @from: the buffer to read from 568 * @available: the size of the buffer 569 * 570 * The simple_read_from_buffer() function reads up to @count bytes from the 571 * buffer @from at offset @ppos into the user space address starting at @to. 572 * 573 * On success, the number of bytes read is returned and the offset @ppos is 574 * advanced by this number, or negative value is returned on error. 575 **/ 576 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, 577 const void *from, size_t available) 578 { 579 loff_t pos = *ppos; 580 size_t ret; 581 582 if (pos < 0) 583 return -EINVAL; 584 if (pos >= available || !count) 585 return 0; 586 if (count > available - pos) 587 count = available - pos; 588 ret = copy_to_user(to, from + pos, count); 589 if (ret == count) 590 return -EFAULT; 591 count -= ret; 592 *ppos = pos + count; 593 return count; 594 } 595 596 /** 597 * simple_write_to_buffer - copy data from user space to the buffer 598 * @to: the buffer to write to 599 * @available: the size of the buffer 600 * @ppos: the current position in the buffer 601 * @from: the user space buffer to read from 602 * @count: the maximum number of bytes to read 603 * 604 * The simple_write_to_buffer() function reads up to @count bytes from the user 605 * space address starting at @from into the buffer @to at offset @ppos. 606 * 607 * On success, the number of bytes written is returned and the offset @ppos is 608 * advanced by this number, or negative value is returned on error. 609 **/ 610 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, 611 const void __user *from, size_t count) 612 { 613 loff_t pos = *ppos; 614 size_t res; 615 616 if (pos < 0) 617 return -EINVAL; 618 if (pos >= available || !count) 619 return 0; 620 if (count > available - pos) 621 count = available - pos; 622 res = copy_from_user(to + pos, from, count); 623 if (res == count) 624 return -EFAULT; 625 count -= res; 626 *ppos = pos + count; 627 return count; 628 } 629 630 /** 631 * memory_read_from_buffer - copy data from the buffer 632 * @to: the kernel space buffer to read to 633 * @count: the maximum number of bytes to read 634 * @ppos: the current position in the buffer 635 * @from: the buffer to read from 636 * @available: the size of the buffer 637 * 638 * The memory_read_from_buffer() function reads up to @count bytes from the 639 * buffer @from at offset @ppos into the kernel space address starting at @to. 640 * 641 * On success, the number of bytes read is returned and the offset @ppos is 642 * advanced by this number, or negative value is returned on error. 643 **/ 644 ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, 645 const void *from, size_t available) 646 { 647 loff_t pos = *ppos; 648 649 if (pos < 0) 650 return -EINVAL; 651 if (pos >= available) 652 return 0; 653 if (count > available - pos) 654 count = available - pos; 655 memcpy(to, from + pos, count); 656 *ppos = pos + count; 657 658 return count; 659 } 660 661 /* 662 * Transaction based IO. 663 * The file expects a single write which triggers the transaction, and then 664 * possibly a read which collects the result - which is stored in a 665 * file-local buffer. 666 */ 667 668 void simple_transaction_set(struct file *file, size_t n) 669 { 670 struct simple_transaction_argresp *ar = file->private_data; 671 672 BUG_ON(n > SIMPLE_TRANSACTION_LIMIT); 673 674 /* 675 * The barrier ensures that ar->size will really remain zero until 676 * ar->data is ready for reading. 677 */ 678 smp_mb(); 679 ar->size = n; 680 } 681 682 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size) 683 { 684 struct simple_transaction_argresp *ar; 685 static DEFINE_SPINLOCK(simple_transaction_lock); 686 687 if (size > SIMPLE_TRANSACTION_LIMIT - 1) 688 return ERR_PTR(-EFBIG); 689 690 ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL); 691 if (!ar) 692 return ERR_PTR(-ENOMEM); 693 694 spin_lock(&simple_transaction_lock); 695 696 /* only one write allowed per open */ 697 if (file->private_data) { 698 spin_unlock(&simple_transaction_lock); 699 free_page((unsigned long)ar); 700 return ERR_PTR(-EBUSY); 701 } 702 703 file->private_data = ar; 704 705 spin_unlock(&simple_transaction_lock); 706 707 if (copy_from_user(ar->data, buf, size)) 708 return ERR_PTR(-EFAULT); 709 710 return ar->data; 711 } 712 713 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 714 { 715 struct simple_transaction_argresp *ar = file->private_data; 716 717 if (!ar) 718 return 0; 719 return simple_read_from_buffer(buf, size, pos, ar->data, ar->size); 720 } 721 722 int simple_transaction_release(struct inode *inode, struct file *file) 723 { 724 free_page((unsigned long)file->private_data); 725 return 0; 726 } 727 728 /* Simple attribute files */ 729 730 struct simple_attr { 731 int (*get)(void *, u64 *); 732 int (*set)(void *, u64); 733 char get_buf[24]; /* enough to store a u64 and "\n\0" */ 734 char set_buf[24]; 735 void *data; 736 const char *fmt; /* format for read operation */ 737 struct mutex mutex; /* protects access to these buffers */ 738 }; 739 740 /* simple_attr_open is called by an actual attribute open file operation 741 * to set the attribute specific access operations. */ 742 int simple_attr_open(struct inode *inode, struct file *file, 743 int (*get)(void *, u64 *), int (*set)(void *, u64), 744 const char *fmt) 745 { 746 struct simple_attr *attr; 747 748 attr = kmalloc(sizeof(*attr), GFP_KERNEL); 749 if (!attr) 750 return -ENOMEM; 751 752 attr->get = get; 753 attr->set = set; 754 attr->data = inode->i_private; 755 attr->fmt = fmt; 756 mutex_init(&attr->mutex); 757 758 file->private_data = attr; 759 760 return nonseekable_open(inode, file); 761 } 762 763 int simple_attr_release(struct inode *inode, struct file *file) 764 { 765 kfree(file->private_data); 766 return 0; 767 } 768 769 /* read from the buffer that is filled with the get function */ 770 ssize_t simple_attr_read(struct file *file, char __user *buf, 771 size_t len, loff_t *ppos) 772 { 773 struct simple_attr *attr; 774 size_t size; 775 ssize_t ret; 776 777 attr = file->private_data; 778 779 if (!attr->get) 780 return -EACCES; 781 782 ret = mutex_lock_interruptible(&attr->mutex); 783 if (ret) 784 return ret; 785 786 if (*ppos) { /* continued read */ 787 size = strlen(attr->get_buf); 788 } else { /* first read */ 789 u64 val; 790 ret = attr->get(attr->data, &val); 791 if (ret) 792 goto out; 793 794 size = scnprintf(attr->get_buf, sizeof(attr->get_buf), 795 attr->fmt, (unsigned long long)val); 796 } 797 798 ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size); 799 out: 800 mutex_unlock(&attr->mutex); 801 return ret; 802 } 803 804 /* interpret the buffer as a number to call the set function with */ 805 ssize_t simple_attr_write(struct file *file, const char __user *buf, 806 size_t len, loff_t *ppos) 807 { 808 struct simple_attr *attr; 809 u64 val; 810 size_t size; 811 ssize_t ret; 812 813 attr = file->private_data; 814 if (!attr->set) 815 return -EACCES; 816 817 ret = mutex_lock_interruptible(&attr->mutex); 818 if (ret) 819 return ret; 820 821 ret = -EFAULT; 822 size = min(sizeof(attr->set_buf) - 1, len); 823 if (copy_from_user(attr->set_buf, buf, size)) 824 goto out; 825 826 attr->set_buf[size] = '\0'; 827 val = simple_strtoll(attr->set_buf, NULL, 0); 828 ret = attr->set(attr->data, val); 829 if (ret == 0) 830 ret = len; /* on success, claim we got the whole input */ 831 out: 832 mutex_unlock(&attr->mutex); 833 return ret; 834 } 835 836 /** 837 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation 838 * @sb: filesystem to do the file handle conversion on 839 * @fid: file handle to convert 840 * @fh_len: length of the file handle in bytes 841 * @fh_type: type of file handle 842 * @get_inode: filesystem callback to retrieve inode 843 * 844 * This function decodes @fid as long as it has one of the well-known 845 * Linux filehandle types and calls @get_inode on it to retrieve the 846 * inode for the object specified in the file handle. 847 */ 848 struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid, 849 int fh_len, int fh_type, struct inode *(*get_inode) 850 (struct super_block *sb, u64 ino, u32 gen)) 851 { 852 struct inode *inode = NULL; 853 854 if (fh_len < 2) 855 return NULL; 856 857 switch (fh_type) { 858 case FILEID_INO32_GEN: 859 case FILEID_INO32_GEN_PARENT: 860 inode = get_inode(sb, fid->i32.ino, fid->i32.gen); 861 break; 862 } 863 864 return d_obtain_alias(inode); 865 } 866 EXPORT_SYMBOL_GPL(generic_fh_to_dentry); 867 868 /** 869 * generic_fh_to_dentry - generic helper for the fh_to_parent export operation 870 * @sb: filesystem to do the file handle conversion on 871 * @fid: file handle to convert 872 * @fh_len: length of the file handle in bytes 873 * @fh_type: type of file handle 874 * @get_inode: filesystem callback to retrieve inode 875 * 876 * This function decodes @fid as long as it has one of the well-known 877 * Linux filehandle types and calls @get_inode on it to retrieve the 878 * inode for the _parent_ object specified in the file handle if it 879 * is specified in the file handle, or NULL otherwise. 880 */ 881 struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid, 882 int fh_len, int fh_type, struct inode *(*get_inode) 883 (struct super_block *sb, u64 ino, u32 gen)) 884 { 885 struct inode *inode = NULL; 886 887 if (fh_len <= 2) 888 return NULL; 889 890 switch (fh_type) { 891 case FILEID_INO32_GEN_PARENT: 892 inode = get_inode(sb, fid->i32.parent_ino, 893 (fh_len > 3 ? fid->i32.parent_gen : 0)); 894 break; 895 } 896 897 return d_obtain_alias(inode); 898 } 899 EXPORT_SYMBOL_GPL(generic_fh_to_parent); 900 901 /** 902 * generic_file_fsync - generic fsync implementation for simple filesystems 903 * @file: file to synchronize 904 * @datasync: only synchronize essential metadata if true 905 * 906 * This is a generic implementation of the fsync method for simple 907 * filesystems which track all non-inode metadata in the buffers list 908 * hanging off the address_space structure. 909 */ 910 int generic_file_fsync(struct file *file, loff_t start, loff_t end, 911 int datasync) 912 { 913 struct inode *inode = file->f_mapping->host; 914 int err; 915 int ret; 916 917 err = filemap_write_and_wait_range(inode->i_mapping, start, end); 918 if (err) 919 return err; 920 921 mutex_lock(&inode->i_mutex); 922 ret = sync_mapping_buffers(inode->i_mapping); 923 if (!(inode->i_state & I_DIRTY)) 924 goto out; 925 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) 926 goto out; 927 928 err = sync_inode_metadata(inode, 1); 929 if (ret == 0) 930 ret = err; 931 out: 932 mutex_unlock(&inode->i_mutex); 933 return ret; 934 } 935 EXPORT_SYMBOL(generic_file_fsync); 936 937 /** 938 * generic_check_addressable - Check addressability of file system 939 * @blocksize_bits: log of file system block size 940 * @num_blocks: number of blocks in file system 941 * 942 * Determine whether a file system with @num_blocks blocks (and a 943 * block size of 2**@blocksize_bits) is addressable by the sector_t 944 * and page cache of the system. Return 0 if so and -EFBIG otherwise. 945 */ 946 int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks) 947 { 948 u64 last_fs_block = num_blocks - 1; 949 u64 last_fs_page = 950 last_fs_block >> (PAGE_CACHE_SHIFT - blocksize_bits); 951 952 if (unlikely(num_blocks == 0)) 953 return 0; 954 955 if ((blocksize_bits < 9) || (blocksize_bits > PAGE_CACHE_SHIFT)) 956 return -EINVAL; 957 958 if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) || 959 (last_fs_page > (pgoff_t)(~0ULL))) { 960 return -EFBIG; 961 } 962 return 0; 963 } 964 EXPORT_SYMBOL(generic_check_addressable); 965 966 /* 967 * No-op implementation of ->fsync for in-memory filesystems. 968 */ 969 int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync) 970 { 971 return 0; 972 } 973 974 EXPORT_SYMBOL(dcache_dir_close); 975 EXPORT_SYMBOL(dcache_dir_lseek); 976 EXPORT_SYMBOL(dcache_dir_open); 977 EXPORT_SYMBOL(dcache_readdir); 978 EXPORT_SYMBOL(generic_read_dir); 979 EXPORT_SYMBOL(mount_pseudo); 980 EXPORT_SYMBOL(simple_write_begin); 981 EXPORT_SYMBOL(simple_write_end); 982 EXPORT_SYMBOL(simple_dir_inode_operations); 983 EXPORT_SYMBOL(simple_dir_operations); 984 EXPORT_SYMBOL(simple_empty); 985 EXPORT_SYMBOL(simple_fill_super); 986 EXPORT_SYMBOL(simple_getattr); 987 EXPORT_SYMBOL(simple_link); 988 EXPORT_SYMBOL(simple_lookup); 989 EXPORT_SYMBOL(simple_pin_fs); 990 EXPORT_SYMBOL(simple_readpage); 991 EXPORT_SYMBOL(simple_release_fs); 992 EXPORT_SYMBOL(simple_rename); 993 EXPORT_SYMBOL(simple_rmdir); 994 EXPORT_SYMBOL(simple_statfs); 995 EXPORT_SYMBOL(noop_fsync); 996 EXPORT_SYMBOL(simple_unlink); 997 EXPORT_SYMBOL(simple_read_from_buffer); 998 EXPORT_SYMBOL(simple_write_to_buffer); 999 EXPORT_SYMBOL(memory_read_from_buffer); 1000 EXPORT_SYMBOL(simple_transaction_set); 1001 EXPORT_SYMBOL(simple_transaction_get); 1002 EXPORT_SYMBOL(simple_transaction_read); 1003 EXPORT_SYMBOL(simple_transaction_release); 1004 EXPORT_SYMBOL_GPL(simple_attr_open); 1005 EXPORT_SYMBOL_GPL(simple_attr_release); 1006 EXPORT_SYMBOL_GPL(simple_attr_read); 1007 EXPORT_SYMBOL_GPL(simple_attr_write); 1008