data.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702
  1. /*
  2. * fs/f2fs/data.c
  3. *
  4. * Copyright (c) 2012 Samsung Electronics Co., Ltd.
  5. * http://www.samsung.com/
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License version 2 as
  9. * published by the Free Software Foundation.
  10. */
  11. #include <linux/fs.h>
  12. #include <linux/f2fs_fs.h>
  13. #include <linux/buffer_head.h>
  14. #include <linux/mpage.h>
  15. #include <linux/writeback.h>
  16. #include <linux/backing-dev.h>
  17. #include <linux/blkdev.h>
  18. #include <linux/bio.h>
  19. #include "f2fs.h"
  20. #include "node.h"
  21. #include "segment.h"
  22. /*
  23. * Lock ordering for the change of data block address:
  24. * ->data_page
  25. * ->node_page
  26. * update block addresses in the node page
  27. */
  28. static void __set_data_blkaddr(struct dnode_of_data *dn, block_t new_addr)
  29. {
  30. struct f2fs_node *rn;
  31. __le32 *addr_array;
  32. struct page *node_page = dn->node_page;
  33. unsigned int ofs_in_node = dn->ofs_in_node;
  34. wait_on_page_writeback(node_page);
  35. rn = (struct f2fs_node *)page_address(node_page);
  36. /* Get physical address of data block */
  37. addr_array = blkaddr_in_node(rn);
  38. addr_array[ofs_in_node] = cpu_to_le32(new_addr);
  39. set_page_dirty(node_page);
  40. }
  41. int reserve_new_block(struct dnode_of_data *dn)
  42. {
  43. struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
  44. if (is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC))
  45. return -EPERM;
  46. if (!inc_valid_block_count(sbi, dn->inode, 1))
  47. return -ENOSPC;
  48. __set_data_blkaddr(dn, NEW_ADDR);
  49. dn->data_blkaddr = NEW_ADDR;
  50. sync_inode_page(dn);
  51. return 0;
  52. }
  53. static int check_extent_cache(struct inode *inode, pgoff_t pgofs,
  54. struct buffer_head *bh_result)
  55. {
  56. struct f2fs_inode_info *fi = F2FS_I(inode);
  57. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  58. pgoff_t start_fofs, end_fofs;
  59. block_t start_blkaddr;
  60. read_lock(&fi->ext.ext_lock);
  61. if (fi->ext.len == 0) {
  62. read_unlock(&fi->ext.ext_lock);
  63. return 0;
  64. }
  65. sbi->total_hit_ext++;
  66. start_fofs = fi->ext.fofs;
  67. end_fofs = fi->ext.fofs + fi->ext.len - 1;
  68. start_blkaddr = fi->ext.blk_addr;
  69. if (pgofs >= start_fofs && pgofs <= end_fofs) {
  70. unsigned int blkbits = inode->i_sb->s_blocksize_bits;
  71. size_t count;
  72. clear_buffer_new(bh_result);
  73. map_bh(bh_result, inode->i_sb,
  74. start_blkaddr + pgofs - start_fofs);
  75. count = end_fofs - pgofs + 1;
  76. if (count < (UINT_MAX >> blkbits))
  77. bh_result->b_size = (count << blkbits);
  78. else
  79. bh_result->b_size = UINT_MAX;
  80. sbi->read_hit_ext++;
  81. read_unlock(&fi->ext.ext_lock);
  82. return 1;
  83. }
  84. read_unlock(&fi->ext.ext_lock);
  85. return 0;
  86. }
  87. void update_extent_cache(block_t blk_addr, struct dnode_of_data *dn)
  88. {
  89. struct f2fs_inode_info *fi = F2FS_I(dn->inode);
  90. pgoff_t fofs, start_fofs, end_fofs;
  91. block_t start_blkaddr, end_blkaddr;
  92. BUG_ON(blk_addr == NEW_ADDR);
  93. fofs = start_bidx_of_node(ofs_of_node(dn->node_page)) + dn->ofs_in_node;
  94. /* Update the page address in the parent node */
  95. __set_data_blkaddr(dn, blk_addr);
  96. write_lock(&fi->ext.ext_lock);
  97. start_fofs = fi->ext.fofs;
  98. end_fofs = fi->ext.fofs + fi->ext.len - 1;
  99. start_blkaddr = fi->ext.blk_addr;
  100. end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
  101. /* Drop and initialize the matched extent */
  102. if (fi->ext.len == 1 && fofs == start_fofs)
  103. fi->ext.len = 0;
  104. /* Initial extent */
  105. if (fi->ext.len == 0) {
  106. if (blk_addr != NULL_ADDR) {
  107. fi->ext.fofs = fofs;
  108. fi->ext.blk_addr = blk_addr;
  109. fi->ext.len = 1;
  110. }
  111. goto end_update;
  112. }
  113. /* Frone merge */
  114. if (fofs == start_fofs - 1 && blk_addr == start_blkaddr - 1) {
  115. fi->ext.fofs--;
  116. fi->ext.blk_addr--;
  117. fi->ext.len++;
  118. goto end_update;
  119. }
  120. /* Back merge */
  121. if (fofs == end_fofs + 1 && blk_addr == end_blkaddr + 1) {
  122. fi->ext.len++;
  123. goto end_update;
  124. }
  125. /* Split the existing extent */
  126. if (fi->ext.len > 1 &&
  127. fofs >= start_fofs && fofs <= end_fofs) {
  128. if ((end_fofs - fofs) < (fi->ext.len >> 1)) {
  129. fi->ext.len = fofs - start_fofs;
  130. } else {
  131. fi->ext.fofs = fofs + 1;
  132. fi->ext.blk_addr = start_blkaddr +
  133. fofs - start_fofs + 1;
  134. fi->ext.len -= fofs - start_fofs + 1;
  135. }
  136. goto end_update;
  137. }
  138. write_unlock(&fi->ext.ext_lock);
  139. return;
  140. end_update:
  141. write_unlock(&fi->ext.ext_lock);
  142. sync_inode_page(dn);
  143. return;
  144. }
  145. struct page *find_data_page(struct inode *inode, pgoff_t index)
  146. {
  147. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  148. struct address_space *mapping = inode->i_mapping;
  149. struct dnode_of_data dn;
  150. struct page *page;
  151. int err;
  152. page = find_get_page(mapping, index);
  153. if (page && PageUptodate(page))
  154. return page;
  155. f2fs_put_page(page, 0);
  156. set_new_dnode(&dn, inode, NULL, NULL, 0);
  157. err = get_dnode_of_data(&dn, index, RDONLY_NODE);
  158. if (err)
  159. return ERR_PTR(err);
  160. f2fs_put_dnode(&dn);
  161. if (dn.data_blkaddr == NULL_ADDR)
  162. return ERR_PTR(-ENOENT);
  163. /* By fallocate(), there is no cached page, but with NEW_ADDR */
  164. if (dn.data_blkaddr == NEW_ADDR)
  165. return ERR_PTR(-EINVAL);
  166. page = grab_cache_page(mapping, index);
  167. if (!page)
  168. return ERR_PTR(-ENOMEM);
  169. err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
  170. if (err) {
  171. f2fs_put_page(page, 1);
  172. return ERR_PTR(err);
  173. }
  174. unlock_page(page);
  175. return page;
  176. }
  177. /*
  178. * If it tries to access a hole, return an error.
  179. * Because, the callers, functions in dir.c and GC, should be able to know
  180. * whether this page exists or not.
  181. */
  182. struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
  183. {
  184. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  185. struct address_space *mapping = inode->i_mapping;
  186. struct dnode_of_data dn;
  187. struct page *page;
  188. int err;
  189. set_new_dnode(&dn, inode, NULL, NULL, 0);
  190. err = get_dnode_of_data(&dn, index, RDONLY_NODE);
  191. if (err)
  192. return ERR_PTR(err);
  193. f2fs_put_dnode(&dn);
  194. if (dn.data_blkaddr == NULL_ADDR)
  195. return ERR_PTR(-ENOENT);
  196. page = grab_cache_page(mapping, index);
  197. if (!page)
  198. return ERR_PTR(-ENOMEM);
  199. if (PageUptodate(page))
  200. return page;
  201. BUG_ON(dn.data_blkaddr == NEW_ADDR);
  202. BUG_ON(dn.data_blkaddr == NULL_ADDR);
  203. err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
  204. if (err) {
  205. f2fs_put_page(page, 1);
  206. return ERR_PTR(err);
  207. }
  208. return page;
  209. }
  210. /*
  211. * Caller ensures that this data page is never allocated.
  212. * A new zero-filled data page is allocated in the page cache.
  213. */
  214. struct page *get_new_data_page(struct inode *inode, pgoff_t index,
  215. bool new_i_size)
  216. {
  217. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  218. struct address_space *mapping = inode->i_mapping;
  219. struct page *page;
  220. struct dnode_of_data dn;
  221. int err;
  222. set_new_dnode(&dn, inode, NULL, NULL, 0);
  223. err = get_dnode_of_data(&dn, index, 0);
  224. if (err)
  225. return ERR_PTR(err);
  226. if (dn.data_blkaddr == NULL_ADDR) {
  227. if (reserve_new_block(&dn)) {
  228. f2fs_put_dnode(&dn);
  229. return ERR_PTR(-ENOSPC);
  230. }
  231. }
  232. f2fs_put_dnode(&dn);
  233. page = grab_cache_page(mapping, index);
  234. if (!page)
  235. return ERR_PTR(-ENOMEM);
  236. if (PageUptodate(page))
  237. return page;
  238. if (dn.data_blkaddr == NEW_ADDR) {
  239. zero_user_segment(page, 0, PAGE_CACHE_SIZE);
  240. } else {
  241. err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
  242. if (err) {
  243. f2fs_put_page(page, 1);
  244. return ERR_PTR(err);
  245. }
  246. }
  247. SetPageUptodate(page);
  248. if (new_i_size &&
  249. i_size_read(inode) < ((index + 1) << PAGE_CACHE_SHIFT)) {
  250. i_size_write(inode, ((index + 1) << PAGE_CACHE_SHIFT));
  251. mark_inode_dirty_sync(inode);
  252. }
  253. return page;
  254. }
  255. static void read_end_io(struct bio *bio, int err)
  256. {
  257. const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
  258. struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
  259. do {
  260. struct page *page = bvec->bv_page;
  261. if (--bvec >= bio->bi_io_vec)
  262. prefetchw(&bvec->bv_page->flags);
  263. if (uptodate) {
  264. SetPageUptodate(page);
  265. } else {
  266. ClearPageUptodate(page);
  267. SetPageError(page);
  268. }
  269. unlock_page(page);
  270. } while (bvec >= bio->bi_io_vec);
  271. kfree(bio->bi_private);
  272. bio_put(bio);
  273. }
  274. /*
  275. * Fill the locked page with data located in the block address.
  276. * Read operation is synchronous, and caller must unlock the page.
  277. */
  278. int f2fs_readpage(struct f2fs_sb_info *sbi, struct page *page,
  279. block_t blk_addr, int type)
  280. {
  281. struct block_device *bdev = sbi->sb->s_bdev;
  282. bool sync = (type == READ_SYNC);
  283. struct bio *bio;
  284. /* This page can be already read by other threads */
  285. if (PageUptodate(page)) {
  286. if (!sync)
  287. unlock_page(page);
  288. return 0;
  289. }
  290. down_read(&sbi->bio_sem);
  291. /* Allocate a new bio */
  292. bio = f2fs_bio_alloc(bdev, 1);
  293. /* Initialize the bio */
  294. bio->bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
  295. bio->bi_end_io = read_end_io;
  296. if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
  297. kfree(bio->bi_private);
  298. bio_put(bio);
  299. up_read(&sbi->bio_sem);
  300. return -EFAULT;
  301. }
  302. submit_bio(type, bio);
  303. up_read(&sbi->bio_sem);
  304. /* wait for read completion if sync */
  305. if (sync) {
  306. lock_page(page);
  307. if (PageError(page))
  308. return -EIO;
  309. }
  310. return 0;
  311. }
  312. /*
  313. * This function should be used by the data read flow only where it
  314. * does not check the "create" flag that indicates block allocation.
  315. * The reason for this special functionality is to exploit VFS readahead
  316. * mechanism.
  317. */
  318. static int get_data_block_ro(struct inode *inode, sector_t iblock,
  319. struct buffer_head *bh_result, int create)
  320. {
  321. unsigned int blkbits = inode->i_sb->s_blocksize_bits;
  322. unsigned maxblocks = bh_result->b_size >> blkbits;
  323. struct dnode_of_data dn;
  324. pgoff_t pgofs;
  325. int err;
  326. /* Get the page offset from the block offset(iblock) */
  327. pgofs = (pgoff_t)(iblock >> (PAGE_CACHE_SHIFT - blkbits));
  328. if (check_extent_cache(inode, pgofs, bh_result))
  329. return 0;
  330. /* When reading holes, we need its node page */
  331. set_new_dnode(&dn, inode, NULL, NULL, 0);
  332. err = get_dnode_of_data(&dn, pgofs, RDONLY_NODE);
  333. if (err)
  334. return (err == -ENOENT) ? 0 : err;
  335. /* It does not support data allocation */
  336. BUG_ON(create);
  337. if (dn.data_blkaddr != NEW_ADDR && dn.data_blkaddr != NULL_ADDR) {
  338. int i;
  339. unsigned int end_offset;
  340. end_offset = IS_INODE(dn.node_page) ?
  341. ADDRS_PER_INODE :
  342. ADDRS_PER_BLOCK;
  343. clear_buffer_new(bh_result);
  344. /* Give more consecutive addresses for the read ahead */
  345. for (i = 0; i < end_offset - dn.ofs_in_node; i++)
  346. if (((datablock_addr(dn.node_page,
  347. dn.ofs_in_node + i))
  348. != (dn.data_blkaddr + i)) || maxblocks == i)
  349. break;
  350. map_bh(bh_result, inode->i_sb, dn.data_blkaddr);
  351. bh_result->b_size = (i << blkbits);
  352. }
  353. f2fs_put_dnode(&dn);
  354. return 0;
  355. }
  356. static int f2fs_read_data_page(struct file *file, struct page *page)
  357. {
  358. return mpage_readpage(page, get_data_block_ro);
  359. }
  360. static int f2fs_read_data_pages(struct file *file,
  361. struct address_space *mapping,
  362. struct list_head *pages, unsigned nr_pages)
  363. {
  364. return mpage_readpages(mapping, pages, nr_pages, get_data_block_ro);
  365. }
  366. int do_write_data_page(struct page *page)
  367. {
  368. struct inode *inode = page->mapping->host;
  369. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  370. block_t old_blk_addr, new_blk_addr;
  371. struct dnode_of_data dn;
  372. int err = 0;
  373. set_new_dnode(&dn, inode, NULL, NULL, 0);
  374. err = get_dnode_of_data(&dn, page->index, RDONLY_NODE);
  375. if (err)
  376. return err;
  377. old_blk_addr = dn.data_blkaddr;
  378. /* This page is already truncated */
  379. if (old_blk_addr == NULL_ADDR)
  380. goto out_writepage;
  381. set_page_writeback(page);
  382. /*
  383. * If current allocation needs SSR,
  384. * it had better in-place writes for updated data.
  385. */
  386. if (old_blk_addr != NEW_ADDR && !is_cold_data(page) &&
  387. need_inplace_update(inode)) {
  388. rewrite_data_page(F2FS_SB(inode->i_sb), page,
  389. old_blk_addr);
  390. } else {
  391. write_data_page(inode, page, &dn,
  392. old_blk_addr, &new_blk_addr);
  393. update_extent_cache(new_blk_addr, &dn);
  394. F2FS_I(inode)->data_version =
  395. le64_to_cpu(F2FS_CKPT(sbi)->checkpoint_ver);
  396. }
  397. out_writepage:
  398. f2fs_put_dnode(&dn);
  399. return err;
  400. }
  401. static int f2fs_write_data_page(struct page *page,
  402. struct writeback_control *wbc)
  403. {
  404. struct inode *inode = page->mapping->host;
  405. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  406. loff_t i_size = i_size_read(inode);
  407. const pgoff_t end_index = ((unsigned long long) i_size)
  408. >> PAGE_CACHE_SHIFT;
  409. unsigned offset;
  410. int err = 0;
  411. if (page->index < end_index)
  412. goto out;
  413. /*
  414. * If the offset is out-of-range of file size,
  415. * this page does not have to be written to disk.
  416. */
  417. offset = i_size & (PAGE_CACHE_SIZE - 1);
  418. if ((page->index >= end_index + 1) || !offset) {
  419. if (S_ISDIR(inode->i_mode)) {
  420. dec_page_count(sbi, F2FS_DIRTY_DENTS);
  421. inode_dec_dirty_dents(inode);
  422. }
  423. goto unlock_out;
  424. }
  425. zero_user_segment(page, offset, PAGE_CACHE_SIZE);
  426. out:
  427. if (sbi->por_doing)
  428. goto redirty_out;
  429. if (wbc->for_reclaim && !S_ISDIR(inode->i_mode) && !is_cold_data(page))
  430. goto redirty_out;
  431. mutex_lock_op(sbi, DATA_WRITE);
  432. if (S_ISDIR(inode->i_mode)) {
  433. dec_page_count(sbi, F2FS_DIRTY_DENTS);
  434. inode_dec_dirty_dents(inode);
  435. }
  436. err = do_write_data_page(page);
  437. if (err && err != -ENOENT) {
  438. wbc->pages_skipped++;
  439. set_page_dirty(page);
  440. }
  441. mutex_unlock_op(sbi, DATA_WRITE);
  442. if (wbc->for_reclaim)
  443. f2fs_submit_bio(sbi, DATA, true);
  444. if (err == -ENOENT)
  445. goto unlock_out;
  446. clear_cold_data(page);
  447. unlock_page(page);
  448. if (!wbc->for_reclaim && !S_ISDIR(inode->i_mode))
  449. f2fs_balance_fs(sbi);
  450. return 0;
  451. unlock_out:
  452. unlock_page(page);
  453. return (err == -ENOENT) ? 0 : err;
  454. redirty_out:
  455. wbc->pages_skipped++;
  456. set_page_dirty(page);
  457. return AOP_WRITEPAGE_ACTIVATE;
  458. }
  459. #define MAX_DESIRED_PAGES_WP 4096
  460. static int f2fs_write_data_pages(struct address_space *mapping,
  461. struct writeback_control *wbc)
  462. {
  463. struct inode *inode = mapping->host;
  464. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  465. int ret;
  466. long excess_nrtw = 0, desired_nrtw;
  467. if (wbc->nr_to_write < MAX_DESIRED_PAGES_WP) {
  468. desired_nrtw = MAX_DESIRED_PAGES_WP;
  469. excess_nrtw = desired_nrtw - wbc->nr_to_write;
  470. wbc->nr_to_write = desired_nrtw;
  471. }
  472. if (!S_ISDIR(inode->i_mode))
  473. mutex_lock(&sbi->writepages);
  474. ret = generic_writepages(mapping, wbc);
  475. if (!S_ISDIR(inode->i_mode))
  476. mutex_unlock(&sbi->writepages);
  477. f2fs_submit_bio(sbi, DATA, (wbc->sync_mode == WB_SYNC_ALL));
  478. remove_dirty_dir_inode(inode);
  479. wbc->nr_to_write -= excess_nrtw;
  480. return ret;
  481. }
  482. static int f2fs_write_begin(struct file *file, struct address_space *mapping,
  483. loff_t pos, unsigned len, unsigned flags,
  484. struct page **pagep, void **fsdata)
  485. {
  486. struct inode *inode = mapping->host;
  487. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  488. struct page *page;
  489. pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
  490. struct dnode_of_data dn;
  491. int err = 0;
  492. /* for nobh_write_end */
  493. *fsdata = NULL;
  494. f2fs_balance_fs(sbi);
  495. page = grab_cache_page_write_begin(mapping, index, flags);
  496. if (!page)
  497. return -ENOMEM;
  498. *pagep = page;
  499. mutex_lock_op(sbi, DATA_NEW);
  500. set_new_dnode(&dn, inode, NULL, NULL, 0);
  501. err = get_dnode_of_data(&dn, index, 0);
  502. if (err) {
  503. mutex_unlock_op(sbi, DATA_NEW);
  504. f2fs_put_page(page, 1);
  505. return err;
  506. }
  507. if (dn.data_blkaddr == NULL_ADDR) {
  508. err = reserve_new_block(&dn);
  509. if (err) {
  510. f2fs_put_dnode(&dn);
  511. mutex_unlock_op(sbi, DATA_NEW);
  512. f2fs_put_page(page, 1);
  513. return err;
  514. }
  515. }
  516. f2fs_put_dnode(&dn);
  517. mutex_unlock_op(sbi, DATA_NEW);
  518. if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
  519. return 0;
  520. if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {
  521. unsigned start = pos & (PAGE_CACHE_SIZE - 1);
  522. unsigned end = start + len;
  523. /* Reading beyond i_size is simple: memset to zero */
  524. zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);
  525. return 0;
  526. }
  527. if (dn.data_blkaddr == NEW_ADDR) {
  528. zero_user_segment(page, 0, PAGE_CACHE_SIZE);
  529. } else {
  530. err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
  531. if (err) {
  532. f2fs_put_page(page, 1);
  533. return err;
  534. }
  535. }
  536. SetPageUptodate(page);
  537. clear_cold_data(page);
  538. return 0;
  539. }
  540. static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
  541. const struct iovec *iov, loff_t offset, unsigned long nr_segs)
  542. {
  543. struct file *file = iocb->ki_filp;
  544. struct inode *inode = file->f_mapping->host;
  545. if (rw == WRITE)
  546. return 0;
  547. /* Needs synchronization with the cleaner */
  548. return blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
  549. get_data_block_ro);
  550. }
  551. static void f2fs_invalidate_data_page(struct page *page, unsigned long offset)
  552. {
  553. struct inode *inode = page->mapping->host;
  554. struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
  555. if (S_ISDIR(inode->i_mode) && PageDirty(page)) {
  556. dec_page_count(sbi, F2FS_DIRTY_DENTS);
  557. inode_dec_dirty_dents(inode);
  558. }
  559. ClearPagePrivate(page);
  560. }
  561. static int f2fs_release_data_page(struct page *page, gfp_t wait)
  562. {
  563. ClearPagePrivate(page);
  564. return 0;
  565. }
  566. static int f2fs_set_data_page_dirty(struct page *page)
  567. {
  568. struct address_space *mapping = page->mapping;
  569. struct inode *inode = mapping->host;
  570. SetPageUptodate(page);
  571. if (!PageDirty(page)) {
  572. __set_page_dirty_nobuffers(page);
  573. set_dirty_dir_page(inode, page);
  574. return 1;
  575. }
  576. return 0;
  577. }
  578. const struct address_space_operations f2fs_dblock_aops = {
  579. .readpage = f2fs_read_data_page,
  580. .readpages = f2fs_read_data_pages,
  581. .writepage = f2fs_write_data_page,
  582. .writepages = f2fs_write_data_pages,
  583. .write_begin = f2fs_write_begin,
  584. .write_end = nobh_write_end,
  585. .set_page_dirty = f2fs_set_data_page_dirty,
  586. .invalidatepage = f2fs_invalidate_data_page,
  587. .releasepage = f2fs_release_data_page,
  588. .direct_IO = f2fs_direct_IO,
  589. };