2012-11-29 05:28:09 +01:00
|
|
|
/*
|
2012-11-02 09:10:12 +01:00
|
|
|
* fs/f2fs/data.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
|
|
* http://www.samsung.com/
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/f2fs_fs.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/mpage.h>
|
|
|
|
#include <linux/writeback.h>
|
|
|
|
#include <linux/backing-dev.h>
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 12:56:10 +02:00
|
|
|
#include <linux/pagevec.h>
|
2012-11-02 09:10:12 +01:00
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/bio.h>
|
2012-12-19 22:19:30 +01:00
|
|
|
#include <linux/prefetch.h>
|
2015-02-22 17:58:50 +01:00
|
|
|
#include <linux/uio.h>
|
2015-04-09 20:20:42 +02:00
|
|
|
#include <linux/cleancache.h>
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
#include "f2fs.h"
|
|
|
|
#include "node.h"
|
|
|
|
#include "segment.h"
|
2014-12-18 05:04:08 +01:00
|
|
|
#include "trace.h"
|
2013-04-23 09:38:02 +02:00
|
|
|
#include <trace/events/f2fs.h>
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-07-20 15:29:37 +02:00
|
|
|
static void f2fs_read_end_io(struct bio *bio)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
2014-01-30 20:19:05 +01:00
|
|
|
struct bio_vec *bvec;
|
|
|
|
int i;
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2015-04-23 21:04:33 +02:00
|
|
|
if (f2fs_bio_encrypted(bio)) {
|
2015-07-20 15:29:37 +02:00
|
|
|
if (bio->bi_error) {
|
2015-04-23 21:04:33 +02:00
|
|
|
f2fs_release_crypto_ctx(bio->bi_private);
|
|
|
|
} else {
|
|
|
|
f2fs_end_io_crypto_work(bio->bi_private, bio);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-25 12:03:38 +02:00
|
|
|
bio_for_each_segment_all(bvec, bio, i) {
|
|
|
|
struct page *page = bvec->bv_page;
|
2015-04-09 20:20:42 +02:00
|
|
|
|
2015-07-20 15:29:37 +02:00
|
|
|
if (!bio->bi_error) {
|
2015-04-09 20:20:42 +02:00
|
|
|
SetPageUptodate(page);
|
|
|
|
} else {
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
|
2015-07-20 15:29:37 +02:00
|
|
|
static void f2fs_write_end_io(struct bio *bio)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
2014-02-03 02:50:22 +01:00
|
|
|
struct f2fs_sb_info *sbi = bio->bi_private;
|
2014-01-30 20:19:05 +01:00
|
|
|
struct bio_vec *bvec;
|
|
|
|
int i;
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2014-01-30 20:19:05 +01:00
|
|
|
bio_for_each_segment_all(bvec, bio, i) {
|
2013-11-30 04:51:14 +01:00
|
|
|
struct page *page = bvec->bv_page;
|
|
|
|
|
2015-04-23 21:04:33 +02:00
|
|
|
f2fs_restore_and_release_control_page(&page);
|
|
|
|
|
2015-07-20 15:29:37 +02:00
|
|
|
if (unlikely(bio->bi_error)) {
|
2014-08-12 03:37:46 +02:00
|
|
|
set_page_dirty(page);
|
2013-11-30 04:51:14 +01:00
|
|
|
set_bit(AS_EIO, &page->mapping->flags);
|
2014-01-24 01:42:16 +01:00
|
|
|
f2fs_stop_checkpoint(sbi);
|
2013-11-30 04:51:14 +01:00
|
|
|
}
|
|
|
|
end_page_writeback(page);
|
|
|
|
dec_page_count(sbi, F2FS_WRITEBACK);
|
2014-01-30 20:19:05 +01:00
|
|
|
}
|
2013-11-30 04:51:14 +01:00
|
|
|
|
|
|
|
if (!get_pages(sbi, F2FS_WRITEBACK) &&
|
|
|
|
!list_empty(&sbi->cp_wait.task_list))
|
|
|
|
wake_up(&sbi->cp_wait);
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
|
2013-12-20 10:39:59 +01:00
|
|
|
/*
|
|
|
|
* Low-level block read/write IO operations.
|
|
|
|
*/
|
|
|
|
static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
|
|
|
|
int npages, bool is_read)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
|
2015-08-14 20:43:56 +02:00
|
|
|
bio = f2fs_bio_alloc(npages);
|
2013-12-20 10:39:59 +01:00
|
|
|
|
|
|
|
bio->bi_bdev = sbi->sb->s_bdev;
|
2014-09-15 12:01:10 +02:00
|
|
|
bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);
|
2013-12-20 10:39:59 +01:00
|
|
|
bio->bi_end_io = is_read ? f2fs_read_end_io : f2fs_write_end_io;
|
2015-05-25 12:03:38 +02:00
|
|
|
bio->bi_private = is_read ? NULL : sbi;
|
2013-12-20 10:39:59 +01:00
|
|
|
|
|
|
|
return bio;
|
|
|
|
}
|
|
|
|
|
2013-12-11 05:54:01 +01:00
|
|
|
static void __submit_merged_bio(struct f2fs_bio_info *io)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
2013-12-11 05:54:01 +01:00
|
|
|
struct f2fs_io_info *fio = &io->fio;
|
2013-11-30 04:51:14 +01:00
|
|
|
|
|
|
|
if (!io->bio)
|
|
|
|
return;
|
|
|
|
|
2014-10-29 22:37:22 +01:00
|
|
|
if (is_read_io(fio->rw))
|
2014-12-24 09:08:14 +01:00
|
|
|
trace_f2fs_submit_read_bio(io->sbi->sb, fio, io->bio);
|
2014-10-29 22:37:22 +01:00
|
|
|
else
|
2014-12-24 09:08:14 +01:00
|
|
|
trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio);
|
2013-12-20 10:39:59 +01:00
|
|
|
|
2014-10-29 22:37:22 +01:00
|
|
|
submit_bio(fio->rw, io->bio);
|
2013-11-30 04:51:14 +01:00
|
|
|
io->bio = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi,
|
2013-12-11 05:54:01 +01:00
|
|
|
enum page_type type, int rw)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
|
|
|
enum page_type btype = PAGE_TYPE_OF_BIO(type);
|
|
|
|
struct f2fs_bio_info *io;
|
|
|
|
|
|
|
|
io = is_read_io(rw) ? &sbi->read_io : &sbi->write_io[btype];
|
|
|
|
|
2014-03-22 07:57:23 +01:00
|
|
|
down_write(&io->io_rwsem);
|
2013-12-11 05:54:01 +01:00
|
|
|
|
|
|
|
/* change META to META_FLUSH in the checkpoint procedure */
|
|
|
|
if (type >= META_FLUSH) {
|
|
|
|
io->fio.type = META_FLUSH;
|
2014-07-23 18:57:31 +02:00
|
|
|
if (test_opt(sbi, NOBARRIER))
|
|
|
|
io->fio.rw = WRITE_FLUSH | REQ_META | REQ_PRIO;
|
|
|
|
else
|
|
|
|
io->fio.rw = WRITE_FLUSH_FUA | REQ_META | REQ_PRIO;
|
2013-12-11 05:54:01 +01:00
|
|
|
}
|
|
|
|
__submit_merged_bio(io);
|
2014-03-22 07:57:23 +01:00
|
|
|
up_write(&io->io_rwsem);
|
2013-11-30 04:51:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill the locked page with data located in the block address.
|
|
|
|
* Return unlocked page.
|
|
|
|
*/
|
2015-04-23 23:38:15 +02:00
|
|
|
int f2fs_submit_page_bio(struct f2fs_io_info *fio)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
|
|
|
struct bio *bio;
|
2015-04-23 21:04:33 +02:00
|
|
|
struct page *page = fio->encrypted_page ? fio->encrypted_page : fio->page;
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2014-12-24 09:08:14 +01:00
|
|
|
trace_f2fs_submit_page_bio(page, fio);
|
2015-04-23 23:38:15 +02:00
|
|
|
f2fs_trace_ios(fio, 0);
|
2013-11-30 04:51:14 +01:00
|
|
|
|
|
|
|
/* Allocate a new bio */
|
2015-04-23 23:38:15 +02:00
|
|
|
bio = __bio_alloc(fio->sbi, fio->blk_addr, 1, is_read_io(fio->rw));
|
2013-11-30 04:51:14 +01:00
|
|
|
|
|
|
|
if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
|
|
|
|
bio_put(bio);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
submit_bio(fio->rw, bio);
|
2013-11-30 04:51:14 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-04-23 23:38:15 +02:00
|
|
|
void f2fs_submit_page_mbio(struct f2fs_io_info *fio)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
2015-04-23 23:38:15 +02:00
|
|
|
struct f2fs_sb_info *sbi = fio->sbi;
|
2013-12-11 05:54:01 +01:00
|
|
|
enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
|
2013-11-30 04:51:14 +01:00
|
|
|
struct f2fs_bio_info *io;
|
2013-12-20 10:39:59 +01:00
|
|
|
bool is_read = is_read_io(fio->rw);
|
2015-04-23 21:04:33 +02:00
|
|
|
struct page *bio_page;
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2013-12-20 10:39:59 +01:00
|
|
|
io = is_read ? &sbi->read_io : &sbi->write_io[btype];
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
verify_block_addr(sbi, fio->blk_addr);
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2014-03-22 07:57:23 +01:00
|
|
|
down_write(&io->io_rwsem);
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2013-12-20 10:39:59 +01:00
|
|
|
if (!is_read)
|
2013-11-30 04:51:14 +01:00
|
|
|
inc_page_count(sbi, F2FS_WRITEBACK);
|
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
if (io->bio && (io->last_block_in_bio != fio->blk_addr - 1 ||
|
2013-12-11 05:54:01 +01:00
|
|
|
io->fio.rw != fio->rw))
|
|
|
|
__submit_merged_bio(io);
|
2013-11-30 04:51:14 +01:00
|
|
|
alloc_new:
|
|
|
|
if (io->bio == NULL) {
|
2014-09-23 01:21:07 +02:00
|
|
|
int bio_blocks = MAX_BIO_BLOCKS(sbi);
|
2013-12-20 10:39:59 +01:00
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
io->bio = __bio_alloc(sbi, fio->blk_addr, bio_blocks, is_read);
|
2013-12-11 05:54:01 +01:00
|
|
|
io->fio = *fio;
|
2013-11-30 04:51:14 +01:00
|
|
|
}
|
|
|
|
|
2015-04-23 21:04:33 +02:00
|
|
|
bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;
|
|
|
|
|
|
|
|
if (bio_add_page(io->bio, bio_page, PAGE_CACHE_SIZE, 0) <
|
2013-11-30 04:51:14 +01:00
|
|
|
PAGE_CACHE_SIZE) {
|
2013-12-11 05:54:01 +01:00
|
|
|
__submit_merged_bio(io);
|
2013-11-30 04:51:14 +01:00
|
|
|
goto alloc_new;
|
|
|
|
}
|
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
io->last_block_in_bio = fio->blk_addr;
|
2015-04-23 23:38:15 +02:00
|
|
|
f2fs_trace_ios(fio, 0);
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2014-03-22 07:57:23 +01:00
|
|
|
up_write(&io->io_rwsem);
|
2015-04-23 23:38:15 +02:00
|
|
|
trace_f2fs_submit_page_mbio(fio->page, fio);
|
2013-11-30 04:51:14 +01:00
|
|
|
}
|
|
|
|
|
2012-11-29 05:28:09 +01:00
|
|
|
/*
|
2012-11-02 09:10:12 +01:00
|
|
|
* Lock ordering for the change of data block address:
|
|
|
|
* ->data_page
|
|
|
|
* ->node_page
|
|
|
|
* update block addresses in the node page
|
|
|
|
*/
|
2015-03-19 12:23:32 +01:00
|
|
|
void set_data_blkaddr(struct dnode_of_data *dn)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct f2fs_node *rn;
|
|
|
|
__le32 *addr_array;
|
|
|
|
struct page *node_page = dn->node_page;
|
|
|
|
unsigned int ofs_in_node = dn->ofs_in_node;
|
|
|
|
|
2014-01-10 08:26:14 +01:00
|
|
|
f2fs_wait_on_page_writeback(node_page, NODE);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-07-15 11:57:38 +02:00
|
|
|
rn = F2FS_NODE(node_page);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
/* Get physical address of data block */
|
|
|
|
addr_array = blkaddr_in_node(rn);
|
2014-12-31 07:57:55 +01:00
|
|
|
addr_array[ofs_in_node] = cpu_to_le32(dn->data_blkaddr);
|
2016-01-07 22:23:12 +01:00
|
|
|
if (set_page_dirty(node_page))
|
|
|
|
dn->node_changed = true;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int reserve_new_block(struct dnode_of_data *dn)
|
|
|
|
{
|
2014-09-03 00:31:18 +02:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
|
2012-11-02 09:10:12 +01:00
|
|
|
return -EPERM;
|
2013-12-05 10:15:22 +01:00
|
|
|
if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
|
2012-11-02 09:10:12 +01:00
|
|
|
return -ENOSPC;
|
|
|
|
|
2013-04-23 10:00:52 +02:00
|
|
|
trace_f2fs_reserve_new_block(dn->inode, dn->nid, dn->ofs_in_node);
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
dn->data_blkaddr = NEW_ADDR;
|
2015-03-19 12:23:32 +01:00
|
|
|
set_data_blkaddr(dn);
|
2014-01-21 05:32:12 +01:00
|
|
|
mark_inode_dirty(dn->inode);
|
2012-11-02 09:10:12 +01:00
|
|
|
sync_inode_page(dn);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-10 16:13:18 +01:00
|
|
|
int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
|
|
|
|
{
|
|
|
|
bool need_put = dn->inode_page ? false : true;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = get_dnode_of_data(dn, index, ALLOC_NODE);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2013-12-27 09:04:17 +01:00
|
|
|
|
2013-11-10 16:13:18 +01:00
|
|
|
if (dn->data_blkaddr == NULL_ADDR)
|
|
|
|
err = reserve_new_block(dn);
|
2013-12-27 09:04:17 +01:00
|
|
|
if (err || need_put)
|
2013-11-10 16:13:18 +01:00
|
|
|
f2fs_put_dnode(dn);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-08-05 09:52:16 +02:00
|
|
|
int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
2015-03-19 12:26:02 +01:00
|
|
|
struct extent_info ei;
|
2015-08-05 09:52:16 +02:00
|
|
|
struct inode *inode = dn->inode;
|
2015-03-19 12:26:02 +01:00
|
|
|
|
2015-08-05 09:52:16 +02:00
|
|
|
if (f2fs_lookup_extent_cache(inode, index, &ei)) {
|
|
|
|
dn->data_blkaddr = ei.blk + index - ei.fofs;
|
|
|
|
return 0;
|
2015-02-05 10:54:31 +01:00
|
|
|
}
|
2015-03-19 12:26:02 +01:00
|
|
|
|
2015-08-05 09:52:16 +02:00
|
|
|
return f2fs_reserve_block(dn, index);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2015-10-10 00:11:38 +02:00
|
|
|
struct page *get_read_data_page(struct inode *inode, pgoff_t index,
|
|
|
|
int rw, bool for_write)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
struct page *page;
|
2015-02-05 11:03:40 +01:00
|
|
|
struct extent_info ei;
|
2012-11-02 09:10:12 +01:00
|
|
|
int err;
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info fio = {
|
2015-04-23 23:38:15 +02:00
|
|
|
.sbi = F2FS_I_SB(inode),
|
2014-12-18 04:33:13 +01:00
|
|
|
.type = DATA,
|
2015-05-01 02:00:33 +02:00
|
|
|
.rw = rw,
|
2015-04-23 21:04:33 +02:00
|
|
|
.encrypted_page = NULL,
|
2014-12-18 04:33:13 +01:00
|
|
|
};
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-04-23 21:04:33 +02:00
|
|
|
if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
|
|
|
|
return read_mapping_page(mapping, index, NULL);
|
|
|
|
|
2015-10-10 00:11:38 +02:00
|
|
|
page = f2fs_grab_cache_page(mapping, index, for_write);
|
2013-05-13 01:38:35 +02:00
|
|
|
if (!page)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2015-02-05 11:03:40 +01:00
|
|
|
if (f2fs_lookup_extent_cache(inode, index, &ei)) {
|
|
|
|
dn.data_blkaddr = ei.blk + index - ei.fofs;
|
|
|
|
goto got_it;
|
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
2013-02-26 05:10:46 +01:00
|
|
|
err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
|
2015-07-15 22:08:21 +02:00
|
|
|
if (err)
|
|
|
|
goto put_err;
|
2012-11-02 09:10:12 +01:00
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(dn.data_blkaddr == NULL_ADDR)) {
|
2015-07-15 22:08:21 +02:00
|
|
|
err = -ENOENT;
|
|
|
|
goto put_err;
|
2013-05-13 01:38:35 +02:00
|
|
|
}
|
2015-02-05 11:03:40 +01:00
|
|
|
got_it:
|
2015-05-01 02:00:33 +02:00
|
|
|
if (PageUptodate(page)) {
|
|
|
|
unlock_page(page);
|
2012-11-02 09:10:12 +01:00
|
|
|
return page;
|
2015-05-01 02:00:33 +02:00
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-08-20 12:13:07 +02:00
|
|
|
/*
|
|
|
|
* A new dentry page is allocated but not able to be written, since its
|
|
|
|
* new inode page couldn't be allocated due to -ENOSPC.
|
|
|
|
* In such the case, its blkaddr can be remained as NEW_ADDR.
|
|
|
|
* see, f2fs_add_link -> get_new_data_page -> init_inode_metadata.
|
|
|
|
*/
|
|
|
|
if (dn.data_blkaddr == NEW_ADDR) {
|
|
|
|
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
|
|
|
|
SetPageUptodate(page);
|
2015-05-01 02:00:33 +02:00
|
|
|
unlock_page(page);
|
2013-08-20 12:13:07 +02:00
|
|
|
return page;
|
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
fio.blk_addr = dn.data_blkaddr;
|
2015-04-23 23:38:15 +02:00
|
|
|
fio.page = page;
|
|
|
|
err = f2fs_submit_page_bio(&fio);
|
2013-03-08 13:29:23 +01:00
|
|
|
if (err)
|
2015-07-15 22:08:21 +02:00
|
|
|
goto put_err;
|
2015-05-01 02:00:33 +02:00
|
|
|
return page;
|
2015-07-15 22:08:21 +02:00
|
|
|
|
|
|
|
put_err:
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
return ERR_PTR(err);
|
2015-05-01 02:00:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
struct page *find_data_page(struct inode *inode, pgoff_t index)
|
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = find_get_page(mapping, index);
|
|
|
|
if (page && PageUptodate(page))
|
|
|
|
return page;
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
|
2015-10-10 00:11:38 +02:00
|
|
|
page = get_read_data_page(inode, index, READ_SYNC, false);
|
2015-05-01 02:00:33 +02:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return page;
|
|
|
|
|
|
|
|
if (PageUptodate(page))
|
|
|
|
return page;
|
|
|
|
|
|
|
|
wait_on_page_locked(page);
|
|
|
|
if (unlikely(!PageUptodate(page))) {
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
}
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If it tries to access a hole, return an error.
|
|
|
|
* Because, the callers, functions in dir.c and GC, should be able to know
|
|
|
|
* whether this page exists or not.
|
|
|
|
*/
|
2015-10-10 00:11:38 +02:00
|
|
|
struct page *get_lock_data_page(struct inode *inode, pgoff_t index,
|
|
|
|
bool for_write)
|
2015-05-01 02:00:33 +02:00
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct page *page;
|
|
|
|
repeat:
|
2015-10-10 00:11:38 +02:00
|
|
|
page = get_read_data_page(inode, index, READ_SYNC, for_write);
|
2015-05-01 02:00:33 +02:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return page;
|
2013-03-08 13:29:23 +01:00
|
|
|
|
2015-05-01 02:00:33 +02:00
|
|
|
/* wait for read completion */
|
2013-03-08 13:29:23 +01:00
|
|
|
lock_page(page);
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(!PageUptodate(page))) {
|
2013-03-08 13:29:23 +01:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
return ERR_PTR(-EIO);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(page->mapping != mapping)) {
|
2013-04-26 04:55:17 +02:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
goto repeat;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2012-11-29 05:28:09 +01:00
|
|
|
/*
|
2012-11-02 09:10:12 +01:00
|
|
|
* Caller ensures that this data page is never allocated.
|
|
|
|
* A new zero-filled data page is allocated in the page cache.
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
*
|
2013-12-21 11:02:14 +01:00
|
|
|
* Also, caller should grab and release a rwsem by calling f2fs_lock_op() and
|
|
|
|
* f2fs_unlock_op().
|
2015-07-14 12:14:06 +02:00
|
|
|
* Note that, ipage is set only by make_empty_dir, and if any error occur,
|
|
|
|
* ipage should be released by this function.
|
2012-11-02 09:10:12 +01:00
|
|
|
*/
|
2013-05-20 02:55:50 +02:00
|
|
|
struct page *get_new_data_page(struct inode *inode,
|
2013-12-27 09:04:17 +01:00
|
|
|
struct page *ipage, pgoff_t index, bool new_i_size)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct page *page;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
int err;
|
2016-01-02 07:03:47 +01:00
|
|
|
|
2015-10-10 00:11:38 +02:00
|
|
|
page = f2fs_grab_cache_page(mapping, index, true);
|
2015-07-14 12:14:06 +02:00
|
|
|
if (!page) {
|
|
|
|
/*
|
|
|
|
* before exiting, we should make sure ipage will be released
|
|
|
|
* if any error occur.
|
|
|
|
*/
|
|
|
|
f2fs_put_page(ipage, 1);
|
2015-04-29 20:18:42 +02:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2015-07-14 12:14:06 +02:00
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-12-27 09:04:17 +01:00
|
|
|
set_new_dnode(&dn, inode, ipage, NULL, 0);
|
2013-11-10 16:13:18 +01:00
|
|
|
err = f2fs_reserve_block(&dn, index);
|
2015-04-29 20:18:42 +02:00
|
|
|
if (err) {
|
|
|
|
f2fs_put_page(page, 1);
|
2012-11-02 09:10:12 +01:00
|
|
|
return ERR_PTR(err);
|
2013-12-27 09:04:17 +01:00
|
|
|
}
|
2015-04-29 20:18:42 +02:00
|
|
|
if (!ipage)
|
|
|
|
f2fs_put_dnode(&dn);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
if (PageUptodate(page))
|
2015-04-29 20:18:42 +02:00
|
|
|
goto got_it;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
if (dn.data_blkaddr == NEW_ADDR) {
|
|
|
|
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
|
2013-03-08 13:29:23 +01:00
|
|
|
SetPageUptodate(page);
|
2012-11-02 09:10:12 +01:00
|
|
|
} else {
|
2015-04-23 21:04:33 +02:00
|
|
|
f2fs_put_page(page, 1);
|
2013-12-27 09:04:17 +01:00
|
|
|
|
2016-01-02 07:03:47 +01:00
|
|
|
/* if ipage exists, blkaddr should be NEW_ADDR */
|
|
|
|
f2fs_bug_on(F2FS_I_SB(inode), ipage);
|
|
|
|
page = get_lock_data_page(inode, index, true);
|
2015-04-23 21:04:33 +02:00
|
|
|
if (IS_ERR(page))
|
2016-01-02 07:03:47 +01:00
|
|
|
return page;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
2015-04-29 20:18:42 +02:00
|
|
|
got_it:
|
2015-09-11 08:43:52 +02:00
|
|
|
if (new_i_size && i_size_read(inode) <
|
|
|
|
((loff_t)(index + 1) << PAGE_CACHE_SHIFT)) {
|
|
|
|
i_size_write(inode, ((loff_t)(index + 1) << PAGE_CACHE_SHIFT));
|
2013-06-07 15:08:23 +02:00
|
|
|
/* Only the directory inode sets new_i_size */
|
|
|
|
set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
static int __allocate_data_block(struct dnode_of_data *dn)
|
|
|
|
{
|
2014-09-03 00:31:18 +02:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
|
2014-09-16 04:32:16 +02:00
|
|
|
struct f2fs_inode_info *fi = F2FS_I(dn->inode);
|
2013-12-16 11:04:05 +01:00
|
|
|
struct f2fs_summary sum;
|
|
|
|
struct node_info ni;
|
2015-01-06 01:02:20 +01:00
|
|
|
int seg = CURSEG_WARM_DATA;
|
2014-09-16 04:32:16 +02:00
|
|
|
pgoff_t fofs;
|
2013-12-16 11:04:05 +01:00
|
|
|
|
|
|
|
if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
|
|
|
|
return -EPERM;
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 03:33:37 +01:00
|
|
|
|
|
|
|
dn->data_blkaddr = datablock_addr(dn->node_page, dn->ofs_in_node);
|
|
|
|
if (dn->data_blkaddr == NEW_ADDR)
|
|
|
|
goto alloc;
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
|
|
|
|
return -ENOSPC;
|
|
|
|
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 03:33:37 +01:00
|
|
|
alloc:
|
2013-12-16 11:04:05 +01:00
|
|
|
get_node_info(sbi, dn->nid, &ni);
|
|
|
|
set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
|
|
|
|
|
2015-01-06 01:02:20 +01:00
|
|
|
if (dn->ofs_in_node == 0 && dn->inode_page == dn->node_page)
|
|
|
|
seg = CURSEG_DIRECT_IO;
|
|
|
|
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 03:33:37 +01:00
|
|
|
allocate_data_block(sbi, NULL, dn->data_blkaddr, &dn->data_blkaddr,
|
|
|
|
&sum, seg);
|
2015-03-19 12:23:32 +01:00
|
|
|
set_data_blkaddr(dn);
|
2013-12-16 11:04:05 +01:00
|
|
|
|
2014-09-16 04:32:16 +02:00
|
|
|
/* update i_size */
|
|
|
|
fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
|
|
|
|
dn->ofs_in_node;
|
2015-09-11 08:43:52 +02:00
|
|
|
if (i_size_read(dn->inode) < ((loff_t)(fofs + 1) << PAGE_CACHE_SHIFT))
|
|
|
|
i_size_write(dn->inode,
|
|
|
|
((loff_t)(fofs + 1) << PAGE_CACHE_SHIFT));
|
2013-12-16 11:04:05 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-12-24 11:04:56 +01:00
|
|
|
static int __allocate_data_blocks(struct inode *inode, loff_t offset,
|
2015-02-09 21:09:53 +01:00
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
u64 start = F2FS_BYTES_TO_BLK(offset);
|
|
|
|
u64 len = F2FS_BYTES_TO_BLK(count);
|
|
|
|
bool allocated;
|
|
|
|
u64 end_offset;
|
2015-12-24 11:04:56 +01:00
|
|
|
int err = 0;
|
2015-02-09 21:09:53 +01:00
|
|
|
|
|
|
|
while (len) {
|
|
|
|
f2fs_lock_op(sbi);
|
|
|
|
|
|
|
|
/* When reading holes, we need its node page */
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
2015-12-24 11:04:56 +01:00
|
|
|
err = get_dnode_of_data(&dn, start, ALLOC_NODE);
|
|
|
|
if (err)
|
2015-02-09 21:09:53 +01:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
allocated = false;
|
|
|
|
end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
|
|
|
|
|
|
|
|
while (dn.ofs_in_node < end_offset && len) {
|
2015-03-12 10:04:24 +01:00
|
|
|
block_t blkaddr;
|
|
|
|
|
2015-12-24 11:04:56 +01:00
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
err = -EIO;
|
2015-09-21 14:17:52 +02:00
|
|
|
goto sync_out;
|
2015-12-24 11:04:56 +01:00
|
|
|
}
|
2015-09-21 14:17:52 +02:00
|
|
|
|
2015-03-12 10:04:24 +01:00
|
|
|
blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 03:33:37 +01:00
|
|
|
if (blkaddr == NULL_ADDR || blkaddr == NEW_ADDR) {
|
2015-12-24 11:04:56 +01:00
|
|
|
err = __allocate_data_block(&dn);
|
|
|
|
if (err)
|
2015-02-09 21:09:53 +01:00
|
|
|
goto sync_out;
|
|
|
|
allocated = true;
|
|
|
|
}
|
|
|
|
len--;
|
|
|
|
start++;
|
|
|
|
dn.ofs_in_node++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (allocated)
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
f2fs_unlock_op(sbi);
|
2015-12-22 22:23:35 +01:00
|
|
|
|
2016-01-07 23:15:04 +01:00
|
|
|
f2fs_balance_fs(sbi, dn.node_changed);
|
2015-02-09 21:09:53 +01:00
|
|
|
}
|
2015-12-24 11:04:56 +01:00
|
|
|
return err;
|
2015-02-09 21:09:53 +01:00
|
|
|
|
|
|
|
sync_out:
|
|
|
|
if (allocated)
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
out:
|
|
|
|
f2fs_unlock_op(sbi);
|
2016-01-07 23:15:04 +01:00
|
|
|
f2fs_balance_fs(sbi, dn.node_changed);
|
2015-12-24 11:04:56 +01:00
|
|
|
return err;
|
2015-02-09 21:09:53 +01:00
|
|
|
}
|
|
|
|
|
2012-11-29 05:28:09 +01:00
|
|
|
/*
|
2015-04-07 04:55:34 +02:00
|
|
|
* f2fs_map_blocks() now supported readahead/bmap/rw direct_IO with
|
|
|
|
* f2fs_map_blocks structure.
|
2013-12-21 11:02:14 +01:00
|
|
|
* If original data blocks are allocated, then give them to blockdev.
|
|
|
|
* Otherwise,
|
|
|
|
* a. preallocate requested block addresses
|
|
|
|
* b. do not use extent cache for better performance
|
|
|
|
* c. give the block addresses to blockdev
|
2012-11-02 09:10:12 +01:00
|
|
|
*/
|
2015-10-27 02:53:45 +01:00
|
|
|
int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
|
2015-08-19 13:11:19 +02:00
|
|
|
int create, int flag)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
2015-04-07 04:55:34 +02:00
|
|
|
unsigned int maxblocks = map->m_len;
|
2012-11-02 09:10:12 +01:00
|
|
|
struct dnode_of_data dn;
|
2015-09-21 14:17:52 +02:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2013-12-16 11:04:05 +01:00
|
|
|
int mode = create ? ALLOC_NODE : LOOKUP_NODE_RA;
|
|
|
|
pgoff_t pgofs, end_offset;
|
|
|
|
int err = 0, ofs = 1;
|
2015-02-05 10:50:30 +01:00
|
|
|
struct extent_info ei;
|
2013-12-16 11:04:05 +01:00
|
|
|
bool allocated = false;
|
2015-12-17 06:20:59 +01:00
|
|
|
block_t blkaddr;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-04-07 04:55:34 +02:00
|
|
|
map->m_len = 0;
|
|
|
|
map->m_flags = 0;
|
|
|
|
|
|
|
|
/* it only supports block size == page size */
|
|
|
|
pgofs = (pgoff_t)map->m_lblk;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-02-05 10:51:34 +01:00
|
|
|
if (f2fs_lookup_extent_cache(inode, pgofs, &ei)) {
|
2015-04-07 04:55:34 +02:00
|
|
|
map->m_pblk = ei.blk + pgofs - ei.fofs;
|
|
|
|
map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
|
|
|
|
map->m_flags = F2FS_MAP_MAPPED;
|
2013-12-16 11:04:05 +01:00
|
|
|
goto out;
|
2015-02-05 10:50:30 +01:00
|
|
|
}
|
2013-12-16 11:04:05 +01:00
|
|
|
|
2015-02-09 21:09:53 +01:00
|
|
|
if (create)
|
2015-12-23 10:11:43 +01:00
|
|
|
f2fs_lock_op(sbi);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
/* When reading holes, we need its node page */
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
2013-12-16 11:04:05 +01:00
|
|
|
err = get_dnode_of_data(&dn, pgofs, mode);
|
2013-12-26 08:55:22 +01:00
|
|
|
if (err) {
|
2013-12-16 11:04:05 +01:00
|
|
|
if (err == -ENOENT)
|
|
|
|
err = 0;
|
|
|
|
goto unlock_out;
|
2013-04-23 09:38:02 +02:00
|
|
|
}
|
2015-09-18 10:51:51 +02:00
|
|
|
|
|
|
|
if (dn.data_blkaddr == NEW_ADDR || dn.data_blkaddr == NULL_ADDR) {
|
|
|
|
if (create) {
|
2015-09-21 14:17:52 +02:00
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
err = -EIO;
|
|
|
|
goto put_out;
|
|
|
|
}
|
2015-09-18 10:51:51 +02:00
|
|
|
err = __allocate_data_block(&dn);
|
|
|
|
if (err)
|
|
|
|
goto put_out;
|
|
|
|
allocated = true;
|
|
|
|
map->m_flags = F2FS_MAP_NEW;
|
|
|
|
} else {
|
|
|
|
if (flag != F2FS_GET_BLOCK_FIEMAP ||
|
|
|
|
dn.data_blkaddr != NEW_ADDR) {
|
|
|
|
if (flag == F2FS_GET_BLOCK_BMAP)
|
|
|
|
err = -ENOENT;
|
|
|
|
goto put_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* preallocated unwritten block should be mapped
|
|
|
|
* for fiemap.
|
|
|
|
*/
|
|
|
|
if (dn.data_blkaddr == NEW_ADDR)
|
|
|
|
map->m_flags = F2FS_MAP_UNWRITTEN;
|
2015-08-19 13:11:19 +02:00
|
|
|
}
|
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-09-18 10:51:51 +02:00
|
|
|
map->m_flags |= F2FS_MAP_MAPPED;
|
|
|
|
map->m_pblk = dn.data_blkaddr;
|
|
|
|
map->m_len = 1;
|
2013-12-16 11:04:05 +01:00
|
|
|
|
2014-04-26 13:59:52 +02:00
|
|
|
end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
|
2013-12-16 11:04:05 +01:00
|
|
|
dn.ofs_in_node++;
|
|
|
|
pgofs++;
|
|
|
|
|
|
|
|
get_next:
|
2015-12-17 06:20:59 +01:00
|
|
|
if (map->m_len >= maxblocks)
|
|
|
|
goto sync_out;
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
if (dn.ofs_in_node >= end_offset) {
|
|
|
|
if (allocated)
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
allocated = false;
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
2015-12-23 10:11:43 +01:00
|
|
|
if (create) {
|
|
|
|
f2fs_unlock_op(sbi);
|
2016-01-07 23:15:04 +01:00
|
|
|
f2fs_balance_fs(sbi, dn.node_changed);
|
2015-12-23 10:11:43 +01:00
|
|
|
f2fs_lock_op(sbi);
|
|
|
|
}
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
|
|
|
err = get_dnode_of_data(&dn, pgofs, mode);
|
2013-12-26 08:55:22 +01:00
|
|
|
if (err) {
|
2013-12-16 11:04:05 +01:00
|
|
|
if (err == -ENOENT)
|
|
|
|
err = 0;
|
|
|
|
goto unlock_out;
|
|
|
|
}
|
2015-08-19 13:11:19 +02:00
|
|
|
|
2014-04-26 13:59:52 +02:00
|
|
|
end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
|
2013-12-16 11:04:05 +01:00
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-12-17 06:20:59 +01:00
|
|
|
blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
|
2015-09-18 10:51:51 +02:00
|
|
|
|
2015-12-17 06:20:59 +01:00
|
|
|
if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR) {
|
|
|
|
if (create) {
|
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
err = -EIO;
|
|
|
|
goto sync_out;
|
2015-09-18 10:51:51 +02:00
|
|
|
}
|
2015-12-17 06:20:59 +01:00
|
|
|
err = __allocate_data_block(&dn);
|
|
|
|
if (err)
|
|
|
|
goto sync_out;
|
|
|
|
allocated = true;
|
|
|
|
map->m_flags |= F2FS_MAP_NEW;
|
|
|
|
blkaddr = dn.data_blkaddr;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* we only merge preallocated unwritten blocks
|
|
|
|
* for fiemap.
|
|
|
|
*/
|
|
|
|
if (flag != F2FS_GET_BLOCK_FIEMAP ||
|
|
|
|
blkaddr != NEW_ADDR)
|
|
|
|
goto sync_out;
|
2013-12-16 11:04:05 +01:00
|
|
|
}
|
2015-12-17 06:20:59 +01:00
|
|
|
}
|
2015-09-18 10:51:51 +02:00
|
|
|
|
2015-12-17 06:20:59 +01:00
|
|
|
/* Give more consecutive addresses for the readahead */
|
|
|
|
if ((map->m_pblk != NEW_ADDR &&
|
|
|
|
blkaddr == (map->m_pblk + ofs)) ||
|
|
|
|
(map->m_pblk == NEW_ADDR &&
|
|
|
|
blkaddr == NEW_ADDR)) {
|
|
|
|
ofs++;
|
|
|
|
dn.ofs_in_node++;
|
|
|
|
pgofs++;
|
|
|
|
map->m_len++;
|
|
|
|
goto get_next;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
2015-12-17 06:20:59 +01:00
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
sync_out:
|
|
|
|
if (allocated)
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
put_out:
|
2012-11-02 09:10:12 +01:00
|
|
|
f2fs_put_dnode(&dn);
|
2013-12-16 11:04:05 +01:00
|
|
|
unlock_out:
|
2015-12-22 22:23:35 +01:00
|
|
|
if (create) {
|
2015-12-23 10:11:43 +01:00
|
|
|
f2fs_unlock_op(sbi);
|
2016-01-07 23:15:04 +01:00
|
|
|
f2fs_balance_fs(sbi, dn.node_changed);
|
2015-12-22 22:23:35 +01:00
|
|
|
}
|
2013-12-16 11:04:05 +01:00
|
|
|
out:
|
2015-04-07 04:55:34 +02:00
|
|
|
trace_f2fs_map_blocks(inode, map, err);
|
2013-12-16 11:04:05 +01:00
|
|
|
return err;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2015-04-07 04:55:34 +02:00
|
|
|
static int __get_data_block(struct inode *inode, sector_t iblock,
|
2015-08-19 13:11:19 +02:00
|
|
|
struct buffer_head *bh, int create, int flag)
|
2015-04-07 04:55:34 +02:00
|
|
|
{
|
|
|
|
struct f2fs_map_blocks map;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
map.m_lblk = iblock;
|
|
|
|
map.m_len = bh->b_size >> inode->i_blkbits;
|
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
ret = f2fs_map_blocks(inode, &map, create, flag);
|
2015-04-07 04:55:34 +02:00
|
|
|
if (!ret) {
|
|
|
|
map_bh(bh, inode->i_sb, map.m_pblk);
|
|
|
|
bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS) | map.m_flags;
|
|
|
|
bh->b_size = map.m_len << inode->i_blkbits;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-13 06:02:11 +02:00
|
|
|
static int get_data_block(struct inode *inode, sector_t iblock,
|
2015-08-19 13:11:19 +02:00
|
|
|
struct buffer_head *bh_result, int create, int flag)
|
|
|
|
{
|
|
|
|
return __get_data_block(inode, iblock, bh_result, create, flag);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_data_block_dio(struct inode *inode, sector_t iblock,
|
2014-06-13 06:02:11 +02:00
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
{
|
2015-08-19 13:11:19 +02:00
|
|
|
return __get_data_block(inode, iblock, bh_result, create,
|
|
|
|
F2FS_GET_BLOCK_DIO);
|
2014-06-13 06:02:11 +02:00
|
|
|
}
|
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
static int get_data_block_bmap(struct inode *inode, sector_t iblock,
|
2014-06-13 06:02:11 +02:00
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
{
|
2015-12-28 14:48:32 +01:00
|
|
|
/* Block number less than F2FS MAX BLOCKS */
|
2015-12-31 07:35:37 +01:00
|
|
|
if (unlikely(iblock >= F2FS_I_SB(inode)->max_file_blocks))
|
2015-12-28 14:48:32 +01:00
|
|
|
return -EFBIG;
|
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
return __get_data_block(inode, iblock, bh_result, create,
|
|
|
|
F2FS_GET_BLOCK_BMAP);
|
2014-06-13 06:02:11 +02:00
|
|
|
}
|
|
|
|
|
2015-05-09 04:30:32 +02:00
|
|
|
static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
|
|
|
|
{
|
|
|
|
return (offset >> inode->i_blkbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline loff_t blk_to_logical(struct inode *inode, sector_t blk)
|
|
|
|
{
|
|
|
|
return (blk << inode->i_blkbits);
|
|
|
|
}
|
|
|
|
|
2014-06-07 21:30:14 +02:00
|
|
|
int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
|
|
|
|
u64 start, u64 len)
|
|
|
|
{
|
2015-05-09 04:30:32 +02:00
|
|
|
struct buffer_head map_bh;
|
|
|
|
sector_t start_blk, last_blk;
|
2016-01-04 08:56:50 +01:00
|
|
|
loff_t isize;
|
2015-05-09 04:30:32 +02:00
|
|
|
u64 logical = 0, phys = 0, size = 0;
|
|
|
|
u32 flags = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2015-10-15 20:34:49 +02:00
|
|
|
if (f2fs_has_inline_data(inode)) {
|
|
|
|
ret = f2fs_inline_data_fiemap(inode, fieinfo, start, len);
|
|
|
|
if (ret != -EAGAIN)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-22 21:40:57 +01:00
|
|
|
inode_lock(inode);
|
2016-01-04 08:56:50 +01:00
|
|
|
|
|
|
|
isize = i_size_read(inode);
|
2015-12-26 11:07:41 +01:00
|
|
|
if (start >= isize)
|
|
|
|
goto out;
|
2015-05-09 04:30:32 +02:00
|
|
|
|
2015-12-26 11:07:41 +01:00
|
|
|
if (start + len > isize)
|
|
|
|
len = isize - start;
|
2015-05-09 04:30:32 +02:00
|
|
|
|
|
|
|
if (logical_to_blk(inode, len) == 0)
|
|
|
|
len = blk_to_logical(inode, 1);
|
|
|
|
|
|
|
|
start_blk = logical_to_blk(inode, start);
|
|
|
|
last_blk = logical_to_blk(inode, start + len - 1);
|
2015-12-26 11:07:41 +01:00
|
|
|
|
2015-05-09 04:30:32 +02:00
|
|
|
next:
|
|
|
|
memset(&map_bh, 0, sizeof(struct buffer_head));
|
|
|
|
map_bh.b_size = len;
|
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
ret = get_data_block(inode, start_blk, &map_bh, 0,
|
|
|
|
F2FS_GET_BLOCK_FIEMAP);
|
2015-05-09 04:30:32 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* HOLE */
|
|
|
|
if (!buffer_mapped(&map_bh)) {
|
2015-12-26 11:07:41 +01:00
|
|
|
/* Go through holes util pass the EOF */
|
|
|
|
if (blk_to_logical(inode, start_blk++) < isize)
|
|
|
|
goto prep_next;
|
|
|
|
/* Found a hole beyond isize means no more extents.
|
|
|
|
* Note that the premise is that filesystems don't
|
|
|
|
* punch holes beyond isize and keep size unchanged.
|
|
|
|
*/
|
|
|
|
flags |= FIEMAP_EXTENT_LAST;
|
|
|
|
}
|
2015-05-09 04:30:32 +02:00
|
|
|
|
2016-01-08 13:19:27 +01:00
|
|
|
if (size) {
|
|
|
|
if (f2fs_encrypted_inode(inode))
|
|
|
|
flags |= FIEMAP_EXTENT_DATA_ENCRYPTED;
|
|
|
|
|
2015-12-26 11:07:41 +01:00
|
|
|
ret = fiemap_fill_next_extent(fieinfo, logical,
|
|
|
|
phys, size, flags);
|
2016-01-08 13:19:27 +01:00
|
|
|
}
|
2015-05-09 04:30:32 +02:00
|
|
|
|
2015-12-26 11:07:41 +01:00
|
|
|
if (start_blk > last_blk || ret)
|
|
|
|
goto out;
|
2015-05-09 04:30:32 +02:00
|
|
|
|
2015-12-26 11:07:41 +01:00
|
|
|
logical = blk_to_logical(inode, start_blk);
|
|
|
|
phys = blk_to_logical(inode, map_bh.b_blocknr);
|
|
|
|
size = map_bh.b_size;
|
|
|
|
flags = 0;
|
|
|
|
if (buffer_unwritten(&map_bh))
|
|
|
|
flags = FIEMAP_EXTENT_UNWRITTEN;
|
2015-05-09 04:30:32 +02:00
|
|
|
|
2015-12-26 11:07:41 +01:00
|
|
|
start_blk += logical_to_blk(inode, size);
|
2015-05-09 04:30:32 +02:00
|
|
|
|
2015-12-26 11:07:41 +01:00
|
|
|
prep_next:
|
2015-05-09 04:30:32 +02:00
|
|
|
cond_resched();
|
|
|
|
if (fatal_signal_pending(current))
|
|
|
|
ret = -EINTR;
|
|
|
|
else
|
|
|
|
goto next;
|
|
|
|
out:
|
|
|
|
if (ret == 1)
|
|
|
|
ret = 0;
|
|
|
|
|
2016-01-22 21:40:57 +01:00
|
|
|
inode_unlock(inode);
|
2015-05-09 04:30:32 +02:00
|
|
|
return ret;
|
2014-06-07 21:30:14 +02:00
|
|
|
}
|
|
|
|
|
2015-04-09 20:20:42 +02:00
|
|
|
/*
|
|
|
|
* This function was originally taken from fs/mpage.c, and customized for f2fs.
|
|
|
|
* Major change was from block_size == page_size in f2fs by default.
|
|
|
|
*/
|
|
|
|
static int f2fs_mpage_readpages(struct address_space *mapping,
|
|
|
|
struct list_head *pages, struct page *page,
|
|
|
|
unsigned nr_pages)
|
|
|
|
{
|
|
|
|
struct bio *bio = NULL;
|
|
|
|
unsigned page_idx;
|
|
|
|
sector_t last_block_in_bio = 0;
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
const unsigned blkbits = inode->i_blkbits;
|
|
|
|
const unsigned blocksize = 1 << blkbits;
|
|
|
|
sector_t block_in_file;
|
|
|
|
sector_t last_block;
|
|
|
|
sector_t last_block_in_file;
|
|
|
|
sector_t block_nr;
|
|
|
|
struct block_device *bdev = inode->i_sb->s_bdev;
|
|
|
|
struct f2fs_map_blocks map;
|
|
|
|
|
|
|
|
map.m_pblk = 0;
|
|
|
|
map.m_lblk = 0;
|
|
|
|
map.m_len = 0;
|
|
|
|
map.m_flags = 0;
|
|
|
|
|
|
|
|
for (page_idx = 0; nr_pages; page_idx++, nr_pages--) {
|
|
|
|
|
|
|
|
prefetchw(&page->flags);
|
|
|
|
if (pages) {
|
|
|
|
page = list_entry(pages->prev, struct page, lru);
|
|
|
|
list_del(&page->lru);
|
|
|
|
if (add_to_page_cache_lru(page, mapping,
|
|
|
|
page->index, GFP_KERNEL))
|
|
|
|
goto next_page;
|
|
|
|
}
|
|
|
|
|
|
|
|
block_in_file = (sector_t)page->index;
|
|
|
|
last_block = block_in_file + nr_pages;
|
|
|
|
last_block_in_file = (i_size_read(inode) + blocksize - 1) >>
|
|
|
|
blkbits;
|
|
|
|
if (last_block > last_block_in_file)
|
|
|
|
last_block = last_block_in_file;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map blocks using the previous result first.
|
|
|
|
*/
|
|
|
|
if ((map.m_flags & F2FS_MAP_MAPPED) &&
|
|
|
|
block_in_file > map.m_lblk &&
|
|
|
|
block_in_file < (map.m_lblk + map.m_len))
|
|
|
|
goto got_it;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Then do more f2fs_map_blocks() calls until we are
|
|
|
|
* done with this page.
|
|
|
|
*/
|
|
|
|
map.m_flags = 0;
|
|
|
|
|
|
|
|
if (block_in_file < last_block) {
|
|
|
|
map.m_lblk = block_in_file;
|
|
|
|
map.m_len = last_block - block_in_file;
|
|
|
|
|
2015-09-18 10:54:16 +02:00
|
|
|
if (f2fs_map_blocks(inode, &map, 0,
|
|
|
|
F2FS_GET_BLOCK_READ))
|
2015-04-09 20:20:42 +02:00
|
|
|
goto set_error_page;
|
|
|
|
}
|
|
|
|
got_it:
|
|
|
|
if ((map.m_flags & F2FS_MAP_MAPPED)) {
|
|
|
|
block_nr = map.m_pblk + block_in_file - map.m_lblk;
|
|
|
|
SetPageMappedToDisk(page);
|
|
|
|
|
|
|
|
if (!PageUptodate(page) && !cleancache_get_page(page)) {
|
|
|
|
SetPageUptodate(page);
|
|
|
|
goto confused;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
unlock_page(page);
|
|
|
|
goto next_page;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This page will go to BIO. Do we need to send this
|
|
|
|
* BIO off first?
|
|
|
|
*/
|
|
|
|
if (bio && (last_block_in_bio != block_nr - 1)) {
|
|
|
|
submit_and_realloc:
|
|
|
|
submit_bio(READ, bio);
|
|
|
|
bio = NULL;
|
|
|
|
}
|
|
|
|
if (bio == NULL) {
|
2015-04-23 21:04:33 +02:00
|
|
|
struct f2fs_crypto_ctx *ctx = NULL;
|
|
|
|
|
|
|
|
if (f2fs_encrypted_inode(inode) &&
|
|
|
|
S_ISREG(inode->i_mode)) {
|
|
|
|
|
|
|
|
ctx = f2fs_get_crypto_ctx(inode);
|
|
|
|
if (IS_ERR(ctx))
|
|
|
|
goto set_error_page;
|
|
|
|
|
|
|
|
/* wait the page to be moved by cleaning */
|
2015-10-08 07:27:34 +02:00
|
|
|
f2fs_wait_on_encrypted_page_writeback(
|
|
|
|
F2FS_I_SB(inode), block_nr);
|
2015-04-23 21:04:33 +02:00
|
|
|
}
|
|
|
|
|
2015-04-09 20:20:42 +02:00
|
|
|
bio = bio_alloc(GFP_KERNEL,
|
2015-05-19 14:31:01 +02:00
|
|
|
min_t(int, nr_pages, BIO_MAX_PAGES));
|
2015-04-23 21:04:33 +02:00
|
|
|
if (!bio) {
|
|
|
|
if (ctx)
|
|
|
|
f2fs_release_crypto_ctx(ctx);
|
2015-04-09 20:20:42 +02:00
|
|
|
goto set_error_page;
|
2015-04-23 21:04:33 +02:00
|
|
|
}
|
2015-04-09 20:20:42 +02:00
|
|
|
bio->bi_bdev = bdev;
|
|
|
|
bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(block_nr);
|
2015-05-25 12:03:38 +02:00
|
|
|
bio->bi_end_io = f2fs_read_end_io;
|
2015-04-23 21:04:33 +02:00
|
|
|
bio->bi_private = ctx;
|
2015-04-09 20:20:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bio_add_page(bio, page, blocksize, 0) < blocksize)
|
|
|
|
goto submit_and_realloc;
|
|
|
|
|
|
|
|
last_block_in_bio = block_nr;
|
|
|
|
goto next_page;
|
|
|
|
set_error_page:
|
|
|
|
SetPageError(page);
|
|
|
|
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
|
|
|
|
unlock_page(page);
|
|
|
|
goto next_page;
|
|
|
|
confused:
|
|
|
|
if (bio) {
|
|
|
|
submit_bio(READ, bio);
|
|
|
|
bio = NULL;
|
|
|
|
}
|
|
|
|
unlock_page(page);
|
|
|
|
next_page:
|
|
|
|
if (pages)
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
BUG_ON(pages && !list_empty(pages));
|
|
|
|
if (bio)
|
|
|
|
submit_bio(READ, bio);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
static int f2fs_read_data_page(struct file *file, struct page *page)
|
|
|
|
{
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
struct inode *inode = page->mapping->host;
|
2014-10-24 04:48:09 +02:00
|
|
|
int ret = -EAGAIN;
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
|
2014-05-06 10:53:08 +02:00
|
|
|
trace_f2fs_readpage(page, DATA);
|
|
|
|
|
2014-08-06 16:22:50 +02:00
|
|
|
/* If the file has inline data, try to read it directly */
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
ret = f2fs_read_inline_data(inode, page);
|
2014-10-24 04:48:09 +02:00
|
|
|
if (ret == -EAGAIN)
|
2015-04-09 20:20:42 +02:00
|
|
|
ret = f2fs_mpage_readpages(page->mapping, NULL, page, 1);
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
return ret;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_read_data_pages(struct file *file,
|
|
|
|
struct address_space *mapping,
|
|
|
|
struct list_head *pages, unsigned nr_pages)
|
|
|
|
{
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
2015-10-12 11:02:26 +02:00
|
|
|
struct page *page = list_entry(pages->prev, struct page, lru);
|
|
|
|
|
|
|
|
trace_f2fs_readpages(inode, page, nr_pages);
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
|
|
|
|
/* If the file has inline data, skip readpages */
|
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
return 0;
|
|
|
|
|
2015-04-09 20:20:42 +02:00
|
|
|
return f2fs_mpage_readpages(mapping, pages, NULL, nr_pages);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2015-04-23 23:38:15 +02:00
|
|
|
int do_write_data_page(struct f2fs_io_info *fio)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
2015-04-23 23:38:15 +02:00
|
|
|
struct page *page = fio->page;
|
2012-11-02 09:10:12 +01:00
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
2013-02-26 05:10:46 +01:00
|
|
|
err = get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
|
2012-11-02 09:10:12 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
fio->blk_addr = dn.data_blkaddr;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
/* This page is already truncated */
|
2015-02-26 04:25:01 +01:00
|
|
|
if (fio->blk_addr == NULL_ADDR) {
|
|
|
|
ClearPageUptodate(page);
|
2012-11-02 09:10:12 +01:00
|
|
|
goto out_writepage;
|
2015-02-26 04:25:01 +01:00
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-04-23 21:04:33 +02:00
|
|
|
if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {
|
2015-10-08 07:27:34 +02:00
|
|
|
|
|
|
|
/* wait for GCed encrypted page writeback */
|
|
|
|
f2fs_wait_on_encrypted_page_writeback(F2FS_I_SB(inode),
|
|
|
|
fio->blk_addr);
|
|
|
|
|
2015-04-23 21:04:33 +02:00
|
|
|
fio->encrypted_page = f2fs_encrypt(inode, fio->page);
|
|
|
|
if (IS_ERR(fio->encrypted_page)) {
|
|
|
|
err = PTR_ERR(fio->encrypted_page);
|
|
|
|
goto out_writepage;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
set_page_writeback(page);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If current allocation needs SSR,
|
|
|
|
* it had better in-place writes for updated data.
|
|
|
|
*/
|
2014-12-18 04:33:13 +01:00
|
|
|
if (unlikely(fio->blk_addr != NEW_ADDR &&
|
2013-06-13 10:59:29 +02:00
|
|
|
!is_cold_data(page) &&
|
2015-10-28 10:56:14 +01:00
|
|
|
!IS_ATOMIC_WRITTEN_PAGE(page) &&
|
2013-06-13 10:59:29 +02:00
|
|
|
need_inplace_update(inode))) {
|
2015-04-23 23:38:15 +02:00
|
|
|
rewrite_data_page(fio);
|
2014-07-25 16:40:59 +02:00
|
|
|
set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
|
2015-03-18 01:58:08 +01:00
|
|
|
trace_f2fs_do_write_data_page(page, IPU);
|
2012-11-02 09:10:12 +01:00
|
|
|
} else {
|
2015-04-23 23:38:15 +02:00
|
|
|
write_data_page(&dn, fio);
|
2015-03-19 12:23:32 +01:00
|
|
|
set_data_blkaddr(&dn);
|
2015-02-05 10:51:34 +01:00
|
|
|
f2fs_update_extent_cache(&dn);
|
2015-03-18 01:58:08 +01:00
|
|
|
trace_f2fs_do_write_data_page(page, OPU);
|
2014-07-25 16:40:59 +02:00
|
|
|
set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
|
2015-03-18 01:16:35 +01:00
|
|
|
if (page->index == 0)
|
|
|
|
set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
out_writepage:
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_write_data_page(struct page *page,
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
2014-09-03 00:31:18 +02:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2012-11-02 09:10:12 +01:00
|
|
|
loff_t i_size = i_size_read(inode);
|
|
|
|
const pgoff_t end_index = ((unsigned long long) i_size)
|
|
|
|
>> PAGE_CACHE_SHIFT;
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
unsigned offset = 0;
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
bool need_balance_fs = false;
|
2012-11-02 09:10:12 +01:00
|
|
|
int err = 0;
|
2013-12-11 05:54:01 +01:00
|
|
|
struct f2fs_io_info fio = {
|
2015-04-23 23:38:15 +02:00
|
|
|
.sbi = sbi,
|
2013-12-11 05:54:01 +01:00
|
|
|
.type = DATA,
|
2014-01-17 21:44:39 +01:00
|
|
|
.rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,
|
2015-04-23 23:38:15 +02:00
|
|
|
.page = page,
|
2015-04-23 21:04:33 +02:00
|
|
|
.encrypted_page = NULL,
|
2013-12-11 05:54:01 +01:00
|
|
|
};
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-05-06 10:48:26 +02:00
|
|
|
trace_f2fs_writepage(page, DATA);
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
if (page->index < end_index)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
goto write;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the offset is out-of-range of file size,
|
|
|
|
* this page does not have to be written to disk.
|
|
|
|
*/
|
|
|
|
offset = i_size & (PAGE_CACHE_SIZE - 1);
|
2014-04-15 09:04:15 +02:00
|
|
|
if ((page->index >= end_index + 1) || !offset)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
goto out;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
zero_user_segment(page, offset, PAGE_CACHE_SIZE);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
write:
|
2015-01-28 10:48:42 +01:00
|
|
|
if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
|
2012-11-02 09:10:12 +01:00
|
|
|
goto redirty_out;
|
2014-12-09 15:08:59 +01:00
|
|
|
if (f2fs_is_drop_cache(inode))
|
|
|
|
goto out;
|
|
|
|
if (f2fs_is_volatile_file(inode) && !wbc->for_reclaim &&
|
|
|
|
available_free_memory(sbi, BASE_CHECK))
|
|
|
|
goto redirty_out;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
/* Dentry blocks are controlled by checkpoint */
|
2012-11-02 09:10:12 +01:00
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
2014-08-12 03:37:46 +02:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
goto redirty_out;
|
2015-04-23 23:38:15 +02:00
|
|
|
err = do_write_data_page(&fio);
|
2014-02-17 11:29:27 +01:00
|
|
|
goto done;
|
|
|
|
}
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
|
2014-08-12 03:37:46 +02:00
|
|
|
/* we should bypass data pages to proceed the kworkder jobs */
|
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
SetPageError(page);
|
2014-09-13 00:53:45 +02:00
|
|
|
goto out;
|
2014-08-12 03:37:46 +02:00
|
|
|
}
|
|
|
|
|
2014-02-17 11:29:27 +01:00
|
|
|
if (!wbc->for_reclaim)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
need_balance_fs = true;
|
2014-02-17 11:29:27 +01:00
|
|
|
else if (has_not_enough_free_secs(sbi, 0))
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
goto redirty_out;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
err = -EAGAIN;
|
2014-02-17 11:29:27 +01:00
|
|
|
f2fs_lock_op(sbi);
|
2014-10-24 04:48:09 +02:00
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
err = f2fs_write_inline_data(inode, page);
|
|
|
|
if (err == -EAGAIN)
|
2015-04-23 23:38:15 +02:00
|
|
|
err = do_write_data_page(&fio);
|
2014-02-17 11:29:27 +01:00
|
|
|
f2fs_unlock_op(sbi);
|
|
|
|
done:
|
|
|
|
if (err && err != -ENOENT)
|
|
|
|
goto redirty_out;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
clear_cold_data(page);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
out:
|
2014-09-13 00:53:45 +02:00
|
|
|
inode_dec_dirty_pages(inode);
|
2015-02-26 04:25:01 +01:00
|
|
|
if (err)
|
|
|
|
ClearPageUptodate(page);
|
2012-11-02 09:10:12 +01:00
|
|
|
unlock_page(page);
|
2016-01-07 23:15:04 +01:00
|
|
|
f2fs_balance_fs(sbi, need_balance_fs);
|
2015-12-31 22:08:02 +01:00
|
|
|
if (wbc->for_reclaim || unlikely(f2fs_cp_error(sbi))) {
|
2014-04-24 02:49:52 +02:00
|
|
|
f2fs_submit_merged_bio(sbi, DATA, WRITE);
|
2015-12-16 06:09:20 +01:00
|
|
|
remove_dirty_inode(inode);
|
2015-11-10 11:45:07 +01:00
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
redirty_out:
|
2014-04-15 09:04:15 +02:00
|
|
|
redirty_page_for_writepage(wbc, page);
|
2014-02-17 11:29:27 +01:00
|
|
|
return AOP_WRITEPAGE_ACTIVATE;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2013-01-15 08:45:24 +01:00
|
|
|
static int __f2fs_writepage(struct page *page, struct writeback_control *wbc,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct address_space *mapping = data;
|
|
|
|
int ret = mapping->a_ops->writepage(page, wbc);
|
|
|
|
mapping_set_error(mapping, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 12:56:10 +02:00
|
|
|
/*
|
|
|
|
* This function was copied from write_cche_pages from mm/page-writeback.c.
|
|
|
|
* The major change is making write step of cold data page separately from
|
|
|
|
* warm/hot data page.
|
|
|
|
*/
|
|
|
|
static int f2fs_write_cache_pages(struct address_space *mapping,
|
|
|
|
struct writeback_control *wbc, writepage_t writepage,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int done = 0;
|
|
|
|
struct pagevec pvec;
|
|
|
|
int nr_pages;
|
|
|
|
pgoff_t uninitialized_var(writeback_index);
|
|
|
|
pgoff_t index;
|
|
|
|
pgoff_t end; /* Inclusive */
|
|
|
|
pgoff_t done_index;
|
|
|
|
int cycled;
|
|
|
|
int range_whole = 0;
|
|
|
|
int tag;
|
|
|
|
int step = 0;
|
|
|
|
|
|
|
|
pagevec_init(&pvec, 0);
|
|
|
|
next:
|
|
|
|
if (wbc->range_cyclic) {
|
|
|
|
writeback_index = mapping->writeback_index; /* prev offset */
|
|
|
|
index = writeback_index;
|
|
|
|
if (index == 0)
|
|
|
|
cycled = 1;
|
|
|
|
else
|
|
|
|
cycled = 0;
|
|
|
|
end = -1;
|
|
|
|
} else {
|
|
|
|
index = wbc->range_start >> PAGE_CACHE_SHIFT;
|
|
|
|
end = wbc->range_end >> PAGE_CACHE_SHIFT;
|
|
|
|
if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
|
|
|
|
range_whole = 1;
|
|
|
|
cycled = 1; /* ignore range_cyclic tests */
|
|
|
|
}
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
|
|
|
|
tag = PAGECACHE_TAG_TOWRITE;
|
|
|
|
else
|
|
|
|
tag = PAGECACHE_TAG_DIRTY;
|
|
|
|
retry:
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
|
|
|
|
tag_pages_for_writeback(mapping, index, end);
|
|
|
|
done_index = index;
|
|
|
|
while (!done && (index <= end)) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
|
|
|
|
min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1);
|
|
|
|
if (nr_pages == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_pages; i++) {
|
|
|
|
struct page *page = pvec.pages[i];
|
|
|
|
|
|
|
|
if (page->index > end) {
|
|
|
|
done = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
done_index = page->index;
|
|
|
|
|
|
|
|
lock_page(page);
|
|
|
|
|
|
|
|
if (unlikely(page->mapping != mapping)) {
|
|
|
|
continue_unlock:
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!PageDirty(page)) {
|
|
|
|
/* someone wrote it for us */
|
|
|
|
goto continue_unlock;
|
|
|
|
}
|
|
|
|
|
2015-07-17 06:56:00 +02:00
|
|
|
if (step == is_cold_data(page))
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 12:56:10 +02:00
|
|
|
goto continue_unlock;
|
|
|
|
|
|
|
|
if (PageWriteback(page)) {
|
|
|
|
if (wbc->sync_mode != WB_SYNC_NONE)
|
|
|
|
f2fs_wait_on_page_writeback(page, DATA);
|
|
|
|
else
|
|
|
|
goto continue_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(PageWriteback(page));
|
|
|
|
if (!clear_page_dirty_for_io(page))
|
|
|
|
goto continue_unlock;
|
|
|
|
|
|
|
|
ret = (*writepage)(page, wbc, data);
|
|
|
|
if (unlikely(ret)) {
|
|
|
|
if (ret == AOP_WRITEPAGE_ACTIVATE) {
|
|
|
|
unlock_page(page);
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
done_index = page->index + 1;
|
|
|
|
done = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (--wbc->nr_to_write <= 0 &&
|
|
|
|
wbc->sync_mode == WB_SYNC_NONE) {
|
|
|
|
done = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (step < 1) {
|
|
|
|
step++;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cycled && !done) {
|
|
|
|
cycled = 1;
|
|
|
|
index = 0;
|
|
|
|
end = writeback_index - 1;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
|
|
|
|
mapping->writeback_index = done_index;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-11-28 08:12:41 +01:00
|
|
|
static int f2fs_write_data_pages(struct address_space *mapping,
|
2012-11-02 09:10:12 +01:00
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
2014-09-03 00:31:18 +02:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2015-04-21 19:40:54 +02:00
|
|
|
bool locked = false;
|
2012-11-02 09:10:12 +01:00
|
|
|
int ret;
|
2014-03-18 05:47:11 +01:00
|
|
|
long diff;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-05-06 10:51:24 +02:00
|
|
|
trace_f2fs_writepages(mapping->host, wbc, DATA);
|
|
|
|
|
2013-04-03 04:38:00 +02:00
|
|
|
/* deal with chardevs and other special file */
|
|
|
|
if (!mapping->a_ops->writepage)
|
|
|
|
return 0;
|
|
|
|
|
2015-07-17 12:02:39 +02:00
|
|
|
/* skip writing if there is no dirty page in this inode */
|
|
|
|
if (!get_dirty_pages(inode) && wbc->sync_mode == WB_SYNC_NONE)
|
|
|
|
return 0;
|
|
|
|
|
2015-10-08 19:40:07 +02:00
|
|
|
if (S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_NONE &&
|
|
|
|
get_dirty_pages(inode) < nr_pages_to_skip(sbi, DATA) &&
|
|
|
|
available_free_memory(sbi, DIRTY_DENTS))
|
|
|
|
goto skip_write;
|
|
|
|
|
2015-10-27 02:53:45 +01:00
|
|
|
/* skip writing during file defragment */
|
|
|
|
if (is_inode_flag_set(F2FS_I(inode), FI_DO_DEFRAG))
|
|
|
|
goto skip_write;
|
|
|
|
|
2015-02-27 22:37:39 +01:00
|
|
|
/* during POR, we don't need to trigger writepage at all. */
|
|
|
|
if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
|
|
|
|
goto skip_write;
|
|
|
|
|
2014-03-18 05:47:11 +01:00
|
|
|
diff = nr_pages_to_write(sbi, DATA, wbc);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2015-04-21 19:40:54 +02:00
|
|
|
if (!S_ISDIR(inode->i_mode)) {
|
|
|
|
mutex_lock(&sbi->writepages);
|
|
|
|
locked = true;
|
|
|
|
}
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 12:56:10 +02:00
|
|
|
ret = f2fs_write_cache_pages(mapping, wbc, __f2fs_writepage, mapping);
|
f2fs: enhance multithread performance
In ->writepages, we use writepages mutex lock to serialize all block
address allocation and page submitting pairs from different inodes.
This method makes our delayed dirty pages of one inode being written
continously as many as possible.
But there is one problem that we did not submit current cached bio in
protection region of writepages mutex lock, so there is a small chance
that we submit the one of other thread's as below, resulting in
splitting more bios.
thread 1 thread 2
->writepages
lock(writepages)
->write_cache_pages
unlock(writepages)
lock(writepages)
->write_cache_pages
->f2fs_submit_merged_bio
->writepage
unlock(writepages)
fs_mark-6535 [002] .... 2242.270230: f2fs_submit_write_bio: dev = (1,0), WRITE_SYNC, DATA, sector = 5766152, size = 524288
fs_mark-6536 [000] .... 2242.270361: f2fs_submit_write_bio: dev = (1,0), WRITE_SYNC, DATA, sector = 5767176, size = 4096
fs_mark-6536 [000] .... 2242.270370: f2fs_submit_write_bio: dev = (1,0), WRITE_SYNC, NODE, sector = 8138112, size = 4096
fs_mark-6535 [002] .... 2242.270776: f2fs_submit_write_bio: dev = (1,0), WRITE_SYNC, DATA, sector = 5767184, size = 516096
This may really increase time of block layer works, and may cause
larger IO lantency.
This patch moves the submitting operation into region of writepages
mutex lock to avoid bio splits when concurrently writebacking is
intensive.
my test environment: virtual machine,
intel cpu i5 2500, 8GB size memory, 4GB size ramdisk
time fs_mark -t 16 -L 1 -s 524288 -S 1 -d /mnt/f2fs/
before:
real 0m4.244s
user 0m0.088s
sys 0m12.336s
after:
real 0m3.822s
user 0m0.072s
sys 0m10.760s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-06 14:31:49 +02:00
|
|
|
f2fs_submit_merged_bio(sbi, DATA, WRITE);
|
2015-04-21 19:40:54 +02:00
|
|
|
if (locked)
|
|
|
|
mutex_unlock(&sbi->writepages);
|
2013-12-11 05:54:01 +01:00
|
|
|
|
2015-12-16 06:09:20 +01:00
|
|
|
remove_dirty_inode(inode);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-03-18 05:47:11 +01:00
|
|
|
wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);
|
2012-11-02 09:10:12 +01:00
|
|
|
return ret;
|
2014-03-18 05:43:05 +01:00
|
|
|
|
|
|
|
skip_write:
|
2014-09-13 00:53:45 +02:00
|
|
|
wbc->pages_skipped += get_dirty_pages(inode);
|
2014-03-18 05:43:05 +01:00
|
|
|
return 0;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2014-07-02 07:25:04 +02:00
|
|
|
static void f2fs_write_failed(struct address_space *mapping, loff_t to)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
2015-12-28 22:48:11 +01:00
|
|
|
loff_t i_size = i_size_read(inode);
|
2014-07-02 07:25:04 +02:00
|
|
|
|
2015-12-28 22:48:11 +01:00
|
|
|
if (to > i_size) {
|
|
|
|
truncate_pagecache(inode, i_size);
|
|
|
|
truncate_blocks(inode, i_size, true);
|
2014-07-02 07:25:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-23 20:55:18 +01:00
|
|
|
static int prepare_write_begin(struct f2fs_sb_info *sbi,
|
|
|
|
struct page *page, loff_t pos, unsigned len,
|
|
|
|
block_t *blk_addr, bool *node_changed)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
pgoff_t index = page->index;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
struct page *ipage;
|
2015-12-23 22:48:58 +01:00
|
|
|
bool locked = false;
|
|
|
|
struct extent_info ei;
|
2015-12-23 20:55:18 +01:00
|
|
|
int err = 0;
|
|
|
|
|
2015-12-23 22:48:58 +01:00
|
|
|
if (f2fs_has_inline_data(inode) ||
|
|
|
|
(pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {
|
|
|
|
f2fs_lock_op(sbi);
|
|
|
|
locked = true;
|
|
|
|
}
|
|
|
|
restart:
|
2015-12-23 20:55:18 +01:00
|
|
|
/* check inline_data */
|
|
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
|
|
|
if (IS_ERR(ipage)) {
|
|
|
|
err = PTR_ERR(ipage);
|
|
|
|
goto unlock_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_new_dnode(&dn, inode, ipage, ipage, 0);
|
|
|
|
|
|
|
|
if (f2fs_has_inline_data(inode)) {
|
|
|
|
if (pos + len <= MAX_INLINE_DATA) {
|
|
|
|
read_inline_data(page, ipage);
|
|
|
|
set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
} else {
|
|
|
|
err = f2fs_convert_inline_page(&dn, page);
|
|
|
|
if (err)
|
2015-12-23 22:48:58 +01:00
|
|
|
goto out;
|
|
|
|
if (dn.data_blkaddr == NULL_ADDR)
|
|
|
|
err = f2fs_get_block(&dn, index);
|
|
|
|
}
|
|
|
|
} else if (locked) {
|
|
|
|
err = f2fs_get_block(&dn, index);
|
|
|
|
} else {
|
|
|
|
if (f2fs_lookup_extent_cache(inode, index, &ei)) {
|
|
|
|
dn.data_blkaddr = ei.blk + index - ei.fofs;
|
|
|
|
} else {
|
|
|
|
bool restart = false;
|
|
|
|
|
|
|
|
/* hole case */
|
|
|
|
err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
|
|
|
|
if (err || (!err && dn.data_blkaddr == NULL_ADDR))
|
|
|
|
restart = true;
|
|
|
|
if (restart) {
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
f2fs_lock_op(sbi);
|
|
|
|
locked = true;
|
|
|
|
goto restart;
|
|
|
|
}
|
2015-12-23 20:55:18 +01:00
|
|
|
}
|
|
|
|
}
|
2015-12-23 22:48:58 +01:00
|
|
|
|
2015-12-23 20:55:18 +01:00
|
|
|
/* convert_inline_page can make node_changed */
|
|
|
|
*blk_addr = dn.data_blkaddr;
|
|
|
|
*node_changed = dn.node_changed;
|
2015-12-23 22:48:58 +01:00
|
|
|
out:
|
2015-12-23 20:55:18 +01:00
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
unlock_out:
|
2015-12-23 22:48:58 +01:00
|
|
|
if (locked)
|
|
|
|
f2fs_unlock_op(sbi);
|
2015-12-23 20:55:18 +01:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
static int f2fs_write_begin(struct file *file, struct address_space *mapping,
|
|
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
|
|
struct page **pagep, void **fsdata)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
2014-09-03 00:31:18 +02:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2015-07-15 22:08:21 +02:00
|
|
|
struct page *page = NULL;
|
2012-11-02 09:10:12 +01:00
|
|
|
pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
|
2015-12-23 20:55:18 +01:00
|
|
|
bool need_balance = false;
|
|
|
|
block_t blkaddr = NULL_ADDR;
|
2012-11-02 09:10:12 +01:00
|
|
|
int err = 0;
|
|
|
|
|
2014-05-06 10:46:04 +02:00
|
|
|
trace_f2fs_write_begin(inode, pos, len, flags);
|
|
|
|
|
2014-11-25 19:59:45 +01:00
|
|
|
/*
|
|
|
|
* We should check this at this moment to avoid deadlock on inode page
|
|
|
|
* and #0 page. The locking rule for inline_data conversion should be:
|
|
|
|
* lock_page(page #0) -> lock_page(inode_page)
|
|
|
|
*/
|
|
|
|
if (index != 0) {
|
|
|
|
err = f2fs_convert_inline_inode(inode);
|
|
|
|
if (err)
|
|
|
|
goto fail;
|
|
|
|
}
|
2013-04-26 04:55:17 +02:00
|
|
|
repeat:
|
2012-11-02 09:10:12 +01:00
|
|
|
page = grab_cache_page_write_begin(mapping, index, flags);
|
2014-07-02 07:25:04 +02:00
|
|
|
if (!page) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2014-04-30 02:22:45 +02:00
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
*pagep = page;
|
|
|
|
|
2015-12-23 20:55:18 +01:00
|
|
|
err = prepare_write_begin(sbi, page, pos, len,
|
|
|
|
&blkaddr, &need_balance);
|
2014-10-18 05:33:55 +02:00
|
|
|
if (err)
|
2015-12-23 20:55:18 +01:00
|
|
|
goto fail;
|
2014-10-18 05:33:55 +02:00
|
|
|
|
2015-12-23 20:55:18 +01:00
|
|
|
if (need_balance && has_not_enough_free_secs(sbi, 0)) {
|
2015-12-22 22:23:35 +01:00
|
|
|
unlock_page(page);
|
2016-01-07 23:15:04 +01:00
|
|
|
f2fs_balance_fs(sbi, true);
|
2015-12-22 22:23:35 +01:00
|
|
|
lock_page(page);
|
|
|
|
if (page->mapping != mapping) {
|
|
|
|
/* The page got truncated from under us */
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
f2fs_wait_on_page_writeback(page, DATA);
|
|
|
|
|
2015-10-08 07:27:34 +02:00
|
|
|
/* wait for GCed encrypted page writeback */
|
|
|
|
if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
|
2015-12-23 20:55:18 +01:00
|
|
|
f2fs_wait_on_encrypted_page_writeback(sbi, blkaddr);
|
2015-10-08 07:27:34 +02:00
|
|
|
|
2015-07-08 12:24:38 +02:00
|
|
|
if (len == PAGE_CACHE_SIZE)
|
|
|
|
goto out_update;
|
|
|
|
if (PageUptodate(page))
|
|
|
|
goto out_clear;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {
|
|
|
|
unsigned start = pos & (PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned end = start + len;
|
|
|
|
|
|
|
|
/* Reading beyond i_size is simple: memset to zero */
|
|
|
|
zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);
|
2015-07-08 12:24:38 +02:00
|
|
|
goto out_update;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2015-12-23 20:55:18 +01:00
|
|
|
if (blkaddr == NEW_ADDR) {
|
2012-11-02 09:10:12 +01:00
|
|
|
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
|
|
|
|
} else {
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info fio = {
|
2015-04-23 23:38:15 +02:00
|
|
|
.sbi = sbi,
|
2014-12-18 04:33:13 +01:00
|
|
|
.type = DATA,
|
|
|
|
.rw = READ_SYNC,
|
2015-12-23 20:55:18 +01:00
|
|
|
.blk_addr = blkaddr,
|
2015-04-23 23:38:15 +02:00
|
|
|
.page = page,
|
2015-04-23 21:04:33 +02:00
|
|
|
.encrypted_page = NULL,
|
2014-12-18 04:33:13 +01:00
|
|
|
};
|
2015-04-23 23:38:15 +02:00
|
|
|
err = f2fs_submit_page_bio(&fio);
|
2014-10-22 15:21:47 +02:00
|
|
|
if (err)
|
|
|
|
goto fail;
|
2014-03-29 08:30:40 +01:00
|
|
|
|
2013-03-08 13:29:23 +01:00
|
|
|
lock_page(page);
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(!PageUptodate(page))) {
|
2014-07-02 07:25:04 +02:00
|
|
|
err = -EIO;
|
|
|
|
goto fail;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(page->mapping != mapping)) {
|
2013-04-26 04:55:17 +02:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
goto repeat;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
2015-04-23 21:04:33 +02:00
|
|
|
|
|
|
|
/* avoid symlink page */
|
|
|
|
if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {
|
|
|
|
err = f2fs_decrypt_one(inode, page);
|
2015-07-15 22:08:21 +02:00
|
|
|
if (err)
|
2015-04-23 21:04:33 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
2015-07-08 12:24:38 +02:00
|
|
|
out_update:
|
2012-11-02 09:10:12 +01:00
|
|
|
SetPageUptodate(page);
|
2015-07-08 12:24:38 +02:00
|
|
|
out_clear:
|
2012-11-02 09:10:12 +01:00
|
|
|
clear_cold_data(page);
|
|
|
|
return 0;
|
2014-10-18 05:33:55 +02:00
|
|
|
|
2014-07-02 07:25:04 +02:00
|
|
|
fail:
|
2015-07-15 22:08:21 +02:00
|
|
|
f2fs_put_page(page, 1);
|
2014-07-02 07:25:04 +02:00
|
|
|
f2fs_write_failed(mapping, pos + len);
|
|
|
|
return err;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2013-06-27 06:04:08 +02:00
|
|
|
static int f2fs_write_end(struct file *file,
|
|
|
|
struct address_space *mapping,
|
|
|
|
loff_t pos, unsigned len, unsigned copied,
|
|
|
|
struct page *page, void *fsdata)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
|
2014-05-06 10:47:23 +02:00
|
|
|
trace_f2fs_write_end(inode, pos, len, copied);
|
|
|
|
|
2014-10-09 22:19:53 +02:00
|
|
|
set_page_dirty(page);
|
2013-06-27 06:04:08 +02:00
|
|
|
|
|
|
|
if (pos + copied > i_size_read(inode)) {
|
|
|
|
i_size_write(inode, pos + copied);
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
update_inode_page(inode);
|
|
|
|
}
|
|
|
|
|
2013-11-16 07:15:59 +01:00
|
|
|
f2fs_put_page(page, 1);
|
2016-01-09 01:57:48 +01:00
|
|
|
f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
|
2013-06-27 06:04:08 +02:00
|
|
|
return copied;
|
|
|
|
}
|
|
|
|
|
2015-03-16 12:33:52 +01:00
|
|
|
static int check_direct_IO(struct inode *inode, struct iov_iter *iter,
|
|
|
|
loff_t offset)
|
2013-12-26 12:15:09 +01:00
|
|
|
{
|
|
|
|
unsigned blocksize_mask = inode->i_sb->s_blocksize - 1;
|
|
|
|
|
|
|
|
if (offset & blocksize_mask)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-03-16 23:07:34 +01:00
|
|
|
if (iov_iter_alignment(iter) & blocksize_mask)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-12-26 12:15:09 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-16 12:33:53 +01:00
|
|
|
static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
|
|
|
|
loff_t offset)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
2014-07-02 07:25:04 +02:00
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
size_t count = iov_iter_count(iter);
|
|
|
|
int err;
|
2013-12-26 12:15:09 +01:00
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
/* we don't need to use inline_data strictly */
|
2015-12-22 20:09:35 +01:00
|
|
|
err = f2fs_convert_inline_inode(inode);
|
|
|
|
if (err)
|
|
|
|
return err;
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 16:13:20 +01:00
|
|
|
|
2015-04-22 05:39:58 +02:00
|
|
|
if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
|
|
|
|
return 0;
|
|
|
|
|
2015-08-07 12:39:32 +02:00
|
|
|
err = check_direct_IO(inode, iter, offset);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2013-12-26 12:15:09 +01:00
|
|
|
|
2015-03-16 12:33:52 +01:00
|
|
|
trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
|
2014-07-31 15:11:22 +02:00
|
|
|
|
2015-09-21 14:17:52 +02:00
|
|
|
if (iov_iter_rw(iter) == WRITE) {
|
2015-12-24 11:04:56 +01:00
|
|
|
err = __allocate_data_blocks(inode, offset, count);
|
|
|
|
if (err)
|
2015-09-21 14:17:52 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2015-02-09 21:09:53 +01:00
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
err = blockdev_direct_IO(iocb, inode, iter, offset, get_data_block_dio);
|
2015-09-21 14:17:52 +02:00
|
|
|
out:
|
2015-03-16 12:33:52 +01:00
|
|
|
if (err < 0 && iov_iter_rw(iter) == WRITE)
|
2014-07-02 07:25:04 +02:00
|
|
|
f2fs_write_failed(mapping, offset + count);
|
2014-07-31 15:11:22 +02:00
|
|
|
|
2015-03-16 12:33:52 +01:00
|
|
|
trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err);
|
2014-07-31 15:11:22 +02:00
|
|
|
|
2014-07-02 07:25:04 +02:00
|
|
|
return err;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2015-02-05 10:44:29 +01:00
|
|
|
void f2fs_invalidate_page(struct page *page, unsigned int offset,
|
|
|
|
unsigned int length)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
2015-02-05 10:44:29 +01:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2014-09-13 00:53:45 +02:00
|
|
|
|
2015-02-05 10:44:29 +01:00
|
|
|
if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
|
|
|
|
(offset % PAGE_CACHE_SIZE || length != PAGE_CACHE_SIZE))
|
2014-09-13 00:53:45 +02:00
|
|
|
return;
|
|
|
|
|
2015-02-05 10:44:29 +01:00
|
|
|
if (PageDirty(page)) {
|
|
|
|
if (inode->i_ino == F2FS_META_INO(sbi))
|
|
|
|
dec_page_count(sbi, F2FS_DIRTY_META);
|
|
|
|
else if (inode->i_ino == F2FS_NODE_INO(sbi))
|
|
|
|
dec_page_count(sbi, F2FS_DIRTY_NODES);
|
|
|
|
else
|
|
|
|
inode_dec_dirty_pages(inode);
|
|
|
|
}
|
2015-08-07 12:42:09 +02:00
|
|
|
|
|
|
|
/* This is atomic written page, keep Private */
|
|
|
|
if (IS_ATOMIC_WRITTEN_PAGE(page))
|
|
|
|
return;
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
ClearPagePrivate(page);
|
|
|
|
}
|
|
|
|
|
2015-02-05 10:44:29 +01:00
|
|
|
int f2fs_release_page(struct page *page, gfp_t wait)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
2015-01-30 20:39:08 +01:00
|
|
|
/* If this is dirty page, keep PagePrivate */
|
|
|
|
if (PageDirty(page))
|
|
|
|
return 0;
|
|
|
|
|
2015-08-07 12:42:09 +02:00
|
|
|
/* This is atomic written page, keep Private */
|
|
|
|
if (IS_ATOMIC_WRITTEN_PAGE(page))
|
|
|
|
return 0;
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
ClearPagePrivate(page);
|
2013-03-14 01:24:32 +01:00
|
|
|
return 1;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_set_data_page_dirty(struct page *page)
|
|
|
|
{
|
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
2013-10-24 10:53:29 +02:00
|
|
|
trace_f2fs_set_page_dirty(page, DATA);
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
SetPageUptodate(page);
|
2014-10-09 22:19:53 +02:00
|
|
|
|
2014-12-09 15:08:59 +01:00
|
|
|
if (f2fs_is_atomic_file(inode)) {
|
2015-08-07 12:42:09 +02:00
|
|
|
if (!IS_ATOMIC_WRITTEN_PAGE(page)) {
|
|
|
|
register_inmem_page(inode, page);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Previously, this page has been registered, we just
|
|
|
|
* return here.
|
|
|
|
*/
|
|
|
|
return 0;
|
2014-10-09 22:19:53 +02:00
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
if (!PageDirty(page)) {
|
|
|
|
__set_page_dirty_nobuffers(page);
|
2014-09-13 00:53:45 +02:00
|
|
|
update_dirty_page(inode, page);
|
2012-11-02 09:10:12 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-17 12:30:23 +01:00
|
|
|
static sector_t f2fs_bmap(struct address_space *mapping, sector_t block)
|
|
|
|
{
|
2014-04-22 07:34:01 +02:00
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
2015-10-19 19:29:51 +02:00
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* make sure allocating whole blocks */
|
|
|
|
if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
|
|
|
|
filemap_write_and_wait(mapping);
|
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
return generic_block_bmap(mapping, block, get_data_block_bmap);
|
2015-02-05 10:54:31 +01:00
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
const struct address_space_operations f2fs_dblock_aops = {
|
|
|
|
.readpage = f2fs_read_data_page,
|
|
|
|
.readpages = f2fs_read_data_pages,
|
|
|
|
.writepage = f2fs_write_data_page,
|
|
|
|
.writepages = f2fs_write_data_pages,
|
|
|
|
.write_begin = f2fs_write_begin,
|
2013-06-27 06:04:08 +02:00
|
|
|
.write_end = f2fs_write_end,
|
2012-11-02 09:10:12 +01:00
|
|
|
.set_page_dirty = f2fs_set_data_page_dirty,
|
2015-02-05 10:44:29 +01:00
|
|
|
.invalidatepage = f2fs_invalidate_page,
|
|
|
|
.releasepage = f2fs_release_page,
|
2012-11-02 09:10:12 +01:00
|
|
|
.direct_IO = f2fs_direct_IO,
|
2013-01-17 12:30:23 +01:00
|
|
|
.bmap = f2fs_bmap,
|
2012-11-02 09:10:12 +01:00
|
|
|
};
|