2012-11-29 08:28:09 +04:00
/*
2012-11-02 12:09:44 +04:00
* fs / f2fs / file . 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/stat.h>
# include <linux/buffer_head.h>
# include <linux/writeback.h>
2013-03-16 06:13:04 +04:00
# include <linux/blkdev.h>
2012-11-02 12:09:44 +04:00
# include <linux/falloc.h>
# include <linux/types.h>
2013-02-04 18:41:41 +04:00
# include <linux/compat.h>
2012-11-02 12:09:44 +04:00
# include <linux/uaccess.h>
# include <linux/mount.h>
# include "f2fs.h"
# include "node.h"
# include "segment.h"
# include "xattr.h"
# include "acl.h"
2013-04-19 20:28:40 +04:00
# include <trace/events/f2fs.h>
2012-11-02 12:09:44 +04:00
static int f2fs_vm_page_mkwrite ( struct vm_area_struct * vma ,
struct vm_fault * vmf )
{
struct page * page = vmf - > page ;
2013-02-28 01:59:05 +04:00
struct inode * inode = file_inode ( vma - > vm_file ) ;
2012-11-02 12:09:44 +04:00
struct f2fs_sb_info * sbi = F2FS_SB ( inode - > i_sb ) ;
block_t old_blk_addr ;
struct dnode_of_data dn ;
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 11:21:29 +04:00
int err , ilock ;
2012-11-02 12:09:44 +04:00
f2fs_balance_fs ( sbi ) ;
sb_start_pagefault ( inode - > i_sb ) ;
/* block allocation */
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 11:21:29 +04:00
ilock = mutex_lock_op ( sbi ) ;
2012-11-02 12:09:44 +04:00
set_new_dnode ( & dn , inode , NULL , NULL , 0 ) ;
2013-02-26 08:10:46 +04:00
err = get_dnode_of_data ( & dn , page - > index , ALLOC_NODE ) ;
2012-11-02 12:09:44 +04:00
if ( err ) {
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
goto out ;
}
old_blk_addr = dn . data_blkaddr ;
if ( old_blk_addr = = NULL_ADDR ) {
err = reserve_new_block ( & dn ) ;
if ( err ) {
f2fs_put_dnode ( & dn ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
goto out ;
}
}
f2fs_put_dnode ( & dn ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
2013-04-28 04:04:18 +04:00
file_update_time ( vma - > vm_file ) ;
2012-11-02 12:09:44 +04:00
lock_page ( page ) ;
if ( page - > mapping ! = inode - > i_mapping | |
2013-04-28 04:04:18 +04:00
page_offset ( page ) > i_size_read ( inode ) | |
2012-11-02 12:09:44 +04:00
! PageUptodate ( page ) ) {
unlock_page ( page ) ;
err = - EFAULT ;
goto out ;
}
/*
* check to see if the page is mapped already ( no holes )
*/
if ( PageMappedToDisk ( page ) )
2013-04-28 04:04:18 +04:00
goto mapped ;
2012-11-02 12:09:44 +04:00
/* page is wholly or partially inside EOF */
if ( ( ( page - > index + 1 ) < < PAGE_CACHE_SHIFT ) > i_size_read ( inode ) ) {
unsigned offset ;
offset = i_size_read ( inode ) & ~ PAGE_CACHE_MASK ;
zero_user_segment ( page , offset , PAGE_CACHE_SIZE ) ;
}
set_page_dirty ( page ) ;
SetPageUptodate ( page ) ;
2013-04-28 04:04:18 +04:00
mapped :
/* fill the page */
wait_on_page_writeback ( page ) ;
2012-11-02 12:09:44 +04:00
out :
sb_end_pagefault ( inode - > i_sb ) ;
return block_page_mkwrite_return ( err ) ;
}
static const struct vm_operations_struct f2fs_file_vm_ops = {
2013-01-17 13:37:41 +04:00
. fault = filemap_fault ,
. page_mkwrite = f2fs_vm_page_mkwrite ,
. remap_pages = generic_file_remap_pages ,
2012-11-02 12:09:44 +04:00
} ;
int f2fs_sync_file ( struct file * file , loff_t start , loff_t end , int datasync )
{
struct inode * inode = file - > f_mapping - > host ;
struct f2fs_sb_info * sbi = F2FS_SB ( inode - > i_sb ) ;
int ret = 0 ;
bool need_cp = false ;
struct writeback_control wbc = {
. sync_mode = WB_SYNC_ALL ,
. nr_to_write = LONG_MAX ,
. for_reclaim = 0 ,
} ;
2013-05-20 15:28:47 +04:00
if ( f2fs_readonly ( inode - > i_sb ) )
2012-12-01 05:56:01 +04:00
return 0 ;
2013-04-19 20:28:40 +04:00
trace_f2fs_sync_file_enter ( inode ) ;
2012-11-02 12:09:44 +04:00
ret = filemap_write_and_wait_range ( inode - > i_mapping , start , end ) ;
2013-04-19 20:28:40 +04:00
if ( ret ) {
trace_f2fs_sync_file_exit ( inode , need_cp , datasync , ret ) ;
2012-11-02 12:09:44 +04:00
return ret ;
2013-04-19 20:28:40 +04:00
}
2012-11-02 12:09:44 +04:00
2013-01-11 08:10:49 +04:00
/* guarantee free sections for fsync */
f2fs_balance_fs ( sbi ) ;
2012-11-02 12:09:44 +04:00
mutex_lock ( & inode - > i_mutex ) ;
if ( datasync & & ! ( inode - > i_state & I_DIRTY_DATASYNC ) )
goto out ;
if ( ! S_ISREG ( inode - > i_mode ) | | inode - > i_nlink ! = 1 )
need_cp = true ;
2013-03-21 10:21:57 +04:00
else if ( is_cp_file ( inode ) )
2012-11-02 12:09:44 +04:00
need_cp = true ;
2013-01-31 12:16:56 +04:00
else if ( ! space_for_roll_forward ( sbi ) )
2012-11-02 12:09:44 +04:00
need_cp = true ;
2013-03-21 10:21:57 +04:00
else if ( ! is_checkpointed_node ( sbi , F2FS_I ( inode ) - > i_pino ) )
2012-11-02 12:09:44 +04:00
need_cp = true ;
if ( need_cp ) {
/* all the dirty node pages should be flushed for POR */
ret = f2fs_sync_fs ( inode - > i_sb , 1 ) ;
} else {
f2fs: fix handling errors got by f2fs_write_inode
Ruslan reported that f2fs hangs with an infinite loop in f2fs_sync_file():
while (sync_node_pages(sbi, inode->i_ino, &wbc) == 0)
f2fs_write_inode(inode, NULL);
The reason was revealed that the cold flag is not set even thought this inode is
a normal file. Therefore, sync_node_pages() skips to write node blocks since it
only writes cold node blocks.
The cold flag is stored to the node_footer in node block, and whenever a new
node page is allocated, it is set according to its file type, file or directory.
But, after sudden-power-off, when recovering the inode page, f2fs doesn't recover
its cold flag.
So, let's assign the cold flag in more right places.
One more thing:
If f2fs_write_inode() returns an error due to whatever situations, there would
be no dirty node pages so that sync_node_pages() returns zero.
(i.e., zero means nothing was written.)
Reported-by: Ruslan N. Marchenko <me@ruff.mobi>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-12-19 10:28:39 +04:00
/* if there is no written node page, write its inode page */
while ( ! sync_node_pages ( sbi , inode - > i_ino , & wbc ) ) {
ret = f2fs_write_inode ( inode , NULL ) ;
if ( ret )
goto out ;
}
2012-11-02 12:09:44 +04:00
filemap_fdatawait_range ( sbi - > node_inode - > i_mapping ,
0 , LONG_MAX ) ;
2013-03-16 06:13:04 +04:00
ret = blkdev_issue_flush ( inode - > i_sb - > s_bdev , GFP_KERNEL , NULL ) ;
2012-11-02 12:09:44 +04:00
}
out :
mutex_unlock ( & inode - > i_mutex ) ;
2013-04-19 20:28:40 +04:00
trace_f2fs_sync_file_exit ( inode , need_cp , datasync , ret ) ;
2012-11-02 12:09:44 +04:00
return ret ;
}
static int f2fs_file_mmap ( struct file * file , struct vm_area_struct * vma )
{
file_accessed ( file ) ;
vma - > vm_ops = & f2fs_file_vm_ops ;
return 0 ;
}
static int truncate_data_blocks_range ( struct dnode_of_data * dn , int count )
{
int nr_free = 0 , ofs = dn - > ofs_in_node ;
struct f2fs_sb_info * sbi = F2FS_SB ( dn - > inode - > i_sb ) ;
struct f2fs_node * raw_node ;
__le32 * addr ;
raw_node = page_address ( dn - > node_page ) ;
addr = blkaddr_in_node ( raw_node ) + ofs ;
for ( ; count > 0 ; count - - , addr + + , dn - > ofs_in_node + + ) {
block_t blkaddr = le32_to_cpu ( * addr ) ;
if ( blkaddr = = NULL_ADDR )
continue ;
update_extent_cache ( NULL_ADDR , dn ) ;
invalidate_blocks ( sbi , blkaddr ) ;
dec_valid_block_count ( sbi , dn - > inode , 1 ) ;
nr_free + + ;
}
if ( nr_free ) {
set_page_dirty ( dn - > node_page ) ;
sync_inode_page ( dn ) ;
}
dn - > ofs_in_node = ofs ;
2013-04-19 20:28:52 +04:00
trace_f2fs_truncate_data_blocks_range ( dn - > inode , dn - > nid ,
dn - > ofs_in_node , nr_free ) ;
2012-11-02 12:09:44 +04:00
return nr_free ;
}
void truncate_data_blocks ( struct dnode_of_data * dn )
{
truncate_data_blocks_range ( dn , ADDRS_PER_BLOCK ) ;
}
static void truncate_partial_data_page ( struct inode * inode , u64 from )
{
unsigned offset = from & ( PAGE_CACHE_SIZE - 1 ) ;
struct page * page ;
if ( ! offset )
return ;
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 08:19:56 +04:00
page = find_data_page ( inode , from > > PAGE_CACHE_SHIFT , false ) ;
2012-11-02 12:09:44 +04:00
if ( IS_ERR ( page ) )
return ;
lock_page ( page ) ;
2013-04-26 06:55:17 +04:00
if ( page - > mapping ! = inode - > i_mapping ) {
f2fs_put_page ( page , 1 ) ;
return ;
}
2012-11-02 12:09:44 +04:00
wait_on_page_writeback ( page ) ;
zero_user ( page , offset , PAGE_CACHE_SIZE - offset ) ;
set_page_dirty ( page ) ;
f2fs_put_page ( page , 1 ) ;
}
static int truncate_blocks ( struct inode * inode , u64 from )
{
struct f2fs_sb_info * sbi = F2FS_SB ( inode - > i_sb ) ;
unsigned int blocksize = inode - > i_sb - > s_blocksize ;
struct dnode_of_data dn ;
pgoff_t free_from ;
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 11:21:29 +04:00
int count = 0 , ilock = - 1 ;
2012-11-02 12:09:44 +04:00
int err ;
2013-04-19 20:28:52 +04:00
trace_f2fs_truncate_blocks_enter ( inode , from ) ;
2012-11-02 12:09:44 +04:00
free_from = ( pgoff_t )
( ( from + blocksize - 1 ) > > ( sbi - > log_blocksize ) ) ;
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 11:21:29 +04:00
ilock = mutex_lock_op ( sbi ) ;
2012-11-02 12:09:44 +04:00
set_new_dnode ( & dn , inode , NULL , NULL , 0 ) ;
2013-02-26 08:10:46 +04:00
err = get_dnode_of_data ( & dn , free_from , LOOKUP_NODE ) ;
2012-11-02 12:09:44 +04:00
if ( err ) {
if ( err = = - ENOENT )
goto free_next ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2013-04-19 20:28:52 +04:00
trace_f2fs_truncate_blocks_exit ( inode , err ) ;
2012-11-02 12:09:44 +04:00
return err ;
}
if ( IS_INODE ( dn . node_page ) )
count = ADDRS_PER_INODE ;
else
count = ADDRS_PER_BLOCK ;
count - = dn . ofs_in_node ;
BUG_ON ( count < 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 11:21:29 +04:00
2012-11-02 12:09:44 +04:00
if ( dn . ofs_in_node | | IS_INODE ( dn . node_page ) ) {
truncate_data_blocks_range ( & dn , count ) ;
free_from + = count ;
}
f2fs_put_dnode ( & dn ) ;
free_next :
err = truncate_inode_blocks ( inode , free_from ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
/* lastly zero out the first data page */
truncate_partial_data_page ( inode , from ) ;
2013-04-19 20:28:52 +04:00
trace_f2fs_truncate_blocks_exit ( inode , err ) ;
2012-11-02 12:09:44 +04:00
return err ;
}
void f2fs_truncate ( struct inode * inode )
{
if ( ! ( S_ISREG ( inode - > i_mode ) | | S_ISDIR ( inode - > i_mode ) | |
S_ISLNK ( inode - > i_mode ) ) )
return ;
2013-04-19 20:28:52 +04:00
trace_f2fs_truncate ( inode ) ;
2012-11-02 12:09:44 +04:00
if ( ! truncate_blocks ( inode , i_size_read ( inode ) ) ) {
inode - > i_mtime = inode - > i_ctime = CURRENT_TIME ;
mark_inode_dirty ( inode ) ;
}
}
static int f2fs_getattr ( struct vfsmount * mnt ,
struct dentry * dentry , struct kstat * stat )
{
struct inode * inode = dentry - > d_inode ;
generic_fillattr ( inode , stat ) ;
stat - > blocks < < = 3 ;
return 0 ;
}
# ifdef CONFIG_F2FS_FS_POSIX_ACL
static void __setattr_copy ( struct inode * inode , const struct iattr * attr )
{
struct f2fs_inode_info * fi = F2FS_I ( inode ) ;
unsigned int ia_valid = attr - > ia_valid ;
if ( ia_valid & ATTR_UID )
inode - > i_uid = attr - > ia_uid ;
if ( ia_valid & ATTR_GID )
inode - > i_gid = attr - > ia_gid ;
if ( ia_valid & ATTR_ATIME )
inode - > i_atime = timespec_trunc ( attr - > ia_atime ,
inode - > i_sb - > s_time_gran ) ;
if ( ia_valid & ATTR_MTIME )
inode - > i_mtime = timespec_trunc ( attr - > ia_mtime ,
inode - > i_sb - > s_time_gran ) ;
if ( ia_valid & ATTR_CTIME )
inode - > i_ctime = timespec_trunc ( attr - > ia_ctime ,
inode - > i_sb - > s_time_gran ) ;
if ( ia_valid & ATTR_MODE ) {
umode_t mode = attr - > ia_mode ;
if ( ! in_group_p ( inode - > i_gid ) & & ! capable ( CAP_FSETID ) )
mode & = ~ S_ISGID ;
set_acl_inode ( fi , mode ) ;
}
}
# else
# define __setattr_copy setattr_copy
# endif
int f2fs_setattr ( struct dentry * dentry , struct iattr * attr )
{
struct inode * inode = dentry - > d_inode ;
struct f2fs_inode_info * fi = F2FS_I ( inode ) ;
int err ;
err = inode_change_ok ( inode , attr ) ;
if ( err )
return err ;
if ( ( attr - > ia_valid & ATTR_SIZE ) & &
attr - > ia_size ! = i_size_read ( inode ) ) {
truncate_setsize ( inode , attr - > ia_size ) ;
f2fs_truncate ( inode ) ;
f2fs: avoid balanc_fs during evict_inode
1. Background
Previously, if f2fs tries to move data blocks of an *evicting* inode during the
cleaning process, it stops the process incompletely and then restarts the whole
process, since it needs a locked inode to grab victim data pages in its address
space. In order to get a locked inode, iget_locked() by f2fs_iget() is normally
used, but, it waits if the inode is on freeing.
So, here is a deadlock scenario.
1. f2fs_evict_inode() <- inode "A"
2. f2fs_balance_fs()
3. f2fs_gc()
4. gc_data_segment()
5. f2fs_iget() <- inode "A" too!
If step #1 and #5 treat a same inode "A", step #5 would fall into deadlock since
the inode "A" is on freeing. In order to resolve this, f2fs_iget_nowait() which
skips __wait_on_freeing_inode() was introduced in step #5, and stops f2fs_gc()
to complete f2fs_evict_inode().
1. f2fs_evict_inode() <- inode "A"
2. f2fs_balance_fs()
3. f2fs_gc()
4. gc_data_segment()
5. f2fs_iget_nowait() <- inode "A", then stop f2fs_gc() w/ -ENOENT
2. Problem and Solution
In the above scenario, however, f2fs cannot finish f2fs_evict_inode() only if:
o there are not enough free sections, and
o f2fs_gc() tries to move data blocks of the *evicting* inode repeatedly.
So, the final solution is to use f2fs_iget() and remove f2fs_balance_fs() in
f2fs_evict_inode().
The f2fs_evict_inode() actually truncates all the data and node blocks, which
means that it doesn't produce any dirty node pages accordingly.
So, we don't need to do f2fs_balance_fs() in practical.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-01-31 10:36:04 +04:00
f2fs_balance_fs ( F2FS_SB ( inode - > i_sb ) ) ;
2012-11-02 12:09:44 +04:00
}
__setattr_copy ( inode , attr ) ;
if ( attr - > ia_valid & ATTR_MODE ) {
err = f2fs_acl_chmod ( inode ) ;
if ( err | | is_inode_flag_set ( fi , FI_ACL_MODE ) ) {
inode - > i_mode = fi - > i_acl_mode ;
clear_inode_flag ( fi , FI_ACL_MODE ) ;
}
}
mark_inode_dirty ( inode ) ;
return err ;
}
const struct inode_operations f2fs_file_inode_operations = {
. getattr = f2fs_getattr ,
. setattr = f2fs_setattr ,
. get_acl = f2fs_get_acl ,
# ifdef CONFIG_F2FS_FS_XATTR
. setxattr = generic_setxattr ,
. getxattr = generic_getxattr ,
. listxattr = f2fs_listxattr ,
. removexattr = generic_removexattr ,
# endif
} ;
static void fill_zero ( struct inode * inode , pgoff_t index ,
loff_t start , loff_t len )
{
2013-01-25 13:33:41 +04:00
struct f2fs_sb_info * sbi = F2FS_SB ( inode - > i_sb ) ;
2012-11-02 12:09:44 +04:00
struct 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 11:21:29 +04:00
int ilock ;
2012-11-02 12:09:44 +04:00
if ( ! len )
return ;
2013-01-25 13:33:41 +04:00
f2fs_balance_fs ( sbi ) ;
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 11:21:29 +04:00
ilock = mutex_lock_op ( sbi ) ;
2013-05-20 04:55:50 +04:00
page = get_new_data_page ( inode , NULL , index , false ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
if ( ! IS_ERR ( page ) ) {
wait_on_page_writeback ( page ) ;
zero_user ( page , start , len ) ;
set_page_dirty ( page ) ;
f2fs_put_page ( page , 1 ) ;
}
}
int truncate_hole ( struct inode * inode , pgoff_t pg_start , pgoff_t pg_end )
{
pgoff_t index ;
int err ;
for ( index = pg_start ; index < pg_end ; index + + ) {
struct dnode_of_data dn ;
2013-01-11 09:09:38 +04:00
2012-11-02 12:09:44 +04:00
set_new_dnode ( & dn , inode , NULL , NULL , 0 ) ;
2013-02-26 08:10:46 +04:00
err = get_dnode_of_data ( & dn , index , LOOKUP_NODE ) ;
2012-11-02 12:09:44 +04:00
if ( err ) {
if ( err = = - ENOENT )
continue ;
return err ;
}
if ( dn . data_blkaddr ! = NULL_ADDR )
truncate_data_blocks_range ( & dn , 1 ) ;
f2fs_put_dnode ( & dn ) ;
}
return 0 ;
}
static int punch_hole ( struct inode * inode , loff_t offset , loff_t len , int mode )
{
pgoff_t pg_start , pg_end ;
loff_t off_start , off_end ;
int ret = 0 ;
pg_start = ( ( unsigned long long ) offset ) > > PAGE_CACHE_SHIFT ;
pg_end = ( ( unsigned long long ) offset + len ) > > PAGE_CACHE_SHIFT ;
off_start = offset & ( PAGE_CACHE_SIZE - 1 ) ;
off_end = ( offset + len ) & ( PAGE_CACHE_SIZE - 1 ) ;
if ( pg_start = = pg_end ) {
fill_zero ( inode , pg_start , off_start ,
off_end - off_start ) ;
} else {
if ( off_start )
fill_zero ( inode , pg_start + + , off_start ,
PAGE_CACHE_SIZE - off_start ) ;
if ( off_end )
fill_zero ( inode , pg_end , 0 , off_end ) ;
if ( pg_start < pg_end ) {
struct address_space * mapping = inode - > i_mapping ;
loff_t blk_start , blk_end ;
2013-04-09 05:16:44 +04:00
struct f2fs_sb_info * sbi = F2FS_SB ( inode - > i_sb ) ;
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 11:21:29 +04:00
int ilock ;
2013-04-09 05:16:44 +04:00
f2fs_balance_fs ( sbi ) ;
2012-11-02 12:09:44 +04:00
blk_start = pg_start < < PAGE_CACHE_SHIFT ;
blk_end = pg_end < < PAGE_CACHE_SHIFT ;
truncate_inode_pages_range ( mapping , blk_start ,
blk_end - 1 ) ;
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 11:21:29 +04:00
ilock = mutex_lock_op ( sbi ) ;
2012-11-02 12:09:44 +04:00
ret = truncate_hole ( inode , pg_start , pg_end ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
}
}
if ( ! ( mode & FALLOC_FL_KEEP_SIZE ) & &
i_size_read ( inode ) < = ( offset + len ) ) {
i_size_write ( inode , offset ) ;
mark_inode_dirty ( inode ) ;
}
return ret ;
}
static int expand_inode_data ( struct inode * inode , loff_t offset ,
loff_t len , int mode )
{
struct f2fs_sb_info * sbi = F2FS_SB ( inode - > i_sb ) ;
pgoff_t index , pg_start , pg_end ;
loff_t new_size = i_size_read ( inode ) ;
loff_t off_start , off_end ;
int ret = 0 ;
ret = inode_newsize_ok ( inode , ( len + offset ) ) ;
if ( ret )
return ret ;
pg_start = ( ( unsigned long long ) offset ) > > PAGE_CACHE_SHIFT ;
pg_end = ( ( unsigned long long ) offset + len ) > > PAGE_CACHE_SHIFT ;
off_start = offset & ( PAGE_CACHE_SIZE - 1 ) ;
off_end = ( offset + len ) & ( PAGE_CACHE_SIZE - 1 ) ;
for ( index = pg_start ; index < = pg_end ; index + + ) {
struct dnode_of_data dn ;
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 11:21:29 +04:00
int ilock ;
2012-11-02 12:09:44 +04: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 11:21:29 +04:00
ilock = mutex_lock_op ( sbi ) ;
2012-11-02 12:09:44 +04:00
set_new_dnode ( & dn , inode , NULL , NULL , 0 ) ;
2013-02-26 08:10:46 +04:00
ret = get_dnode_of_data ( & dn , index , ALLOC_NODE ) ;
2012-11-02 12:09:44 +04:00
if ( ret ) {
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
break ;
}
if ( dn . data_blkaddr = = NULL_ADDR ) {
ret = reserve_new_block ( & dn ) ;
if ( ret ) {
f2fs_put_dnode ( & dn ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
break ;
}
}
f2fs_put_dnode ( & dn ) ;
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 11:21:29 +04:00
mutex_unlock_op ( sbi , ilock ) ;
2012-11-02 12:09:44 +04:00
if ( pg_start = = pg_end )
new_size = offset + len ;
else if ( index = = pg_start & & off_start )
new_size = ( index + 1 ) < < PAGE_CACHE_SHIFT ;
else if ( index = = pg_end )
new_size = ( index < < PAGE_CACHE_SHIFT ) + off_end ;
else
new_size + = PAGE_CACHE_SIZE ;
}
if ( ! ( mode & FALLOC_FL_KEEP_SIZE ) & &
i_size_read ( inode ) < new_size ) {
i_size_write ( inode , new_size ) ;
mark_inode_dirty ( inode ) ;
}
return ret ;
}
static long f2fs_fallocate ( struct file * file , int mode ,
loff_t offset , loff_t len )
{
2013-02-28 01:59:05 +04:00
struct inode * inode = file_inode ( file ) ;
2012-11-02 12:09:44 +04:00
long ret ;
if ( mode & ~ ( FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE ) )
return - EOPNOTSUPP ;
if ( mode & FALLOC_FL_PUNCH_HOLE )
ret = punch_hole ( inode , offset , len , mode ) ;
else
ret = expand_inode_data ( inode , offset , len , mode ) ;
2012-12-30 09:52:37 +04:00
if ( ! ret ) {
inode - > i_mtime = inode - > i_ctime = CURRENT_TIME ;
mark_inode_dirty ( inode ) ;
}
2013-04-23 12:00:52 +04:00
trace_f2fs_fallocate ( inode , mode , offset , len , ret ) ;
2012-11-02 12:09:44 +04:00
return ret ;
}
# define F2FS_REG_FLMASK (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
# define F2FS_OTHER_FLMASK (FS_NODUMP_FL | FS_NOATIME_FL)
static inline __u32 f2fs_mask_flags ( umode_t mode , __u32 flags )
{
if ( S_ISDIR ( mode ) )
return flags ;
else if ( S_ISREG ( mode ) )
return flags & F2FS_REG_FLMASK ;
else
return flags & F2FS_OTHER_FLMASK ;
}
long f2fs_ioctl ( struct file * filp , unsigned int cmd , unsigned long arg )
{
2013-02-28 01:59:05 +04:00
struct inode * inode = file_inode ( filp ) ;
2012-11-02 12:09:44 +04:00
struct f2fs_inode_info * fi = F2FS_I ( inode ) ;
unsigned int flags ;
int ret ;
switch ( cmd ) {
case FS_IOC_GETFLAGS :
flags = fi - > i_flags & FS_FL_USER_VISIBLE ;
return put_user ( flags , ( int __user * ) arg ) ;
case FS_IOC_SETFLAGS :
{
unsigned int oldflags ;
2013-03-20 17:33:23 +04:00
ret = mnt_want_write_file ( filp ) ;
2012-11-02 12:09:44 +04:00
if ( ret )
return ret ;
if ( ! inode_owner_or_capable ( inode ) ) {
ret = - EACCES ;
goto out ;
}
if ( get_user ( flags , ( int __user * ) arg ) ) {
ret = - EFAULT ;
goto out ;
}
flags = f2fs_mask_flags ( inode - > i_mode , flags ) ;
mutex_lock ( & inode - > i_mutex ) ;
oldflags = fi - > i_flags ;
if ( ( flags ^ oldflags ) & ( FS_APPEND_FL | FS_IMMUTABLE_FL ) ) {
if ( ! capable ( CAP_LINUX_IMMUTABLE ) ) {
mutex_unlock ( & inode - > i_mutex ) ;
ret = - EPERM ;
goto out ;
}
}
flags = flags & FS_FL_USER_MODIFIABLE ;
flags | = oldflags & ~ FS_FL_USER_MODIFIABLE ;
fi - > i_flags = flags ;
mutex_unlock ( & inode - > i_mutex ) ;
f2fs_set_inode_flags ( inode ) ;
inode - > i_ctime = CURRENT_TIME ;
mark_inode_dirty ( inode ) ;
out :
2013-03-20 17:33:23 +04:00
mnt_drop_write_file ( filp ) ;
2012-11-02 12:09:44 +04:00
return ret ;
}
default :
return - ENOTTY ;
}
}
2013-02-04 18:41:41 +04:00
# ifdef CONFIG_COMPAT
long f2fs_compat_ioctl ( struct file * file , unsigned int cmd , unsigned long arg )
{
switch ( cmd ) {
case F2FS_IOC32_GETFLAGS :
cmd = F2FS_IOC_GETFLAGS ;
break ;
case F2FS_IOC32_SETFLAGS :
cmd = F2FS_IOC_SETFLAGS ;
break ;
default :
return - ENOIOCTLCMD ;
}
return f2fs_ioctl ( file , cmd , ( unsigned long ) compat_ptr ( arg ) ) ;
}
# endif
2012-11-02 12:09:44 +04:00
const struct file_operations f2fs_file_operations = {
. llseek = generic_file_llseek ,
. read = do_sync_read ,
. write = do_sync_write ,
. aio_read = generic_file_aio_read ,
. aio_write = generic_file_aio_write ,
. open = generic_file_open ,
. mmap = f2fs_file_mmap ,
. fsync = f2fs_sync_file ,
. fallocate = f2fs_fallocate ,
. unlocked_ioctl = f2fs_ioctl ,
2013-02-04 18:41:41 +04:00
# ifdef CONFIG_COMPAT
. compat_ioctl = f2fs_compat_ioctl ,
# endif
2012-11-02 12:09:44 +04:00
. splice_read = generic_file_splice_read ,
. splice_write = generic_file_splice_write ,
} ;
