data.c (4ba24fef3eb3b142197135223b90ced2f319cd53) data.c (caf0047e7e1e60a7ad1d655d3b81b32e2dfb6095)
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

--- 8 unchanged lines hidden (view full) ---

17#include <linux/backing-dev.h>
18#include <linux/blkdev.h>
19#include <linux/bio.h>
20#include <linux/prefetch.h>
21
22#include "f2fs.h"
23#include "node.h"
24#include "segment.h"
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

--- 8 unchanged lines hidden (view full) ---

17#include <linux/backing-dev.h>
18#include <linux/blkdev.h>
19#include <linux/bio.h>
20#include <linux/prefetch.h>
21
22#include "f2fs.h"
23#include "node.h"
24#include "segment.h"
25#include "trace.h"
25#include <trace/events/f2fs.h>
26
27static void f2fs_read_end_io(struct bio *bio, int err)
28{
29 struct bio_vec *bvec;
30 int i;
31
32 bio_for_each_segment_all(bvec, bio, i) {

--- 57 unchanged lines hidden (view full) ---

90static void __submit_merged_bio(struct f2fs_bio_info *io)
91{
92 struct f2fs_io_info *fio = &io->fio;
93
94 if (!io->bio)
95 return;
96
97 if (is_read_io(fio->rw))
26#include <trace/events/f2fs.h>
27
28static void f2fs_read_end_io(struct bio *bio, int err)
29{
30 struct bio_vec *bvec;
31 int i;
32
33 bio_for_each_segment_all(bvec, bio, i) {

--- 57 unchanged lines hidden (view full) ---

91static void __submit_merged_bio(struct f2fs_bio_info *io)
92{
93 struct f2fs_io_info *fio = &io->fio;
94
95 if (!io->bio)
96 return;
97
98 if (is_read_io(fio->rw))
98 trace_f2fs_submit_read_bio(io->sbi->sb, fio->rw,
99 fio->type, io->bio);
99 trace_f2fs_submit_read_bio(io->sbi->sb, fio, io->bio);
100 else
100 else
101 trace_f2fs_submit_write_bio(io->sbi->sb, fio->rw,
102 fio->type, io->bio);
101 trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio);
103
104 submit_bio(fio->rw, io->bio);
105 io->bio = NULL;
106}
107
108void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi,
109 enum page_type type, int rw)
110{

--- 16 unchanged lines hidden (view full) ---

127 up_write(&io->io_rwsem);
128}
129
130/*
131 * Fill the locked page with data located in the block address.
132 * Return unlocked page.
133 */
134int f2fs_submit_page_bio(struct f2fs_sb_info *sbi, struct page *page,
102
103 submit_bio(fio->rw, io->bio);
104 io->bio = NULL;
105}
106
107void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi,
108 enum page_type type, int rw)
109{

--- 16 unchanged lines hidden (view full) ---

126 up_write(&io->io_rwsem);
127}
128
129/*
130 * Fill the locked page with data located in the block address.
131 * Return unlocked page.
132 */
133int f2fs_submit_page_bio(struct f2fs_sb_info *sbi, struct page *page,
135 block_t blk_addr, int rw)
134 struct f2fs_io_info *fio)
136{
137 struct bio *bio;
138
135{
136 struct bio *bio;
137
139 trace_f2fs_submit_page_bio(page, blk_addr, rw);
138 trace_f2fs_submit_page_bio(page, fio);
139 f2fs_trace_ios(page, fio, 0);
140
141 /* Allocate a new bio */
140
141 /* Allocate a new bio */
142 bio = __bio_alloc(sbi, blk_addr, 1, is_read_io(rw));
142 bio = __bio_alloc(sbi, fio->blk_addr, 1, is_read_io(fio->rw));
143
144 if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
145 bio_put(bio);
146 f2fs_put_page(page, 1);
147 return -EFAULT;
148 }
149
143
144 if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
145 bio_put(bio);
146 f2fs_put_page(page, 1);
147 return -EFAULT;
148 }
149
150 submit_bio(rw, bio);
150 submit_bio(fio->rw, bio);
151 return 0;
152}
153
154void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
151 return 0;
152}
153
154void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
155 block_t blk_addr, struct f2fs_io_info *fio)
155 struct f2fs_io_info *fio)
156{
157 enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
158 struct f2fs_bio_info *io;
159 bool is_read = is_read_io(fio->rw);
160
161 io = is_read ? &sbi->read_io : &sbi->write_io[btype];
162
156{
157 enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
158 struct f2fs_bio_info *io;
159 bool is_read = is_read_io(fio->rw);
160
161 io = is_read ? &sbi->read_io : &sbi->write_io[btype];
162
163 verify_block_addr(sbi, blk_addr);
163 verify_block_addr(sbi, fio->blk_addr);
164
165 down_write(&io->io_rwsem);
166
167 if (!is_read)
168 inc_page_count(sbi, F2FS_WRITEBACK);
169
164
165 down_write(&io->io_rwsem);
166
167 if (!is_read)
168 inc_page_count(sbi, F2FS_WRITEBACK);
169
170 if (io->bio && (io->last_block_in_bio != blk_addr - 1 ||
170 if (io->bio && (io->last_block_in_bio != fio->blk_addr - 1 ||
171 io->fio.rw != fio->rw))
172 __submit_merged_bio(io);
173alloc_new:
174 if (io->bio == NULL) {
175 int bio_blocks = MAX_BIO_BLOCKS(sbi);
176
171 io->fio.rw != fio->rw))
172 __submit_merged_bio(io);
173alloc_new:
174 if (io->bio == NULL) {
175 int bio_blocks = MAX_BIO_BLOCKS(sbi);
176
177 io->bio = __bio_alloc(sbi, blk_addr, bio_blocks, is_read);
177 io->bio = __bio_alloc(sbi, fio->blk_addr, bio_blocks, is_read);
178 io->fio = *fio;
179 }
180
181 if (bio_add_page(io->bio, page, PAGE_CACHE_SIZE, 0) <
182 PAGE_CACHE_SIZE) {
183 __submit_merged_bio(io);
184 goto alloc_new;
185 }
186
178 io->fio = *fio;
179 }
180
181 if (bio_add_page(io->bio, page, PAGE_CACHE_SIZE, 0) <
182 PAGE_CACHE_SIZE) {
183 __submit_merged_bio(io);
184 goto alloc_new;
185 }
186
187 io->last_block_in_bio = blk_addr;
187 io->last_block_in_bio = fio->blk_addr;
188 f2fs_trace_ios(page, fio, 0);
188
189 up_write(&io->io_rwsem);
189
190 up_write(&io->io_rwsem);
190 trace_f2fs_submit_page_mbio(page, fio->rw, fio->type, blk_addr);
191 trace_f2fs_submit_page_mbio(page, fio);
191}
192
193/*
194 * Lock ordering for the change of data block address:
195 * ->data_page
196 * ->node_page
197 * update block addresses in the node page
198 */
192}
193
194/*
195 * Lock ordering for the change of data block address:
196 * ->data_page
197 * ->node_page
198 * update block addresses in the node page
199 */
199static void __set_data_blkaddr(struct dnode_of_data *dn, block_t new_addr)
200static void __set_data_blkaddr(struct dnode_of_data *dn)
200{
201 struct f2fs_node *rn;
202 __le32 *addr_array;
203 struct page *node_page = dn->node_page;
204 unsigned int ofs_in_node = dn->ofs_in_node;
205
206 f2fs_wait_on_page_writeback(node_page, NODE);
207
208 rn = F2FS_NODE(node_page);
209
210 /* Get physical address of data block */
211 addr_array = blkaddr_in_node(rn);
201{
202 struct f2fs_node *rn;
203 __le32 *addr_array;
204 struct page *node_page = dn->node_page;
205 unsigned int ofs_in_node = dn->ofs_in_node;
206
207 f2fs_wait_on_page_writeback(node_page, NODE);
208
209 rn = F2FS_NODE(node_page);
210
211 /* Get physical address of data block */
212 addr_array = blkaddr_in_node(rn);
212 addr_array[ofs_in_node] = cpu_to_le32(new_addr);
213 addr_array[ofs_in_node] = cpu_to_le32(dn->data_blkaddr);
213 set_page_dirty(node_page);
214}
215
216int reserve_new_block(struct dnode_of_data *dn)
217{
218 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
219
220 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
221 return -EPERM;
222 if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
223 return -ENOSPC;
224
225 trace_f2fs_reserve_new_block(dn->inode, dn->nid, dn->ofs_in_node);
226
214 set_page_dirty(node_page);
215}
216
217int reserve_new_block(struct dnode_of_data *dn)
218{
219 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
220
221 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
222 return -EPERM;
223 if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
224 return -ENOSPC;
225
226 trace_f2fs_reserve_new_block(dn->inode, dn->nid, dn->ofs_in_node);
227
227 __set_data_blkaddr(dn, NEW_ADDR);
228 dn->data_blkaddr = NEW_ADDR;
228 dn->data_blkaddr = NEW_ADDR;
229 __set_data_blkaddr(dn);
229 mark_inode_dirty(dn->inode);
230 sync_inode_page(dn);
231 return 0;
232}
233
234int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
235{
236 bool need_put = dn->inode_page ? false : true;

--- 48 unchanged lines hidden (view full) ---

285 stat_inc_read_hit(inode->i_sb);
286 read_unlock(&fi->ext.ext_lock);
287 return 1;
288 }
289 read_unlock(&fi->ext.ext_lock);
290 return 0;
291}
292
230 mark_inode_dirty(dn->inode);
231 sync_inode_page(dn);
232 return 0;
233}
234
235int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
236{
237 bool need_put = dn->inode_page ? false : true;

--- 48 unchanged lines hidden (view full) ---

286 stat_inc_read_hit(inode->i_sb);
287 read_unlock(&fi->ext.ext_lock);
288 return 1;
289 }
290 read_unlock(&fi->ext.ext_lock);
291 return 0;
292}
293
293void update_extent_cache(block_t blk_addr, struct dnode_of_data *dn)
294void update_extent_cache(struct dnode_of_data *dn)
294{
295 struct f2fs_inode_info *fi = F2FS_I(dn->inode);
296 pgoff_t fofs, start_fofs, end_fofs;
297 block_t start_blkaddr, end_blkaddr;
298 int need_update = true;
299
295{
296 struct f2fs_inode_info *fi = F2FS_I(dn->inode);
297 pgoff_t fofs, start_fofs, end_fofs;
298 block_t start_blkaddr, end_blkaddr;
299 int need_update = true;
300
300 f2fs_bug_on(F2FS_I_SB(dn->inode), blk_addr == NEW_ADDR);
301 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
302 dn->ofs_in_node;
301 f2fs_bug_on(F2FS_I_SB(dn->inode), dn->data_blkaddr == NEW_ADDR);
303
304 /* Update the page address in the parent node */
302
303 /* Update the page address in the parent node */
305 __set_data_blkaddr(dn, blk_addr);
304 __set_data_blkaddr(dn);
306
307 if (is_inode_flag_set(fi, FI_NO_EXTENT))
308 return;
309
305
306 if (is_inode_flag_set(fi, FI_NO_EXTENT))
307 return;
308
309 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
310 dn->ofs_in_node;
311
310 write_lock(&fi->ext.ext_lock);
311
312 start_fofs = fi->ext.fofs;
313 end_fofs = fi->ext.fofs + fi->ext.len - 1;
314 start_blkaddr = fi->ext.blk_addr;
315 end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
316
317 /* Drop and initialize the matched extent */
318 if (fi->ext.len == 1 && fofs == start_fofs)
319 fi->ext.len = 0;
320
321 /* Initial extent */
322 if (fi->ext.len == 0) {
312 write_lock(&fi->ext.ext_lock);
313
314 start_fofs = fi->ext.fofs;
315 end_fofs = fi->ext.fofs + fi->ext.len - 1;
316 start_blkaddr = fi->ext.blk_addr;
317 end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
318
319 /* Drop and initialize the matched extent */
320 if (fi->ext.len == 1 && fofs == start_fofs)
321 fi->ext.len = 0;
322
323 /* Initial extent */
324 if (fi->ext.len == 0) {
323 if (blk_addr != NULL_ADDR) {
325 if (dn->data_blkaddr != NULL_ADDR) {
324 fi->ext.fofs = fofs;
326 fi->ext.fofs = fofs;
325 fi->ext.blk_addr = blk_addr;
327 fi->ext.blk_addr = dn->data_blkaddr;
326 fi->ext.len = 1;
327 }
328 goto end_update;
329 }
330
331 /* Front merge */
328 fi->ext.len = 1;
329 }
330 goto end_update;
331 }
332
333 /* Front merge */
332 if (fofs == start_fofs - 1 && blk_addr == start_blkaddr - 1) {
334 if (fofs == start_fofs - 1 && dn->data_blkaddr == start_blkaddr - 1) {
333 fi->ext.fofs--;
334 fi->ext.blk_addr--;
335 fi->ext.len++;
336 goto end_update;
337 }
338
339 /* Back merge */
335 fi->ext.fofs--;
336 fi->ext.blk_addr--;
337 fi->ext.len++;
338 goto end_update;
339 }
340
341 /* Back merge */
340 if (fofs == end_fofs + 1 && blk_addr == end_blkaddr + 1) {
342 if (fofs == end_fofs + 1 && dn->data_blkaddr == end_blkaddr + 1) {
341 fi->ext.len++;
342 goto end_update;
343 }
344
345 /* Split the existing extent */
346 if (fi->ext.len > 1 &&
347 fofs >= start_fofs && fofs <= end_fofs) {
348 if ((end_fofs - fofs) < (fi->ext.len >> 1)) {

--- 22 unchanged lines hidden (view full) ---

371}
372
373struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
374{
375 struct address_space *mapping = inode->i_mapping;
376 struct dnode_of_data dn;
377 struct page *page;
378 int err;
343 fi->ext.len++;
344 goto end_update;
345 }
346
347 /* Split the existing extent */
348 if (fi->ext.len > 1 &&
349 fofs >= start_fofs && fofs <= end_fofs) {
350 if ((end_fofs - fofs) < (fi->ext.len >> 1)) {

--- 22 unchanged lines hidden (view full) ---

373}
374
375struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
376{
377 struct address_space *mapping = inode->i_mapping;
378 struct dnode_of_data dn;
379 struct page *page;
380 int err;
381 struct f2fs_io_info fio = {
382 .type = DATA,
383 .rw = sync ? READ_SYNC : READA,
384 };
379
380 page = find_get_page(mapping, index);
381 if (page && PageUptodate(page))
382 return page;
383 f2fs_put_page(page, 0);
384
385 set_new_dnode(&dn, inode, NULL, NULL, 0);
386 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);

--- 12 unchanged lines hidden (view full) ---

399 if (!page)
400 return ERR_PTR(-ENOMEM);
401
402 if (PageUptodate(page)) {
403 unlock_page(page);
404 return page;
405 }
406
385
386 page = find_get_page(mapping, index);
387 if (page && PageUptodate(page))
388 return page;
389 f2fs_put_page(page, 0);
390
391 set_new_dnode(&dn, inode, NULL, NULL, 0);
392 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);

--- 12 unchanged lines hidden (view full) ---

405 if (!page)
406 return ERR_PTR(-ENOMEM);
407
408 if (PageUptodate(page)) {
409 unlock_page(page);
410 return page;
411 }
412
407 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, dn.data_blkaddr,
408 sync ? READ_SYNC : READA);
413 fio.blk_addr = dn.data_blkaddr;
414 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
409 if (err)
410 return ERR_PTR(err);
411
412 if (sync) {
413 wait_on_page_locked(page);
414 if (unlikely(!PageUptodate(page))) {
415 f2fs_put_page(page, 0);
416 return ERR_PTR(-EIO);

--- 8 unchanged lines hidden (view full) ---

425 * whether this page exists or not.
426 */
427struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
428{
429 struct address_space *mapping = inode->i_mapping;
430 struct dnode_of_data dn;
431 struct page *page;
432 int err;
415 if (err)
416 return ERR_PTR(err);
417
418 if (sync) {
419 wait_on_page_locked(page);
420 if (unlikely(!PageUptodate(page))) {
421 f2fs_put_page(page, 0);
422 return ERR_PTR(-EIO);

--- 8 unchanged lines hidden (view full) ---

431 * whether this page exists or not.
432 */
433struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
434{
435 struct address_space *mapping = inode->i_mapping;
436 struct dnode_of_data dn;
437 struct page *page;
438 int err;
433
439 struct f2fs_io_info fio = {
440 .type = DATA,
441 .rw = READ_SYNC,
442 };
434repeat:
435 page = grab_cache_page(mapping, index);
436 if (!page)
437 return ERR_PTR(-ENOMEM);
438
439 set_new_dnode(&dn, inode, NULL, NULL, 0);
440 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
441 if (err) {

--- 17 unchanged lines hidden (view full) ---

459 * see, f2fs_add_link -> get_new_data_page -> init_inode_metadata.
460 */
461 if (dn.data_blkaddr == NEW_ADDR) {
462 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
463 SetPageUptodate(page);
464 return page;
465 }
466
443repeat:
444 page = grab_cache_page(mapping, index);
445 if (!page)
446 return ERR_PTR(-ENOMEM);
447
448 set_new_dnode(&dn, inode, NULL, NULL, 0);
449 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
450 if (err) {

--- 17 unchanged lines hidden (view full) ---

468 * see, f2fs_add_link -> get_new_data_page -> init_inode_metadata.
469 */
470 if (dn.data_blkaddr == NEW_ADDR) {
471 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
472 SetPageUptodate(page);
473 return page;
474 }
475
467 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,
468 dn.data_blkaddr, READ_SYNC);
476 fio.blk_addr = dn.data_blkaddr;
477 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
469 if (err)
470 return ERR_PTR(err);
471
472 lock_page(page);
473 if (unlikely(!PageUptodate(page))) {
474 f2fs_put_page(page, 1);
475 return ERR_PTR(-EIO);
476 }

--- 33 unchanged lines hidden (view full) ---

510
511 if (PageUptodate(page))
512 return page;
513
514 if (dn.data_blkaddr == NEW_ADDR) {
515 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
516 SetPageUptodate(page);
517 } else {
478 if (err)
479 return ERR_PTR(err);
480
481 lock_page(page);
482 if (unlikely(!PageUptodate(page))) {
483 f2fs_put_page(page, 1);
484 return ERR_PTR(-EIO);
485 }

--- 33 unchanged lines hidden (view full) ---

519
520 if (PageUptodate(page))
521 return page;
522
523 if (dn.data_blkaddr == NEW_ADDR) {
524 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
525 SetPageUptodate(page);
526 } else {
518 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,
519 dn.data_blkaddr, READ_SYNC);
527 struct f2fs_io_info fio = {
528 .type = DATA,
529 .rw = READ_SYNC,
530 .blk_addr = dn.data_blkaddr,
531 };
532 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
520 if (err)
521 goto put_err;
522
523 lock_page(page);
524 if (unlikely(!PageUptodate(page))) {
525 f2fs_put_page(page, 1);
526 err = -EIO;
527 goto put_err;

--- 17 unchanged lines hidden (view full) ---

545 return ERR_PTR(err);
546}
547
548static int __allocate_data_block(struct dnode_of_data *dn)
549{
550 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
551 struct f2fs_inode_info *fi = F2FS_I(dn->inode);
552 struct f2fs_summary sum;
533 if (err)
534 goto put_err;
535
536 lock_page(page);
537 if (unlikely(!PageUptodate(page))) {
538 f2fs_put_page(page, 1);
539 err = -EIO;
540 goto put_err;

--- 17 unchanged lines hidden (view full) ---

558 return ERR_PTR(err);
559}
560
561static int __allocate_data_block(struct dnode_of_data *dn)
562{
563 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
564 struct f2fs_inode_info *fi = F2FS_I(dn->inode);
565 struct f2fs_summary sum;
553 block_t new_blkaddr;
554 struct node_info ni;
566 struct node_info ni;
567 int seg = CURSEG_WARM_DATA;
555 pgoff_t fofs;
568 pgoff_t fofs;
556 int type;
557
558 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
559 return -EPERM;
560 if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
561 return -ENOSPC;
562
569
570 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
571 return -EPERM;
572 if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
573 return -ENOSPC;
574
563 __set_data_blkaddr(dn, NEW_ADDR);
564 dn->data_blkaddr = NEW_ADDR;
565
566 get_node_info(sbi, dn->nid, &ni);
567 set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
568
575 get_node_info(sbi, dn->nid, &ni);
576 set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
577
569 type = CURSEG_WARM_DATA;
578 if (dn->ofs_in_node == 0 && dn->inode_page == dn->node_page)
579 seg = CURSEG_DIRECT_IO;
570
580
571 allocate_data_block(sbi, NULL, NULL_ADDR, &new_blkaddr, &sum, type);
581 allocate_data_block(sbi, NULL, NULL_ADDR, &dn->data_blkaddr, &sum, seg);
572
573 /* direct IO doesn't use extent cache to maximize the performance */
582
583 /* direct IO doesn't use extent cache to maximize the performance */
574 set_inode_flag(F2FS_I(dn->inode), FI_NO_EXTENT);
575 update_extent_cache(new_blkaddr, dn);
576 clear_inode_flag(F2FS_I(dn->inode), FI_NO_EXTENT);
584 __set_data_blkaddr(dn);
577
578 /* update i_size */
579 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
580 dn->ofs_in_node;
581 if (i_size_read(dn->inode) < ((fofs + 1) << PAGE_CACHE_SHIFT))
582 i_size_write(dn->inode, ((fofs + 1) << PAGE_CACHE_SHIFT));
583
585
586 /* update i_size */
587 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
588 dn->ofs_in_node;
589 if (i_size_read(dn->inode) < ((fofs + 1) << PAGE_CACHE_SHIFT))
590 i_size_write(dn->inode, ((fofs + 1) << PAGE_CACHE_SHIFT));
591
584 dn->data_blkaddr = new_blkaddr;
585 return 0;
586}
587
588/*
589 * get_data_block() now supported readahead/bmap/rw direct_IO with mapped bh.
590 * If original data blocks are allocated, then give them to blockdev.
591 * Otherwise,
592 * a. preallocate requested block addresses

--- 147 unchanged lines hidden (view full) ---

740 return 0;
741
742 return mpage_readpages(mapping, pages, nr_pages, get_data_block);
743}
744
745int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
746{
747 struct inode *inode = page->mapping->host;
592 return 0;
593}
594
595/*
596 * get_data_block() now supported readahead/bmap/rw direct_IO with mapped bh.
597 * If original data blocks are allocated, then give them to blockdev.
598 * Otherwise,
599 * a. preallocate requested block addresses

--- 147 unchanged lines hidden (view full) ---

747 return 0;
748
749 return mpage_readpages(mapping, pages, nr_pages, get_data_block);
750}
751
752int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
753{
754 struct inode *inode = page->mapping->host;
748 block_t old_blkaddr, new_blkaddr;
749 struct dnode_of_data dn;
750 int err = 0;
751
752 set_new_dnode(&dn, inode, NULL, NULL, 0);
753 err = get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
754 if (err)
755 return err;
756
755 struct dnode_of_data dn;
756 int err = 0;
757
758 set_new_dnode(&dn, inode, NULL, NULL, 0);
759 err = get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
760 if (err)
761 return err;
762
757 old_blkaddr = dn.data_blkaddr;
763 fio->blk_addr = dn.data_blkaddr;
758
759 /* This page is already truncated */
764
765 /* This page is already truncated */
760 if (old_blkaddr == NULL_ADDR)
766 if (fio->blk_addr == NULL_ADDR)
761 goto out_writepage;
762
763 set_page_writeback(page);
764
765 /*
766 * If current allocation needs SSR,
767 * it had better in-place writes for updated data.
768 */
767 goto out_writepage;
768
769 set_page_writeback(page);
770
771 /*
772 * If current allocation needs SSR,
773 * it had better in-place writes for updated data.
774 */
769 if (unlikely(old_blkaddr != NEW_ADDR &&
775 if (unlikely(fio->blk_addr != NEW_ADDR &&
770 !is_cold_data(page) &&
771 need_inplace_update(inode))) {
776 !is_cold_data(page) &&
777 need_inplace_update(inode))) {
772 rewrite_data_page(page, old_blkaddr, fio);
778 rewrite_data_page(page, fio);
773 set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
774 } else {
779 set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
780 } else {
775 write_data_page(page, &dn, &new_blkaddr, fio);
776 update_extent_cache(new_blkaddr, &dn);
781 write_data_page(page, &dn, fio);
782 update_extent_cache(&dn);
777 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
778 }
779out_writepage:
780 f2fs_put_dnode(&dn);
781 return err;
782}
783
784static int f2fs_write_data_page(struct page *page,

--- 22 unchanged lines hidden (view full) ---

807 * this page does not have to be written to disk.
808 */
809 offset = i_size & (PAGE_CACHE_SIZE - 1);
810 if ((page->index >= end_index + 1) || !offset)
811 goto out;
812
813 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
814write:
783 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
784 }
785out_writepage:
786 f2fs_put_dnode(&dn);
787 return err;
788}
789
790static int f2fs_write_data_page(struct page *page,

--- 22 unchanged lines hidden (view full) ---

813 * this page does not have to be written to disk.
814 */
815 offset = i_size & (PAGE_CACHE_SIZE - 1);
816 if ((page->index >= end_index + 1) || !offset)
817 goto out;
818
819 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
820write:
815 if (unlikely(sbi->por_doing))
821 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
816 goto redirty_out;
822 goto redirty_out;
823 if (f2fs_is_drop_cache(inode))
824 goto out;
825 if (f2fs_is_volatile_file(inode) && !wbc->for_reclaim &&
826 available_free_memory(sbi, BASE_CHECK))
827 goto redirty_out;
817
818 /* Dentry blocks are controlled by checkpoint */
819 if (S_ISDIR(inode->i_mode)) {
820 if (unlikely(f2fs_cp_error(sbi)))
821 goto redirty_out;
822 err = do_write_data_page(page, &fio);
823 goto done;
824 }
825
826 /* we should bypass data pages to proceed the kworkder jobs */
827 if (unlikely(f2fs_cp_error(sbi))) {
828 SetPageError(page);
828
829 /* Dentry blocks are controlled by checkpoint */
830 if (S_ISDIR(inode->i_mode)) {
831 if (unlikely(f2fs_cp_error(sbi)))
832 goto redirty_out;
833 err = do_write_data_page(page, &fio);
834 goto done;
835 }
836
837 /* we should bypass data pages to proceed the kworkder jobs */
838 if (unlikely(f2fs_cp_error(sbi))) {
839 SetPageError(page);
829 unlock_page(page);
830 goto out;
831 }
832
833 if (!wbc->for_reclaim)
834 need_balance_fs = true;
835 else if (has_not_enough_free_secs(sbi, 0))
836 goto redirty_out;
837

--- 159 unchanged lines hidden (view full) ---

997 /* Reading beyond i_size is simple: memset to zero */
998 zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);
999 goto out;
1000 }
1001
1002 if (dn.data_blkaddr == NEW_ADDR) {
1003 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
1004 } else {
840 goto out;
841 }
842
843 if (!wbc->for_reclaim)
844 need_balance_fs = true;
845 else if (has_not_enough_free_secs(sbi, 0))
846 goto redirty_out;
847

--- 159 unchanged lines hidden (view full) ---

1007 /* Reading beyond i_size is simple: memset to zero */
1008 zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);
1009 goto out;
1010 }
1011
1012 if (dn.data_blkaddr == NEW_ADDR) {
1013 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
1014 } else {
1005 err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr,
1006 READ_SYNC);
1015 struct f2fs_io_info fio = {
1016 .type = DATA,
1017 .rw = READ_SYNC,
1018 .blk_addr = dn.data_blkaddr,
1019 };
1020 err = f2fs_submit_page_bio(sbi, page, &fio);
1007 if (err)
1008 goto fail;
1009
1010 lock_page(page);
1011 if (unlikely(!PageUptodate(page))) {
1012 f2fs_put_page(page, 1);
1013 err = -EIO;
1014 goto fail;

--- 89 unchanged lines hidden (view full) ---

1104static void f2fs_invalidate_data_page(struct page *page, unsigned int offset,
1105 unsigned int length)
1106{
1107 struct inode *inode = page->mapping->host;
1108
1109 if (offset % PAGE_CACHE_SIZE || length != PAGE_CACHE_SIZE)
1110 return;
1111
1021 if (err)
1022 goto fail;
1023
1024 lock_page(page);
1025 if (unlikely(!PageUptodate(page))) {
1026 f2fs_put_page(page, 1);
1027 err = -EIO;
1028 goto fail;

--- 89 unchanged lines hidden (view full) ---

1118static void f2fs_invalidate_data_page(struct page *page, unsigned int offset,
1119 unsigned int length)
1120{
1121 struct inode *inode = page->mapping->host;
1122
1123 if (offset % PAGE_CACHE_SIZE || length != PAGE_CACHE_SIZE)
1124 return;
1125
1112 if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
1113 invalidate_inmem_page(inode, page);
1114
1115 if (PageDirty(page))
1116 inode_dec_dirty_pages(inode);
1117 ClearPagePrivate(page);
1118}
1119
1120static int f2fs_release_data_page(struct page *page, gfp_t wait)
1121{
1122 ClearPagePrivate(page);

--- 4 unchanged lines hidden (view full) ---

1127{
1128 struct address_space *mapping = page->mapping;
1129 struct inode *inode = mapping->host;
1130
1131 trace_f2fs_set_page_dirty(page, DATA);
1132
1133 SetPageUptodate(page);
1134
1126 if (PageDirty(page))
1127 inode_dec_dirty_pages(inode);
1128 ClearPagePrivate(page);
1129}
1130
1131static int f2fs_release_data_page(struct page *page, gfp_t wait)
1132{
1133 ClearPagePrivate(page);

--- 4 unchanged lines hidden (view full) ---

1138{
1139 struct address_space *mapping = page->mapping;
1140 struct inode *inode = mapping->host;
1141
1142 trace_f2fs_set_page_dirty(page, DATA);
1143
1144 SetPageUptodate(page);
1145
1135 if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode)) {
1146 if (f2fs_is_atomic_file(inode)) {
1136 register_inmem_page(inode, page);
1137 return 1;
1138 }
1139
1140 mark_inode_dirty(inode);
1141
1142 if (!PageDirty(page)) {
1143 __set_page_dirty_nobuffers(page);

--- 32 unchanged lines hidden --- 		1147 register_inmem_page(inode, page);
1148 return 1;
1149 }
1150
1151 mark_inode_dirty(inode);
1152
1153 if (!PageDirty(page)) {
1154 __set_page_dirty_nobuffers(page);

--- 32 unchanged lines hidden ---