file.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/hpfs/file.c
  4. *
  5. * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
  6. *
  7. * file VFS functions
  8. */
  9. #include "hpfs_fn.h"
  10. #include <linux/mpage.h>
  11. #include <linux/fiemap.h>
  12. #define BLOCKS(size) (((size) + 511) >> 9)
  13. static int hpfs_file_release(struct inode *inode, struct file *file)
  14. {
  15. hpfs_lock(inode->i_sb);
  16. hpfs_write_if_changed(inode);
  17. hpfs_unlock(inode->i_sb);
  18. return 0;
  19. }
  20. int hpfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
  21. {
  22. struct inode *inode = file->f_mapping->host;
  23. int ret;
  24. ret = file_write_and_wait_range(file, start, end);
  25. if (ret)
  26. return ret;
  27. return sync_blockdev(inode->i_sb->s_bdev);
  28. }
  29. /*
  30. * generic_file_read often calls bmap with non-existing sector,
  31. * so we must ignore such errors.
  32. */
  33. static secno hpfs_bmap(struct inode *inode, unsigned file_secno, unsigned *n_secs)
  34. {
  35. struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
  36. unsigned n, disk_secno;
  37. struct fnode *fnode;
  38. struct buffer_head *bh;
  39. if (BLOCKS(hpfs_i(inode)->mmu_private) <= file_secno) return 0;
  40. n = file_secno - hpfs_inode->i_file_sec;
  41. if (n < hpfs_inode->i_n_secs) {
  42. *n_secs = hpfs_inode->i_n_secs - n;
  43. return hpfs_inode->i_disk_sec + n;
  44. }
  45. if (!(fnode = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) return 0;
  46. disk_secno = hpfs_bplus_lookup(inode->i_sb, inode, &fnode->btree, file_secno, bh);
  47. if (disk_secno == -1) return 0;
  48. if (hpfs_chk_sectors(inode->i_sb, disk_secno, 1, "bmap")) return 0;
  49. n = file_secno - hpfs_inode->i_file_sec;
  50. if (n < hpfs_inode->i_n_secs) {
  51. *n_secs = hpfs_inode->i_n_secs - n;
  52. return hpfs_inode->i_disk_sec + n;
  53. }
  54. *n_secs = 1;
  55. return disk_secno;
  56. }
  57. void hpfs_truncate(struct inode *i)
  58. {
  59. if (IS_IMMUTABLE(i)) return /*-EPERM*/;
  60. hpfs_lock_assert(i->i_sb);
  61. hpfs_i(i)->i_n_secs = 0;
  62. i->i_blocks = 1 + ((i->i_size + 511) >> 9);
  63. hpfs_i(i)->mmu_private = i->i_size;
  64. hpfs_truncate_btree(i->i_sb, i->i_ino, 1, ((i->i_size + 511) >> 9));
  65. hpfs_write_inode(i);
  66. hpfs_i(i)->i_n_secs = 0;
  67. }
  68. static int hpfs_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
  69. {
  70. int r;
  71. secno s;
  72. unsigned n_secs;
  73. hpfs_lock(inode->i_sb);
  74. s = hpfs_bmap(inode, iblock, &n_secs);
  75. if (s) {
  76. if (bh_result->b_size >> 9 < n_secs)
  77. n_secs = bh_result->b_size >> 9;
  78. n_secs = hpfs_search_hotfix_map_for_range(inode->i_sb, s, n_secs);
  79. if (unlikely(!n_secs)) {
  80. s = hpfs_search_hotfix_map(inode->i_sb, s);
  81. n_secs = 1;
  82. }
  83. map_bh(bh_result, inode->i_sb, s);
  84. bh_result->b_size = n_secs << 9;
  85. goto ret_0;
  86. }
  87. if (!create) goto ret_0;
  88. if (iblock<<9 != hpfs_i(inode)->mmu_private) {
  89. BUG();
  90. r = -EIO;
  91. goto ret_r;
  92. }
  93. if ((s = hpfs_add_sector_to_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1)) == -1) {
  94. hpfs_truncate_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1);
  95. r = -ENOSPC;
  96. goto ret_r;
  97. }
  98. inode->i_blocks++;
  99. hpfs_i(inode)->mmu_private += 512;
  100. set_buffer_new(bh_result);
  101. map_bh(bh_result, inode->i_sb, hpfs_search_hotfix_map(inode->i_sb, s));
  102. ret_0:
  103. r = 0;
  104. ret_r:
  105. hpfs_unlock(inode->i_sb);
  106. return r;
  107. }
  108. static int hpfs_readpage(struct file *file, struct page *page)
  109. {
  110. return mpage_readpage(page, hpfs_get_block);
  111. }
  112. static int hpfs_writepage(struct page *page, struct writeback_control *wbc)
  113. {
  114. return block_write_full_page(page, hpfs_get_block, wbc);
  115. }
  116. static void hpfs_readahead(struct readahead_control *rac)
  117. {
  118. mpage_readahead(rac, hpfs_get_block);
  119. }
  120. static int hpfs_writepages(struct address_space *mapping,
  121. struct writeback_control *wbc)
  122. {
  123. return mpage_writepages(mapping, wbc, hpfs_get_block);
  124. }
  125. static void hpfs_write_failed(struct address_space *mapping, loff_t to)
  126. {
  127. struct inode *inode = mapping->host;
  128. hpfs_lock(inode->i_sb);
  129. if (to > inode->i_size) {
  130. truncate_pagecache(inode, inode->i_size);
  131. hpfs_truncate(inode);
  132. }
  133. hpfs_unlock(inode->i_sb);
  134. }
  135. static int hpfs_write_begin(struct file *file, struct address_space *mapping,
  136. loff_t pos, unsigned len, unsigned flags,
  137. struct page **pagep, void **fsdata)
  138. {
  139. int ret;
  140. *pagep = NULL;
  141. ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
  142. hpfs_get_block,
  143. &hpfs_i(mapping->host)->mmu_private);
  144. if (unlikely(ret))
  145. hpfs_write_failed(mapping, pos + len);
  146. return ret;
  147. }
  148. static int hpfs_write_end(struct file *file, struct address_space *mapping,
  149. loff_t pos, unsigned len, unsigned copied,
  150. struct page *pagep, void *fsdata)
  151. {
  152. struct inode *inode = mapping->host;
  153. int err;
  154. err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
  155. if (err < len)
  156. hpfs_write_failed(mapping, pos + len);
  157. if (!(err < 0)) {
  158. /* make sure we write it on close, if not earlier */
  159. hpfs_lock(inode->i_sb);
  160. hpfs_i(inode)->i_dirty = 1;
  161. hpfs_unlock(inode->i_sb);
  162. }
  163. return err;
  164. }
  165. static sector_t _hpfs_bmap(struct address_space *mapping, sector_t block)
  166. {
  167. return generic_block_bmap(mapping, block, hpfs_get_block);
  168. }
  169. static int hpfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, u64 start, u64 len)
  170. {
  171. return generic_block_fiemap(inode, fieinfo, start, len, hpfs_get_block);
  172. }
  173. const struct address_space_operations hpfs_aops = {
  174. .readpage = hpfs_readpage,
  175. .writepage = hpfs_writepage,
  176. .readahead = hpfs_readahead,
  177. .writepages = hpfs_writepages,
  178. .write_begin = hpfs_write_begin,
  179. .write_end = hpfs_write_end,
  180. .bmap = _hpfs_bmap
  181. };
  182. const struct file_operations hpfs_file_ops =
  183. {
  184. .llseek = generic_file_llseek,
  185. .read_iter = generic_file_read_iter,
  186. .write_iter = generic_file_write_iter,
  187. .mmap = generic_file_mmap,
  188. .release = hpfs_file_release,
  189. .fsync = hpfs_file_fsync,
  190. .splice_read = generic_file_splice_read,
  191. .unlocked_ioctl = hpfs_ioctl,
  192. .compat_ioctl = compat_ptr_ioctl,
  193. };
  194. const struct inode_operations hpfs_file_iops =
  195. {
  196. .setattr = hpfs_setattr,
  197. .fiemap = hpfs_fiemap,
  198. };