file.c 3.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * file.c - NILFS regular file handling primitives including fsync().
  4. *
  5. * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
  6. *
  7. * Written by Amagai Yoshiji and Ryusuke Konishi.
  8. */
  9. #include <linux/fs.h>
  10. #include <linux/mm.h>
  11. #include <linux/writeback.h>
  12. #include "nilfs.h"
  13. #include "segment.h"
  14. int nilfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
  15. {
  16. /*
  17. * Called from fsync() system call
  18. * This is the only entry point that can catch write and synch
  19. * timing for both data blocks and intermediate blocks.
  20. *
  21. * This function should be implemented when the writeback function
  22. * will be implemented.
  23. */
  24. struct the_nilfs *nilfs;
  25. struct inode *inode = file->f_mapping->host;
  26. int err = 0;
  27. if (nilfs_inode_dirty(inode)) {
  28. if (datasync)
  29. err = nilfs_construct_dsync_segment(inode->i_sb, inode,
  30. start, end);
  31. else
  32. err = nilfs_construct_segment(inode->i_sb);
  33. }
  34. nilfs = inode->i_sb->s_fs_info;
  35. if (!err)
  36. err = nilfs_flush_device(nilfs);
  37. return err;
  38. }
  39. static vm_fault_t nilfs_page_mkwrite(struct vm_fault *vmf)
  40. {
  41. struct vm_area_struct *vma = vmf->vma;
  42. struct page *page = vmf->page;
  43. struct inode *inode = file_inode(vma->vm_file);
  44. struct nilfs_transaction_info ti;
  45. int ret = 0;
  46. if (unlikely(nilfs_near_disk_full(inode->i_sb->s_fs_info)))
  47. return VM_FAULT_SIGBUS; /* -ENOSPC */
  48. sb_start_pagefault(inode->i_sb);
  49. lock_page(page);
  50. if (page->mapping != inode->i_mapping ||
  51. page_offset(page) >= i_size_read(inode) || !PageUptodate(page)) {
  52. unlock_page(page);
  53. ret = -EFAULT; /* make the VM retry the fault */
  54. goto out;
  55. }
  56. /*
  57. * check to see if the page is mapped already (no holes)
  58. */
  59. if (PageMappedToDisk(page))
  60. goto mapped;
  61. if (page_has_buffers(page)) {
  62. struct buffer_head *bh, *head;
  63. int fully_mapped = 1;
  64. bh = head = page_buffers(page);
  65. do {
  66. if (!buffer_mapped(bh)) {
  67. fully_mapped = 0;
  68. break;
  69. }
  70. } while (bh = bh->b_this_page, bh != head);
  71. if (fully_mapped) {
  72. SetPageMappedToDisk(page);
  73. goto mapped;
  74. }
  75. }
  76. unlock_page(page);
  77. /*
  78. * fill hole blocks
  79. */
  80. ret = nilfs_transaction_begin(inode->i_sb, &ti, 1);
  81. /* never returns -ENOMEM, but may return -ENOSPC */
  82. if (unlikely(ret))
  83. goto out;
  84. file_update_time(vma->vm_file);
  85. ret = block_page_mkwrite(vma, vmf, nilfs_get_block);
  86. if (ret) {
  87. nilfs_transaction_abort(inode->i_sb);
  88. goto out;
  89. }
  90. nilfs_set_file_dirty(inode, 1 << (PAGE_SHIFT - inode->i_blkbits));
  91. nilfs_transaction_commit(inode->i_sb);
  92. mapped:
  93. wait_for_stable_page(page);
  94. out:
  95. sb_end_pagefault(inode->i_sb);
  96. return block_page_mkwrite_return(ret);
  97. }
  98. static const struct vm_operations_struct nilfs_file_vm_ops = {
  99. .fault = filemap_fault,
  100. .map_pages = filemap_map_pages,
  101. .page_mkwrite = nilfs_page_mkwrite,
  102. };
  103. static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma)
  104. {
  105. file_accessed(file);
  106. vma->vm_ops = &nilfs_file_vm_ops;
  107. return 0;
  108. }
  109. /*
  110. * We have mostly NULL's here: the current defaults are ok for
  111. * the nilfs filesystem.
  112. */
  113. const struct file_operations nilfs_file_operations = {
  114. .llseek = generic_file_llseek,
  115. .read_iter = generic_file_read_iter,
  116. .write_iter = generic_file_write_iter,
  117. .unlocked_ioctl = nilfs_ioctl,
  118. #ifdef CONFIG_COMPAT
  119. .compat_ioctl = nilfs_compat_ioctl,
  120. #endif /* CONFIG_COMPAT */
  121. .mmap = nilfs_file_mmap,
  122. .open = generic_file_open,
  123. /* .release = nilfs_release_file, */
  124. .fsync = nilfs_sync_file,
  125. .splice_read = generic_file_splice_read,
  126. .splice_write = iter_file_splice_write,
  127. };
  128. const struct inode_operations nilfs_file_inode_operations = {
  129. .setattr = nilfs_setattr,
  130. .permission = nilfs_permission,
  131. .fiemap = nilfs_fiemap,
  132. };
  133. /* end of file */