Commit d407574e authored by Linus Torvalds's avatar Linus Torvalds

Merge tag 'for-f2fs-4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs

Pull f2fs updates from Jaegeuk Kim:
 "New Features:
   - uplift filesystem encryption into fs/crypto/
   - give sysfs entries to control memroy consumption

  Enhancements:
   - aio performance by preallocating blocks in ->write_iter
   - use writepages lock for only WB_SYNC_ALL
   - avoid redundant inline_data conversion
   - enhance forground GC
   - use wait_for_stable_page as possible
   - speed up SEEK_DATA and fiiemap

  Bug Fixes:
   - corner case in terms of -ENOSPC for inline_data
   - hung task caused by long latency in shrinker
   - corruption between atomic write and f2fs_trace_pid
   - avoid garbage lengths in dentries
   - revoke atomicly written pages if an error occurs

  In addition, there are various minor bug fixes and clean-ups"

* tag 'for-f2fs-4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (81 commits)
  f2fs: submit node page write bios when really required
  f2fs: add missing argument to f2fs_setxattr stub
  f2fs: fix to avoid unneeded unlock_new_inode
  f2fs: clean up opened code with f2fs_update_dentry
  f2fs: declare static functions
  f2fs: use cryptoapi crc32 functions
  f2fs: modify the readahead method in ra_node_page()
  f2fs crypto: sync ext4_lookup and ext4_file_open
  fs crypto: move per-file encryption from f2fs tree to fs/crypto
  f2fs: mutex can't be used by down_write_nest_lock()
  f2fs: recovery missing dot dentries in root directory
  f2fs: fix to avoid deadlock when merging inline data
  f2fs: introduce f2fs_flush_merged_bios for cleanup
  f2fs: introduce f2fs_update_data_blkaddr for cleanup
  f2fs crypto: fix incorrect positioning for GCing encrypted data page
  f2fs: fix incorrect upper bound when iterating inode mapping tree
  f2fs: avoid hungtask problem caused by losing wake_up
  f2fs: trace old block address for CoWed page
  f2fs: try to flush inode after merging inline data
  f2fs: show more info about superblock recovery
  ...
