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>
|
2013-05-08 01:19:08 +02:00
|
|
|
#include <linux/aio.h>
|
2012-11-02 09:10:12 +01:00
|
|
|
#include <linux/writeback.h>
|
|
|
|
#include <linux/backing-dev.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/bio.h>
|
2012-12-19 22:19:30 +01:00
|
|
|
#include <linux/prefetch.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
|
|
|
|
2013-11-30 04:51:14 +01:00
|
|
|
static void f2fs_read_end_io(struct bio *bio, int err)
|
|
|
|
{
|
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;
|
|
|
|
|
2014-01-30 20:19:05 +01:00
|
|
|
if (!err) {
|
|
|
|
SetPageUptodate(page);
|
|
|
|
} else {
|
2013-11-30 04:51:14 +01:00
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
|
|
|
unlock_page(page);
|
2014-01-30 20:19:05 +01:00
|
|
|
}
|
2013-11-30 04:51:14 +01:00
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f2fs_write_end_io(struct bio *bio, int err)
|
|
|
|
{
|
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;
|
|
|
|
|
2014-01-30 20:19:05 +01:00
|
|
|
if (unlikely(err)) {
|
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;
|
|
|
|
|
|
|
|
/* No failure on bio allocation */
|
|
|
|
bio = bio_alloc(GFP_NOIO, npages);
|
|
|
|
|
|
|
|
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;
|
2014-02-03 02:50:22 +01:00
|
|
|
bio->bi_private = 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.
|
|
|
|
*/
|
|
|
|
int f2fs_submit_page_bio(struct f2fs_sb_info *sbi, struct page *page,
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info *fio)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
|
2014-12-24 09:08:14 +01:00
|
|
|
trace_f2fs_submit_page_bio(page, fio);
|
2014-12-18 05:04:08 +01:00
|
|
|
f2fs_trace_ios(page, fio, 0);
|
2013-11-30 04:51:14 +01:00
|
|
|
|
|
|
|
/* Allocate a new bio */
|
2014-12-18 04:33:13 +01:00
|
|
|
bio = __bio_alloc(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);
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info *fio)
|
2013-11-30 04:51:14 +01:00
|
|
|
{
|
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);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
if (bio_add_page(io->bio, page, PAGE_CACHE_SIZE, 0) <
|
|
|
|
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;
|
2014-12-18 05:04:08 +01:00
|
|
|
f2fs_trace_ios(page, fio, 0);
|
2013-11-30 04:51:14 +01:00
|
|
|
|
2014-03-22 07:57:23 +01:00
|
|
|
up_write(&io->io_rwsem);
|
2014-12-24 09:08:14 +01:00
|
|
|
trace_f2fs_submit_page_mbio(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
|
|
|
|
*/
|
2014-12-31 07:57:55 +01:00
|
|
|
static 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);
|
2012-11-02 09:10:12 +01:00
|
|
|
set_page_dirty(node_page);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2014-12-31 07:57:55 +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;
|
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
static int check_extent_cache(struct inode *inode, pgoff_t pgofs,
|
|
|
|
struct buffer_head *bh_result)
|
|
|
|
{
|
|
|
|
struct f2fs_inode_info *fi = F2FS_I(inode);
|
|
|
|
pgoff_t start_fofs, end_fofs;
|
|
|
|
block_t start_blkaddr;
|
|
|
|
|
2013-11-19 02:41:54 +01:00
|
|
|
if (is_inode_flag_set(fi, FI_NO_EXTENT))
|
|
|
|
return 0;
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
read_lock(&fi->ext.ext_lock);
|
|
|
|
if (fi->ext.len == 0) {
|
|
|
|
read_unlock(&fi->ext.ext_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-22 13:56:10 +02:00
|
|
|
stat_inc_total_hit(inode->i_sb);
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
start_fofs = fi->ext.fofs;
|
|
|
|
end_fofs = fi->ext.fofs + fi->ext.len - 1;
|
|
|
|
start_blkaddr = fi->ext.blk_addr;
|
|
|
|
|
|
|
|
if (pgofs >= start_fofs && pgofs <= end_fofs) {
|
|
|
|
unsigned int blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
size_t count;
|
|
|
|
|
2015-02-09 19:34:38 +01:00
|
|
|
set_buffer_new(bh_result);
|
2012-11-02 09:10:12 +01:00
|
|
|
map_bh(bh_result, inode->i_sb,
|
|
|
|
start_blkaddr + pgofs - start_fofs);
|
|
|
|
count = end_fofs - pgofs + 1;
|
|
|
|
if (count < (UINT_MAX >> blkbits))
|
|
|
|
bh_result->b_size = (count << blkbits);
|
|
|
|
else
|
|
|
|
bh_result->b_size = UINT_MAX;
|
|
|
|
|
2013-10-22 13:56:10 +02:00
|
|
|
stat_inc_read_hit(inode->i_sb);
|
2012-11-02 09:10:12 +01:00
|
|
|
read_unlock(&fi->ext.ext_lock);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
read_unlock(&fi->ext.ext_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-31 07:57:55 +01:00
|
|
|
void update_extent_cache(struct dnode_of_data *dn)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct f2fs_inode_info *fi = F2FS_I(dn->inode);
|
|
|
|
pgoff_t fofs, start_fofs, end_fofs;
|
|
|
|
block_t start_blkaddr, end_blkaddr;
|
2013-11-19 02:41:54 +01:00
|
|
|
int need_update = true;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-12-31 07:57:55 +01:00
|
|
|
f2fs_bug_on(F2FS_I_SB(dn->inode), dn->data_blkaddr == NEW_ADDR);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
/* Update the page address in the parent node */
|
2014-12-31 07:57:55 +01:00
|
|
|
__set_data_blkaddr(dn);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-11-19 02:41:54 +01:00
|
|
|
if (is_inode_flag_set(fi, FI_NO_EXTENT))
|
|
|
|
return;
|
|
|
|
|
2014-12-31 08:08:26 +01:00
|
|
|
fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
|
|
|
|
dn->ofs_in_node;
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
write_lock(&fi->ext.ext_lock);
|
|
|
|
|
|
|
|
start_fofs = fi->ext.fofs;
|
|
|
|
end_fofs = fi->ext.fofs + fi->ext.len - 1;
|
|
|
|
start_blkaddr = fi->ext.blk_addr;
|
|
|
|
end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
|
|
|
|
|
|
|
|
/* Drop and initialize the matched extent */
|
|
|
|
if (fi->ext.len == 1 && fofs == start_fofs)
|
|
|
|
fi->ext.len = 0;
|
|
|
|
|
|
|
|
/* Initial extent */
|
|
|
|
if (fi->ext.len == 0) {
|
2014-12-31 07:57:55 +01:00
|
|
|
if (dn->data_blkaddr != NULL_ADDR) {
|
2012-11-02 09:10:12 +01:00
|
|
|
fi->ext.fofs = fofs;
|
2014-12-31 07:57:55 +01:00
|
|
|
fi->ext.blk_addr = dn->data_blkaddr;
|
2012-11-02 09:10:12 +01:00
|
|
|
fi->ext.len = 1;
|
|
|
|
}
|
|
|
|
goto end_update;
|
|
|
|
}
|
|
|
|
|
2013-04-06 07:44:32 +02:00
|
|
|
/* Front merge */
|
2014-12-31 07:57:55 +01:00
|
|
|
if (fofs == start_fofs - 1 && dn->data_blkaddr == start_blkaddr - 1) {
|
2012-11-02 09:10:12 +01:00
|
|
|
fi->ext.fofs--;
|
|
|
|
fi->ext.blk_addr--;
|
|
|
|
fi->ext.len++;
|
|
|
|
goto end_update;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Back merge */
|
2014-12-31 07:57:55 +01:00
|
|
|
if (fofs == end_fofs + 1 && dn->data_blkaddr == end_blkaddr + 1) {
|
2012-11-02 09:10:12 +01:00
|
|
|
fi->ext.len++;
|
|
|
|
goto end_update;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Split the existing extent */
|
|
|
|
if (fi->ext.len > 1 &&
|
|
|
|
fofs >= start_fofs && fofs <= end_fofs) {
|
|
|
|
if ((end_fofs - fofs) < (fi->ext.len >> 1)) {
|
|
|
|
fi->ext.len = fofs - start_fofs;
|
|
|
|
} else {
|
|
|
|
fi->ext.fofs = fofs + 1;
|
|
|
|
fi->ext.blk_addr = start_blkaddr +
|
|
|
|
fofs - start_fofs + 1;
|
|
|
|
fi->ext.len -= fofs - start_fofs + 1;
|
|
|
|
}
|
2013-11-19 02:41:54 +01:00
|
|
|
} else {
|
|
|
|
need_update = false;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 02:41:54 +01:00
|
|
|
/* Finally, if the extent is very fragmented, let's drop the cache. */
|
|
|
|
if (fi->ext.len < F2FS_MIN_EXTENT_LEN) {
|
|
|
|
fi->ext.len = 0;
|
|
|
|
set_inode_flag(fi, FI_NO_EXTENT);
|
|
|
|
need_update = true;
|
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
end_update:
|
|
|
|
write_unlock(&fi->ext.ext_lock);
|
2013-11-19 02:41:54 +01:00
|
|
|
if (need_update)
|
|
|
|
sync_inode_page(dn);
|
|
|
|
return;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
f2fs: give a chance to merge IOs by IO scheduler
Previously, background GC submits many 4KB read requests to load victim blocks
and/or its (i)node blocks.
...
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb61, blkaddr = 0x3b964ed
f2fs_gc : block_rq_complete: 8,16 R () 499854968 + 8 [0]
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb6f, blkaddr = 0x3b964ee
f2fs_gc : block_rq_complete: 8,16 R () 499854976 + 8 [0]
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb79, blkaddr = 0x3b964ef
f2fs_gc : block_rq_complete: 8,16 R () 499854984 + 8 [0]
...
However, by the fact that many IOs are sequential, we can give a chance to merge
the IOs by IO scheduler.
In order to do that, let's use blk_plug.
...
f2fs_gc : f2fs_iget: ino = 143
f2fs_gc : f2fs_readpage: ino = 143, page_index = 0x1c6, blkaddr = 0x2e6ee
f2fs_gc : f2fs_iget: ino = 143
f2fs_gc : f2fs_readpage: ino = 143, page_index = 0x1c7, blkaddr = 0x2e6ef
<idle> : block_rq_complete: 8,16 R () 1519616 + 8 [0]
<idle> : block_rq_complete: 8,16 R () 1519848 + 8 [0]
<idle> : block_rq_complete: 8,16 R () 1520432 + 96 [0]
<idle> : block_rq_complete: 8,16 R () 1520536 + 104 [0]
<idle> : block_rq_complete: 8,16 R () 1521008 + 112 [0]
<idle> : block_rq_complete: 8,16 R () 1521440 + 152 [0]
<idle> : block_rq_complete: 8,16 R () 1521688 + 144 [0]
<idle> : block_rq_complete: 8,16 R () 1522128 + 192 [0]
<idle> : block_rq_complete: 8,16 R () 1523256 + 328 [0]
...
Note that this issue should be addressed in checkpoint, and some readahead
flows too.
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-04-24 06:19:56 +02:00
|
|
|
struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
struct page *page;
|
|
|
|
int err;
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info fio = {
|
|
|
|
.type = DATA,
|
|
|
|
.rw = sync ? READ_SYNC : READA,
|
|
|
|
};
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
page = find_get_page(mapping, index);
|
|
|
|
if (page && PageUptodate(page))
|
|
|
|
return page;
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
|
|
|
|
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);
|
2012-11-02 09:10:12 +01:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
|
|
|
if (dn.data_blkaddr == NULL_ADDR)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
/* By fallocate(), there is no cached page, but with NEW_ADDR */
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(dn.data_blkaddr == NEW_ADDR))
|
2012-11-02 09:10:12 +01:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2014-04-29 10:35:10 +02:00
|
|
|
page = grab_cache_page(mapping, index);
|
2012-11-02 09:10:12 +01:00
|
|
|
if (!page)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2013-03-08 13:29:23 +01:00
|
|
|
if (PageUptodate(page)) {
|
|
|
|
unlock_page(page);
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
fio.blk_addr = dn.data_blkaddr;
|
|
|
|
err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
|
2013-11-28 08:43:43 +01:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
f2fs: give a chance to merge IOs by IO scheduler
Previously, background GC submits many 4KB read requests to load victim blocks
and/or its (i)node blocks.
...
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb61, blkaddr = 0x3b964ed
f2fs_gc : block_rq_complete: 8,16 R () 499854968 + 8 [0]
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb6f, blkaddr = 0x3b964ee
f2fs_gc : block_rq_complete: 8,16 R () 499854976 + 8 [0]
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb79, blkaddr = 0x3b964ef
f2fs_gc : block_rq_complete: 8,16 R () 499854984 + 8 [0]
...
However, by the fact that many IOs are sequential, we can give a chance to merge
the IOs by IO scheduler.
In order to do that, let's use blk_plug.
...
f2fs_gc : f2fs_iget: ino = 143
f2fs_gc : f2fs_readpage: ino = 143, page_index = 0x1c6, blkaddr = 0x2e6ee
f2fs_gc : f2fs_iget: ino = 143
f2fs_gc : f2fs_readpage: ino = 143, page_index = 0x1c7, blkaddr = 0x2e6ef
<idle> : block_rq_complete: 8,16 R () 1519616 + 8 [0]
<idle> : block_rq_complete: 8,16 R () 1519848 + 8 [0]
<idle> : block_rq_complete: 8,16 R () 1520432 + 96 [0]
<idle> : block_rq_complete: 8,16 R () 1520536 + 104 [0]
<idle> : block_rq_complete: 8,16 R () 1521008 + 112 [0]
<idle> : block_rq_complete: 8,16 R () 1521440 + 152 [0]
<idle> : block_rq_complete: 8,16 R () 1521688 + 144 [0]
<idle> : block_rq_complete: 8,16 R () 1522128 + 192 [0]
<idle> : block_rq_complete: 8,16 R () 1523256 + 328 [0]
...
Note that this issue should be addressed in checkpoint, and some readahead
flows too.
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-04-24 06:19:56 +02:00
|
|
|
if (sync) {
|
|
|
|
wait_on_page_locked(page);
|
2013-12-06 07:00:58 +01:00
|
|
|
if (unlikely(!PageUptodate(page))) {
|
f2fs: give a chance to merge IOs by IO scheduler
Previously, background GC submits many 4KB read requests to load victim blocks
and/or its (i)node blocks.
...
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb61, blkaddr = 0x3b964ed
f2fs_gc : block_rq_complete: 8,16 R () 499854968 + 8 [0]
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb6f, blkaddr = 0x3b964ee
f2fs_gc : block_rq_complete: 8,16 R () 499854976 + 8 [0]
f2fs_gc : f2fs_readpage: ino = 1, page_index = 0xb79, blkaddr = 0x3b964ef
f2fs_gc : block_rq_complete: 8,16 R () 499854984 + 8 [0]
...
However, by the fact that many IOs are sequential, we can give a chance to merge
the IOs by IO scheduler.
In order to do that, let's use blk_plug.
...
f2fs_gc : f2fs_iget: ino = 143
f2fs_gc : f2fs_readpage: ino = 143, page_index = 0x1c6, blkaddr = 0x2e6ee
f2fs_gc : f2fs_iget: ino = 143
f2fs_gc : f2fs_readpage: ino = 143, page_index = 0x1c7, blkaddr = 0x2e6ef
<idle> : block_rq_complete: 8,16 R () 1519616 + 8 [0]
<idle> : block_rq_complete: 8,16 R () 1519848 + 8 [0]
<idle> : block_rq_complete: 8,16 R () 1520432 + 96 [0]
<idle> : block_rq_complete: 8,16 R () 1520536 + 104 [0]
<idle> : block_rq_complete: 8,16 R () 1521008 + 112 [0]
<idle> : block_rq_complete: 8,16 R () 1521440 + 152 [0]
<idle> : block_rq_complete: 8,16 R () 1521688 + 144 [0]
<idle> : block_rq_complete: 8,16 R () 1522128 + 192 [0]
<idle> : block_rq_complete: 8,16 R () 1523256 + 328 [0]
...
Note that this issue should be addressed in checkpoint, and some readahead
flows too.
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-04-24 06:19:56 +02:00
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
}
|
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
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
|
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
struct page *page;
|
|
|
|
int err;
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info fio = {
|
|
|
|
.type = DATA,
|
|
|
|
.rw = READ_SYNC,
|
|
|
|
};
|
2013-05-13 01:38:35 +02:00
|
|
|
repeat:
|
2014-04-29 10:35:10 +02:00
|
|
|
page = grab_cache_page(mapping, index);
|
2013-05-13 01:38:35 +02:00
|
|
|
if (!page)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
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);
|
2013-05-13 01:38:35 +02:00
|
|
|
if (err) {
|
|
|
|
f2fs_put_page(page, 1);
|
2012-11-02 09:10:12 +01:00
|
|
|
return ERR_PTR(err);
|
2013-05-13 01:38:35 +02:00
|
|
|
}
|
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)) {
|
2013-05-13 01:38:35 +02:00
|
|
|
f2fs_put_page(page, 1);
|
2012-11-02 09:10:12 +01:00
|
|
|
return ERR_PTR(-ENOENT);
|
2013-05-13 01:38:35 +02:00
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
if (PageUptodate(page))
|
|
|
|
return page;
|
|
|
|
|
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);
|
|
|
|
return page;
|
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2014-12-18 04:33:13 +01:00
|
|
|
fio.blk_addr = dn.data_blkaddr;
|
|
|
|
err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
|
2013-03-08 13:29:23 +01:00
|
|
|
if (err)
|
2012-11-02 09:10:12 +01:00
|
|
|
return ERR_PTR(err);
|
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().
|
2013-12-27 09:04:17 +01:00
|
|
|
* Note that, ipage is set only by make_empty_dir.
|
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;
|
|
|
|
|
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);
|
2012-11-02 09:10:12 +01:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
2013-04-26 04:55:17 +02:00
|
|
|
repeat:
|
2012-11-02 09:10:12 +01:00
|
|
|
page = grab_cache_page(mapping, index);
|
2013-12-27 09:04:17 +01:00
|
|
|
if (!page) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto put_err;
|
|
|
|
}
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
if (PageUptodate(page))
|
|
|
|
return page;
|
|
|
|
|
|
|
|
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 {
|
2014-12-18 04:33:13 +01:00
|
|
|
struct f2fs_io_info fio = {
|
|
|
|
.type = DATA,
|
|
|
|
.rw = READ_SYNC,
|
|
|
|
.blk_addr = dn.data_blkaddr,
|
|
|
|
};
|
|
|
|
err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
|
2013-03-08 13:29:23 +01:00
|
|
|
if (err)
|
2013-12-27 09:04:17 +01:00
|
|
|
goto put_err;
|
|
|
|
|
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);
|
2013-12-27 09:04:17 +01:00
|
|
|
err = -EIO;
|
|
|
|
goto put_err;
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_i_size &&
|
|
|
|
i_size_read(inode) < ((index + 1) << PAGE_CACHE_SHIFT)) {
|
|
|
|
i_size_write(inode, ((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-27 09:04:17 +01:00
|
|
|
|
|
|
|
put_err:
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
return ERR_PTR(err);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
allocate_data_block(sbi, NULL, NULL_ADDR, &dn->data_blkaddr, &sum, seg);
|
2013-12-16 11:04:05 +01:00
|
|
|
|
|
|
|
/* direct IO doesn't use extent cache to maximize the performance */
|
2014-12-31 08:12:11 +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;
|
|
|
|
if (i_size_read(dn->inode) < ((fofs + 1) << PAGE_CACHE_SHIFT))
|
|
|
|
i_size_write(dn->inode, ((fofs + 1) << PAGE_CACHE_SHIFT));
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-09 21:09:53 +01:00
|
|
|
static void __allocate_data_blocks(struct inode *inode, loff_t offset,
|
|
|
|
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;
|
|
|
|
|
|
|
|
while (len) {
|
|
|
|
f2fs_balance_fs(sbi);
|
|
|
|
f2fs_lock_op(sbi);
|
|
|
|
|
|
|
|
/* When reading holes, we need its node page */
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
|
|
|
if (get_dnode_of_data(&dn, start, ALLOC_NODE))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
allocated = false;
|
|
|
|
end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
|
|
|
|
|
|
|
|
while (dn.ofs_in_node < end_offset && len) {
|
|
|
|
if (dn.data_blkaddr == NULL_ADDR) {
|
|
|
|
if (__allocate_data_block(&dn))
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
sync_out:
|
|
|
|
if (allocated)
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
out:
|
|
|
|
f2fs_unlock_op(sbi);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-11-29 05:28:09 +01:00
|
|
|
/*
|
2013-12-21 11:02:14 +01:00
|
|
|
* get_data_block() now supported readahead/bmap/rw direct_IO with mapped bh.
|
|
|
|
* 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
|
|
|
*/
|
2014-06-13 06:02:11 +02:00
|
|
|
static int __get_data_block(struct inode *inode, sector_t iblock,
|
|
|
|
struct buffer_head *bh_result, int create, bool fiemap)
|
2012-11-02 09:10:12 +01:00
|
|
|
{
|
|
|
|
unsigned int blkbits = inode->i_sb->s_blocksize_bits;
|
|
|
|
unsigned maxblocks = bh_result->b_size >> blkbits;
|
|
|
|
struct dnode_of_data dn;
|
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;
|
|
|
|
bool allocated = false;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
/* Get the page offset from the block offset(iblock) */
|
|
|
|
pgofs = (pgoff_t)(iblock >> (PAGE_CACHE_SHIFT - blkbits));
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
if (check_extent_cache(inode, pgofs, bh_result))
|
|
|
|
goto out;
|
|
|
|
|
2015-02-09 21:09:53 +01:00
|
|
|
if (create)
|
2014-09-03 00:31:18 +02:00
|
|
|
f2fs_lock_op(F2FS_I_SB(inode));
|
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
|
|
|
}
|
2014-06-13 06:02:11 +02:00
|
|
|
if (dn.data_blkaddr == NEW_ADDR && !fiemap)
|
2013-12-26 08:55:22 +01:00
|
|
|
goto put_out;
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
if (dn.data_blkaddr != NULL_ADDR) {
|
2015-02-09 19:34:38 +01:00
|
|
|
set_buffer_new(bh_result);
|
2013-12-16 11:04:05 +01:00
|
|
|
map_bh(bh_result, inode->i_sb, dn.data_blkaddr);
|
|
|
|
} else if (create) {
|
|
|
|
err = __allocate_data_block(&dn);
|
|
|
|
if (err)
|
|
|
|
goto put_out;
|
|
|
|
allocated = true;
|
2015-02-09 19:34:38 +01:00
|
|
|
set_buffer_new(bh_result);
|
2013-12-16 11:04:05 +01:00
|
|
|
map_bh(bh_result, inode->i_sb, dn.data_blkaddr);
|
|
|
|
} else {
|
|
|
|
goto put_out;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
bh_result->b_size = (((size_t)1) << blkbits);
|
|
|
|
dn.ofs_in_node++;
|
|
|
|
pgofs++;
|
|
|
|
|
|
|
|
get_next:
|
|
|
|
if (dn.ofs_in_node >= end_offset) {
|
|
|
|
if (allocated)
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
allocated = false;
|
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2014-06-13 06:02:11 +02:00
|
|
|
if (dn.data_blkaddr == NEW_ADDR && !fiemap)
|
2013-12-26 08:55:22 +01:00
|
|
|
goto put_out;
|
|
|
|
|
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
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
if (maxblocks > (bh_result->b_size >> blkbits)) {
|
|
|
|
block_t blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
|
|
|
|
if (blkaddr == NULL_ADDR && create) {
|
|
|
|
err = __allocate_data_block(&dn);
|
|
|
|
if (err)
|
|
|
|
goto sync_out;
|
|
|
|
allocated = true;
|
|
|
|
blkaddr = dn.data_blkaddr;
|
|
|
|
}
|
2014-08-06 16:22:50 +02:00
|
|
|
/* Give more consecutive addresses for the readahead */
|
2013-12-16 11:04:05 +01:00
|
|
|
if (blkaddr == (bh_result->b_blocknr + ofs)) {
|
|
|
|
ofs++;
|
|
|
|
dn.ofs_in_node++;
|
|
|
|
pgofs++;
|
|
|
|
bh_result->b_size += (((size_t)1) << blkbits);
|
|
|
|
goto get_next;
|
|
|
|
}
|
2012-11-02 09:10:12 +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:
|
|
|
|
if (create)
|
2014-09-03 00:31:18 +02:00
|
|
|
f2fs_unlock_op(F2FS_I_SB(inode));
|
2013-12-16 11:04:05 +01:00
|
|
|
out:
|
|
|
|
trace_f2fs_get_data_block(inode, iblock, bh_result, err);
|
|
|
|
return err;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2014-06-13 06:02:11 +02:00
|
|
|
static int get_data_block(struct inode *inode, sector_t iblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
{
|
|
|
|
return __get_data_block(inode, iblock, bh_result, create, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_data_block_fiemap(struct inode *inode, sector_t iblock,
|
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
{
|
|
|
|
return __get_data_block(inode, iblock, bh_result, create, true);
|
|
|
|
}
|
|
|
|
|
2014-06-07 21:30:14 +02:00
|
|
|
int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
|
|
|
|
u64 start, u64 len)
|
|
|
|
{
|
2014-06-13 06:02:11 +02:00
|
|
|
return generic_block_fiemap(inode, fieinfo,
|
|
|
|
start, len, get_data_block_fiemap);
|
2014-06-07 21:30:14 +02:00
|
|
|
}
|
|
|
|
|
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)
|
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
|
|
|
ret = mpage_readpage(page, get_data_block);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* If the file has inline data, skip readpages */
|
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
return 0;
|
|
|
|
|
2013-12-16 11:04:05 +01:00
|
|
|
return mpage_readpages(mapping, pages, nr_pages, get_data_block);
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2013-12-11 05:54:01 +01:00
|
|
|
int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
|
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 */
|
2014-12-18 04:33:13 +01:00
|
|
|
if (fio->blk_addr == NULL_ADDR)
|
2012-11-02 09:10:12 +01:00
|
|
|
goto out_writepage;
|
|
|
|
|
|
|
|
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) &&
|
|
|
|
need_inplace_update(inode))) {
|
2014-12-18 04:33:13 +01:00
|
|
|
rewrite_data_page(page, fio);
|
2014-07-25 16:40:59 +02:00
|
|
|
set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
|
2012-11-02 09:10:12 +01:00
|
|
|
} else {
|
2014-12-18 04:33:13 +01:00
|
|
|
write_data_page(page, &dn, fio);
|
2014-12-31 07:57:55 +01:00
|
|
|
update_extent_cache(&dn);
|
2014-07-25 16:40:59 +02:00
|
|
|
set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
|
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 = {
|
|
|
|
.type = DATA,
|
2014-01-17 21:44:39 +01:00
|
|
|
.rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,
|
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;
|
2013-12-11 05:54:01 +01:00
|
|
|
err = do_write_data_page(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)
|
2014-02-17 11:29:27 +01:00
|
|
|
err = do_write_data_page(page, &fio);
|
|
|
|
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);
|
2012-11-02 09:10:12 +01:00
|
|
|
unlock_page(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
|
|
|
if (need_balance_fs)
|
2012-11-02 09:10:12 +01:00
|
|
|
f2fs_balance_fs(sbi);
|
2014-04-24 02:49:52 +02:00
|
|
|
if (wbc->for_reclaim)
|
|
|
|
f2fs_submit_merged_bio(sbi, DATA, WRITE);
|
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;
|
|
|
|
}
|
|
|
|
|
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);
|
2013-04-30 04:33:27 +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;
|
|
|
|
|
2014-03-18 04:40:49 +01:00
|
|
|
if (S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_NONE &&
|
2014-09-13 00:53:45 +02:00
|
|
|
get_dirty_pages(inode) < nr_pages_to_skip(sbi, DATA) &&
|
2014-04-16 03:47:06 +02:00
|
|
|
available_free_memory(sbi, DIRTY_DENTS))
|
2014-03-18 05:43:05 +01:00
|
|
|
goto skip_write;
|
2014-03-18 04:40:49 +01:00
|
|
|
|
2014-03-18 05:47:11 +01:00
|
|
|
diff = nr_pages_to_write(sbi, DATA, wbc);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
2013-04-30 04:33:27 +02:00
|
|
|
if (!S_ISDIR(inode->i_mode)) {
|
2012-11-02 09:10:12 +01:00
|
|
|
mutex_lock(&sbi->writepages);
|
2013-04-30 04:33:27 +02:00
|
|
|
locked = true;
|
|
|
|
}
|
2013-01-15 08:45:24 +01:00
|
|
|
ret = write_cache_pages(mapping, wbc, __f2fs_writepage, mapping);
|
2013-04-30 04:33:27 +02:00
|
|
|
if (locked)
|
2012-11-02 09:10:12 +01:00
|
|
|
mutex_unlock(&sbi->writepages);
|
2013-12-11 05:54:01 +01:00
|
|
|
|
|
|
|
f2fs_submit_merged_bio(sbi, DATA, WRITE);
|
2012-11-02 09:10:12 +01:00
|
|
|
|
|
|
|
remove_dirty_dir_inode(inode);
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (to > inode->i_size) {
|
|
|
|
truncate_pagecache(inode, inode->i_size);
|
2014-08-15 01:32:54 +02:00
|
|
|
truncate_blocks(inode, inode->i_size, true);
|
2014-07-02 07:25:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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);
|
2014-10-18 05:33:55 +02:00
|
|
|
struct page *page, *ipage;
|
2012-11-02 09:10:12 +01:00
|
|
|
pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
int err = 0;
|
|
|
|
|
2014-05-06 10:46:04 +02:00
|
|
|
trace_f2fs_write_begin(inode, pos, len, flags);
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
f2fs_balance_fs(sbi);
|
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;
|
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
f2fs_lock_op(sbi);
|
2014-10-18 05:33:55 +02:00
|
|
|
|
|
|
|
/* check inline_data */
|
|
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
2014-12-01 04:30:20 +01:00
|
|
|
if (IS_ERR(ipage)) {
|
|
|
|
err = PTR_ERR(ipage);
|
2014-10-18 05:33:55 +02:00
|
|
|
goto unlock_fail;
|
2014-12-01 04:30:20 +01:00
|
|
|
}
|
2014-10-18 05:33:55 +02:00
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
set_new_dnode(&dn, inode, ipage, ipage, 0);
|
|
|
|
|
2014-10-18 05:33:55 +02:00
|
|
|
if (f2fs_has_inline_data(inode)) {
|
2014-10-24 04:48:09 +02:00
|
|
|
if (pos + len <= MAX_INLINE_DATA) {
|
|
|
|
read_inline_data(page, ipage);
|
|
|
|
set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
|
|
|
|
sync_inode_page(&dn);
|
|
|
|
goto put_next;
|
|
|
|
}
|
2014-11-25 19:59:45 +01:00
|
|
|
err = f2fs_convert_inline_page(&dn, page);
|
|
|
|
if (err)
|
|
|
|
goto put_fail;
|
2013-11-10 16:13:18 +01:00
|
|
|
}
|
2014-10-18 05:33:55 +02:00
|
|
|
err = f2fs_reserve_block(&dn, index);
|
|
|
|
if (err)
|
2014-11-18 01:14:11 +01:00
|
|
|
goto put_fail;
|
2014-10-24 04:48:09 +02:00
|
|
|
put_next:
|
2014-10-18 05:33:55 +02:00
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
f2fs_unlock_op(sbi);
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
|
|
|
|
return 0;
|
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
f2fs_wait_on_page_writeback(page, DATA);
|
|
|
|
|
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);
|
2013-03-08 13:29:23 +01:00
|
|
|
goto out;
|
2012-11-02 09:10:12 +01:00
|
|
|
}
|
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
if (dn.data_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 = {
|
|
|
|
.type = DATA,
|
|
|
|
.rw = READ_SYNC,
|
|
|
|
.blk_addr = dn.data_blkaddr,
|
|
|
|
};
|
|
|
|
err = f2fs_submit_page_bio(sbi, page, &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))) {
|
2013-03-08 13:29:23 +01:00
|
|
|
f2fs_put_page(page, 1);
|
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
|
|
|
}
|
|
|
|
}
|
2013-03-08 13:29:23 +01:00
|
|
|
out:
|
2012-11-02 09:10:12 +01:00
|
|
|
SetPageUptodate(page);
|
|
|
|
clear_cold_data(page);
|
|
|
|
return 0;
|
2014-10-18 05:33:55 +02:00
|
|
|
|
2014-11-18 01:14:11 +01:00
|
|
|
put_fail:
|
|
|
|
f2fs_put_dnode(&dn);
|
2014-10-18 05:33:55 +02:00
|
|
|
unlock_fail:
|
|
|
|
f2fs_unlock_op(sbi);
|
2014-10-24 04:48:09 +02:00
|
|
|
f2fs_put_page(page, 1);
|
2014-07-02 07:25:04 +02:00
|
|
|
fail:
|
|
|
|
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);
|
2013-06-27 06:04:08 +02:00
|
|
|
return copied;
|
|
|
|
}
|
|
|
|
|
2013-12-26 12:15:09 +01:00
|
|
|
static int check_direct_IO(struct inode *inode, int rw,
|
2014-03-16 23:07:34 +01:00
|
|
|
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 (rw == READ)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-11-02 09:10:12 +01:00
|
|
|
static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
|
2014-03-05 03:27:34 +01:00
|
|
|
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 */
|
|
|
|
if (f2fs_has_inline_data(inode)) {
|
|
|
|
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
|
|
|
|
2014-03-16 23:07:34 +01:00
|
|
|
if (check_direct_IO(inode, rw, iter, offset))
|
2013-12-26 12:15:09 +01:00
|
|
|
return 0;
|
|
|
|
|
2014-07-31 15:11:22 +02:00
|
|
|
trace_f2fs_direct_IO_enter(inode, offset, count, rw);
|
|
|
|
|
2015-02-09 21:09:53 +01:00
|
|
|
if (rw & WRITE)
|
|
|
|
__allocate_data_blocks(inode, offset, count);
|
|
|
|
|
2014-07-02 07:25:04 +02:00
|
|
|
err = blockdev_direct_IO(rw, iocb, inode, iter, offset, get_data_block);
|
|
|
|
if (err < 0 && (rw & WRITE))
|
|
|
|
f2fs_write_failed(mapping, offset + count);
|
2014-07-31 15:11:22 +02:00
|
|
|
|
|
|
|
trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
|
|
|
|
|
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);
|
|
|
|
}
|
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;
|
|
|
|
|
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)) {
|
2014-10-09 22:19:53 +02:00
|
|
|
register_inmem_page(inode, page);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-01-21 05:32:12 +01:00
|
|
|
mark_inode_dirty(inode);
|
|
|
|
|
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;
|
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
/* we don't need to use inline_data strictly */
|
|
|
|
if (f2fs_has_inline_data(inode)) {
|
|
|
|
int err = f2fs_convert_inline_inode(inode);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2013-12-16 11:04:05 +01:00
|
|
|
return generic_block_bmap(mapping, block, get_data_block);
|
2013-01-17 12:30:23 +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
|
|
|
};
|