2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2012-11-02 08:08:18 +00:00
|
|
|
* fs/f2fs/checkpoint.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/bio.h>
|
|
|
|
#include <linux/mpage.h>
|
|
|
|
#include <linux/writeback.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/f2fs_fs.h>
|
|
|
|
#include <linux/pagevec.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
|
|
|
|
#include "f2fs.h"
|
|
|
|
#include "node.h"
|
|
|
|
#include "segment.h"
|
2013-04-23 09:26:54 +00:00
|
|
|
#include <trace/events/f2fs.h>
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-07-25 22:47:17 +00:00
|
|
|
static struct kmem_cache *ino_entry_slab;
|
2012-11-02 08:08:18 +00:00
|
|
|
static struct kmem_cache *inode_entry_slab;
|
|
|
|
|
2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2012-11-02 08:08:18 +00:00
|
|
|
* We guarantee no failure on the returned page.
|
|
|
|
*/
|
|
|
|
struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
|
|
|
|
{
|
2014-01-20 10:37:04 +00:00
|
|
|
struct address_space *mapping = META_MAPPING(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
struct page *page = NULL;
|
|
|
|
repeat:
|
2014-04-30 00:18:53 +00:00
|
|
|
page = grab_cache_page(mapping, index);
|
2012-11-02 08:08:18 +00:00
|
|
|
if (!page) {
|
|
|
|
cond_resched();
|
|
|
|
goto repeat;
|
|
|
|
}
|
2014-04-30 00:18:53 +00:00
|
|
|
f2fs_wait_on_page_writeback(page, META);
|
2012-11-02 08:08:18 +00:00
|
|
|
SetPageUptodate(page);
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2012-11-02 08:08:18 +00:00
|
|
|
* We guarantee no failure on the returned page.
|
|
|
|
*/
|
|
|
|
struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
|
|
|
|
{
|
2014-01-20 10:37:04 +00:00
|
|
|
struct address_space *mapping = META_MAPPING(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
struct page *page;
|
|
|
|
repeat:
|
|
|
|
page = grab_cache_page(mapping, index);
|
|
|
|
if (!page) {
|
|
|
|
cond_resched();
|
|
|
|
goto repeat;
|
|
|
|
}
|
2013-03-08 12:29:23 +00:00
|
|
|
if (PageUptodate(page))
|
|
|
|
goto out;
|
|
|
|
|
2013-11-30 03:51:14 +00:00
|
|
|
if (f2fs_submit_page_bio(sbi, page, index,
|
|
|
|
READ_SYNC | REQ_META | REQ_PRIO))
|
2012-11-02 08:08:18 +00:00
|
|
|
goto repeat;
|
|
|
|
|
2013-03-08 12:29:23 +00:00
|
|
|
lock_page(page);
|
2013-12-06 06:00:58 +00:00
|
|
|
if (unlikely(page->mapping != mapping)) {
|
2013-04-26 02:55:17 +00:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
goto repeat;
|
|
|
|
}
|
2013-03-08 12:29:23 +00:00
|
|
|
out:
|
2012-11-02 08:08:18 +00:00
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2014-12-08 06:59:17 +00:00
|
|
|
static inline bool is_valid_blkaddr(struct f2fs_sb_info *sbi,
|
|
|
|
block_t blkaddr, int type)
|
2014-02-07 08:11:53 +00:00
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case META_NAT:
|
2014-12-08 06:59:17 +00:00
|
|
|
break;
|
2014-02-07 08:11:53 +00:00
|
|
|
case META_SIT:
|
2014-12-08 06:59:17 +00:00
|
|
|
if (unlikely(blkaddr >= SIT_BLK_CNT(sbi)))
|
|
|
|
return false;
|
|
|
|
break;
|
2014-02-27 11:12:24 +00:00
|
|
|
case META_SSA:
|
2014-12-08 06:59:17 +00:00
|
|
|
if (unlikely(blkaddr >= MAIN_BLKADDR(sbi) ||
|
|
|
|
blkaddr < SM_I(sbi)->ssa_blkaddr))
|
|
|
|
return false;
|
|
|
|
break;
|
2014-02-07 08:11:53 +00:00
|
|
|
case META_CP:
|
2014-12-08 06:59:17 +00:00
|
|
|
if (unlikely(blkaddr >= SIT_I(sbi)->sit_base_addr ||
|
|
|
|
blkaddr < __start_cp_addr(sbi)))
|
|
|
|
return false;
|
|
|
|
break;
|
2014-09-11 20:49:55 +00:00
|
|
|
case META_POR:
|
2014-12-08 06:59:17 +00:00
|
|
|
if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
|
|
|
|
blkaddr < MAIN_BLKADDR(sbi)))
|
|
|
|
return false;
|
|
|
|
break;
|
2014-02-07 08:11:53 +00:00
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
2014-12-08 06:59:17 +00:00
|
|
|
|
|
|
|
return true;
|
2014-02-07 08:11:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-02-27 11:12:24 +00:00
|
|
|
* Readahead CP/NAT/SIT/SSA pages
|
2014-02-07 08:11:53 +00:00
|
|
|
*/
|
2014-09-11 20:49:55 +00:00
|
|
|
int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int type)
|
2014-02-07 08:11:53 +00:00
|
|
|
{
|
|
|
|
block_t prev_blk_addr = 0;
|
|
|
|
struct page *page;
|
2014-09-11 20:49:55 +00:00
|
|
|
block_t blkno = start;
|
2014-02-07 08:11:53 +00:00
|
|
|
|
|
|
|
struct f2fs_io_info fio = {
|
|
|
|
.type = META,
|
|
|
|
.rw = READ_SYNC | REQ_META | REQ_PRIO
|
|
|
|
};
|
|
|
|
|
|
|
|
for (; nrpages-- > 0; blkno++) {
|
|
|
|
block_t blk_addr;
|
|
|
|
|
2014-12-08 06:59:17 +00:00
|
|
|
if (!is_valid_blkaddr(sbi, blkno, type))
|
|
|
|
goto out;
|
|
|
|
|
2014-02-07 08:11:53 +00:00
|
|
|
switch (type) {
|
|
|
|
case META_NAT:
|
2014-12-08 06:59:17 +00:00
|
|
|
if (unlikely(blkno >=
|
|
|
|
NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid)))
|
2014-02-07 08:11:53 +00:00
|
|
|
blkno = 0;
|
2014-12-08 06:59:17 +00:00
|
|
|
/* get nat block addr */
|
2014-02-07 08:11:53 +00:00
|
|
|
blk_addr = current_nat_addr(sbi,
|
|
|
|
blkno * NAT_ENTRY_PER_BLOCK);
|
|
|
|
break;
|
|
|
|
case META_SIT:
|
|
|
|
/* get sit block addr */
|
|
|
|
blk_addr = current_sit_addr(sbi,
|
|
|
|
blkno * SIT_ENTRY_PER_BLOCK);
|
|
|
|
if (blkno != start && prev_blk_addr + 1 != blk_addr)
|
|
|
|
goto out;
|
|
|
|
prev_blk_addr = blk_addr;
|
|
|
|
break;
|
2014-02-27 11:12:24 +00:00
|
|
|
case META_SSA:
|
2014-02-07 08:11:53 +00:00
|
|
|
case META_CP:
|
2014-09-11 20:49:55 +00:00
|
|
|
case META_POR:
|
2014-02-07 08:11:53 +00:00
|
|
|
blk_addr = blkno;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
page = grab_cache_page(META_MAPPING(sbi), blk_addr);
|
|
|
|
if (!page)
|
|
|
|
continue;
|
|
|
|
if (PageUptodate(page)) {
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
f2fs_submit_page_mbio(sbi, page, blk_addr, &fio);
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
f2fs_submit_merged_bio(sbi, META, READ);
|
|
|
|
return blkno - start;
|
|
|
|
}
|
|
|
|
|
2014-12-08 07:02:52 +00:00
|
|
|
void ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
bool readahead = false;
|
|
|
|
|
|
|
|
page = find_get_page(META_MAPPING(sbi), index);
|
|
|
|
if (!page || (page && !PageUptodate(page)))
|
|
|
|
readahead = true;
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
|
|
|
|
if (readahead)
|
|
|
|
ra_meta_pages(sbi, index, MAX_BIO_BLOCKS(sbi), META_POR);
|
|
|
|
}
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
static int f2fs_write_meta_page(struct page *page,
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
2014-09-02 22:31:18 +00:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_P_SB(page);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-05-06 08:48:26 +00:00
|
|
|
trace_f2fs_writepage(page, META);
|
|
|
|
|
2014-02-05 04:03:57 +00:00
|
|
|
if (unlikely(sbi->por_doing))
|
2013-12-05 09:15:22 +00:00
|
|
|
goto redirty_out;
|
2014-11-19 19:03:34 +00:00
|
|
|
if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0))
|
2013-12-05 09:15:22 +00:00
|
|
|
goto redirty_out;
|
2014-08-11 23:49:25 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
2014-08-12 01:37:46 +00:00
|
|
|
goto redirty_out;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-03-18 04:29:07 +00:00
|
|
|
f2fs_wait_on_page_writeback(page, META);
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 10:56:11 +00:00
|
|
|
write_meta_page(sbi, page);
|
|
|
|
dec_page_count(sbi, F2FS_DIRTY_META);
|
|
|
|
unlock_page(page);
|
2014-11-19 19:03:34 +00:00
|
|
|
|
|
|
|
if (wbc->for_reclaim)
|
|
|
|
f2fs_submit_merged_bio(sbi, META, WRITE);
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 10:56:11 +00:00
|
|
|
return 0;
|
2013-12-05 09:15:22 +00:00
|
|
|
|
|
|
|
redirty_out:
|
2014-04-15 07:04:15 +00:00
|
|
|
redirty_page_for_writepage(wbc, page);
|
2013-12-05 09:15:22 +00:00
|
|
|
return AOP_WRITEPAGE_ACTIVATE;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_write_meta_pages(struct address_space *mapping,
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
2014-09-02 22:31:18 +00:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
|
2014-03-18 04:47:11 +00:00
|
|
|
long diff, written;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-05-06 08:51:24 +00:00
|
|
|
trace_f2fs_writepages(mapping->host, wbc, META);
|
|
|
|
|
2013-12-17 08:28:41 +00:00
|
|
|
/* collect a number of dirty meta pages and write together */
|
2014-03-18 04:47:11 +00:00
|
|
|
if (wbc->for_kupdate ||
|
|
|
|
get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META))
|
2014-03-18 04:43:05 +00:00
|
|
|
goto skip_write;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* if mounting is failed, skip writing node pages */
|
|
|
|
mutex_lock(&sbi->cp_mutex);
|
2014-03-18 04:47:11 +00:00
|
|
|
diff = nr_pages_to_write(sbi, META, wbc);
|
|
|
|
written = sync_meta_pages(sbi, META, wbc->nr_to_write);
|
2012-11-02 08:08:18 +00:00
|
|
|
mutex_unlock(&sbi->cp_mutex);
|
2014-03-18 04:47:11 +00:00
|
|
|
wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);
|
2012-11-02 08:08:18 +00:00
|
|
|
return 0;
|
2014-03-18 04:43:05 +00:00
|
|
|
|
|
|
|
skip_write:
|
|
|
|
wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_META);
|
|
|
|
return 0;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
|
|
|
|
long nr_to_write)
|
|
|
|
{
|
2014-01-20 10:37:04 +00:00
|
|
|
struct address_space *mapping = META_MAPPING(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
pgoff_t index = 0, end = LONG_MAX;
|
|
|
|
struct pagevec pvec;
|
|
|
|
long nwritten = 0;
|
|
|
|
struct writeback_control wbc = {
|
|
|
|
.for_reclaim = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
pagevec_init(&pvec, 0);
|
|
|
|
|
|
|
|
while (index <= end) {
|
|
|
|
int i, nr_pages;
|
|
|
|
nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
|
|
|
|
PAGECACHE_TAG_DIRTY,
|
|
|
|
min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
|
2013-12-05 09:15:22 +00:00
|
|
|
if (unlikely(nr_pages == 0))
|
2012-11-02 08:08:18 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_pages; i++) {
|
|
|
|
struct page *page = pvec.pages[i];
|
2014-02-05 04:03:57 +00:00
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
lock_page(page);
|
2014-02-05 04:03:57 +00:00
|
|
|
|
|
|
|
if (unlikely(page->mapping != mapping)) {
|
|
|
|
continue_unlock:
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!PageDirty(page)) {
|
|
|
|
/* someone wrote it for us */
|
|
|
|
goto continue_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!clear_page_dirty_for_io(page))
|
|
|
|
goto continue_unlock;
|
|
|
|
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 10:56:11 +00:00
|
|
|
if (f2fs_write_meta_page(page, &wbc)) {
|
|
|
|
unlock_page(page);
|
|
|
|
break;
|
|
|
|
}
|
2013-12-05 09:15:22 +00:00
|
|
|
nwritten++;
|
|
|
|
if (unlikely(nwritten >= nr_to_write))
|
2012-11-02 08:08:18 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nwritten)
|
2013-12-11 04:54:01 +00:00
|
|
|
f2fs_submit_merged_bio(sbi, type, WRITE);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
return nwritten;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_set_meta_page_dirty(struct page *page)
|
|
|
|
{
|
2013-10-24 08:53:29 +00:00
|
|
|
trace_f2fs_set_page_dirty(page, META);
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
SetPageUptodate(page);
|
|
|
|
if (!PageDirty(page)) {
|
|
|
|
__set_page_dirty_nobuffers(page);
|
2014-09-02 22:31:18 +00:00
|
|
|
inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);
|
2012-11-02 08:08:18 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct address_space_operations f2fs_meta_aops = {
|
|
|
|
.writepage = f2fs_write_meta_page,
|
|
|
|
.writepages = f2fs_write_meta_pages,
|
|
|
|
.set_page_dirty = f2fs_set_meta_page_dirty,
|
|
|
|
};
|
|
|
|
|
2014-07-25 22:47:17 +00:00
|
|
|
static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
|
2014-07-25 22:47:16 +00:00
|
|
|
{
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[type];
|
2014-07-25 01:15:17 +00:00
|
|
|
struct ino_entry *e;
|
|
|
|
retry:
|
2014-12-04 04:47:26 +00:00
|
|
|
if (radix_tree_preload(GFP_NOFS)) {
|
|
|
|
cond_resched();
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_lock(&im->ino_lock);
|
2014-07-25 01:15:17 +00:00
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
e = radix_tree_lookup(&im->ino_root, ino);
|
2014-07-25 01:15:17 +00:00
|
|
|
if (!e) {
|
|
|
|
e = kmem_cache_alloc(ino_entry_slab, GFP_ATOMIC);
|
|
|
|
if (!e) {
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_unlock(&im->ino_lock);
|
2014-12-04 04:47:26 +00:00
|
|
|
radix_tree_preload_end();
|
2014-07-25 01:15:17 +00:00
|
|
|
goto retry;
|
2014-07-25 22:47:16 +00:00
|
|
|
}
|
2014-11-18 03:18:36 +00:00
|
|
|
if (radix_tree_insert(&im->ino_root, ino, e)) {
|
|
|
|
spin_unlock(&im->ino_lock);
|
2014-07-25 01:15:17 +00:00
|
|
|
kmem_cache_free(ino_entry_slab, e);
|
2014-12-04 04:47:26 +00:00
|
|
|
radix_tree_preload_end();
|
2014-07-25 01:15:17 +00:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
memset(e, 0, sizeof(struct ino_entry));
|
|
|
|
e->ino = ino;
|
2014-07-25 22:47:16 +00:00
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
list_add_tail(&e->list, &im->ino_list);
|
2014-11-06 23:16:04 +00:00
|
|
|
if (type != ORPHAN_INO)
|
2014-11-18 03:18:36 +00:00
|
|
|
im->ino_num++;
|
2014-07-25 01:15:17 +00:00
|
|
|
}
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_unlock(&im->ino_lock);
|
2014-12-04 04:47:26 +00:00
|
|
|
radix_tree_preload_end();
|
2014-07-25 22:47:16 +00:00
|
|
|
}
|
|
|
|
|
2014-07-25 22:47:17 +00:00
|
|
|
static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
|
2014-07-25 22:47:16 +00:00
|
|
|
{
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[type];
|
2014-07-25 22:47:17 +00:00
|
|
|
struct ino_entry *e;
|
2014-07-25 22:47:16 +00:00
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_lock(&im->ino_lock);
|
|
|
|
e = radix_tree_lookup(&im->ino_root, ino);
|
2014-07-25 01:15:17 +00:00
|
|
|
if (e) {
|
|
|
|
list_del(&e->list);
|
2014-11-18 03:18:36 +00:00
|
|
|
radix_tree_delete(&im->ino_root, ino);
|
|
|
|
im->ino_num--;
|
|
|
|
spin_unlock(&im->ino_lock);
|
2014-07-25 01:15:17 +00:00
|
|
|
kmem_cache_free(ino_entry_slab, e);
|
|
|
|
return;
|
2014-07-25 22:47:16 +00:00
|
|
|
}
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_unlock(&im->ino_lock);
|
2014-07-25 22:47:16 +00:00
|
|
|
}
|
|
|
|
|
2014-07-25 14:40:59 +00:00
|
|
|
void add_dirty_inode(struct f2fs_sb_info *sbi, nid_t ino, int type)
|
|
|
|
{
|
|
|
|
/* add new dirty ino entry into list */
|
|
|
|
__add_ino_entry(sbi, ino, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void remove_dirty_inode(struct f2fs_sb_info *sbi, nid_t ino, int type)
|
|
|
|
{
|
|
|
|
/* remove dirty ino entry from list */
|
|
|
|
__remove_ino_entry(sbi, ino, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* mode should be APPEND_INO or UPDATE_INO */
|
|
|
|
bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)
|
|
|
|
{
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[mode];
|
2014-07-25 14:40:59 +00:00
|
|
|
struct ino_entry *e;
|
2014-11-18 03:18:36 +00:00
|
|
|
|
|
|
|
spin_lock(&im->ino_lock);
|
|
|
|
e = radix_tree_lookup(&im->ino_root, ino);
|
|
|
|
spin_unlock(&im->ino_lock);
|
2014-07-25 14:40:59 +00:00
|
|
|
return e ? true : false;
|
|
|
|
}
|
|
|
|
|
2014-08-19 16:48:22 +00:00
|
|
|
void release_dirty_inode(struct f2fs_sb_info *sbi)
|
2014-07-25 14:40:59 +00:00
|
|
|
{
|
|
|
|
struct ino_entry *e, *tmp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = APPEND_INO; i <= UPDATE_INO; i++) {
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[i];
|
|
|
|
|
|
|
|
spin_lock(&im->ino_lock);
|
|
|
|
list_for_each_entry_safe(e, tmp, &im->ino_list, list) {
|
2014-07-25 14:40:59 +00:00
|
|
|
list_del(&e->list);
|
2014-11-18 03:18:36 +00:00
|
|
|
radix_tree_delete(&im->ino_root, e->ino);
|
2014-07-25 14:40:59 +00:00
|
|
|
kmem_cache_free(ino_entry_slab, e);
|
2014-11-18 03:18:36 +00:00
|
|
|
im->ino_num--;
|
2014-07-25 14:40:59 +00:00
|
|
|
}
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_unlock(&im->ino_lock);
|
2014-07-25 14:40:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-30 02:36:53 +00:00
|
|
|
int acquire_orphan_inode(struct f2fs_sb_info *sbi)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[ORPHAN_INO];
|
2012-11-02 08:08:18 +00:00
|
|
|
int err = 0;
|
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_lock(&im->ino_lock);
|
|
|
|
if (unlikely(im->ino_num >= sbi->max_orphans))
|
2012-11-02 08:08:18 +00:00
|
|
|
err = -ENOSPC;
|
2013-07-30 02:36:53 +00:00
|
|
|
else
|
2014-11-18 03:18:36 +00:00
|
|
|
im->ino_num++;
|
|
|
|
spin_unlock(&im->ino_lock);
|
2013-12-26 10:24:19 +00:00
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-07-30 02:36:53 +00:00
|
|
|
void release_orphan_inode(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[ORPHAN_INO];
|
|
|
|
|
|
|
|
spin_lock(&im->ino_lock);
|
|
|
|
f2fs_bug_on(sbi, im->ino_num == 0);
|
|
|
|
im->ino_num--;
|
|
|
|
spin_unlock(&im->ino_lock);
|
2013-07-30 02:36:53 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
|
|
|
|
{
|
2014-07-25 01:15:17 +00:00
|
|
|
/* add new orphan ino entry into list */
|
2014-07-25 22:47:17 +00:00
|
|
|
__add_ino_entry(sbi, ino, ORPHAN_INO);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
|
|
|
|
{
|
2014-07-25 22:47:16 +00:00
|
|
|
/* remove orphan entry from orphan list */
|
2014-07-25 22:47:17 +00:00
|
|
|
__remove_ino_entry(sbi, ino, ORPHAN_INO);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
|
|
|
|
{
|
|
|
|
struct inode *inode = f2fs_iget(sbi->sb, ino);
|
2014-09-02 22:52:58 +00:00
|
|
|
f2fs_bug_on(sbi, IS_ERR(inode));
|
2012-11-02 08:08:18 +00:00
|
|
|
clear_nlink(inode);
|
|
|
|
|
|
|
|
/* truncate all the data during iput */
|
|
|
|
iput(inode);
|
|
|
|
}
|
|
|
|
|
2013-11-28 07:43:43 +00:00
|
|
|
void recover_orphan_inodes(struct f2fs_sb_info *sbi)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
|
|
|
block_t start_blk, orphan_blkaddr, i, j;
|
|
|
|
|
2012-11-28 07:12:41 +00:00
|
|
|
if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))
|
2013-11-28 07:43:43 +00:00
|
|
|
return;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2013-10-23 04:39:32 +00:00
|
|
|
sbi->por_doing = true;
|
2014-05-12 03:27:43 +00:00
|
|
|
|
|
|
|
start_blk = __start_cp_addr(sbi) + 1 +
|
|
|
|
le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
|
2012-11-02 08:08:18 +00:00
|
|
|
orphan_blkaddr = __start_sum_addr(sbi) - 1;
|
|
|
|
|
2014-02-07 08:11:53 +00:00
|
|
|
ra_meta_pages(sbi, start_blk, orphan_blkaddr, META_CP);
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
for (i = 0; i < orphan_blkaddr; i++) {
|
|
|
|
struct page *page = get_meta_page(sbi, start_blk + i);
|
|
|
|
struct f2fs_orphan_block *orphan_blk;
|
|
|
|
|
|
|
|
orphan_blk = (struct f2fs_orphan_block *)page_address(page);
|
|
|
|
for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
|
|
|
|
nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
|
|
|
|
recover_orphan_inode(sbi, ino);
|
|
|
|
}
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
}
|
|
|
|
/* clear Orphan Flag */
|
2012-11-28 07:12:41 +00:00
|
|
|
clear_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG);
|
2013-10-23 04:39:32 +00:00
|
|
|
sbi->por_doing = false;
|
2013-11-28 07:43:43 +00:00
|
|
|
return;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk)
|
|
|
|
{
|
2013-11-19 10:03:58 +00:00
|
|
|
struct list_head *head;
|
2012-11-02 08:08:18 +00:00
|
|
|
struct f2fs_orphan_block *orphan_blk = NULL;
|
|
|
|
unsigned int nentries = 0;
|
2014-01-10 10:09:02 +00:00
|
|
|
unsigned short index;
|
2014-11-06 23:16:04 +00:00
|
|
|
unsigned short orphan_blocks;
|
2014-01-10 10:09:02 +00:00
|
|
|
struct page *page = NULL;
|
2014-07-25 22:47:17 +00:00
|
|
|
struct ino_entry *orphan = NULL;
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[ORPHAN_INO];
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
orphan_blocks = GET_ORPHAN_BLOCKS(im->ino_num);
|
2014-11-06 23:16:04 +00:00
|
|
|
|
2014-01-10 10:09:02 +00:00
|
|
|
for (index = 0; index < orphan_blocks; index++)
|
2014-01-20 10:37:30 +00:00
|
|
|
grab_meta_page(sbi, start_blk + index);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-01-10 10:09:02 +00:00
|
|
|
index = 1;
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_lock(&im->ino_lock);
|
|
|
|
head = &im->ino_list;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* loop for each orphan inode entry and write them in Jornal block */
|
2013-11-19 10:03:58 +00:00
|
|
|
list_for_each_entry(orphan, head, list) {
|
|
|
|
if (!page) {
|
2014-01-20 10:37:30 +00:00
|
|
|
page = find_get_page(META_MAPPING(sbi), start_blk++);
|
2014-09-02 22:52:58 +00:00
|
|
|
f2fs_bug_on(sbi, !page);
|
2013-11-19 10:03:58 +00:00
|
|
|
orphan_blk =
|
|
|
|
(struct f2fs_orphan_block *)page_address(page);
|
|
|
|
memset(orphan_blk, 0, sizeof(*orphan_blk));
|
2014-01-20 10:37:30 +00:00
|
|
|
f2fs_put_page(page, 0);
|
2013-11-19 10:03:58 +00:00
|
|
|
}
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2013-11-26 08:44:16 +00:00
|
|
|
orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2013-11-26 08:44:16 +00:00
|
|
|
if (nentries == F2FS_ORPHANS_PER_BLOCK) {
|
2012-11-02 08:08:18 +00:00
|
|
|
/*
|
|
|
|
* an orphan block is full of 1020 entries,
|
|
|
|
* then we need to flush current orphan blocks
|
|
|
|
* and bring another one in memory
|
|
|
|
*/
|
|
|
|
orphan_blk->blk_addr = cpu_to_le16(index);
|
|
|
|
orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
|
|
|
|
orphan_blk->entry_count = cpu_to_le32(nentries);
|
|
|
|
set_page_dirty(page);
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
index++;
|
|
|
|
nentries = 0;
|
|
|
|
page = NULL;
|
|
|
|
}
|
2013-11-19 10:03:58 +00:00
|
|
|
}
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2013-11-19 10:03:58 +00:00
|
|
|
if (page) {
|
|
|
|
orphan_blk->blk_addr = cpu_to_le16(index);
|
|
|
|
orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
|
|
|
|
orphan_blk->entry_count = cpu_to_le32(nentries);
|
|
|
|
set_page_dirty(page);
|
|
|
|
f2fs_put_page(page, 1);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
2013-11-19 10:03:58 +00:00
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
spin_unlock(&im->ino_lock);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
|
|
|
|
block_t cp_addr, unsigned long long *version)
|
|
|
|
{
|
|
|
|
struct page *cp_page_1, *cp_page_2 = NULL;
|
|
|
|
unsigned long blk_size = sbi->blocksize;
|
|
|
|
struct f2fs_checkpoint *cp_block;
|
|
|
|
unsigned long long cur_version = 0, pre_version = 0;
|
|
|
|
size_t crc_offset;
|
2013-06-19 11:47:19 +00:00
|
|
|
__u32 crc = 0;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* Read the 1st cp block in this CP pack */
|
|
|
|
cp_page_1 = get_meta_page(sbi, cp_addr);
|
|
|
|
|
|
|
|
/* get the version number */
|
|
|
|
cp_block = (struct f2fs_checkpoint *)page_address(cp_page_1);
|
|
|
|
crc_offset = le32_to_cpu(cp_block->checksum_offset);
|
|
|
|
if (crc_offset >= blk_size)
|
|
|
|
goto invalid_cp1;
|
|
|
|
|
2013-06-19 11:47:19 +00:00
|
|
|
crc = le32_to_cpu(*((__u32 *)((unsigned char *)cp_block + crc_offset)));
|
2012-11-02 08:08:18 +00:00
|
|
|
if (!f2fs_crc_valid(crc, cp_block, crc_offset))
|
|
|
|
goto invalid_cp1;
|
|
|
|
|
2013-08-09 06:03:21 +00:00
|
|
|
pre_version = cur_cp_version(cp_block);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* Read the 2nd cp block in this CP pack */
|
2012-11-28 07:12:41 +00:00
|
|
|
cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
|
2012-11-02 08:08:18 +00:00
|
|
|
cp_page_2 = get_meta_page(sbi, cp_addr);
|
|
|
|
|
|
|
|
cp_block = (struct f2fs_checkpoint *)page_address(cp_page_2);
|
|
|
|
crc_offset = le32_to_cpu(cp_block->checksum_offset);
|
|
|
|
if (crc_offset >= blk_size)
|
|
|
|
goto invalid_cp2;
|
|
|
|
|
2013-06-19 11:47:19 +00:00
|
|
|
crc = le32_to_cpu(*((__u32 *)((unsigned char *)cp_block + crc_offset)));
|
2012-11-02 08:08:18 +00:00
|
|
|
if (!f2fs_crc_valid(crc, cp_block, crc_offset))
|
|
|
|
goto invalid_cp2;
|
|
|
|
|
2013-08-09 06:03:21 +00:00
|
|
|
cur_version = cur_cp_version(cp_block);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
if (cur_version == pre_version) {
|
|
|
|
*version = cur_version;
|
|
|
|
f2fs_put_page(cp_page_2, 1);
|
|
|
|
return cp_page_1;
|
|
|
|
}
|
|
|
|
invalid_cp2:
|
|
|
|
f2fs_put_page(cp_page_2, 1);
|
|
|
|
invalid_cp1:
|
|
|
|
f2fs_put_page(cp_page_1, 1);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_valid_checkpoint(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
struct f2fs_checkpoint *cp_block;
|
|
|
|
struct f2fs_super_block *fsb = sbi->raw_super;
|
|
|
|
struct page *cp1, *cp2, *cur_page;
|
|
|
|
unsigned long blk_size = sbi->blocksize;
|
|
|
|
unsigned long long cp1_version = 0, cp2_version = 0;
|
|
|
|
unsigned long long cp_start_blk_no;
|
2014-05-12 03:27:43 +00:00
|
|
|
unsigned int cp_blks = 1 + le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
|
|
|
|
block_t cp_blk_no;
|
|
|
|
int i;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-05-12 03:27:43 +00:00
|
|
|
sbi->ckpt = kzalloc(cp_blks * blk_size, GFP_KERNEL);
|
2012-11-02 08:08:18 +00:00
|
|
|
if (!sbi->ckpt)
|
|
|
|
return -ENOMEM;
|
|
|
|
/*
|
|
|
|
* Finding out valid cp block involves read both
|
|
|
|
* sets( cp pack1 and cp pack 2)
|
|
|
|
*/
|
|
|
|
cp_start_blk_no = le32_to_cpu(fsb->cp_blkaddr);
|
|
|
|
cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
|
|
|
|
|
|
|
|
/* The second checkpoint pack should start at the next segment */
|
2013-11-28 03:44:05 +00:00
|
|
|
cp_start_blk_no += ((unsigned long long)1) <<
|
|
|
|
le32_to_cpu(fsb->log_blocks_per_seg);
|
2012-11-02 08:08:18 +00:00
|
|
|
cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
|
|
|
|
|
|
|
|
if (cp1 && cp2) {
|
|
|
|
if (ver_after(cp2_version, cp1_version))
|
|
|
|
cur_page = cp2;
|
|
|
|
else
|
|
|
|
cur_page = cp1;
|
|
|
|
} else if (cp1) {
|
|
|
|
cur_page = cp1;
|
|
|
|
} else if (cp2) {
|
|
|
|
cur_page = cp2;
|
|
|
|
} else {
|
|
|
|
goto fail_no_cp;
|
|
|
|
}
|
|
|
|
|
|
|
|
cp_block = (struct f2fs_checkpoint *)page_address(cur_page);
|
|
|
|
memcpy(sbi->ckpt, cp_block, blk_size);
|
|
|
|
|
2014-05-12 03:27:43 +00:00
|
|
|
if (cp_blks <= 1)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
cp_blk_no = le32_to_cpu(fsb->cp_blkaddr);
|
|
|
|
if (cur_page == cp2)
|
|
|
|
cp_blk_no += 1 << le32_to_cpu(fsb->log_blocks_per_seg);
|
|
|
|
|
|
|
|
for (i = 1; i < cp_blks; i++) {
|
|
|
|
void *sit_bitmap_ptr;
|
|
|
|
unsigned char *ckpt = (unsigned char *)sbi->ckpt;
|
|
|
|
|
|
|
|
cur_page = get_meta_page(sbi, cp_blk_no + i);
|
|
|
|
sit_bitmap_ptr = page_address(cur_page);
|
|
|
|
memcpy(ckpt + i * blk_size, sit_bitmap_ptr, blk_size);
|
|
|
|
f2fs_put_page(cur_page, 1);
|
|
|
|
}
|
|
|
|
done:
|
2012-11-02 08:08:18 +00:00
|
|
|
f2fs_put_page(cp1, 1);
|
|
|
|
f2fs_put_page(cp2, 1);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_no_cp:
|
|
|
|
kfree(sbi->ckpt);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-06-05 08:42:45 +00:00
|
|
|
static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
2014-09-02 22:31:18 +00:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-04-15 02:19:28 +00:00
|
|
|
if (is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR))
|
|
|
|
return -EEXIST;
|
2014-03-29 03:33:17 +00:00
|
|
|
|
2014-04-15 02:19:28 +00:00
|
|
|
set_inode_flag(F2FS_I(inode), FI_DIRTY_DIR);
|
|
|
|
F2FS_I(inode)->dirty_dir = new;
|
|
|
|
list_add_tail(&new->list, &sbi->dir_inode_list);
|
2013-10-22 11:56:10 +00:00
|
|
|
stat_inc_dirty_dir(sbi);
|
2013-06-05 08:42:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-12 22:53:45 +00:00
|
|
|
void update_dirty_page(struct inode *inode, struct page *page)
|
2013-06-05 08:42:45 +00:00
|
|
|
{
|
2014-09-02 22:31:18 +00:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2013-06-05 08:42:45 +00:00
|
|
|
struct dir_inode_entry *new;
|
2014-04-02 00:55:00 +00:00
|
|
|
int ret = 0;
|
2013-06-05 08:42:45 +00:00
|
|
|
|
2014-09-12 22:53:45 +00:00
|
|
|
if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
|
2012-11-02 08:08:18 +00:00
|
|
|
return;
|
2013-10-22 06:52:26 +00:00
|
|
|
|
2014-09-12 22:53:45 +00:00
|
|
|
if (!S_ISDIR(inode->i_mode)) {
|
|
|
|
inode_inc_dirty_pages(inode);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-10-22 06:52:26 +00:00
|
|
|
new = f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
|
2012-11-02 08:08:18 +00:00
|
|
|
new->inode = inode;
|
|
|
|
INIT_LIST_HEAD(&new->list);
|
|
|
|
|
|
|
|
spin_lock(&sbi->dir_inode_lock);
|
2014-04-02 00:55:00 +00:00
|
|
|
ret = __add_dirty_inode(inode, new);
|
2014-09-12 22:53:45 +00:00
|
|
|
inode_inc_dirty_pages(inode);
|
2013-06-05 08:42:45 +00:00
|
|
|
spin_unlock(&sbi->dir_inode_lock);
|
2014-04-02 00:55:00 +00:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
kmem_cache_free(inode_entry_slab, new);
|
2014-09-12 22:53:45 +00:00
|
|
|
out:
|
|
|
|
SetPagePrivate(page);
|
2013-06-05 08:42:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void add_dirty_dir_inode(struct inode *inode)
|
|
|
|
{
|
2014-09-02 22:31:18 +00:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2013-10-22 06:52:26 +00:00
|
|
|
struct dir_inode_entry *new =
|
|
|
|
f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
|
2014-04-02 00:55:00 +00:00
|
|
|
int ret = 0;
|
2013-10-22 06:52:26 +00:00
|
|
|
|
2013-06-05 08:42:45 +00:00
|
|
|
new->inode = inode;
|
|
|
|
INIT_LIST_HEAD(&new->list);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2013-06-05 08:42:45 +00:00
|
|
|
spin_lock(&sbi->dir_inode_lock);
|
2014-04-02 00:55:00 +00:00
|
|
|
ret = __add_dirty_inode(inode, new);
|
2012-11-02 08:08:18 +00:00
|
|
|
spin_unlock(&sbi->dir_inode_lock);
|
2014-04-02 00:55:00 +00:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
kmem_cache_free(inode_entry_slab, new);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void remove_dirty_dir_inode(struct inode *inode)
|
|
|
|
{
|
2014-09-02 22:31:18 +00:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2014-03-29 03:33:17 +00:00
|
|
|
struct dir_inode_entry *entry;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
if (!S_ISDIR(inode->i_mode))
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock(&sbi->dir_inode_lock);
|
2014-09-12 22:53:45 +00:00
|
|
|
if (get_dirty_pages(inode) ||
|
2014-04-15 02:19:28 +00:00
|
|
|
!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR)) {
|
2013-05-27 01:32:01 +00:00
|
|
|
spin_unlock(&sbi->dir_inode_lock);
|
|
|
|
return;
|
|
|
|
}
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-04-15 02:19:28 +00:00
|
|
|
entry = F2FS_I(inode)->dirty_dir;
|
|
|
|
list_del(&entry->list);
|
|
|
|
F2FS_I(inode)->dirty_dir = NULL;
|
|
|
|
clear_inode_flag(F2FS_I(inode), FI_DIRTY_DIR);
|
|
|
|
stat_dec_dirty_dir(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
spin_unlock(&sbi->dir_inode_lock);
|
2014-04-15 02:19:28 +00:00
|
|
|
kmem_cache_free(inode_entry_slab, entry);
|
2013-05-15 07:40:02 +00:00
|
|
|
|
|
|
|
/* Only from the recovery routine */
|
2013-05-28 00:59:27 +00:00
|
|
|
if (is_inode_flag_set(F2FS_I(inode), FI_DELAY_IPUT)) {
|
|
|
|
clear_inode_flag(F2FS_I(inode), FI_DELAY_IPUT);
|
2013-05-15 07:40:02 +00:00
|
|
|
iput(inode);
|
2013-05-28 00:59:27 +00:00
|
|
|
}
|
2013-05-15 07:40:02 +00:00
|
|
|
}
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
void sync_dirty_dir_inodes(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2013-11-19 10:03:47 +00:00
|
|
|
struct list_head *head;
|
2012-11-02 08:08:18 +00:00
|
|
|
struct dir_inode_entry *entry;
|
|
|
|
struct inode *inode;
|
|
|
|
retry:
|
2014-10-17 21:14:16 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
return;
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
spin_lock(&sbi->dir_inode_lock);
|
2013-11-19 10:03:47 +00:00
|
|
|
|
|
|
|
head = &sbi->dir_inode_list;
|
2012-11-02 08:08:18 +00:00
|
|
|
if (list_empty(head)) {
|
|
|
|
spin_unlock(&sbi->dir_inode_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
entry = list_entry(head->next, struct dir_inode_entry, list);
|
|
|
|
inode = igrab(entry->inode);
|
|
|
|
spin_unlock(&sbi->dir_inode_lock);
|
|
|
|
if (inode) {
|
2014-03-18 03:40:49 +00:00
|
|
|
filemap_fdatawrite(inode->i_mapping);
|
2012-11-02 08:08:18 +00:00
|
|
|
iput(inode);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We should submit bio, since it exists several
|
|
|
|
* wribacking dentry pages in the freeing inode.
|
|
|
|
*/
|
2013-12-11 04:54:01 +00:00
|
|
|
f2fs_submit_merged_bio(sbi, DATA, WRITE);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2012-11-02 08:08:18 +00:00
|
|
|
* Freeze all the FS-operations for checkpoint.
|
|
|
|
*/
|
2014-08-12 01:37:46 +00:00
|
|
|
static int block_operations(struct f2fs_sb_info *sbi)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
|
|
|
struct writeback_control wbc = {
|
|
|
|
.sync_mode = WB_SYNC_ALL,
|
|
|
|
.nr_to_write = LONG_MAX,
|
|
|
|
.for_reclaim = 0,
|
|
|
|
};
|
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 04:19:56 +00:00
|
|
|
struct blk_plug plug;
|
2014-08-12 01:37:46 +00:00
|
|
|
int err = 0;
|
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 04:19:56 +00:00
|
|
|
|
|
|
|
blk_start_plug(&plug);
|
|
|
|
|
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 07:21:29 +00:00
|
|
|
retry_flush_dents:
|
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 10:08:30 +00:00
|
|
|
f2fs_lock_all(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
/* write all the dirty dentry pages */
|
|
|
|
if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
|
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 10:08:30 +00:00
|
|
|
f2fs_unlock_all(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 07:21:29 +00:00
|
|
|
sync_dirty_dir_inodes(sbi);
|
2014-08-12 01:37:46 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
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 07:21:29 +00:00
|
|
|
goto retry_flush_dents;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-08-06 14:22:50 +00:00
|
|
|
* POR: we should ensure that there are no dirty node pages
|
2012-11-02 08:08:18 +00:00
|
|
|
* until finishing nat/sit flush.
|
|
|
|
*/
|
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 07:21:29 +00:00
|
|
|
retry_flush_nodes:
|
2014-07-03 10:58:39 +00:00
|
|
|
down_write(&sbi->node_write);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
if (get_pages(sbi, F2FS_DIRTY_NODES)) {
|
2014-07-03 10:58:39 +00:00
|
|
|
up_write(&sbi->node_write);
|
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 07:21:29 +00:00
|
|
|
sync_node_pages(sbi, 0, &wbc);
|
2014-08-12 01:37:46 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
f2fs_unlock_all(sbi);
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
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 07:21:29 +00:00
|
|
|
goto retry_flush_nodes;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
2014-08-12 01:37:46 +00:00
|
|
|
out:
|
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 04:19:56 +00:00
|
|
|
blk_finish_plug(&plug);
|
2014-08-12 01:37:46 +00:00
|
|
|
return err;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void unblock_operations(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2014-07-03 10:58:39 +00:00
|
|
|
up_write(&sbi->node_write);
|
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 10:08:30 +00:00
|
|
|
f2fs_unlock_all(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 03:48:25 +00:00
|
|
|
static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
|
|
|
|
if (!get_pages(sbi, F2FS_WRITEBACK))
|
|
|
|
break;
|
|
|
|
|
|
|
|
io_schedule();
|
|
|
|
}
|
|
|
|
finish_wait(&sbi->cp_wait, &wait);
|
|
|
|
}
|
|
|
|
|
2014-09-21 04:57:51 +00:00
|
|
|
static void do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
|
|
|
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
|
2014-07-25 22:47:25 +00:00
|
|
|
struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
|
2014-09-12 12:19:48 +00:00
|
|
|
struct f2fs_nm_info *nm_i = NM_I(sbi);
|
2014-11-18 03:18:36 +00:00
|
|
|
unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;
|
2014-09-12 12:19:48 +00:00
|
|
|
nid_t last_nid = nm_i->next_scan_nid;
|
2012-11-02 08:08:18 +00:00
|
|
|
block_t start_blk;
|
|
|
|
struct page *cp_page;
|
|
|
|
unsigned int data_sum_blocks, orphan_blocks;
|
2013-06-19 11:47:19 +00:00
|
|
|
__u32 crc32 = 0;
|
2012-11-02 08:08:18 +00:00
|
|
|
void *kaddr;
|
|
|
|
int i;
|
2014-05-12 03:27:43 +00:00
|
|
|
int cp_payload_blks = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-04-15 04:57:55 +00:00
|
|
|
/*
|
|
|
|
* This avoids to conduct wrong roll-forward operations and uses
|
|
|
|
* metapages, so should be called prior to sync_meta_pages below.
|
|
|
|
*/
|
2014-07-25 22:47:25 +00:00
|
|
|
discard_next_dnode(sbi, NEXT_FREE_BLKADDR(sbi, curseg));
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* Flush all the NAT/SIT pages */
|
2014-08-12 01:37:46 +00:00
|
|
|
while (get_pages(sbi, F2FS_DIRTY_META)) {
|
2012-11-02 08:08:18 +00:00
|
|
|
sync_meta_pages(sbi, META, LONG_MAX);
|
2014-08-12 01:37:46 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
return;
|
|
|
|
}
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
next_free_nid(sbi, &last_nid);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* modify checkpoint
|
|
|
|
* version number is already updated
|
|
|
|
*/
|
|
|
|
ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi));
|
|
|
|
ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi));
|
|
|
|
ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));
|
2014-08-22 08:17:38 +00:00
|
|
|
for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
|
2012-11-02 08:08:18 +00:00
|
|
|
ckpt->cur_node_segno[i] =
|
|
|
|
cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE));
|
|
|
|
ckpt->cur_node_blkoff[i] =
|
|
|
|
cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_NODE));
|
|
|
|
ckpt->alloc_type[i + CURSEG_HOT_NODE] =
|
|
|
|
curseg_alloc_type(sbi, i + CURSEG_HOT_NODE);
|
|
|
|
}
|
2014-08-22 08:17:38 +00:00
|
|
|
for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
|
2012-11-02 08:08:18 +00:00
|
|
|
ckpt->cur_data_segno[i] =
|
|
|
|
cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA));
|
|
|
|
ckpt->cur_data_blkoff[i] =
|
|
|
|
cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_DATA));
|
|
|
|
ckpt->alloc_type[i + CURSEG_HOT_DATA] =
|
|
|
|
curseg_alloc_type(sbi, i + CURSEG_HOT_DATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi));
|
|
|
|
ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi));
|
|
|
|
ckpt->next_free_nid = cpu_to_le32(last_nid);
|
|
|
|
|
|
|
|
/* 2 cp + n data seg summary + orphan inode blocks */
|
|
|
|
data_sum_blocks = npages_for_summary_flush(sbi);
|
2014-08-22 08:17:38 +00:00
|
|
|
if (data_sum_blocks < NR_CURSEG_DATA_TYPE)
|
2012-11-28 07:12:41 +00:00
|
|
|
set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
|
2012-11-02 08:08:18 +00:00
|
|
|
else
|
2012-11-28 07:12:41 +00:00
|
|
|
clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num);
|
2014-05-12 03:27:43 +00:00
|
|
|
ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
|
|
|
|
orphan_blocks);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-09-21 04:57:51 +00:00
|
|
|
if (cpc->reason == CP_UMOUNT) {
|
2012-11-28 07:12:41 +00:00
|
|
|
set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
|
2014-08-22 08:17:38 +00:00
|
|
|
ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+
|
2014-05-12 03:27:43 +00:00
|
|
|
cp_payload_blks + data_sum_blocks +
|
|
|
|
orphan_blocks + NR_CURSEG_NODE_TYPE);
|
2012-11-02 08:08:18 +00:00
|
|
|
} else {
|
2012-11-28 07:12:41 +00:00
|
|
|
clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
|
2014-08-22 08:17:38 +00:00
|
|
|
ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS +
|
2014-05-12 03:27:43 +00:00
|
|
|
cp_payload_blks + data_sum_blocks +
|
|
|
|
orphan_blocks);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
if (orphan_num)
|
2012-11-28 07:12:41 +00:00
|
|
|
set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
|
2012-11-02 08:08:18 +00:00
|
|
|
else
|
2012-11-28 07:12:41 +00:00
|
|
|
clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-09-02 22:43:52 +00:00
|
|
|
if (sbi->need_fsck)
|
|
|
|
set_ckpt_flags(ckpt, CP_FSCK_FLAG);
|
|
|
|
|
2012-11-02 08:08:18 +00:00
|
|
|
/* update SIT/NAT bitmap */
|
|
|
|
get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
|
|
|
|
get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
|
|
|
|
|
|
|
|
crc32 = f2fs_crc32(ckpt, le32_to_cpu(ckpt->checksum_offset));
|
2013-06-19 11:47:19 +00:00
|
|
|
*((__le32 *)((unsigned char *)ckpt +
|
|
|
|
le32_to_cpu(ckpt->checksum_offset)))
|
2012-11-02 08:08:18 +00:00
|
|
|
= cpu_to_le32(crc32);
|
|
|
|
|
|
|
|
start_blk = __start_cp_addr(sbi);
|
|
|
|
|
|
|
|
/* write out checkpoint buffer at block 0 */
|
|
|
|
cp_page = grab_meta_page(sbi, start_blk++);
|
|
|
|
kaddr = page_address(cp_page);
|
|
|
|
memcpy(kaddr, ckpt, (1 << sbi->log_blocksize));
|
|
|
|
set_page_dirty(cp_page);
|
|
|
|
f2fs_put_page(cp_page, 1);
|
|
|
|
|
2014-05-12 03:27:43 +00:00
|
|
|
for (i = 1; i < 1 + cp_payload_blks; i++) {
|
|
|
|
cp_page = grab_meta_page(sbi, start_blk++);
|
|
|
|
kaddr = page_address(cp_page);
|
|
|
|
memcpy(kaddr, (char *)ckpt + i * F2FS_BLKSIZE,
|
|
|
|
(1 << sbi->log_blocksize));
|
|
|
|
set_page_dirty(cp_page);
|
|
|
|
f2fs_put_page(cp_page, 1);
|
|
|
|
}
|
|
|
|
|
2014-11-18 03:18:36 +00:00
|
|
|
if (orphan_num) {
|
2012-11-02 08:08:18 +00:00
|
|
|
write_orphan_inodes(sbi, start_blk);
|
|
|
|
start_blk += orphan_blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_data_summaries(sbi, start_blk);
|
|
|
|
start_blk += data_sum_blocks;
|
2014-09-21 04:57:51 +00:00
|
|
|
if (cpc->reason == CP_UMOUNT) {
|
2012-11-02 08:08:18 +00:00
|
|
|
write_node_summaries(sbi, start_blk);
|
|
|
|
start_blk += NR_CURSEG_NODE_TYPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* writeout checkpoint block */
|
|
|
|
cp_page = grab_meta_page(sbi, start_blk);
|
|
|
|
kaddr = page_address(cp_page);
|
|
|
|
memcpy(kaddr, ckpt, (1 << sbi->log_blocksize));
|
|
|
|
set_page_dirty(cp_page);
|
|
|
|
f2fs_put_page(cp_page, 1);
|
|
|
|
|
|
|
|
/* wait for previous submitted node/meta pages writeback */
|
2013-11-07 03:48:25 +00:00
|
|
|
wait_on_all_pages_writeback(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-08-12 01:37:46 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
return;
|
|
|
|
|
2014-01-21 09:51:16 +00:00
|
|
|
filemap_fdatawait_range(NODE_MAPPING(sbi), 0, LONG_MAX);
|
2014-01-20 10:37:04 +00:00
|
|
|
filemap_fdatawait_range(META_MAPPING(sbi), 0, LONG_MAX);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* update user_block_counts */
|
|
|
|
sbi->last_valid_block_count = sbi->total_valid_block_count;
|
|
|
|
sbi->alloc_valid_block_count = 0;
|
|
|
|
|
|
|
|
/* Here, we only have one bio having CP pack */
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 10:56:11 +00:00
|
|
|
sync_meta_pages(sbi, META_FLUSH, LONG_MAX);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-10-29 21:37:22 +00:00
|
|
|
/* wait for previous submitted meta pages writeback */
|
|
|
|
wait_on_all_pages_writeback(sbi);
|
|
|
|
|
2014-08-12 01:37:46 +00:00
|
|
|
release_dirty_inode(sbi);
|
|
|
|
|
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
clear_prefree_segments(sbi);
|
|
|
|
F2FS_RESET_SB_DIRT(sbi);
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2014-08-06 14:22:50 +00:00
|
|
|
* We guarantee that this checkpoint procedure will not fail.
|
2012-11-02 08:08:18 +00:00
|
|
|
*/
|
2014-09-21 04:57:51 +00:00
|
|
|
void write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
|
|
|
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
|
|
|
|
unsigned long long ckpt_ver;
|
|
|
|
|
2014-09-21 04:57:51 +00:00
|
|
|
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
|
2013-04-23 09:26:54 +00:00
|
|
|
|
2013-02-04 06:11:17 +00:00
|
|
|
mutex_lock(&sbi->cp_mutex);
|
2014-08-12 01:37:46 +00:00
|
|
|
|
2014-09-21 05:06:39 +00:00
|
|
|
if (!sbi->s_dirty && cpc->reason != CP_DISCARD)
|
2014-08-12 01:37:46 +00:00
|
|
|
goto out;
|
2014-08-12 01:37:46 +00:00
|
|
|
if (unlikely(f2fs_cp_error(sbi)))
|
|
|
|
goto out;
|
|
|
|
if (block_operations(sbi))
|
|
|
|
goto out;
|
2012-11-02 08:08:18 +00:00
|
|
|
|
2014-09-21 04:57:51 +00:00
|
|
|
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
|
2013-04-23 09:26:54 +00:00
|
|
|
|
2013-12-11 04:54:01 +00:00
|
|
|
f2fs_submit_merged_bio(sbi, DATA, WRITE);
|
|
|
|
f2fs_submit_merged_bio(sbi, NODE, WRITE);
|
|
|
|
f2fs_submit_merged_bio(sbi, META, WRITE);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* update checkpoint pack index
|
|
|
|
* Increase the version number so that
|
|
|
|
* SIT entries and seg summaries are written at correct place
|
|
|
|
*/
|
2013-08-09 06:03:21 +00:00
|
|
|
ckpt_ver = cur_cp_version(ckpt);
|
2012-11-02 08:08:18 +00:00
|
|
|
ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);
|
|
|
|
|
|
|
|
/* write cached NAT/SIT entries to NAT/SIT area */
|
|
|
|
flush_nat_entries(sbi);
|
2014-09-21 05:06:39 +00:00
|
|
|
flush_sit_entries(sbi, cpc);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
/* unlock all the fs_lock[] in do_checkpoint() */
|
2014-09-21 04:57:51 +00:00
|
|
|
do_checkpoint(sbi, cpc);
|
2012-11-02 08:08:18 +00:00
|
|
|
|
|
|
|
unblock_operations(sbi);
|
2014-02-13 06:12:29 +00:00
|
|
|
stat_inc_cp_count(sbi->stat_info);
|
2014-08-12 01:37:46 +00:00
|
|
|
out:
|
|
|
|
mutex_unlock(&sbi->cp_mutex);
|
2014-09-21 04:57:51 +00:00
|
|
|
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
2014-07-25 22:47:17 +00:00
|
|
|
void init_ino_entry_info(struct f2fs_sb_info *sbi)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
2014-07-25 22:47:17 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_INO_ENTRY; i++) {
|
2014-11-18 03:18:36 +00:00
|
|
|
struct inode_management *im = &sbi->im[i];
|
|
|
|
|
|
|
|
INIT_RADIX_TREE(&im->ino_root, GFP_ATOMIC);
|
|
|
|
spin_lock_init(&im->ino_lock);
|
|
|
|
INIT_LIST_HEAD(&im->ino_list);
|
|
|
|
im->ino_num = 0;
|
2014-07-25 22:47:17 +00:00
|
|
|
}
|
|
|
|
|
2013-12-26 10:24:19 +00:00
|
|
|
/*
|
|
|
|
* considering 512 blocks in a segment 8 blocks are needed for cp
|
|
|
|
* and log segment summaries. Remaining blocks are used to keep
|
|
|
|
* orphan entries with the limitation one reserved segment
|
|
|
|
* for cp pack we can have max 1020*504 orphan entries
|
|
|
|
*/
|
2014-08-22 08:17:38 +00:00
|
|
|
sbi->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS -
|
|
|
|
NR_CURSEG_TYPE) * F2FS_ORPHANS_PER_BLOCK;
|
2012-11-02 08:08:18 +00:00
|
|
|
}
|
|
|
|
|
2013-01-16 15:08:30 +00:00
|
|
|
int __init create_checkpoint_caches(void)
|
2012-11-02 08:08:18 +00:00
|
|
|
{
|
2014-07-25 22:47:17 +00:00
|
|
|
ino_entry_slab = f2fs_kmem_cache_create("f2fs_ino_entry",
|
|
|
|
sizeof(struct ino_entry));
|
|
|
|
if (!ino_entry_slab)
|
2012-11-02 08:08:18 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
inode_entry_slab = f2fs_kmem_cache_create("f2fs_dirty_dir_entry",
|
2014-03-07 10:43:28 +00:00
|
|
|
sizeof(struct dir_inode_entry));
|
2013-12-06 06:00:58 +00:00
|
|
|
if (!inode_entry_slab) {
|
2014-07-25 22:47:17 +00:00
|
|
|
kmem_cache_destroy(ino_entry_slab);
|
2012-11-02 08:08:18 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void destroy_checkpoint_caches(void)
|
|
|
|
{
|
2014-07-25 22:47:17 +00:00
|
|
|
kmem_cache_destroy(ino_entry_slab);
|
2012-11-02 08:08:18 +00:00
|
|
|
kmem_cache_destroy(inode_entry_slab);
|
|
|
|
}
|