parents 5518f66b 12bb0a8f
...@@ -98,3 +98,17 @@ Date: October 2015 ...@@ -98,3 +98,17 @@ Date: October 2015
Contact: "Chao Yu" <chao2.yu@samsung.com> Contact: "Chao Yu" <chao2.yu@samsung.com>
Description: Description:
Controls the count of nid pages to be readaheaded. Controls the count of nid pages to be readaheaded.
What: /sys/fs/f2fs/<disk>/dirty_nats_ratio
Date: January 2016
Contact: "Chao Yu" <chao2.yu@samsung.com>
Description:
Controls dirty nat entries ratio threshold, if current
ratio exceeds configured threshold, checkpoint will
be triggered for flushing dirty nat entries.
What: /sys/fs/f2fs/<disk>/lifetime_write_kbytes
Date: January 2016
Contact: "Shuoran Liu" <liushuoran@huawei.com>
Description:
Shows total written kbytes issued to disk.
...@@ -84,6 +84,8 @@ config MANDATORY_FILE_LOCKING ...@@ -84,6 +84,8 @@ config MANDATORY_FILE_LOCKING
To the best of my knowledge this is dead code that no one cares about. To the best of my knowledge this is dead code that no one cares about.
source "fs/crypto/Kconfig"
source "fs/notify/Kconfig" source "fs/notify/Kconfig"
source "fs/quota/Kconfig" source "fs/quota/Kconfig"
......
...@@ -30,6 +30,7 @@ obj-$(CONFIG_EVENTFD) += eventfd.o ...@@ -30,6 +30,7 @@ obj-$(CONFIG_EVENTFD) += eventfd.o
obj-$(CONFIG_USERFAULTFD) += userfaultfd.o obj-$(CONFIG_USERFAULTFD) += userfaultfd.o
obj-$(CONFIG_AIO) += aio.o obj-$(CONFIG_AIO) += aio.o
obj-$(CONFIG_FS_DAX) += dax.o obj-$(CONFIG_FS_DAX) += dax.o
obj-$(CONFIG_FS_ENCRYPTION) += crypto/
obj-$(CONFIG_FILE_LOCKING) += locks.o obj-$(CONFIG_FILE_LOCKING) += locks.o
obj-$(CONFIG_COMPAT) += compat.o compat_ioctl.o obj-$(CONFIG_COMPAT) += compat.o compat_ioctl.o
obj-$(CONFIG_BINFMT_AOUT) += binfmt_aout.o obj-$(CONFIG_BINFMT_AOUT) += binfmt_aout.o
......
config FS_ENCRYPTION
tristate "FS Encryption (Per-file encryption)"
depends on BLOCK
select CRYPTO
select CRYPTO_AES
select CRYPTO_CBC
select CRYPTO_ECB
select CRYPTO_XTS
select CRYPTO_CTS
select CRYPTO_CTR
select CRYPTO_SHA256
select KEYS
select ENCRYPTED_KEYS
help
Enable encryption of files and directories. This
feature is similar to ecryptfs, but it is more memory
efficient since it avoids caching the encrypted and
decrypted pages in the page cache.
obj-$(CONFIG_FS_ENCRYPTION) += fscrypto.o
fscrypto-y := crypto.o fname.o policy.o keyinfo.o
This diff is collapsed.
config F2FS_FS config F2FS_FS
tristate "F2FS filesystem support" tristate "F2FS filesystem support"
depends on BLOCK depends on BLOCK
select CRYPTO
select CRYPTO_CRC32
help help
F2FS is based on Log-structured File System (LFS), which supports F2FS is based on Log-structured File System (LFS), which supports
versatile "flash-friendly" features. The design has been focused on versatile "flash-friendly" features. The design has been focused on
...@@ -76,15 +78,7 @@ config F2FS_FS_ENCRYPTION ...@@ -76,15 +78,7 @@ config F2FS_FS_ENCRYPTION
bool "F2FS Encryption" bool "F2FS Encryption"
depends on F2FS_FS depends on F2FS_FS
depends on F2FS_FS_XATTR depends on F2FS_FS_XATTR
select CRYPTO_AES select FS_ENCRYPTION
select CRYPTO_CBC
select CRYPTO_ECB
select CRYPTO_XTS
select CRYPTO_CTS
select CRYPTO_CTR
select CRYPTO_SHA256
select KEYS
select ENCRYPTED_KEYS
help help
Enable encryption of f2fs files and directories. This Enable encryption of f2fs files and directories. This
feature is similar to ecryptfs, but it is more memory feature is similar to ecryptfs, but it is more memory
......
...@@ -7,5 +7,3 @@ f2fs-$(CONFIG_F2FS_STAT_FS) += debug.o ...@@ -7,5 +7,3 @@ f2fs-$(CONFIG_F2FS_STAT_FS) += debug.o
f2fs-$(CONFIG_F2FS_FS_XATTR) += xattr.o f2fs-$(CONFIG_F2FS_FS_XATTR) += xattr.o
f2fs-$(CONFIG_F2FS_FS_POSIX_ACL) += acl.o f2fs-$(CONFIG_F2FS_FS_POSIX_ACL) += acl.o
f2fs-$(CONFIG_F2FS_IO_TRACE) += trace.o f2fs-$(CONFIG_F2FS_IO_TRACE) += trace.o
f2fs-$(CONFIG_F2FS_FS_ENCRYPTION) += crypto_policy.o crypto.o \
crypto_key.o crypto_fname.o
...@@ -39,7 +39,7 @@ struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index) ...@@ -39,7 +39,7 @@ struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
cond_resched(); cond_resched();
goto repeat; goto repeat;
} }
f2fs_wait_on_page_writeback(page, META); f2fs_wait_on_page_writeback(page, META, true);
SetPageUptodate(page); SetPageUptodate(page);
return page; return page;
} }
...@@ -56,7 +56,8 @@ static struct page *__get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index, ...@@ -56,7 +56,8 @@ static struct page *__get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index,
.sbi = sbi, .sbi = sbi,
.type = META, .type = META,
.rw = READ_SYNC | REQ_META | REQ_PRIO, .rw = READ_SYNC | REQ_META | REQ_PRIO,
.blk_addr = index, .old_blkaddr = index,
.new_blkaddr = index,
.encrypted_page = NULL, .encrypted_page = NULL,
}; };
...@@ -143,7 +144,6 @@ bool is_valid_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type) ...@@ -143,7 +144,6 @@ bool is_valid_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type)
int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
int type, bool sync) int type, bool sync)
{ {
block_t prev_blk_addr = 0;
struct page *page; struct page *page;
block_t blkno = start; block_t blkno = start;
struct f2fs_io_info fio = { struct f2fs_io_info fio = {
...@@ -152,10 +152,12 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, ...@@ -152,10 +152,12 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
.rw = sync ? (READ_SYNC | REQ_META | REQ_PRIO) : READA, .rw = sync ? (READ_SYNC | REQ_META | REQ_PRIO) : READA,
.encrypted_page = NULL, .encrypted_page = NULL,
}; };
struct blk_plug plug;
if (unlikely(type == META_POR)) if (unlikely(type == META_POR))
fio.rw &= ~REQ_META; fio.rw &= ~REQ_META;
blk_start_plug(&plug);
for (; nrpages-- > 0; blkno++) { for (; nrpages-- > 0; blkno++) {
if (!is_valid_blkaddr(sbi, blkno, type)) if (!is_valid_blkaddr(sbi, blkno, type))
...@@ -167,27 +169,24 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, ...@@ -167,27 +169,24 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid))) NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid)))
blkno = 0; blkno = 0;
/* get nat block addr */ /* get nat block addr */
fio.blk_addr = current_nat_addr(sbi, fio.new_blkaddr = current_nat_addr(sbi,
blkno * NAT_ENTRY_PER_BLOCK); blkno * NAT_ENTRY_PER_BLOCK);
break; break;
case META_SIT: case META_SIT:
/* get sit block addr */ /* get sit block addr */
fio.blk_addr = current_sit_addr(sbi, fio.new_blkaddr = current_sit_addr(sbi,
blkno * SIT_ENTRY_PER_BLOCK); blkno * SIT_ENTRY_PER_BLOCK);
if (blkno != start && prev_blk_addr + 1 != fio.blk_addr)
goto out;
prev_blk_addr = fio.blk_addr;
break; break;
case META_SSA: case META_SSA:
case META_CP: case META_CP:
case META_POR: case META_POR:
fio.blk_addr = blkno; fio.new_blkaddr = blkno;
break; break;
default: default:
BUG(); BUG();
} }
page = grab_cache_page(META_MAPPING(sbi), fio.blk_addr); page = grab_cache_page(META_MAPPING(sbi), fio.new_blkaddr);
if (!page) if (!page)
continue; continue;
if (PageUptodate(page)) { if (PageUptodate(page)) {
...@@ -196,11 +195,13 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, ...@@ -196,11 +195,13 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
} }
fio.page = page; fio.page = page;
fio.old_blkaddr = fio.new_blkaddr;
f2fs_submit_page_mbio(&fio); f2fs_submit_page_mbio(&fio);
f2fs_put_page(page, 0); f2fs_put_page(page, 0);
} }
out: out:
f2fs_submit_merged_bio(sbi, META, READ); f2fs_submit_merged_bio(sbi, META, READ);
blk_finish_plug(&plug);
return blkno - start; return blkno - start;
} }
...@@ -232,13 +233,17 @@ static int f2fs_write_meta_page(struct page *page, ...@@ -232,13 +233,17 @@ static int f2fs_write_meta_page(struct page *page,
if (unlikely(f2fs_cp_error(sbi))) if (unlikely(f2fs_cp_error(sbi)))
goto redirty_out; goto redirty_out;
f2fs_wait_on_page_writeback(page, META);
write_meta_page(sbi, page); write_meta_page(sbi, page);
dec_page_count(sbi, F2FS_DIRTY_META); dec_page_count(sbi, F2FS_DIRTY_META);
if (wbc->for_reclaim)
f2fs_submit_merged_bio_cond(sbi, NULL, page, 0, META, WRITE);
unlock_page(page); unlock_page(page);
if (wbc->for_reclaim || unlikely(f2fs_cp_error(sbi))) if (unlikely(f2fs_cp_error(sbi)))
f2fs_submit_merged_bio(sbi, META, WRITE); f2fs_submit_merged_bio(sbi, META, WRITE);
return 0; return 0;
redirty_out: redirty_out:
...@@ -252,13 +257,13 @@ static int f2fs_write_meta_pages(struct address_space *mapping, ...@@ -252,13 +257,13 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
long diff, written; long diff, written;
trace_f2fs_writepages(mapping->host, wbc, META);
/* collect a number of dirty meta pages and write together */ /* collect a number of dirty meta pages and write together */
if (wbc->for_kupdate || if (wbc->for_kupdate ||
get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META)) get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META))
goto skip_write; goto skip_write;
trace_f2fs_writepages(mapping->host, wbc, META);
/* if mounting is failed, skip writing node pages */ /* if mounting is failed, skip writing node pages */
mutex_lock(&sbi->cp_mutex); mutex_lock(&sbi->cp_mutex);
diff = nr_pages_to_write(sbi, META, wbc); diff = nr_pages_to_write(sbi, META, wbc);
...@@ -269,6 +274,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping, ...@@ -269,6 +274,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
skip_write: skip_write:
wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_META); wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_META);
trace_f2fs_writepages(mapping->host, wbc, META);
return 0; return 0;
} }
...@@ -276,15 +282,18 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, ...@@ -276,15 +282,18 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
long nr_to_write) long nr_to_write)
{ {
struct address_space *mapping = META_MAPPING(sbi); struct address_space *mapping = META_MAPPING(sbi);
pgoff_t index = 0, end = LONG_MAX, prev = LONG_MAX; pgoff_t index = 0, end = ULONG_MAX, prev = ULONG_MAX;
struct pagevec pvec; struct pagevec pvec;
long nwritten = 0; long nwritten = 0;
struct writeback_control wbc = { struct writeback_control wbc = {
.for_reclaim = 0, .for_reclaim = 0,
}; };
struct blk_plug plug;
pagevec_init(&pvec, 0); pagevec_init(&pvec, 0);
blk_start_plug(&plug);
while (index <= end) { while (index <= end) {
int i, nr_pages; int i, nr_pages;
nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
...@@ -296,7 +305,7 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, ...@@ -296,7 +305,7 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
for (i = 0; i < nr_pages; i++) { for (i = 0; i < nr_pages; i++) {
struct page *page = pvec.pages[i]; struct page *page = pvec.pages[i];
if (prev == LONG_MAX) if (prev == ULONG_MAX)
prev = page->index - 1; prev = page->index - 1;
if (nr_to_write != LONG_MAX && page->index != prev + 1) { if (nr_to_write != LONG_MAX && page->index != prev + 1) {
pagevec_release(&pvec); pagevec_release(&pvec);
...@@ -315,6 +324,9 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, ...@@ -315,6 +324,9 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
goto continue_unlock; goto continue_unlock;
} }
f2fs_wait_on_page_writeback(page, META, true);
BUG_ON(PageWriteback(page));
if (!clear_page_dirty_for_io(page)) if (!clear_page_dirty_for_io(page))
goto continue_unlock; goto continue_unlock;
...@@ -334,6 +346,8 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, ...@@ -334,6 +346,8 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
if (nwritten) if (nwritten)
f2fs_submit_merged_bio(sbi, type, WRITE); f2fs_submit_merged_bio(sbi, type, WRITE);
blk_finish_plug(&plug);
return nwritten; return nwritten;
} }
...@@ -621,7 +635,7 @@ static struct page *validate_checkpoint(struct f2fs_sb_info *sbi, ...@@ -621,7 +635,7 @@ static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
goto invalid_cp1; goto invalid_cp1;
crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset))); crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset)));
if (!f2fs_crc_valid(crc, cp_block, crc_offset)) if (!f2fs_crc_valid(sbi, crc, cp_block, crc_offset))
goto invalid_cp1; goto invalid_cp1;
pre_version = cur_cp_version(cp_block); pre_version = cur_cp_version(cp_block);
...@@ -636,7 +650,7 @@ static struct page *validate_checkpoint(struct f2fs_sb_info *sbi, ...@@ -636,7 +650,7 @@ static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
goto invalid_cp2; goto invalid_cp2;
crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset))); crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset)));
if (!f2fs_crc_valid(crc, cp_block, crc_offset)) if (!f2fs_crc_valid(sbi, crc, cp_block, crc_offset))
goto invalid_cp2; goto invalid_cp2;
cur_version = cur_cp_version(cp_block); cur_version = cur_cp_version(cp_block);
...@@ -696,6 +710,10 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) ...@@ -696,6 +710,10 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi)
cp_block = (struct f2fs_checkpoint *)page_address(cur_page); cp_block = (struct f2fs_checkpoint *)page_address(cur_page);
memcpy(sbi->ckpt, cp_block, blk_size); memcpy(sbi->ckpt, cp_block, blk_size);
/* Sanity checking of checkpoint */
if (sanity_check_ckpt(sbi))
goto fail_no_cp;
if (cp_blks <= 1) if (cp_blks <= 1)
goto done; goto done;
...@@ -902,7 +920,7 @@ static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi) ...@@ -902,7 +920,7 @@ static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi)
if (!get_pages(sbi, F2FS_WRITEBACK)) if (!get_pages(sbi, F2FS_WRITEBACK))
break; break;
io_schedule(); io_schedule_timeout(5*HZ);
} }
finish_wait(&sbi->cp_wait, &wait); finish_wait(&sbi->cp_wait, &wait);
} }
...@@ -921,6 +939,9 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -921,6 +939,9 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
int cp_payload_blks = __cp_payload(sbi); int cp_payload_blks = __cp_payload(sbi);
block_t discard_blk = NEXT_FREE_BLKADDR(sbi, curseg); block_t discard_blk = NEXT_FREE_BLKADDR(sbi, curseg);
bool invalidate = false; bool invalidate = false;
struct super_block *sb = sbi->sb;
struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
u64 kbytes_written;
/* /*
* This avoids to conduct wrong roll-forward operations and uses * This avoids to conduct wrong roll-forward operations and uses
...@@ -1008,7 +1029,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1008,7 +1029,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP)); get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP)); get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
crc32 = f2fs_crc32(ckpt, le32_to_cpu(ckpt->checksum_offset)); crc32 = f2fs_crc32(sbi, ckpt, le32_to_cpu(ckpt->checksum_offset));
*((__le32 *)((unsigned char *)ckpt + *((__le32 *)((unsigned char *)ckpt +
le32_to_cpu(ckpt->checksum_offset))) le32_to_cpu(ckpt->checksum_offset)))
= cpu_to_le32(crc32); = cpu_to_le32(crc32);
...@@ -1034,6 +1055,14 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1034,6 +1055,14 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
write_data_summaries(sbi, start_blk); write_data_summaries(sbi, start_blk);
start_blk += data_sum_blocks; start_blk += data_sum_blocks;
/* Record write statistics in the hot node summary */
kbytes_written = sbi->kbytes_written;
if (sb->s_bdev->bd_part)
kbytes_written += BD_PART_WRITTEN(sbi);
seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written);
if (__remain_node_summaries(cpc->reason)) { if (__remain_node_summaries(cpc->reason)) {
write_node_summaries(sbi, start_blk); write_node_summaries(sbi, start_blk);
start_blk += NR_CURSEG_NODE_TYPE; start_blk += NR_CURSEG_NODE_TYPE;
...@@ -1048,8 +1077,8 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1048,8 +1077,8 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
if (unlikely(f2fs_cp_error(sbi))) if (unlikely(f2fs_cp_error(sbi)))
return -EIO; return -EIO;
filemap_fdatawait_range(NODE_MAPPING(sbi), 0, LONG_MAX); filemap_fdatawait_range(NODE_MAPPING(sbi), 0, LLONG_MAX);
filemap_fdatawait_range(META_MAPPING(sbi), 0, LONG_MAX); filemap_fdatawait_range(META_MAPPING(sbi), 0, LLONG_MAX);
/* update user_block_counts */ /* update user_block_counts */
sbi->last_valid_block_count = sbi->total_valid_block_count; sbi->last_valid_block_count = sbi->total_valid_block_count;
...@@ -1112,9 +1141,7 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1112,9 +1141,7 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops"); trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
f2fs_submit_merged_bio(sbi, DATA, WRITE); f2fs_flush_merged_bios(sbi);
f2fs_submit_merged_bio(sbi, NODE, WRITE);
f2fs_submit_merged_bio(sbi, META, WRITE);
/* /*
* update checkpoint pack index * update checkpoint pack index
......
This diff is collapsed.
...@@ -77,7 +77,7 @@ static unsigned long dir_block_index(unsigned int level, ...@@ -77,7 +77,7 @@ static unsigned long dir_block_index(unsigned int level,
} }
static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
struct f2fs_filename *fname, struct fscrypt_name *fname,
f2fs_hash_t namehash, f2fs_hash_t namehash,
int *max_slots, int *max_slots,
struct page **res_page) struct page **res_page)
...@@ -103,15 +103,15 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, ...@@ -103,15 +103,15 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
return de; return de;
} }
struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *fname, struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,
f2fs_hash_t namehash, int *max_slots, f2fs_hash_t namehash, int *max_slots,
struct f2fs_dentry_ptr *d) struct f2fs_dentry_ptr *d)
{ {
struct f2fs_dir_entry *de; struct f2fs_dir_entry *de;
unsigned long bit_pos = 0; unsigned long bit_pos = 0;
int max_len = 0; int max_len = 0;
struct f2fs_str de_name = FSTR_INIT(NULL, 0); struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
struct f2fs_str *name = &fname->disk_name; struct fscrypt_str *name = &fname->disk_name;
if (max_slots) if (max_slots)
*max_slots = 0; *max_slots = 0;
...@@ -157,7 +157,7 @@ struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *fname, ...@@ -157,7 +157,7 @@ struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *fname,
static struct f2fs_dir_entry *find_in_level(struct inode *dir, static struct f2fs_dir_entry *find_in_level(struct inode *dir,
unsigned int level, unsigned int level,
struct f2fs_filename *fname, struct fscrypt_name *fname,
struct page **res_page) struct page **res_page)
{ {
struct qstr name = FSTR_TO_QSTR(&fname->disk_name); struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
...@@ -218,12 +218,12 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, ...@@ -218,12 +218,12 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
struct f2fs_dir_entry *de = NULL; struct f2fs_dir_entry *de = NULL;
unsigned int max_depth; unsigned int max_depth;
unsigned int level; unsigned int level;
struct f2fs_filename fname; struct fscrypt_name fname;
int err; int err;
*res_page = NULL; *res_page = NULL;
err = f2fs_fname_setup_filename(dir, child, 1, &fname); err = fscrypt_setup_filename(dir, child, 1, &fname);
if (err) if (err)
return NULL; return NULL;
...@@ -251,7 +251,7 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, ...@@ -251,7 +251,7 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
break; break;
} }
out: out:
f2fs_fname_free_filename(&fname); fscrypt_free_filename(&fname);
return de; return de;
} }
...@@ -296,7 +296,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, ...@@ -296,7 +296,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
{ {
enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA; enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
lock_page(page); lock_page(page);
f2fs_wait_on_page_writeback(page, type); f2fs_wait_on_page_writeback(page, type, true);
de->ino = cpu_to_le32(inode->i_ino); de->ino = cpu_to_le32(inode->i_ino);
set_de_type(de, inode->i_mode); set_de_type(de, inode->i_mode);
f2fs_dentry_kunmap(dir, page); f2fs_dentry_kunmap(dir, page);
...@@ -311,7 +311,7 @@ static void init_dent_inode(const struct qstr *name, struct page *ipage) ...@@ -311,7 +311,7 @@ static void init_dent_inode(const struct qstr *name, struct page *ipage)
{ {
struct f2fs_inode *ri; struct f2fs_inode *ri;
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE, true);
/* copy name info. to this inode page */ /* copy name info. to this inode page */
ri = F2FS_INODE(ipage); ri = F2FS_INODE(ipage);
...@@ -341,24 +341,14 @@ int update_dent_inode(struct inode *inode, struct inode *to, ...@@ -341,24 +341,14 @@ int update_dent_inode(struct inode *inode, struct inode *to,
void do_make_empty_dir(struct inode *inode, struct inode *parent, void do_make_empty_dir(struct inode *inode, struct inode *parent,
struct f2fs_dentry_ptr *d) struct f2fs_dentry_ptr *d)
{ {
struct f2fs_dir_entry *de; struct qstr dot = QSTR_INIT(".", 1);
struct qstr dotdot = QSTR_INIT("..", 2);
de = &d->dentry[0];
de->name_len = cpu_to_le16(1);
de->hash_code = 0;
de->ino = cpu_to_le32(inode->i_ino);
memcpy(d->filename[0], ".", 1);
set_de_type(de, inode->i_mode);
de = &d->dentry[1]; /* update dirent of "." */
de->hash_code = 0; f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
de->name_len = cpu_to_le16(2);
de->ino = cpu_to_le32(parent->i_ino);
memcpy(d->filename[1], "..", 2);
set_de_type(de, parent->i_mode);
test_and_set_bit_le(0, (void *)d->bitmap); /* update dirent of ".." */
test_and_set_bit_le(1, (void *)d->bitmap); f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
} }
static int make_empty_dir(struct inode *inode, static int make_empty_dir(struct inode *inode,
...@@ -413,7 +403,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, ...@@ -413,7 +403,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
goto put_error; goto put_error;
if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) { if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {
err = f2fs_inherit_context(dir, inode, page); err = fscrypt_inherit_context(dir, inode, page, false);
if (err) if (err)
goto put_error; goto put_error;
} }
...@@ -511,8 +501,12 @@ void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d, ...@@ -511,8 +501,12 @@ void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
memcpy(d->filename[bit_pos], name->name, name->len); memcpy(d->filename[bit_pos], name->name, name->len);
de->ino = cpu_to_le32(ino); de->ino = cpu_to_le32(ino);
set_de_type(de, mode); set_de_type(de, mode);
for (i = 0; i < slots; i++) for (i = 0; i < slots; i++) {
test_and_set_bit_le(bit_pos + i, (void *)d->bitmap); test_and_set_bit_le(bit_pos + i, (void *)d->bitmap);
/* avoid wrong garbage data for readdir */
if (i)
(de + i)->name_len = 0;
}
} }
/* /*
...@@ -532,11 +526,11 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, ...@@ -532,11 +526,11 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
struct f2fs_dentry_block *dentry_blk = NULL; struct f2fs_dentry_block *dentry_blk = NULL;
struct f2fs_dentry_ptr d; struct f2fs_dentry_ptr d;
struct page *page = NULL; struct page *page = NULL;
struct f2fs_filename fname; struct fscrypt_name fname;
struct qstr new_name; struct qstr new_name;
int slots, err; int slots, err;
err = f2fs_fname_setup_filename(dir, name, 0, &fname); err = fscrypt_setup_filename(dir, name, 0, &fname);
if (err) if (err)
return err; return err;
...@@ -598,7 +592,7 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, ...@@ -598,7 +592,7 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
++level; ++level;
goto start; goto start;
add_dentry: add_dentry:
f2fs_wait_on_page_writeback(dentry_page, DATA); f2fs_wait_on_page_writeback(dentry_page, DATA, true);
if (inode) { if (inode) {
down_write(&F2FS_I(inode)->i_sem); down_write(&F2FS_I(inode)->i_sem);
...@@ -635,7 +629,7 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, ...@@ -635,7 +629,7 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
kunmap(dentry_page); kunmap(dentry_page);
f2fs_put_page(dentry_page, 1); f2fs_put_page(dentry_page, 1);
out: out:
f2fs_fname_free_filename(&fname); fscrypt_free_filename(&fname);
f2fs_update_time(F2FS_I_SB(dir), REQ_TIME); f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
return err; return err;
} }
...@@ -709,7 +703,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, ...@@ -709,7 +703,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
return f2fs_delete_inline_entry(dentry, page, dir, inode); return f2fs_delete_inline_entry(dentry, page, dir, inode);
lock_page(page); lock_page(page);
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA, true);
dentry_blk = page_address(page); dentry_blk = page_address(page);
bit_pos = dentry - dentry_blk->dentry; bit_pos = dentry - dentry_blk->dentry;
...@@ -777,12 +771,12 @@ bool f2fs_empty_dir(struct inode *dir) ...@@ -777,12 +771,12 @@ bool f2fs_empty_dir(struct inode *dir)
} }
bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
unsigned int start_pos, struct f2fs_str *fstr) unsigned int start_pos, struct fscrypt_str *fstr)
{ {
unsigned char d_type = DT_UNKNOWN; unsigned char d_type = DT_UNKNOWN;
unsigned int bit_pos; unsigned int bit_pos;
struct f2fs_dir_entry *de = NULL; struct f2fs_dir_entry *de = NULL;
struct f2fs_str de_name = FSTR_INIT(NULL, 0); struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
bit_pos = ((unsigned long)ctx->pos % d->max); bit_pos = ((unsigned long)ctx->pos % d->max);
...@@ -792,6 +786,12 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, ...@@ -792,6 +786,12 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
break; break;
de = &d->dentry[bit_pos]; de = &d->dentry[bit_pos];
if (de->name_len == 0) {
bit_pos++;
ctx->pos = start_pos + bit_pos;
continue;
}
if (de->file_type < F2FS_FT_MAX) if (de->file_type < F2FS_FT_MAX)
d_type = f2fs_filetype_table[de->file_type]; d_type = f2fs_filetype_table[de->file_type];
else else
...@@ -810,8 +810,9 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, ...@@ -810,8 +810,9 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
memcpy(de_name.name, d->filename[bit_pos], de_name.len); memcpy(de_name.name, d->filename[bit_pos], de_name.len);
ret = f2fs_fname_disk_to_usr(d->inode, &de->hash_code, ret = fscrypt_fname_disk_to_usr(d->inode,
&de_name, fstr); (u32)de->hash_code, 0,
&de_name, fstr);
kfree(de_name.name); kfree(de_name.name);
if (ret < 0) if (ret < 0)
return true; return true;
...@@ -839,16 +840,15 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx) ...@@ -839,16 +840,15 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
struct file_ra_state *ra = &file->f_ra; struct file_ra_state *ra = &file->f_ra;
unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK); unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
struct f2fs_dentry_ptr d; struct f2fs_dentry_ptr d;
struct f2fs_str fstr = FSTR_INIT(NULL, 0); struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
int err = 0; int err = 0;
if (f2fs_encrypted_inode(inode)) { if (f2fs_encrypted_inode(inode)) {
err = f2fs_get_encryption_info(inode); err = fscrypt_get_encryption_info(inode);
if (err) if (err && err != -ENOKEY)
return err; return err;
err = f2fs_fname_crypto_alloc_buffer(inode, F2FS_NAME_LEN, err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
&fstr);
if (err < 0) if (err < 0)
return err; return err;
} }
...@@ -888,15 +888,23 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx) ...@@ -888,15 +888,23 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
f2fs_put_page(dentry_page, 1); f2fs_put_page(dentry_page, 1);
} }
out: out:
f2fs_fname_crypto_free_buffer(&fstr); fscrypt_fname_free_buffer(&fstr);
return err; return err;
} }
static int f2fs_dir_open(struct inode *inode, struct file *filp)
{
if (f2fs_encrypted_inode(inode))
return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
return 0;
}
const struct file_operations f2fs_dir_operations = { const struct file_operations f2fs_dir_operations = {
.llseek = generic_file_llseek, .llseek = generic_file_llseek,
.read = generic_read_dir, .read = generic_read_dir,
.iterate = f2fs_readdir, .iterate = f2fs_readdir,
.fsync = f2fs_sync_file, .fsync = f2fs_sync_file,
.open = f2fs_dir_open,
.unlocked_ioctl = f2fs_ioctl, .unlocked_ioctl = f2fs_ioctl,
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
.compat_ioctl = f2fs_compat_ioctl, .compat_ioctl = f2fs_compat_ioctl,
......
...@@ -33,6 +33,7 @@ static struct extent_node *__attach_extent_node(struct f2fs_sb_info *sbi, ...@@ -33,6 +33,7 @@ static struct extent_node *__attach_extent_node(struct f2fs_sb_info *sbi,
en->ei = *ei; en->ei = *ei;
INIT_LIST_HEAD(&en->list); INIT_LIST_HEAD(&en->list);
en->et = et;
rb_link_node(&en->rb_node, parent, p); rb_link_node(&en->rb_node, parent, p);
rb_insert_color(&en->rb_node, &et->root); rb_insert_color(&en->rb_node, &et->root);
...@@ -50,6 +51,24 @@ static void __detach_extent_node(struct f2fs_sb_info *sbi, ...@@ -50,6 +51,24 @@ static void __detach_extent_node(struct f2fs_sb_info *sbi,
if (et->cached_en == en) if (et->cached_en == en)
et->cached_en = NULL; et->cached_en = NULL;
kmem_cache_free(extent_node_slab, en);
}
/*
* Flow to release an extent_node:
* 1. list_del_init
* 2. __detach_extent_node
* 3. kmem_cache_free.
*/
static void __release_extent_node(struct f2fs_sb_info *sbi,
struct extent_tree *et, struct extent_node *en)
{
spin_lock(&sbi->extent_lock);
f2fs_bug_on(sbi, list_empty(&en->list));
list_del_init(&en->list);
spin_unlock(&sbi->extent_lock);
__detach_extent_node(sbi, et, en);
} }
static struct extent_tree *__grab_extent_tree(struct inode *inode) static struct extent_tree *__grab_extent_tree(struct inode *inode)
...@@ -129,7 +148,7 @@ static struct extent_node *__init_extent_tree(struct f2fs_sb_info *sbi, ...@@ -129,7 +148,7 @@ static struct extent_node *__init_extent_tree(struct f2fs_sb_info *sbi,
} }
static unsigned int __free_extent_tree(struct f2fs_sb_info *sbi, static unsigned int __free_extent_tree(struct f2fs_sb_info *sbi,
struct extent_tree *et, bool free_all) struct extent_tree *et)
{ {
struct rb_node *node, *next; struct rb_node *node, *next;
struct extent_node *en; struct extent_node *en;
...@@ -139,18 +158,7 @@ static unsigned int __free_extent_tree(struct f2fs_sb_info *sbi, ...@@ -139,18 +158,7 @@ static unsigned int __free_extent_tree(struct f2fs_sb_info *sbi,
while (node) { while (node) {
next = rb_next(node); next = rb_next(node);
en = rb_entry(node, struct extent_node, rb_node); en = rb_entry(node, struct extent_node, rb_node);
__release_extent_node(sbi, et, en);
if (free_all) {
spin_lock(&sbi->extent_lock);
if (!list_empty(&en->list))
list_del_init(&en->list);
spin_unlock(&sbi->extent_lock);
}
if (free_all || list_empty(&en->list)) {
__detach_extent_node(sbi, et, en);
kmem_cache_free(extent_node_slab, en);
}
node = next; node = next;
} }
...@@ -232,9 +240,10 @@ static bool f2fs_lookup_extent_tree(struct inode *inode, pgoff_t pgofs, ...@@ -232,9 +240,10 @@ static bool f2fs_lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
if (en) { if (en) {
*ei = en->ei; *ei = en->ei;
spin_lock(&sbi->extent_lock); spin_lock(&sbi->extent_lock);
if (!list_empty(&en->list)) if (!list_empty(&en->list)) {
list_move_tail(&en->list, &sbi->extent_list); list_move_tail(&en->list, &sbi->extent_list);
et->cached_en = en; et->cached_en = en;
}
spin_unlock(&sbi->extent_lock); spin_unlock(&sbi->extent_lock);
ret = true; ret = true;
} }
...@@ -329,7 +338,6 @@ static struct extent_node *__lookup_extent_tree_ret(struct extent_tree *et, ...@@ -329,7 +338,6 @@ static struct extent_node *__lookup_extent_tree_ret(struct extent_tree *et,
static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi, static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi,
struct extent_tree *et, struct extent_info *ei, struct extent_tree *et, struct extent_info *ei,
struct extent_node **den,
struct extent_node *prev_ex, struct extent_node *prev_ex,
struct extent_node *next_ex) struct extent_node *next_ex)
{ {
...@@ -342,20 +350,25 @@ static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi, ...@@ -342,20 +350,25 @@ static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi,
} }
if (next_ex && __is_front_mergeable(ei, &next_ex->ei)) { if (next_ex && __is_front_mergeable(ei, &next_ex->ei)) {
if (en) { if (en)
__detach_extent_node(sbi, et, prev_ex); __release_extent_node(sbi, et, prev_ex);
*den = prev_ex;
}
next_ex->ei.fofs = ei->fofs; next_ex->ei.fofs = ei->fofs;
next_ex->ei.blk = ei->blk; next_ex->ei.blk = ei->blk;
next_ex->ei.len += ei->len; next_ex->ei.len += ei->len;
en = next_ex; en = next_ex;
} }
if (en) { if (!en)
__try_update_largest_extent(et, en); return NULL;
__try_update_largest_extent(et, en);
spin_lock(&sbi->extent_lock);
if (!list_empty(&en->list)) {
list_move_tail(&en->list, &sbi->extent_list);
et->cached_en = en; et->cached_en = en;
} }
spin_unlock(&sbi->extent_lock);
return en; return en;
} }
...@@ -391,7 +404,12 @@ static struct extent_node *__insert_extent_tree(struct f2fs_sb_info *sbi, ...@@ -391,7 +404,12 @@ static struct extent_node *__insert_extent_tree(struct f2fs_sb_info *sbi,
return NULL; return NULL;
__try_update_largest_extent(et, en); __try_update_largest_extent(et, en);
/* update in global extent list */
spin_lock(&sbi->extent_lock);
list_add_tail(&en->list, &sbi->extent_list);
et->cached_en = en; et->cached_en = en;
spin_unlock(&sbi->extent_lock);
return en; return en;
} }
...@@ -479,7 +497,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode, ...@@ -479,7 +497,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
if (parts) if (parts)
__try_update_largest_extent(et, en); __try_update_largest_extent(et, en);
else else
__detach_extent_node(sbi, et, en); __release_extent_node(sbi, et, en);
/* /*
* if original extent is split into zero or two parts, extent * if original extent is split into zero or two parts, extent
...@@ -490,31 +508,15 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode, ...@@ -490,31 +508,15 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
insert_p = NULL; insert_p = NULL;
insert_parent = NULL; insert_parent = NULL;
} }
/* update in global extent list */
spin_lock(&sbi->extent_lock);
if (!parts && !list_empty(&en->list))
list_del(&en->list);
if (en1)
list_add_tail(&en1->list, &sbi->extent_list);
spin_unlock(&sbi->extent_lock);
/* release extent node */
if (!parts)
kmem_cache_free(extent_node_slab, en);
en = next_en; en = next_en;
} }
/* 3. update extent in extent cache */ /* 3. update extent in extent cache */
if (blkaddr) { if (blkaddr) {
struct extent_node *den = NULL;
set_extent_info(&ei, fofs, blkaddr, len); set_extent_info(&ei, fofs, blkaddr, len);
en1 = __try_merge_extent_node(sbi, et, &ei, &den, if (!__try_merge_extent_node(sbi, et, &ei, prev_en, next_en))
prev_en, next_en); __insert_extent_tree(sbi, et, &ei,
if (!en1)
en1 = __insert_extent_tree(sbi, et, &ei,
insert_p, insert_parent); insert_p, insert_parent);
/* give up extent_cache, if split and small updates happen */ /* give up extent_cache, if split and small updates happen */
...@@ -524,24 +526,10 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode, ...@@ -524,24 +526,10 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
et->largest.len = 0; et->largest.len = 0;
set_inode_flag(F2FS_I(inode), FI_NO_EXTENT); set_inode_flag(F2FS_I(inode), FI_NO_EXTENT);
} }
spin_lock(&sbi->extent_lock);
if (en1) {
if (list_empty(&en1->list))
list_add_tail(&en1->list, &sbi->extent_list);
else
list_move_tail(&en1->list, &sbi->extent_list);
}
if (den && !list_empty(&den->list))
list_del(&den->list);
spin_unlock(&sbi->extent_lock);
if (den)
kmem_cache_free(extent_node_slab, den);
} }
if (is_inode_flag_set(F2FS_I(inode), FI_NO_EXTENT)) if (is_inode_flag_set(F2FS_I(inode), FI_NO_EXTENT))
__free_extent_tree(sbi, et, true); __free_extent_tree(sbi, et);
write_unlock(&et->lock); write_unlock(&et->lock);
...@@ -550,14 +538,10 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode, ...@@ -550,14 +538,10 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink) unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
{ {
struct extent_tree *treevec[EXT_TREE_VEC_SIZE];
struct extent_tree *et, *next; struct extent_tree *et, *next;
struct extent_node *en, *tmp; struct extent_node *en;
unsigned long ino = F2FS_ROOT_INO(sbi);
unsigned int found;
unsigned int node_cnt = 0, tree_cnt = 0; unsigned int node_cnt = 0, tree_cnt = 0;
int remained; int remained;
bool do_free = false;
if (!test_opt(sbi, EXTENT_CACHE)) if (!test_opt(sbi, EXTENT_CACHE))
return 0; return 0;
...@@ -572,10 +556,10 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink) ...@@ -572,10 +556,10 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
list_for_each_entry_safe(et, next, &sbi->zombie_list, list) { list_for_each_entry_safe(et, next, &sbi->zombie_list, list) {
if (atomic_read(&et->node_cnt)) { if (atomic_read(&et->node_cnt)) {
write_lock(&et->lock); write_lock(&et->lock);
node_cnt += __free_extent_tree(sbi, et, true); node_cnt += __free_extent_tree(sbi, et);
write_unlock(&et->lock); write_unlock(&et->lock);
} }
f2fs_bug_on(sbi, atomic_read(&et->node_cnt));
list_del_init(&et->list); list_del_init(&et->list);
radix_tree_delete(&sbi->extent_tree_root, et->ino); radix_tree_delete(&sbi->extent_tree_root, et->ino);
kmem_cache_free(extent_tree_slab, et); kmem_cache_free(extent_tree_slab, et);
...@@ -585,6 +569,7 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink) ...@@ -585,6 +569,7 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
if (node_cnt + tree_cnt >= nr_shrink) if (node_cnt + tree_cnt >= nr_shrink)
goto unlock_out; goto unlock_out;
cond_resched();
} }
up_write(&sbi->extent_tree_lock); up_write(&sbi->extent_tree_lock);
...@@ -596,42 +581,29 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink) ...@@ -596,42 +581,29 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
remained = nr_shrink - (node_cnt + tree_cnt); remained = nr_shrink - (node_cnt + tree_cnt);
spin_lock(&sbi->extent_lock); spin_lock(&sbi->extent_lock);
list_for_each_entry_safe(en, tmp, &sbi->extent_list, list) { for (; remained > 0; remained--) {
if (!remained--) if (list_empty(&sbi->extent_list))
break; break;
list_del_init(&en->list); en = list_first_entry(&sbi->extent_list,
do_free = true; struct extent_node, list);
} et = en->et;
spin_unlock(&sbi->extent_lock); if (!write_trylock(&et->lock)) {
/* refresh this extent node's position in extent list */
if (do_free == false) list_move_tail(&en->list, &sbi->extent_list);
goto unlock_out; continue;
}
/*
* reset ino for searching victims from beginning of global extent tree.
*/
ino = F2FS_ROOT_INO(sbi);
while ((found = radix_tree_gang_lookup(&sbi->extent_tree_root,
(void **)treevec, ino, EXT_TREE_VEC_SIZE))) {
unsigned i;
ino = treevec[found - 1]->ino + 1;
for (i = 0; i < found; i++) {
struct extent_tree *et = treevec[i];
if (!atomic_read(&et->node_cnt)) list_del_init(&en->list);
continue; spin_unlock(&sbi->extent_lock);
if (write_trylock(&et->lock)) { __detach_extent_node(sbi, et, en);
node_cnt += __free_extent_tree(sbi, et, false);
write_unlock(&et->lock);
}
if (node_cnt + tree_cnt >= nr_shrink) write_unlock(&et->lock);
goto unlock_out; node_cnt++;
} spin_lock(&sbi->extent_lock);
} }
spin_unlock(&sbi->extent_lock);
unlock_out: unlock_out:
up_write(&sbi->extent_tree_lock); up_write(&sbi->extent_tree_lock);
out: out:
...@@ -650,7 +622,7 @@ unsigned int f2fs_destroy_extent_node(struct inode *inode) ...@@ -650,7 +622,7 @@ unsigned int f2fs_destroy_extent_node(struct inode *inode)
return 0; return 0;
write_lock(&et->lock); write_lock(&et->lock);
node_cnt = __free_extent_tree(sbi, et, true); node_cnt = __free_extent_tree(sbi, et);
write_unlock(&et->lock); write_unlock(&et->lock);
return node_cnt; return node_cnt;
...@@ -701,19 +673,21 @@ bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs, ...@@ -701,19 +673,21 @@ bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
void f2fs_update_extent_cache(struct dnode_of_data *dn) void f2fs_update_extent_cache(struct dnode_of_data *dn)
{ {
struct f2fs_inode_info *fi = F2FS_I(dn->inode);
pgoff_t fofs; pgoff_t fofs;
block_t blkaddr;
if (!f2fs_may_extent_tree(dn->inode)) if (!f2fs_may_extent_tree(dn->inode))
return; return;
f2fs_bug_on(F2FS_I_SB(dn->inode), dn->data_blkaddr == NEW_ADDR); if (dn->data_blkaddr == NEW_ADDR)
blkaddr = NULL_ADDR;
else
blkaddr = dn->data_blkaddr;
fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) + fofs = start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +
dn->ofs_in_node; dn->ofs_in_node;
if (f2fs_update_extent_tree_range(dn->inode, fofs, dn->data_blkaddr, 1)) if (f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, 1))
sync_inode_page(dn); sync_inode_page(dn);
} }
......
This diff is collapsed.
/*
* linux/fs/f2fs/f2fs_crypto.h
*
* Copied from linux/fs/ext4/ext4_crypto.h
*
* Copyright (C) 2015, Google, Inc.
*
* This contains encryption header content for f2fs
*
* Written by Michael Halcrow, 2015.
* Modified by Jaegeuk Kim, 2015.
*/
#ifndef _F2FS_CRYPTO_H
#define _F2FS_CRYPTO_H
#include <linux/fs.h>
#define F2FS_KEY_DESCRIPTOR_SIZE 8
/* Policy provided via an ioctl on the topmost directory */
struct f2fs_encryption_policy {
char version;
char contents_encryption_mode;
char filenames_encryption_mode;
char flags;
char master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
} __attribute__((__packed__));
#define F2FS_ENCRYPTION_CONTEXT_FORMAT_V1 1
#define F2FS_KEY_DERIVATION_NONCE_SIZE 16
#define F2FS_POLICY_FLAGS_PAD_4 0x00
#define F2FS_POLICY_FLAGS_PAD_8 0x01
#define F2FS_POLICY_FLAGS_PAD_16 0x02
#define F2FS_POLICY_FLAGS_PAD_32 0x03
#define F2FS_POLICY_FLAGS_PAD_MASK 0x03
#define F2FS_POLICY_FLAGS_VALID 0x03
/**
* Encryption context for inode
*
* Protector format:
* 1 byte: Protector format (1 = this version)
* 1 byte: File contents encryption mode
* 1 byte: File names encryption mode
* 1 byte: Flags
* 8 bytes: Master Key descriptor
* 16 bytes: Encryption Key derivation nonce
*/
struct f2fs_encryption_context {
char format;
char contents_encryption_mode;
char filenames_encryption_mode;
char flags;
char master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
char nonce[F2FS_KEY_DERIVATION_NONCE_SIZE];
} __attribute__((__packed__));
/* Encryption parameters */
#define F2FS_XTS_TWEAK_SIZE 16
#define F2FS_AES_128_ECB_KEY_SIZE 16
#define F2FS_AES_256_GCM_KEY_SIZE 32
#define F2FS_AES_256_CBC_KEY_SIZE 32
#define F2FS_AES_256_CTS_KEY_SIZE 32
#define F2FS_AES_256_XTS_KEY_SIZE 64
#define F2FS_MAX_KEY_SIZE 64
#define F2FS_KEY_DESC_PREFIX "f2fs:"
#define F2FS_KEY_DESC_PREFIX_SIZE 5
struct f2fs_encryption_key {
__u32 mode;
char raw[F2FS_MAX_KEY_SIZE];
__u32 size;
} __attribute__((__packed__));
struct f2fs_crypt_info {
char ci_data_mode;
char ci_filename_mode;
char ci_flags;
struct crypto_skcipher *ci_ctfm;
struct key *ci_keyring_key;
char ci_master_key[F2FS_KEY_DESCRIPTOR_SIZE];
};
#define F2FS_CTX_REQUIRES_FREE_ENCRYPT_FL 0x00000001
#define F2FS_WRITE_PATH_FL 0x00000002
struct f2fs_crypto_ctx {
union {
struct {
struct page *bounce_page; /* Ciphertext page */
struct page *control_page; /* Original page */
} w;
struct {
struct bio *bio;
struct work_struct work;
} r;
struct list_head free_list; /* Free list */
};
char flags; /* Flags */
};
struct f2fs_completion_result {
struct completion completion;
int res;
};
#define DECLARE_F2FS_COMPLETION_RESULT(ecr) \
struct f2fs_completion_result ecr = { \
COMPLETION_INITIALIZER((ecr).completion), 0 }
static inline int f2fs_encryption_key_size(int mode)
{
switch (mode) {
case F2FS_ENCRYPTION_MODE_AES_256_XTS:
return F2FS_AES_256_XTS_KEY_SIZE;
case F2FS_ENCRYPTION_MODE_AES_256_GCM:
return F2FS_AES_256_GCM_KEY_SIZE;
case F2FS_ENCRYPTION_MODE_AES_256_CBC:
return F2FS_AES_256_CBC_KEY_SIZE;
case F2FS_ENCRYPTION_MODE_AES_256_CTS:
return F2FS_AES_256_CTS_KEY_SIZE;
default:
BUG();
}
return 0;
}
#define F2FS_FNAME_NUM_SCATTER_ENTRIES 4
#define F2FS_CRYPTO_BLOCK_SIZE 16
#define F2FS_FNAME_CRYPTO_DIGEST_SIZE 32
/**
* For encrypted symlinks, the ciphertext length is stored at the beginning
* of the string in little-endian format.
*/
struct f2fs_encrypted_symlink_data {
__le16 len;
char encrypted_path[1];
} __attribute__((__packed__));
/**
* This function is used to calculate the disk space required to
* store a filename of length l in encrypted symlink format.
*/
static inline u32 encrypted_symlink_data_len(u32 l)
{
return (l + sizeof(struct f2fs_encrypted_symlink_data) - 1);
}
#endif /* _F2FS_CRYPTO_H */
...@@ -86,7 +86,7 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma, ...@@ -86,7 +86,7 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
trace_f2fs_vm_page_mkwrite(page, DATA); trace_f2fs_vm_page_mkwrite(page, DATA);
mapped: mapped:
/* fill the page */ /* fill the page */
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA, false);
/* wait for GCed encrypted page writeback */ /* wait for GCed encrypted page writeback */
if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
...@@ -301,7 +301,7 @@ static pgoff_t __get_first_dirty_index(struct address_space *mapping, ...@@ -301,7 +301,7 @@ static pgoff_t __get_first_dirty_index(struct address_space *mapping,
pagevec_init(&pvec, 0); pagevec_init(&pvec, 0);
nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs, nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
PAGECACHE_TAG_DIRTY, 1); PAGECACHE_TAG_DIRTY, 1);
pgofs = nr_pages ? pvec.pages[0]->index : LONG_MAX; pgofs = nr_pages ? pvec.pages[0]->index : ULONG_MAX;
pagevec_release(&pvec); pagevec_release(&pvec);
return pgofs; return pgofs;
} }
...@@ -358,15 +358,14 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence) ...@@ -358,15 +358,14 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
} else if (err == -ENOENT) { } else if (err == -ENOENT) {
/* direct node does not exists */ /* direct node does not exists */
if (whence == SEEK_DATA) { if (whence == SEEK_DATA) {
pgofs = PGOFS_OF_NEXT_DNODE(pgofs, pgofs = get_next_page_offset(&dn, pgofs);
F2FS_I(inode));
continue; continue;
} else { } else {
goto found; goto found;
} }
} }
end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode)); end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
/* find data/hole in dnode block */ /* find data/hole in dnode block */
for (; dn.ofs_in_node < end_offset; for (; dn.ofs_in_node < end_offset;
...@@ -422,9 +421,11 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma) ...@@ -422,9 +421,11 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
int err; int err;
if (f2fs_encrypted_inode(inode)) { if (f2fs_encrypted_inode(inode)) {
err = f2fs_get_encryption_info(inode); err = fscrypt_get_encryption_info(inode);
if (err) if (err)
return 0; return 0;
if (!f2fs_encrypted_inode(inode))
return -ENOKEY;
} }
/* we don't need to use inline_data strictly */ /* we don't need to use inline_data strictly */
...@@ -440,12 +441,18 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma) ...@@ -440,12 +441,18 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
static int f2fs_file_open(struct inode *inode, struct file *filp) static int f2fs_file_open(struct inode *inode, struct file *filp)
{ {
int ret = generic_file_open(inode, filp); int ret = generic_file_open(inode, filp);
struct inode *dir = filp->f_path.dentry->d_parent->d_inode;
if (!ret && f2fs_encrypted_inode(inode)) { if (!ret && f2fs_encrypted_inode(inode)) {
ret = f2fs_get_encryption_info(inode); ret = fscrypt_get_encryption_info(inode);
if (ret) if (ret)
ret = -EACCES; return -EACCES;
if (!fscrypt_has_encryption_key(inode))
return -ENOKEY;
} }
if (f2fs_encrypted_inode(dir) &&
!fscrypt_has_permitted_context(dir, inode))
return -EPERM;
return ret; return ret;
} }
...@@ -480,7 +487,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count) ...@@ -480,7 +487,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
* we will invalidate all blkaddr in the whole range. * we will invalidate all blkaddr in the whole range.
*/ */
fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fofs = start_bidx_of_node(ofs_of_node(dn->node_page),
F2FS_I(dn->inode)) + ofs; dn->inode) + ofs;
f2fs_update_extent_cache_range(dn, fofs, 0, len); f2fs_update_extent_cache_range(dn, fofs, 0, len);
dec_valid_block_count(sbi, dn->inode, nr_free); dec_valid_block_count(sbi, dn->inode, nr_free);
sync_inode_page(dn); sync_inode_page(dn);
...@@ -521,9 +528,10 @@ static int truncate_partial_data_page(struct inode *inode, u64 from, ...@@ -521,9 +528,10 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
if (IS_ERR(page)) if (IS_ERR(page))
return 0; return 0;
truncate_out: truncate_out:
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA, true);
zero_user(page, offset, PAGE_CACHE_SIZE - offset); zero_user(page, offset, PAGE_CACHE_SIZE - offset);
if (!cache_only || !f2fs_encrypted_inode(inode) || !S_ISREG(inode->i_mode)) if (!cache_only || !f2fs_encrypted_inode(inode) ||
!S_ISREG(inode->i_mode))
set_page_dirty(page); set_page_dirty(page);
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
return 0; return 0;
...@@ -568,7 +576,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock) ...@@ -568,7 +576,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
goto out; goto out;
} }
count = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode)); count = ADDRS_PER_PAGE(dn.node_page, inode);
count -= dn.ofs_in_node; count -= dn.ofs_in_node;
f2fs_bug_on(sbi, count < 0); f2fs_bug_on(sbi, count < 0);
...@@ -671,7 +679,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr) ...@@ -671,7 +679,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
if (attr->ia_valid & ATTR_SIZE) { if (attr->ia_valid & ATTR_SIZE) {
if (f2fs_encrypted_inode(inode) && if (f2fs_encrypted_inode(inode) &&
f2fs_get_encryption_info(inode)) fscrypt_get_encryption_info(inode))
return -EACCES; return -EACCES;
if (attr->ia_size <= i_size_read(inode)) { if (attr->ia_size <= i_size_read(inode)) {
...@@ -743,7 +751,7 @@ static int fill_zero(struct inode *inode, pgoff_t index, ...@@ -743,7 +751,7 @@ static int fill_zero(struct inode *inode, pgoff_t index,
if (IS_ERR(page)) if (IS_ERR(page))
return PTR_ERR(page); return PTR_ERR(page);
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA, true);
zero_user(page, start, len); zero_user(page, start, len);
set_page_dirty(page); set_page_dirty(page);
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
...@@ -768,7 +776,7 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end) ...@@ -768,7 +776,7 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
return err; return err;
} }
end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode)); end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
count = min(end_offset - dn.ofs_in_node, pg_end - pg_start); count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset); f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
...@@ -854,10 +862,8 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src, ...@@ -854,10 +862,8 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src,
} else { } else {
new_addr = dn.data_blkaddr; new_addr = dn.data_blkaddr;
if (!is_checkpointed_data(sbi, new_addr)) { if (!is_checkpointed_data(sbi, new_addr)) {
dn.data_blkaddr = NULL_ADDR;
/* do not invalidate this block address */ /* do not invalidate this block address */
set_data_blkaddr(&dn); f2fs_update_data_blkaddr(&dn, NULL_ADDR);
f2fs_update_extent_cache(&dn);
do_replace = true; do_replace = true;
} }
f2fs_put_dnode(&dn); f2fs_put_dnode(&dn);
...@@ -884,7 +890,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src, ...@@ -884,7 +890,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src,
get_node_info(sbi, dn.nid, &ni); get_node_info(sbi, dn.nid, &ni);
f2fs_replace_block(sbi, &dn, dn.data_blkaddr, new_addr, f2fs_replace_block(sbi, &dn, dn.data_blkaddr, new_addr,
ni.version, true); ni.version, true, false);
f2fs_put_dnode(&dn); f2fs_put_dnode(&dn);
} else { } else {
struct page *psrc, *pdst; struct page *psrc, *pdst;
...@@ -892,7 +898,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src, ...@@ -892,7 +898,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src,
psrc = get_lock_data_page(inode, src, true); psrc = get_lock_data_page(inode, src, true);
if (IS_ERR(psrc)) if (IS_ERR(psrc))
return PTR_ERR(psrc); return PTR_ERR(psrc);
pdst = get_new_data_page(inode, NULL, dst, false); pdst = get_new_data_page(inode, NULL, dst, true);
if (IS_ERR(pdst)) { if (IS_ERR(pdst)) {
f2fs_put_page(psrc, 1); f2fs_put_page(psrc, 1);
return PTR_ERR(pdst); return PTR_ERR(pdst);
...@@ -908,9 +914,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src, ...@@ -908,9 +914,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src,
err_out: err_out:
if (!get_dnode_of_data(&dn, src, LOOKUP_NODE)) { if (!get_dnode_of_data(&dn, src, LOOKUP_NODE)) {
dn.data_blkaddr = new_addr; f2fs_update_data_blkaddr(&dn, new_addr);
set_data_blkaddr(&dn);
f2fs_update_extent_cache(&dn);
f2fs_put_dnode(&dn); f2fs_put_dnode(&dn);
} }
return ret; return ret;
...@@ -1050,12 +1054,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len, ...@@ -1050,12 +1054,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
if (dn.data_blkaddr != NEW_ADDR) { if (dn.data_blkaddr != NEW_ADDR) {
invalidate_blocks(sbi, dn.data_blkaddr); invalidate_blocks(sbi, dn.data_blkaddr);
f2fs_update_data_blkaddr(&dn, NEW_ADDR);
dn.data_blkaddr = NEW_ADDR;
set_data_blkaddr(&dn);
dn.data_blkaddr = NULL_ADDR;
f2fs_update_extent_cache(&dn);
} }
f2fs_put_dnode(&dn); f2fs_put_dnode(&dn);
f2fs_unlock_op(sbi); f2fs_unlock_op(sbi);
...@@ -1253,7 +1252,7 @@ static int f2fs_release_file(struct inode *inode, struct file *filp) ...@@ -1253,7 +1252,7 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
{ {
/* some remained atomic pages should discarded */ /* some remained atomic pages should discarded */
if (f2fs_is_atomic_file(inode)) if (f2fs_is_atomic_file(inode))
commit_inmem_pages(inode, true); drop_inmem_pages(inode);
if (f2fs_is_volatile_file(inode)) { if (f2fs_is_volatile_file(inode)) {
set_inode_flag(F2FS_I(inode), FI_DROP_CACHE); set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
filemap_fdatawrite(inode->i_mapping); filemap_fdatawrite(inode->i_mapping);
...@@ -1377,7 +1376,7 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp) ...@@ -1377,7 +1376,7 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
if (f2fs_is_atomic_file(inode)) { if (f2fs_is_atomic_file(inode)) {
clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
ret = commit_inmem_pages(inode, false); ret = commit_inmem_pages(inode);
if (ret) { if (ret) {
set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
goto err_out; goto err_out;
...@@ -1440,7 +1439,7 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp) ...@@ -1440,7 +1439,7 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
if (f2fs_is_atomic_file(inode)) { if (f2fs_is_atomic_file(inode)) {
clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
commit_inmem_pages(inode, true); drop_inmem_pages(inode);
} }
if (f2fs_is_volatile_file(inode)) { if (f2fs_is_volatile_file(inode)) {
clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE); clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
...@@ -1535,39 +1534,30 @@ static bool uuid_is_nonzero(__u8 u[16]) ...@@ -1535,39 +1534,30 @@ static bool uuid_is_nonzero(__u8 u[16])
static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg) static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
{ {
#ifdef CONFIG_F2FS_FS_ENCRYPTION struct fscrypt_policy policy;
struct f2fs_encryption_policy policy;
struct inode *inode = file_inode(filp); struct inode *inode = file_inode(filp);
if (copy_from_user(&policy, (struct f2fs_encryption_policy __user *)arg, if (copy_from_user(&policy, (struct fscrypt_policy __user *)arg,
sizeof(policy))) sizeof(policy)))
return -EFAULT; return -EFAULT;
f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
return f2fs_process_policy(&policy, inode); return fscrypt_process_policy(inode, &policy);
#else
return -EOPNOTSUPP;
#endif
} }
static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg) static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
{ {
#ifdef CONFIG_F2FS_FS_ENCRYPTION struct fscrypt_policy policy;
struct f2fs_encryption_policy policy;
struct inode *inode = file_inode(filp); struct inode *inode = file_inode(filp);
int err; int err;
err = f2fs_get_policy(inode, &policy); err = fscrypt_get_policy(inode, &policy);
if (err) if (err)
return err; return err;
if (copy_to_user((struct f2fs_encryption_policy __user *)arg, &policy, if (copy_to_user((struct fscrypt_policy __user *)arg, &policy, sizeof(policy)))
sizeof(policy)))
return -EFAULT; return -EFAULT;
return 0; return 0;
#else
return -EOPNOTSUPP;
#endif
} }
static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg) static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
...@@ -1648,7 +1638,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi, ...@@ -1648,7 +1638,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
struct f2fs_defragment *range) struct f2fs_defragment *range)
{ {
struct inode *inode = file_inode(filp); struct inode *inode = file_inode(filp);
struct f2fs_map_blocks map; struct f2fs_map_blocks map = { .m_next_pgofs = NULL };
struct extent_info ei; struct extent_info ei;
pgoff_t pg_start, pg_end; pgoff_t pg_start, pg_end;
unsigned int blk_per_seg = sbi->blocks_per_seg; unsigned int blk_per_seg = sbi->blocks_per_seg;
...@@ -1874,14 +1864,32 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -1874,14 +1864,32 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{ {
struct inode *inode = file_inode(iocb->ki_filp); struct file *file = iocb->ki_filp;
struct inode *inode = file_inode(file);
ssize_t ret;
if (f2fs_encrypted_inode(inode) && if (f2fs_encrypted_inode(inode) &&
!f2fs_has_encryption_key(inode) && !fscrypt_has_encryption_key(inode) &&
f2fs_get_encryption_info(inode)) fscrypt_get_encryption_info(inode))
return -EACCES; return -EACCES;
return generic_file_write_iter(iocb, from); inode_lock(inode);
ret = generic_write_checks(iocb, from);
if (ret > 0) {
ret = f2fs_preallocate_blocks(iocb, from);
if (!ret)
ret = __generic_file_write_iter(iocb, from);
}
inode_unlock(inode);
if (ret > 0) {
ssize_t err;
err = generic_write_sync(file, iocb->ki_pos - ret, ret);
if (err < 0)
ret = err;
}
return ret;
} }
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
......
This diff is collapsed.
...@@ -71,7 +71,7 @@ bool truncate_inline_inode(struct page *ipage, u64 from) ...@@ -71,7 +71,7 @@ bool truncate_inline_inode(struct page *ipage, u64 from)
addr = inline_data_addr(ipage); addr = inline_data_addr(ipage);
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE, true);
memset(addr + from, 0, MAX_INLINE_DATA - from); memset(addr + from, 0, MAX_INLINE_DATA - from);
return true; return true;
...@@ -105,7 +105,6 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page) ...@@ -105,7 +105,6 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
{ {
void *src_addr, *dst_addr;
struct f2fs_io_info fio = { struct f2fs_io_info fio = {
.sbi = F2FS_I_SB(dn->inode), .sbi = F2FS_I_SB(dn->inode),
.type = DATA, .type = DATA,
...@@ -115,8 +114,6 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) ...@@ -115,8 +114,6 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
}; };
int dirty, err; int dirty, err;
f2fs_bug_on(F2FS_I_SB(dn->inode), page->index);
if (!f2fs_exist_data(dn->inode)) if (!f2fs_exist_data(dn->inode))
goto clear_out; goto clear_out;
...@@ -124,21 +121,9 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) ...@@ -124,21 +121,9 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
if (err) if (err)
return err; return err;
f2fs_wait_on_page_writeback(page, DATA); f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
if (PageUptodate(page))
goto no_update;
zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
/* Copy the whole inline data block */ read_inline_data(page, dn->inode_page);
src_addr = inline_data_addr(dn->inode_page);
dst_addr = kmap_atomic(page);
memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
flush_dcache_page(page);
kunmap_atomic(dst_addr);
SetPageUptodate(page);
no_update:
set_page_dirty(page); set_page_dirty(page);
/* clear dirty state */ /* clear dirty state */
...@@ -146,11 +131,9 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) ...@@ -146,11 +131,9 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
/* write data page to try to make data consistent */ /* write data page to try to make data consistent */
set_page_writeback(page); set_page_writeback(page);
fio.blk_addr = dn->data_blkaddr; fio.old_blkaddr = dn->data_blkaddr;
write_data_page(dn, &fio); write_data_page(dn, &fio);
set_data_blkaddr(dn); f2fs_wait_on_page_writeback(page, DATA, true);
f2fs_update_extent_cache(dn);
f2fs_wait_on_page_writeback(page, DATA);
if (dirty) if (dirty)
inode_dec_dirty_pages(dn->inode); inode_dec_dirty_pages(dn->inode);
...@@ -159,6 +142,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) ...@@ -159,6 +142,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
/* clear inline data and flag after data writeback */ /* clear inline data and flag after data writeback */
truncate_inline_inode(dn->inode_page, 0); truncate_inline_inode(dn->inode_page, 0);
clear_inline_node(dn->inode_page);
clear_out: clear_out:
stat_dec_inline_inode(dn->inode); stat_dec_inline_inode(dn->inode);
f2fs_clear_inline_inode(dn->inode); f2fs_clear_inline_inode(dn->inode);
...@@ -223,7 +207,7 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page) ...@@ -223,7 +207,7 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page)
f2fs_bug_on(F2FS_I_SB(inode), page->index); f2fs_bug_on(F2FS_I_SB(inode), page->index);
f2fs_wait_on_page_writeback(dn.inode_page, NODE); f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
src_addr = kmap_atomic(page); src_addr = kmap_atomic(page);
dst_addr = inline_data_addr(dn.inode_page); dst_addr = inline_data_addr(dn.inode_page);
memcpy(dst_addr, src_addr, MAX_INLINE_DATA); memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
...@@ -233,6 +217,7 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page) ...@@ -233,6 +217,7 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page)
set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
sync_inode_page(&dn); sync_inode_page(&dn);
clear_inline_node(dn.inode_page);
f2fs_put_dnode(&dn); f2fs_put_dnode(&dn);
return 0; return 0;
} }
...@@ -261,7 +246,7 @@ bool recover_inline_data(struct inode *inode, struct page *npage) ...@@ -261,7 +246,7 @@ bool recover_inline_data(struct inode *inode, struct page *npage)
ipage = get_node_page(sbi, inode->i_ino); ipage = get_node_page(sbi, inode->i_ino);
f2fs_bug_on(sbi, IS_ERR(ipage)); f2fs_bug_on(sbi, IS_ERR(ipage));
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE, true);
src_addr = inline_data_addr(npage); src_addr = inline_data_addr(npage);
dst_addr = inline_data_addr(ipage); dst_addr = inline_data_addr(ipage);
...@@ -292,7 +277,7 @@ bool recover_inline_data(struct inode *inode, struct page *npage) ...@@ -292,7 +277,7 @@ bool recover_inline_data(struct inode *inode, struct page *npage)
} }
struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
struct f2fs_filename *fname, struct page **res_page) struct fscrypt_name *fname, struct page **res_page)
{ {
struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
struct f2fs_inline_dentry *inline_dentry; struct f2fs_inline_dentry *inline_dentry;
...@@ -389,7 +374,7 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, ...@@ -389,7 +374,7 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
if (err) if (err)
goto out; goto out;
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA, true);
zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE); zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
dentry_blk = kmap_atomic(page); dentry_blk = kmap_atomic(page);
...@@ -469,7 +454,7 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name, ...@@ -469,7 +454,7 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
} }
} }
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE, true);
name_hash = f2fs_dentry_hash(name); name_hash = f2fs_dentry_hash(name);
make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2); make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
...@@ -507,7 +492,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, ...@@ -507,7 +492,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
int i; int i;
lock_page(page); lock_page(page);
f2fs_wait_on_page_writeback(page, NODE); f2fs_wait_on_page_writeback(page, NODE, true);
inline_dentry = inline_data_addr(page); inline_dentry = inline_data_addr(page);
bit_pos = dentry - inline_dentry->dentry; bit_pos = dentry - inline_dentry->dentry;
...@@ -550,7 +535,7 @@ bool f2fs_empty_inline_dir(struct inode *dir) ...@@ -550,7 +535,7 @@ bool f2fs_empty_inline_dir(struct inode *dir)
} }
int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
struct f2fs_str *fstr) struct fscrypt_str *fstr)
{ {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct f2fs_inline_dentry *inline_dentry = NULL; struct f2fs_inline_dentry *inline_dentry = NULL;
......
...@@ -83,7 +83,7 @@ static void __recover_inline_status(struct inode *inode, struct page *ipage) ...@@ -83,7 +83,7 @@ static void __recover_inline_status(struct inode *inode, struct page *ipage)
while (start < end) { while (start < end) {
if (*start++) { if (*start++) {
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE, true);
set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage)); set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage));
...@@ -227,7 +227,7 @@ int update_inode(struct inode *inode, struct page *node_page) ...@@ -227,7 +227,7 @@ int update_inode(struct inode *inode, struct page *node_page)
{ {
struct f2fs_inode *ri; struct f2fs_inode *ri;
f2fs_wait_on_page_writeback(node_page, NODE); f2fs_wait_on_page_writeback(node_page, NODE, true);
ri = F2FS_INODE(node_page); ri = F2FS_INODE(node_page);
...@@ -263,6 +263,10 @@ int update_inode(struct inode *inode, struct page *node_page) ...@@ -263,6 +263,10 @@ int update_inode(struct inode *inode, struct page *node_page)
set_cold_node(inode, node_page); set_cold_node(inode, node_page);
clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE); clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
/* deleted inode */
if (inode->i_nlink == 0)
clear_inline_node(node_page);
return set_page_dirty(node_page); return set_page_dirty(node_page);
} }
...@@ -320,7 +324,7 @@ void f2fs_evict_inode(struct inode *inode) ...@@ -320,7 +324,7 @@ void f2fs_evict_inode(struct inode *inode)
/* some remained atomic pages should discarded */ /* some remained atomic pages should discarded */
if (f2fs_is_atomic_file(inode)) if (f2fs_is_atomic_file(inode))
commit_inmem_pages(inode, true); drop_inmem_pages(inode);
trace_f2fs_evict_inode(inode); trace_f2fs_evict_inode(inode);
truncate_inode_pages_final(&inode->i_data); truncate_inode_pages_final(&inode->i_data);
...@@ -385,10 +389,7 @@ void f2fs_evict_inode(struct inode *inode) ...@@ -385,10 +389,7 @@ void f2fs_evict_inode(struct inode *inode)
} }
} }
out_clear: out_clear:
#ifdef CONFIG_F2FS_FS_ENCRYPTION fscrypt_put_encryption_info(inode, NULL);
if (fi->i_crypt_info)
f2fs_free_encryption_info(inode, fi->i_crypt_info);
#endif
clear_inode(inode); clear_inode(inode);
} }
......
This diff is collapsed.
This diff is collapsed.
...@@ -25,6 +25,9 @@ ...@@ -25,6 +25,9 @@
/* control the memory footprint threshold (10MB per 1GB ram) */ /* control the memory footprint threshold (10MB per 1GB ram) */
#define DEF_RAM_THRESHOLD 10 #define DEF_RAM_THRESHOLD 10
/* control dirty nats ratio threshold (default: 10% over max nid count) */
#define DEF_DIRTY_NAT_RATIO_THRESHOLD 10
/* vector size for gang look-up from nat cache that consists of radix tree */ /* vector size for gang look-up from nat cache that consists of radix tree */
#define NATVEC_SIZE 64 #define NATVEC_SIZE 64
#define SETVEC_SIZE 32 #define SETVEC_SIZE 32
...@@ -117,6 +120,12 @@ static inline void raw_nat_from_node_info(struct f2fs_nat_entry *raw_ne, ...@@ -117,6 +120,12 @@ static inline void raw_nat_from_node_info(struct f2fs_nat_entry *raw_ne,
raw_ne->version = ni->version; raw_ne->version = ni->version;
} }
static inline bool excess_dirty_nats(struct f2fs_sb_info *sbi)
{
return NM_I(sbi)->dirty_nat_cnt >= NM_I(sbi)->max_nid *
NM_I(sbi)->dirty_nats_ratio / 100;
}
enum mem_type { enum mem_type {
FREE_NIDS, /* indicates the free nid list */ FREE_NIDS, /* indicates the free nid list */
NAT_ENTRIES, /* indicates the cached nat entry */ NAT_ENTRIES, /* indicates the cached nat entry */
...@@ -321,7 +330,7 @@ static inline int set_nid(struct page *p, int off, nid_t nid, bool i) ...@@ -321,7 +330,7 @@ static inline int set_nid(struct page *p, int off, nid_t nid, bool i)
{ {
struct f2fs_node *rn = F2FS_NODE(p); struct f2fs_node *rn = F2FS_NODE(p);
f2fs_wait_on_page_writeback(p, NODE); f2fs_wait_on_page_writeback(p, NODE, true);
if (i) if (i)
rn->i.i_nid[off - NODE_DIR1_BLOCK] = cpu_to_le32(nid); rn->i.i_nid[off - NODE_DIR1_BLOCK] = cpu_to_le32(nid);
...@@ -370,6 +379,21 @@ static inline int is_node(struct page *page, int type) ...@@ -370,6 +379,21 @@ static inline int is_node(struct page *page, int type)
#define is_fsync_dnode(page) is_node(page, FSYNC_BIT_SHIFT) #define is_fsync_dnode(page) is_node(page, FSYNC_BIT_SHIFT)
#define is_dent_dnode(page) is_node(page, DENT_BIT_SHIFT) #define is_dent_dnode(page) is_node(page, DENT_BIT_SHIFT)
static inline int is_inline_node(struct page *page)
{
return PageChecked(page);
}
static inline void set_inline_node(struct page *page)
{
SetPageChecked(page);
}
static inline void clear_inline_node(struct page *page)
{
ClearPageChecked(page);
}
static inline void set_cold_node(struct inode *inode, struct page *page) static inline void set_cold_node(struct inode *inode, struct page *page)
{ {
struct f2fs_node *rn = F2FS_NODE(page); struct f2fs_node *rn = F2FS_NODE(page);
......
...@@ -350,8 +350,7 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi, ...@@ -350,8 +350,7 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
inode = dn->inode; inode = dn->inode;
} }
bidx = start_bidx_of_node(offset, F2FS_I(inode)) + bidx = start_bidx_of_node(offset, inode) + le16_to_cpu(sum.ofs_in_node);
le16_to_cpu(sum.ofs_in_node);
/* /*
* if inode page is locked, unlock temporarily, but its reference * if inode page is locked, unlock temporarily, but its reference
...@@ -386,10 +385,9 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi, ...@@ -386,10 +385,9 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode, static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
struct page *page, block_t blkaddr) struct page *page, block_t blkaddr)
{ {
struct f2fs_inode_info *fi = F2FS_I(inode);
unsigned int start, end;
struct dnode_of_data dn; struct dnode_of_data dn;
struct node_info ni; struct node_info ni;
unsigned int start, end;
int err = 0, recovered = 0; int err = 0, recovered = 0;
/* step 1: recover xattr */ /* step 1: recover xattr */
...@@ -409,8 +407,8 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode, ...@@ -409,8 +407,8 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
goto out; goto out;
/* step 3: recover data indices */ /* step 3: recover data indices */
start = start_bidx_of_node(ofs_of_node(page), fi); start = start_bidx_of_node(ofs_of_node(page), inode);
end = start + ADDRS_PER_PAGE(page, fi); end = start + ADDRS_PER_PAGE(page, inode);
set_new_dnode(&dn, inode, NULL, NULL, 0); set_new_dnode(&dn, inode, NULL, NULL, 0);
...@@ -418,7 +416,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode, ...@@ -418,7 +416,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
if (err) if (err)
goto out; goto out;
f2fs_wait_on_page_writeback(dn.node_page, NODE); f2fs_wait_on_page_writeback(dn.node_page, NODE, true);
get_node_info(sbi, dn.nid, &ni); get_node_info(sbi, dn.nid, &ni);
f2fs_bug_on(sbi, ni.ino != ino_of_node(page)); f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
...@@ -467,7 +465,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode, ...@@ -467,7 +465,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
/* write dummy data page */ /* write dummy data page */
f2fs_replace_block(sbi, &dn, src, dest, f2fs_replace_block(sbi, &dn, src, dest,
ni.version, false); ni.version, false, false);
recovered++; recovered++;
} }
} }
......
This diff is collapsed.
...@@ -183,7 +183,7 @@ struct segment_allocation { ...@@ -183,7 +183,7 @@ struct segment_allocation {
* this value is set in page as a private data which indicate that * this value is set in page as a private data which indicate that
* the page is atomically written, and it is in inmem_pages list. * the page is atomically written, and it is in inmem_pages list.
*/ */
#define ATOMIC_WRITTEN_PAGE 0x0000ffff #define ATOMIC_WRITTEN_PAGE ((unsigned long)-1)
#define IS_ATOMIC_WRITTEN_PAGE(page) \ #define IS_ATOMIC_WRITTEN_PAGE(page) \
(page_private(page) == (unsigned long)ATOMIC_WRITTEN_PAGE) (page_private(page) == (unsigned long)ATOMIC_WRITTEN_PAGE)
...@@ -191,6 +191,7 @@ struct segment_allocation { ...@@ -191,6 +191,7 @@ struct segment_allocation {
struct inmem_pages { struct inmem_pages {
struct list_head list; struct list_head list;
struct page *page; struct page *page;
block_t old_addr; /* for revoking when fail to commit */
}; };
struct sit_info { struct sit_info {
...@@ -257,6 +258,8 @@ struct victim_selection { ...@@ -257,6 +258,8 @@ struct victim_selection {
struct curseg_info { struct curseg_info {
struct mutex curseg_mutex; /* lock for consistency */ struct mutex curseg_mutex; /* lock for consistency */
struct f2fs_summary_block *sum_blk; /* cached summary block */ struct f2fs_summary_block *sum_blk; /* cached summary block */
struct rw_semaphore journal_rwsem; /* protect journal area */
struct f2fs_journal *journal; /* cached journal info */
unsigned char alloc_type; /* current allocation type */ unsigned char alloc_type; /* current allocation type */
unsigned int segno; /* current segment number */ unsigned int segno; /* current segment number */
unsigned short next_blkoff; /* next block offset to write */ unsigned short next_blkoff; /* next block offset to write */
......
This diff is collapsed.
...@@ -29,7 +29,8 @@ static inline void __print_last_io(void) ...@@ -29,7 +29,8 @@ static inline void __print_last_io(void)
last_io.major, last_io.minor, last_io.major, last_io.minor,
last_io.pid, "----------------", last_io.pid, "----------------",
last_io.type, last_io.type,
last_io.fio.rw, last_io.fio.blk_addr, last_io.fio.rw,
last_io.fio.new_blkaddr,
last_io.len); last_io.len);
memset(&last_io, 0, sizeof(last_io)); memset(&last_io, 0, sizeof(last_io));
} }
...@@ -101,7 +102,8 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush) ...@@ -101,7 +102,8 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
last_io.pid == pid && last_io.pid == pid &&
last_io.type == __file_type(inode, pid) && last_io.type == __file_type(inode, pid) &&
last_io.fio.rw == fio->rw && last_io.fio.rw == fio->rw &&
last_io.fio.blk_addr + last_io.len == fio->blk_addr) { last_io.fio.new_blkaddr + last_io.len ==
fio->new_blkaddr) {
last_io.len++; last_io.len++;
return; return;
} }
......
...@@ -300,7 +300,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize, ...@@ -300,7 +300,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
if (ipage) { if (ipage) {
inline_addr = inline_xattr_addr(ipage); inline_addr = inline_xattr_addr(ipage);
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE, true);
} else { } else {
page = get_node_page(sbi, inode->i_ino); page = get_node_page(sbi, inode->i_ino);
if (IS_ERR(page)) { if (IS_ERR(page)) {
...@@ -308,7 +308,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize, ...@@ -308,7 +308,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
return PTR_ERR(page); return PTR_ERR(page);
} }
inline_addr = inline_xattr_addr(page); inline_addr = inline_xattr_addr(page);
f2fs_wait_on_page_writeback(page, NODE); f2fs_wait_on_page_writeback(page, NODE, true);
} }
memcpy(inline_addr, txattr_addr, inline_size); memcpy(inline_addr, txattr_addr, inline_size);
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
...@@ -329,7 +329,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize, ...@@ -329,7 +329,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
return PTR_ERR(xpage); return PTR_ERR(xpage);
} }
f2fs_bug_on(sbi, new_nid); f2fs_bug_on(sbi, new_nid);
f2fs_wait_on_page_writeback(xpage, NODE); f2fs_wait_on_page_writeback(xpage, NODE, true);
} else { } else {
struct dnode_of_data dn; struct dnode_of_data dn;
set_new_dnode(&dn, inode, NULL, NULL, new_nid); set_new_dnode(&dn, inode, NULL, NULL, new_nid);
......
...@@ -126,7 +126,8 @@ extern ssize_t f2fs_listxattr(struct dentry *, char *, size_t); ...@@ -126,7 +126,8 @@ extern ssize_t f2fs_listxattr(struct dentry *, char *, size_t);
#define f2fs_xattr_handlers NULL #define f2fs_xattr_handlers NULL
static inline int f2fs_setxattr(struct inode *inode, int index, static inline int f2fs_setxattr(struct inode *inode, int index,
const char *name, const void *value, size_t size, int flags) const char *name, const void *value, size_t size,
struct page *page, int flags)
{ {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
......
...@@ -228,6 +228,8 @@ struct dentry_operations { ...@@ -228,6 +228,8 @@ struct dentry_operations {
#define DCACHE_FALLTHRU 0x01000000 /* Fall through to lower layer */ #define DCACHE_FALLTHRU 0x01000000 /* Fall through to lower layer */
#define DCACHE_OP_SELECT_INODE 0x02000000 /* Unioned entry: dcache op selects inode */ #define DCACHE_OP_SELECT_INODE 0x02000000 /* Unioned entry: dcache op selects inode */
#define DCACHE_ENCRYPTED_WITH_KEY 0x04000000 /* dir is encrypted with a valid key */
extern seqlock_t rename_lock; extern seqlock_t rename_lock;
/* /*
......
This diff is collapsed.
...@@ -53,6 +53,8 @@ struct swap_info_struct; ...@@ -53,6 +53,8 @@ struct swap_info_struct;
struct seq_file; struct seq_file;
struct workqueue_struct; struct workqueue_struct;
struct iov_iter; struct iov_iter;
struct fscrypt_info;
struct fscrypt_operations;
extern void __init inode_init(void); extern void __init inode_init(void);
extern void __init inode_init_early(void); extern void __init inode_init_early(void);
...@@ -679,6 +681,10 @@ struct inode { ...@@ -679,6 +681,10 @@ struct inode {
struct hlist_head i_fsnotify_marks; struct hlist_head i_fsnotify_marks;
#endif #endif
#if IS_ENABLED(CONFIG_FS_ENCRYPTION)
struct fscrypt_info *i_crypt_info;
#endif
void *i_private; /* fs or device private pointer */ void *i_private; /* fs or device private pointer */
}; };
...@@ -1324,6 +1330,8 @@ struct super_block { ...@@ -1324,6 +1330,8 @@ struct super_block {
#endif #endif
const struct xattr_handler **s_xattr; const struct xattr_handler **s_xattr;
const struct fscrypt_operations *s_cop;
struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */ struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */
struct list_head s_mounts; /* list of mounts; _not_ for fs use */ struct list_head s_mounts; /* list of mounts; _not_ for fs use */
struct block_device *s_bdev; struct block_device *s_bdev;
......
This diff is collapsed.
...@@ -52,6 +52,7 @@ TRACE_DEFINE_ENUM(CP_DISCARD); ...@@ -52,6 +52,7 @@ TRACE_DEFINE_ENUM(CP_DISCARD);
{ META_FLUSH, "META_FLUSH" }, \ { META_FLUSH, "META_FLUSH" }, \
{ INMEM, "INMEM" }, \ { INMEM, "INMEM" }, \
{ INMEM_DROP, "INMEM_DROP" }, \ { INMEM_DROP, "INMEM_DROP" }, \
{ INMEM_REVOKE, "INMEM_REVOKE" }, \
{ IPU, "IN-PLACE" }, \ { IPU, "IN-PLACE" }, \
{ OPU, "OUT-OF-PLACE" }) { OPU, "OUT-OF-PLACE" })
...@@ -727,7 +728,8 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio, ...@@ -727,7 +728,8 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
__field(dev_t, dev) __field(dev_t, dev)
__field(ino_t, ino) __field(ino_t, ino)
__field(pgoff_t, index) __field(pgoff_t, index)
__field(block_t, blkaddr) __field(block_t, old_blkaddr)
__field(block_t, new_blkaddr)
__field(int, rw) __field(int, rw)
__field(int, type) __field(int, type)
), ),
...@@ -736,16 +738,18 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio, ...@@ -736,16 +738,18 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
__entry->dev = page->mapping->host->i_sb->s_dev; __entry->dev = page->mapping->host->i_sb->s_dev;
__entry->ino = page->mapping->host->i_ino; __entry->ino = page->mapping->host->i_ino;
__entry->index = page->index; __entry->index = page->index;
__entry->blkaddr = fio->blk_addr; __entry->old_blkaddr = fio->old_blkaddr;
__entry->new_blkaddr = fio->new_blkaddr;
__entry->rw = fio->rw; __entry->rw = fio->rw;
__entry->type = fio->type; __entry->type = fio->type;
), ),
TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, " TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
"blkaddr = 0x%llx, rw = %s%s, type = %s", "oldaddr = 0x%llx, newaddr = 0x%llx rw = %s%s, type = %s",
show_dev_ino(__entry), show_dev_ino(__entry),
(unsigned long)__entry->index, (unsigned long)__entry->index,
(unsigned long long)__entry->blkaddr, (unsigned long long)__entry->old_blkaddr,
(unsigned long long)__entry->new_blkaddr,
show_bio_type(__entry->rw), show_bio_type(__entry->rw),
show_block_type(__entry->type)) show_block_type(__entry->type))
); );
......
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment