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