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