2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2012-11-14 07:59:04 +00:00
|
|
|
* fs/f2fs/dir.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
|
|
* http://www.samsung.com/
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/f2fs_fs.h>
|
|
|
|
#include "f2fs.h"
|
f2fs: fix handling errors got by f2fs_write_inode
Ruslan reported that f2fs hangs with an infinite loop in f2fs_sync_file():
while (sync_node_pages(sbi, inode->i_ino, &wbc) == 0)
f2fs_write_inode(inode, NULL);
The reason was revealed that the cold flag is not set even thought this inode is
a normal file. Therefore, sync_node_pages() skips to write node blocks since it
only writes cold node blocks.
The cold flag is stored to the node_footer in node block, and whenever a new
node page is allocated, it is set according to its file type, file or directory.
But, after sudden-power-off, when recovering the inode page, f2fs doesn't recover
its cold flag.
So, let's assign the cold flag in more right places.
One more thing:
If f2fs_write_inode() returns an error due to whatever situations, there would
be no dirty node pages so that sync_node_pages() returns zero.
(i.e., zero means nothing was written.)
Reported-by: Ruslan N. Marchenko <me@ruff.mobi>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-12-19 06:28:39 +00:00
|
|
|
#include "node.h"
|
2012-11-14 07:59:04 +00:00
|
|
|
#include "acl.h"
|
2013-06-03 10:46:19 +00:00
|
|
|
#include "xattr.h"
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
static unsigned long dir_blocks(struct inode *inode)
|
|
|
|
{
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))
|
|
|
|
>> PAGE_SHIFT;
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
2014-02-27 09:20:00 +00:00
|
|
|
static unsigned int dir_buckets(unsigned int level, int dir_level)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
2014-05-28 00:56:09 +00:00
|
|
|
if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
|
2014-02-27 09:20:00 +00:00
|
|
|
return 1 << (level + dir_level);
|
2012-11-14 07:59:04 +00:00
|
|
|
else
|
2014-05-28 00:56:09 +00:00
|
|
|
return MAX_DIR_BUCKETS;
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int bucket_blocks(unsigned int level)
|
|
|
|
{
|
|
|
|
if (level < MAX_DIR_HASH_DEPTH / 2)
|
|
|
|
return 2;
|
|
|
|
else
|
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
|
2014-09-24 10:17:04 +00:00
|
|
|
unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
|
2012-11-14 07:59:04 +00:00
|
|
|
[F2FS_FT_UNKNOWN] = DT_UNKNOWN,
|
|
|
|
[F2FS_FT_REG_FILE] = DT_REG,
|
|
|
|
[F2FS_FT_DIR] = DT_DIR,
|
|
|
|
[F2FS_FT_CHRDEV] = DT_CHR,
|
|
|
|
[F2FS_FT_BLKDEV] = DT_BLK,
|
|
|
|
[F2FS_FT_FIFO] = DT_FIFO,
|
|
|
|
[F2FS_FT_SOCK] = DT_SOCK,
|
|
|
|
[F2FS_FT_SYMLINK] = DT_LNK,
|
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
|
|
|
|
[S_IFREG >> S_SHIFT] = F2FS_FT_REG_FILE,
|
|
|
|
[S_IFDIR >> S_SHIFT] = F2FS_FT_DIR,
|
|
|
|
[S_IFCHR >> S_SHIFT] = F2FS_FT_CHRDEV,
|
|
|
|
[S_IFBLK >> S_SHIFT] = F2FS_FT_BLKDEV,
|
|
|
|
[S_IFIFO >> S_SHIFT] = F2FS_FT_FIFO,
|
|
|
|
[S_IFSOCK >> S_SHIFT] = F2FS_FT_SOCK,
|
|
|
|
[S_IFLNK >> S_SHIFT] = F2FS_FT_SYMLINK,
|
|
|
|
};
|
|
|
|
|
2015-03-30 22:07:16 +00:00
|
|
|
void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
|
|
|
de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
|
|
|
|
}
|
|
|
|
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
unsigned char get_de_type(struct f2fs_dir_entry *de)
|
|
|
|
{
|
|
|
|
if (de->file_type < F2FS_FT_MAX)
|
|
|
|
return f2fs_filetype_table[de->file_type];
|
|
|
|
return DT_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2014-02-27 09:20:00 +00:00
|
|
|
static unsigned long dir_block_index(unsigned int level,
|
|
|
|
int dir_level, unsigned int idx)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long bidx = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < level; i++)
|
2014-02-27 09:20:00 +00:00
|
|
|
bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
|
2012-11-14 07:59:04 +00:00
|
|
|
bidx += idx * bucket_blocks(level);
|
|
|
|
return bidx;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
|
2015-05-15 23:26:10 +00:00
|
|
|
struct fscrypt_name *fname,
|
2015-04-28 00:12:39 +00:00
|
|
|
f2fs_hash_t namehash,
|
|
|
|
int *max_slots,
|
2014-10-14 00:26:14 +00:00
|
|
|
struct page **res_page)
|
|
|
|
{
|
|
|
|
struct f2fs_dentry_block *dentry_blk;
|
|
|
|
struct f2fs_dir_entry *de;
|
2014-10-19 05:52:52 +00:00
|
|
|
struct f2fs_dentry_ptr d;
|
2014-10-14 00:26:14 +00:00
|
|
|
|
|
|
|
dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);
|
2014-10-19 05:52:52 +00:00
|
|
|
|
2015-04-27 23:26:24 +00:00
|
|
|
make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
|
2015-04-28 00:12:39 +00:00
|
|
|
de = find_target_dentry(fname, namehash, max_slots, &d);
|
2014-10-14 00:26:14 +00:00
|
|
|
if (de)
|
|
|
|
*res_page = dentry_page;
|
|
|
|
else
|
|
|
|
kunmap(dentry_page);
|
|
|
|
|
|
|
|
return de;
|
|
|
|
}
|
|
|
|
|
2015-05-15 23:26:10 +00:00
|
|
|
struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,
|
2015-04-28 00:12:39 +00:00
|
|
|
f2fs_hash_t namehash, int *max_slots,
|
|
|
|
struct f2fs_dentry_ptr *d)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
|
|
|
struct f2fs_dir_entry *de;
|
2014-02-27 04:57:53 +00:00
|
|
|
unsigned long bit_pos = 0;
|
|
|
|
int max_len = 0;
|
2015-05-15 23:26:10 +00:00
|
|
|
struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
|
|
|
|
struct fscrypt_str *name = &fname->disk_name;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2014-10-19 05:52:52 +00:00
|
|
|
if (max_slots)
|
|
|
|
*max_slots = 0;
|
|
|
|
while (bit_pos < d->max) {
|
|
|
|
if (!test_bit_le(bit_pos, d->bitmap)) {
|
2014-02-27 04:57:53 +00:00
|
|
|
bit_pos++;
|
2015-03-09 09:33:16 +00:00
|
|
|
max_len++;
|
2014-02-27 04:57:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
2015-03-09 09:33:16 +00:00
|
|
|
|
2014-10-19 05:52:52 +00:00
|
|
|
de = &d->dentry[bit_pos];
|
2015-04-28 00:12:39 +00:00
|
|
|
|
2016-04-27 14:22:20 +00:00
|
|
|
if (unlikely(!de->name_len)) {
|
|
|
|
bit_pos++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-04-28 00:12:39 +00:00
|
|
|
/* encrypted case */
|
|
|
|
de_name.name = d->filename[bit_pos];
|
|
|
|
de_name.len = le16_to_cpu(de->name_len);
|
|
|
|
|
|
|
|
/* show encrypted name */
|
|
|
|
if (fname->hash) {
|
|
|
|
if (de->hash_code == fname->hash)
|
|
|
|
goto found;
|
|
|
|
} else if (de_name.len == name->len &&
|
|
|
|
de->hash_code == namehash &&
|
|
|
|
!memcmp(de_name.name, name->name, name->len))
|
2014-10-14 00:26:14 +00:00
|
|
|
goto found;
|
|
|
|
|
2015-03-09 09:33:16 +00:00
|
|
|
if (max_slots && max_len > *max_slots)
|
2014-02-27 04:57:53 +00:00
|
|
|
*max_slots = max_len;
|
2015-03-09 09:33:16 +00:00
|
|
|
max_len = 0;
|
2014-07-10 04:37:46 +00:00
|
|
|
|
2014-02-27 04:57:53 +00:00
|
|
|
bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
de = NULL;
|
|
|
|
found:
|
2014-10-19 05:52:52 +00:00
|
|
|
if (max_slots && max_len > *max_slots)
|
2014-02-27 04:57:53 +00:00
|
|
|
*max_slots = max_len;
|
2012-11-14 07:59:04 +00:00
|
|
|
return de;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct f2fs_dir_entry *find_in_level(struct inode *dir,
|
2015-04-28 00:12:39 +00:00
|
|
|
unsigned int level,
|
2015-05-15 23:26:10 +00:00
|
|
|
struct fscrypt_name *fname,
|
2015-04-28 00:12:39 +00:00
|
|
|
struct page **res_page)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
2015-04-28 00:12:39 +00:00
|
|
|
struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
|
|
|
|
int s = GET_DENTRY_SLOTS(name.len);
|
2012-11-14 07:59:04 +00:00
|
|
|
unsigned int nbucket, nblock;
|
|
|
|
unsigned int bidx, end_block;
|
|
|
|
struct page *dentry_page;
|
|
|
|
struct f2fs_dir_entry *de = NULL;
|
|
|
|
bool room = false;
|
2014-10-14 00:26:14 +00:00
|
|
|
int max_slots;
|
2015-04-28 00:12:39 +00:00
|
|
|
f2fs_hash_t namehash;
|
|
|
|
|
|
|
|
namehash = f2fs_dentry_hash(&name);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2014-02-27 09:20:00 +00:00
|
|
|
nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
|
2012-11-14 07:59:04 +00:00
|
|
|
nblock = bucket_blocks(level);
|
|
|
|
|
2014-02-27 09:20:00 +00:00
|
|
|
bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
|
|
|
|
le32_to_cpu(namehash) % nbucket);
|
2012-11-14 07:59:04 +00:00
|
|
|
end_block = bidx + nblock;
|
|
|
|
|
|
|
|
for (; bidx < end_block; bidx++) {
|
|
|
|
/* no need to allocate new dentry pages to all the indices */
|
2015-05-01 00:00:33 +00:00
|
|
|
dentry_page = find_data_page(dir, bidx);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (IS_ERR(dentry_page)) {
|
|
|
|
room = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-04-28 00:12:39 +00:00
|
|
|
de = find_in_block(dentry_page, fname, namehash, &max_slots,
|
|
|
|
res_page);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (de)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (max_slots >= s)
|
|
|
|
room = true;
|
|
|
|
f2fs_put_page(dentry_page, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!de && room && F2FS_I(dir)->chash != namehash) {
|
|
|
|
F2FS_I(dir)->chash = namehash;
|
|
|
|
F2FS_I(dir)->clevel = level;
|
|
|
|
}
|
|
|
|
|
|
|
|
return de;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find an entry in the specified directory with the wanted name.
|
|
|
|
* It returns the page where the entry was found (as a parameter - res_page),
|
|
|
|
* and the entry itself. Page is returned mapped and unlocked.
|
|
|
|
* Entry is guaranteed to be valid.
|
|
|
|
*/
|
|
|
|
struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
|
|
|
|
struct qstr *child, struct page **res_page)
|
|
|
|
{
|
|
|
|
unsigned long npages = dir_blocks(dir);
|
|
|
|
struct f2fs_dir_entry *de = NULL;
|
|
|
|
unsigned int max_depth;
|
|
|
|
unsigned int level;
|
2015-05-15 23:26:10 +00:00
|
|
|
struct fscrypt_name fname;
|
2015-04-28 00:12:39 +00:00
|
|
|
int err;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2015-03-07 10:07:42 +00:00
|
|
|
*res_page = NULL;
|
|
|
|
|
2015-05-15 23:26:10 +00:00
|
|
|
err = fscrypt_setup_filename(dir, child, 1, &fname);
|
2015-04-28 00:12:39 +00:00
|
|
|
if (err)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (f2fs_has_inline_dentry(dir)) {
|
|
|
|
de = find_in_inline_dir(dir, &fname, res_page);
|
|
|
|
goto out;
|
|
|
|
}
|
2014-09-24 10:19:10 +00:00
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
if (npages == 0)
|
2015-04-28 00:12:39 +00:00
|
|
|
goto out;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
max_depth = F2FS_I(dir)->i_current_depth;
|
2015-12-31 18:28:52 +00:00
|
|
|
if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
|
|
|
|
f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING,
|
|
|
|
"Corrupted max_depth of %lu: %u",
|
|
|
|
dir->i_ino, max_depth);
|
|
|
|
max_depth = MAX_DIR_HASH_DEPTH;
|
|
|
|
F2FS_I(dir)->i_current_depth = max_depth;
|
|
|
|
mark_inode_dirty(dir);
|
|
|
|
}
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
for (level = 0; level < max_depth; level++) {
|
2015-04-28 00:12:39 +00:00
|
|
|
de = find_in_level(dir, level, &fname, res_page);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (de)
|
|
|
|
break;
|
|
|
|
}
|
2015-04-28 00:12:39 +00:00
|
|
|
out:
|
2015-05-15 23:26:10 +00:00
|
|
|
fscrypt_free_filename(&fname);
|
2012-11-14 07:59:04 +00:00
|
|
|
return de;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
|
|
|
|
{
|
2013-05-23 13:58:07 +00:00
|
|
|
struct page *page;
|
|
|
|
struct f2fs_dir_entry *de;
|
|
|
|
struct f2fs_dentry_block *dentry_blk;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2014-09-24 10:19:10 +00:00
|
|
|
if (f2fs_has_inline_dentry(dir))
|
|
|
|
return f2fs_parent_inline_dir(dir, p);
|
|
|
|
|
2015-10-09 22:11:38 +00:00
|
|
|
page = get_lock_data_page(dir, 0, false);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dentry_blk = kmap(page);
|
|
|
|
de = &dentry_blk->dentry[1];
|
|
|
|
*p = page;
|
|
|
|
unlock_page(page);
|
|
|
|
return de;
|
|
|
|
}
|
|
|
|
|
|
|
|
ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr)
|
|
|
|
{
|
|
|
|
ino_t res = 0;
|
|
|
|
struct f2fs_dir_entry *de;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
de = f2fs_find_entry(dir, qstr, &page);
|
|
|
|
if (de) {
|
|
|
|
res = le32_to_cpu(de->ino);
|
2014-11-22 00:36:28 +00:00
|
|
|
f2fs_dentry_kunmap(dir, page);
|
2012-11-14 07:59:04 +00:00
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
|
|
|
|
struct page *page, struct inode *inode)
|
|
|
|
{
|
2014-10-14 02:34:26 +00:00
|
|
|
enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
|
2012-11-14 07:59:04 +00:00
|
|
|
lock_page(page);
|
2016-01-20 15:43:51 +00:00
|
|
|
f2fs_wait_on_page_writeback(page, type, true);
|
2012-11-14 07:59:04 +00:00
|
|
|
de->ino = cpu_to_le32(inode->i_ino);
|
2015-03-30 22:07:16 +00:00
|
|
|
set_de_type(de, inode->i_mode);
|
2014-12-13 21:13:11 +00:00
|
|
|
f2fs_dentry_kunmap(dir, page);
|
2012-11-14 07:59:04 +00:00
|
|
|
set_page_dirty(page);
|
|
|
|
dir->i_mtime = dir->i_ctime = CURRENT_TIME;
|
|
|
|
mark_inode_dirty(dir);
|
f2fs: fix tracking parent inode number
Previously, f2fs didn't track the parent inode number correctly which is stored
in each f2fs_inode. In the case of the following scenario, a bug can be occured.
Let's suppose there are one directory, "/b", and two files, "/a" and "/b/a".
- pino of "/a" is ROOT_INO.
- pino of "/b/a" is DIR_B_INO.
Then,
# sync
: The inode pages of "/a" and "/b/a" contain the parent inode numbers as
ROOT_INO and DIR_B_INO respectively.
# mv /a /b/a
: The parent inode number of "/a" should be changed to DIR_B_INO, but f2fs
didn't do that. Ref. f2fs_set_link().
In order to fix this clearly, I added i_pino in f2fs_inode_info, and whenever
it needs to be changed like in f2fs_add_link() and f2fs_set_link(), it is
updated temporarily in f2fs_inode_info.
And later, f2fs_write_inode() stores the latest information to the inode pages.
For power-off-recovery, f2fs_sync_file() triggers simply f2fs_write_inode().
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-12-10 08:52:48 +00:00
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
}
|
|
|
|
|
2013-05-20 01:10:29 +00:00
|
|
|
static void init_dent_inode(const struct qstr *name, struct page *ipage)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
2013-12-26 07:30:41 +00:00
|
|
|
struct f2fs_inode *ri;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2016-01-20 15:43:51 +00:00
|
|
|
f2fs_wait_on_page_writeback(ipage, NODE, true);
|
2014-04-29 08:28:32 +00:00
|
|
|
|
2013-01-25 21:01:21 +00:00
|
|
|
/* copy name info. to this inode page */
|
2013-12-26 07:30:41 +00:00
|
|
|
ri = F2FS_INODE(ipage);
|
|
|
|
ri->i_namelen = cpu_to_le32(name->len);
|
|
|
|
memcpy(ri->i_name, name->name, name->len);
|
2012-11-14 07:59:04 +00:00
|
|
|
set_page_dirty(ipage);
|
|
|
|
}
|
|
|
|
|
2015-04-30 00:02:18 +00:00
|
|
|
int update_dent_inode(struct inode *inode, struct inode *to,
|
|
|
|
const struct qstr *name)
|
2013-07-18 09:02:31 +00:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
2015-04-30 00:02:18 +00:00
|
|
|
if (file_enc_name(to))
|
|
|
|
return 0;
|
|
|
|
|
2014-09-02 22:31:18 +00:00
|
|
|
page = get_node_page(F2FS_I_SB(inode), inode->i_ino);
|
2013-07-18 09:02:31 +00:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return PTR_ERR(page);
|
|
|
|
|
|
|
|
init_dent_inode(name, page);
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-19 06:06:41 +00:00
|
|
|
void do_make_empty_dir(struct inode *inode, struct inode *parent,
|
|
|
|
struct f2fs_dentry_ptr *d)
|
|
|
|
{
|
2016-03-09 14:07:28 +00:00
|
|
|
struct qstr dot = QSTR_INIT(".", 1);
|
|
|
|
struct qstr dotdot = QSTR_INIT("..", 2);
|
2014-10-19 06:06:41 +00:00
|
|
|
|
2016-03-09 14:07:28 +00:00
|
|
|
/* update dirent of "." */
|
|
|
|
f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
|
2014-10-19 06:06:41 +00:00
|
|
|
|
2016-03-09 14:07:28 +00:00
|
|
|
/* update dirent of ".." */
|
|
|
|
f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
|
2014-10-19 06:06:41 +00:00
|
|
|
}
|
|
|
|
|
2013-05-20 01:10:29 +00:00
|
|
|
static int make_empty_dir(struct inode *inode,
|
|
|
|
struct inode *parent, struct page *page)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 07:21:29 +00:00
|
|
|
{
|
|
|
|
struct page *dentry_page;
|
|
|
|
struct f2fs_dentry_block *dentry_blk;
|
2014-10-19 06:06:41 +00:00
|
|
|
struct f2fs_dentry_ptr d;
|
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
|
|
|
|
2014-09-24 10:19:10 +00:00
|
|
|
if (f2fs_has_inline_dentry(inode))
|
|
|
|
return make_empty_inline_dir(inode, parent, page);
|
|
|
|
|
2013-05-20 01:10:29 +00:00
|
|
|
dentry_page = get_new_data_page(inode, page, 0, true);
|
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
|
|
|
if (IS_ERR(dentry_page))
|
|
|
|
return PTR_ERR(dentry_page);
|
|
|
|
|
2014-06-27 09:57:04 +00:00
|
|
|
dentry_blk = kmap_atomic(dentry_page);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 07:21:29 +00:00
|
|
|
|
2015-04-27 23:26:24 +00:00
|
|
|
make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
|
2014-10-19 06:06:41 +00:00
|
|
|
do_make_empty_dir(inode, parent, &d);
|
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
|
|
|
|
2014-06-27 09:57:04 +00:00
|
|
|
kunmap_atomic(dentry_blk);
|
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
|
|
|
|
|
|
|
set_page_dirty(dentry_page);
|
|
|
|
f2fs_put_page(dentry_page, 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-14 02:42:53 +00:00
|
|
|
struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
|
|
|
|
const struct qstr *name, struct page *dpage)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
2013-05-20 01:10:29 +00:00
|
|
|
struct page *page;
|
|
|
|
int err;
|
|
|
|
|
2014-06-21 04:37:02 +00:00
|
|
|
if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
|
2014-06-21 04:44:02 +00:00
|
|
|
page = new_inode_page(inode);
|
2013-05-20 01:10:29 +00:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return page;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
2013-05-20 01:10:29 +00:00
|
|
|
err = make_empty_dir(inode, dir, page);
|
|
|
|
if (err)
|
|
|
|
goto error;
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 02:42:53 +00:00
|
|
|
err = f2fs_init_acl(inode, dir, page, dpage);
|
2013-05-20 01:10:29 +00:00
|
|
|
if (err)
|
2013-12-27 08:04:17 +00:00
|
|
|
goto put_error;
|
2013-05-20 01:10:29 +00:00
|
|
|
|
2013-06-03 10:46:19 +00:00
|
|
|
err = f2fs_init_security(inode, dir, name, page);
|
|
|
|
if (err)
|
2013-12-27 08:04:17 +00:00
|
|
|
goto put_error;
|
2015-04-22 03:39:58 +00:00
|
|
|
|
|
|
|
if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {
|
2015-05-15 23:26:10 +00:00
|
|
|
err = fscrypt_inherit_context(dir, inode, page, false);
|
2015-04-22 03:39:58 +00:00
|
|
|
if (err)
|
|
|
|
goto put_error;
|
|
|
|
}
|
2012-11-14 07:59:04 +00:00
|
|
|
} else {
|
2014-09-02 22:31:18 +00:00
|
|
|
page = get_node_page(F2FS_I_SB(dir), inode->i_ino);
|
2013-05-20 01:10:29 +00:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return page;
|
|
|
|
|
|
|
|
set_cold_node(inode, page);
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
2013-05-20 01:10:29 +00:00
|
|
|
|
2014-06-21 04:37:02 +00:00
|
|
|
if (name)
|
|
|
|
init_dent_inode(name, page);
|
2013-05-20 01:10:29 +00:00
|
|
|
|
2013-05-28 03:25:47 +00:00
|
|
|
/*
|
|
|
|
* This file should be checkpointed during fsync.
|
|
|
|
* We lost i_pino from now on.
|
|
|
|
*/
|
2012-11-14 07:59:04 +00:00
|
|
|
if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {
|
2013-06-13 23:52:35 +00:00
|
|
|
file_lost_pino(inode);
|
2014-06-19 08:23:19 +00:00
|
|
|
/*
|
|
|
|
* If link the tmpfile to alias through linkat path,
|
|
|
|
* we should remove this inode from orphan list.
|
|
|
|
*/
|
|
|
|
if (inode->i_nlink == 0)
|
2014-09-02 22:31:18 +00:00
|
|
|
remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
|
2012-11-14 07:59:04 +00:00
|
|
|
inc_nlink(inode);
|
|
|
|
}
|
2013-05-20 01:10:29 +00:00
|
|
|
return page;
|
|
|
|
|
2013-12-27 08:04:17 +00:00
|
|
|
put_error:
|
2013-05-20 01:10:29 +00:00
|
|
|
f2fs_put_page(page, 1);
|
2014-06-24 02:34:00 +00:00
|
|
|
error:
|
2014-02-05 02:16:39 +00:00
|
|
|
/* once the failed inode becomes a bad inode, i_mode is S_IFREG */
|
|
|
|
truncate_inode_pages(&inode->i_data, 0);
|
2014-08-14 23:32:54 +00:00
|
|
|
truncate_blocks(inode, 0, false);
|
2015-12-16 05:09:20 +00:00
|
|
|
remove_dirty_inode(inode);
|
2013-05-20 01:10:29 +00:00
|
|
|
remove_inode_page(inode);
|
|
|
|
return ERR_PTR(err);
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
2014-09-24 10:17:04 +00:00
|
|
|
void update_parent_metadata(struct inode *dir, struct inode *inode,
|
2012-11-14 07:59:04 +00:00
|
|
|
unsigned int current_depth)
|
|
|
|
{
|
2015-03-30 22:07:16 +00:00
|
|
|
if (inode && is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
|
2012-11-14 07:59:04 +00:00
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
inc_nlink(dir);
|
2013-06-07 13:08:23 +00:00
|
|
|
set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
|
|
|
|
}
|
|
|
|
dir->i_mtime = dir->i_ctime = CURRENT_TIME;
|
2014-01-21 04:32:12 +00:00
|
|
|
mark_inode_dirty(dir);
|
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
if (F2FS_I(dir)->i_current_depth != current_depth) {
|
|
|
|
F2FS_I(dir)->i_current_depth = current_depth;
|
2013-06-07 13:08:23 +00:00
|
|
|
set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
2015-03-30 22:07:16 +00:00
|
|
|
if (inode && is_inode_flag_set(F2FS_I(inode), FI_INC_LINK))
|
2012-11-14 07:59:04 +00:00
|
|
|
clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
|
|
|
|
}
|
|
|
|
|
2014-10-13 23:28:13 +00:00
|
|
|
int room_for_filename(const void *bitmap, int slots, int max_slots)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
|
|
|
int bit_start = 0;
|
|
|
|
int zero_start, zero_end;
|
|
|
|
next:
|
2014-10-13 23:28:13 +00:00
|
|
|
zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
|
|
|
|
if (zero_start >= max_slots)
|
|
|
|
return max_slots;
|
|
|
|
|
|
|
|
zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (zero_end - zero_start >= slots)
|
|
|
|
return zero_start;
|
|
|
|
|
|
|
|
bit_start = zero_end + 1;
|
|
|
|
|
2014-10-13 23:28:13 +00:00
|
|
|
if (zero_end + 1 >= max_slots)
|
|
|
|
return max_slots;
|
2012-11-14 07:59:04 +00:00
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
2015-03-30 22:07:16 +00:00
|
|
|
void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
|
2015-02-16 08:17:20 +00:00
|
|
|
const struct qstr *name, f2fs_hash_t name_hash,
|
|
|
|
unsigned int bit_pos)
|
|
|
|
{
|
|
|
|
struct f2fs_dir_entry *de;
|
|
|
|
int slots = GET_DENTRY_SLOTS(name->len);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
de = &d->dentry[bit_pos];
|
|
|
|
de->hash_code = name_hash;
|
|
|
|
de->name_len = cpu_to_le16(name->len);
|
|
|
|
memcpy(d->filename[bit_pos], name->name, name->len);
|
2015-03-30 22:07:16 +00:00
|
|
|
de->ino = cpu_to_le32(ino);
|
|
|
|
set_de_type(de, mode);
|
2016-02-12 22:29:28 +00:00
|
|
|
for (i = 0; i < slots; i++) {
|
2015-02-16 08:17:20 +00:00
|
|
|
test_and_set_bit_le(bit_pos + i, (void *)d->bitmap);
|
2016-02-12 22:29:28 +00:00
|
|
|
/* avoid wrong garbage data for readdir */
|
|
|
|
if (i)
|
|
|
|
(de + i)->name_len = 0;
|
|
|
|
}
|
2015-02-16 08:17:20 +00:00
|
|
|
}
|
|
|
|
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
|
2015-03-30 22:07:16 +00:00
|
|
|
struct inode *inode, nid_t ino, umode_t mode)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
|
|
|
unsigned int bit_pos;
|
|
|
|
unsigned int level;
|
|
|
|
unsigned int current_depth;
|
|
|
|
unsigned long bidx, block;
|
|
|
|
f2fs_hash_t dentry_hash;
|
|
|
|
unsigned int nbucket, nblock;
|
|
|
|
struct page *dentry_page = NULL;
|
|
|
|
struct f2fs_dentry_block *dentry_blk = NULL;
|
2015-02-16 08:17:20 +00:00
|
|
|
struct f2fs_dentry_ptr d;
|
2015-03-30 22:07:16 +00:00
|
|
|
struct page *page = NULL;
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
int slots, err = 0;
|
2014-09-24 10:19:10 +00:00
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
level = 0;
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
slots = GET_DENTRY_SLOTS(new_name->len);
|
|
|
|
dentry_hash = f2fs_dentry_hash(new_name);
|
2015-04-27 21:51:02 +00:00
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
current_depth = F2FS_I(dir)->i_current_depth;
|
|
|
|
if (F2FS_I(dir)->chash == dentry_hash) {
|
|
|
|
level = F2FS_I(dir)->clevel;
|
|
|
|
F2FS_I(dir)->chash = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
start:
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
|
|
|
|
return -ENOSPC;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
/* Increase the depth, if required */
|
|
|
|
if (level == current_depth)
|
|
|
|
++current_depth;
|
|
|
|
|
2014-02-27 09:20:00 +00:00
|
|
|
nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
|
2012-11-14 07:59:04 +00:00
|
|
|
nblock = bucket_blocks(level);
|
|
|
|
|
2014-02-27 09:20:00 +00:00
|
|
|
bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
|
|
|
|
(le32_to_cpu(dentry_hash) % nbucket));
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
for (block = bidx; block <= (bidx + nblock - 1); block++) {
|
2013-05-20 00:55:50 +00:00
|
|
|
dentry_page = get_new_data_page(dir, NULL, block, true);
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
if (IS_ERR(dentry_page))
|
|
|
|
return PTR_ERR(dentry_page);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
dentry_blk = kmap(dentry_page);
|
2014-10-13 23:28:13 +00:00
|
|
|
bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
|
|
|
|
slots, NR_DENTRY_IN_BLOCK);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (bit_pos < NR_DENTRY_IN_BLOCK)
|
|
|
|
goto add_dentry;
|
|
|
|
|
|
|
|
kunmap(dentry_page);
|
|
|
|
f2fs_put_page(dentry_page, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move to next level to find the empty slot for new dentry */
|
|
|
|
++level;
|
|
|
|
goto start;
|
|
|
|
add_dentry:
|
2016-01-20 15:43:51 +00:00
|
|
|
f2fs_wait_on_page_writeback(dentry_page, DATA, true);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2015-03-30 22:07:16 +00:00
|
|
|
if (inode) {
|
|
|
|
down_write(&F2FS_I(inode)->i_sem);
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
page = init_inode_metadata(inode, dir, new_name, NULL);
|
2015-03-30 22:07:16 +00:00
|
|
|
if (IS_ERR(page)) {
|
|
|
|
err = PTR_ERR(page);
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-04-30 00:02:18 +00:00
|
|
|
if (f2fs_encrypted_inode(dir))
|
|
|
|
file_set_enc_name(inode);
|
2013-05-20 01:10:29 +00:00
|
|
|
}
|
2015-02-16 08:17:20 +00:00
|
|
|
|
2015-04-27 23:26:24 +00:00
|
|
|
make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos);
|
2015-02-16 08:17:20 +00:00
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
set_page_dirty(dentry_page);
|
f2fs: fix tracking parent inode number
Previously, f2fs didn't track the parent inode number correctly which is stored
in each f2fs_inode. In the case of the following scenario, a bug can be occured.
Let's suppose there are one directory, "/b", and two files, "/a" and "/b/a".
- pino of "/a" is ROOT_INO.
- pino of "/b/a" is DIR_B_INO.
Then,
# sync
: The inode pages of "/a" and "/b/a" contain the parent inode numbers as
ROOT_INO and DIR_B_INO respectively.
# mv /a /b/a
: The parent inode number of "/a" should be changed to DIR_B_INO, but f2fs
didn't do that. Ref. f2fs_set_link().
In order to fix this clearly, I added i_pino in f2fs_inode_info, and whenever
it needs to be changed like in f2fs_add_link() and f2fs_set_link(), it is
updated temporarily in f2fs_inode_info.
And later, f2fs_write_inode() stores the latest information to the inode pages.
For power-off-recovery, f2fs_sync_file() triggers simply f2fs_write_inode().
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-12-10 08:52:48 +00:00
|
|
|
|
2015-03-30 22:07:16 +00:00
|
|
|
if (inode) {
|
|
|
|
/* we don't need to mark_inode_dirty now */
|
|
|
|
F2FS_I(inode)->i_pino = dir->i_ino;
|
|
|
|
update_inode(inode, page);
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
}
|
2013-05-20 01:10:29 +00:00
|
|
|
|
|
|
|
update_parent_metadata(dir, inode, current_depth);
|
2012-11-14 07:59:04 +00:00
|
|
|
fail:
|
2015-03-30 22:07:16 +00:00
|
|
|
if (inode)
|
|
|
|
up_write(&F2FS_I(inode)->i_sem);
|
2014-03-20 10:10:08 +00:00
|
|
|
|
2014-02-03 08:24:51 +00:00
|
|
|
if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
|
|
|
|
update_inode_page(dir);
|
|
|
|
clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
|
|
|
|
}
|
2012-11-14 07:59:04 +00:00
|
|
|
kunmap(dentry_page);
|
|
|
|
f2fs_put_page(dentry_page, 1);
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Caller should grab and release a rwsem by calling f2fs_lock_op() and
|
|
|
|
* f2fs_unlock_op().
|
|
|
|
*/
|
|
|
|
int __f2fs_add_link(struct inode *dir, const struct qstr *name,
|
|
|
|
struct inode *inode, nid_t ino, umode_t mode)
|
|
|
|
{
|
|
|
|
struct fscrypt_name fname;
|
|
|
|
struct qstr new_name;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = fscrypt_setup_filename(dir, name, 0, &fname);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
new_name.name = fname_name(&fname);
|
|
|
|
new_name.len = fname_len(&fname);
|
|
|
|
|
|
|
|
err = -EAGAIN;
|
|
|
|
if (f2fs_has_inline_dentry(dir))
|
|
|
|
err = f2fs_add_inline_entry(dir, &new_name, inode, ino, mode);
|
|
|
|
if (err == -EAGAIN)
|
|
|
|
err = f2fs_add_regular_entry(dir, &new_name, inode, ino, mode);
|
|
|
|
|
2015-05-15 23:26:10 +00:00
|
|
|
fscrypt_free_filename(&fname);
|
2016-01-09 00:57:48 +00:00
|
|
|
f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
|
2012-11-14 07:59:04 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-06-21 04:37:02 +00:00
|
|
|
int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
down_write(&F2FS_I(inode)->i_sem);
|
2014-10-14 02:42:53 +00:00
|
|
|
page = init_inode_metadata(inode, dir, NULL, NULL);
|
2014-06-21 04:37:02 +00:00
|
|
|
if (IS_ERR(page)) {
|
|
|
|
err = PTR_ERR(page);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
/* we don't need to mark_inode_dirty now */
|
|
|
|
update_inode(inode, page);
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
|
|
|
clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
|
|
|
|
fail:
|
|
|
|
up_write(&F2FS_I(inode)->i_sem);
|
2016-01-09 00:57:48 +00:00
|
|
|
f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
|
2014-06-21 04:37:02 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-09-24 10:17:04 +00:00
|
|
|
void f2fs_drop_nlink(struct inode *dir, struct inode *inode, struct page *page)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
|
|
|
|
|
|
|
|
down_write(&F2FS_I(inode)->i_sem);
|
|
|
|
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
drop_nlink(dir);
|
|
|
|
if (page)
|
|
|
|
update_inode(dir, page);
|
|
|
|
else
|
|
|
|
update_inode_page(dir);
|
|
|
|
}
|
|
|
|
inode->i_ctime = CURRENT_TIME;
|
|
|
|
|
|
|
|
drop_nlink(inode);
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
drop_nlink(inode);
|
|
|
|
i_size_write(inode, 0);
|
|
|
|
}
|
|
|
|
up_write(&F2FS_I(inode)->i_sem);
|
|
|
|
update_inode_page(inode);
|
|
|
|
|
|
|
|
if (inode->i_nlink == 0)
|
|
|
|
add_orphan_inode(sbi, inode->i_ino);
|
|
|
|
else
|
|
|
|
release_orphan_inode(sbi);
|
|
|
|
}
|
|
|
|
|
2012-11-29 04:28:09 +00:00
|
|
|
/*
|
2014-08-06 14:22:50 +00:00
|
|
|
* It only removes the dentry from the dentry page, corresponding name
|
2012-11-14 07:59:04 +00:00
|
|
|
* entry in name page does not need to be touched during deletion.
|
|
|
|
*/
|
|
|
|
void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
|
2014-09-24 10:17:04 +00:00
|
|
|
struct inode *dir, struct inode *inode)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
|
|
|
struct f2fs_dentry_block *dentry_blk;
|
|
|
|
unsigned int bit_pos;
|
2012-12-08 05:54:50 +00:00
|
|
|
int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
|
2012-11-14 07:59:04 +00:00
|
|
|
int i;
|
|
|
|
|
2016-01-09 00:57:48 +00:00
|
|
|
f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
|
|
|
|
|
2014-09-24 10:19:10 +00:00
|
|
|
if (f2fs_has_inline_dentry(dir))
|
|
|
|
return f2fs_delete_inline_entry(dentry, page, dir, inode);
|
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
lock_page(page);
|
2016-01-20 15:43:51 +00:00
|
|
|
f2fs_wait_on_page_writeback(page, DATA, true);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2014-06-27 09:57:04 +00:00
|
|
|
dentry_blk = page_address(page);
|
|
|
|
bit_pos = dentry - dentry_blk->dentry;
|
2012-11-14 07:59:04 +00:00
|
|
|
for (i = 0; i < slots; i++)
|
2014-10-23 12:40:20 +00:00
|
|
|
clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
/* Let's check and deallocate this dentry page */
|
|
|
|
bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
|
|
|
|
NR_DENTRY_IN_BLOCK,
|
|
|
|
0);
|
|
|
|
kunmap(page); /* kunmap - pair of f2fs_find_entry */
|
|
|
|
set_page_dirty(page);
|
|
|
|
|
|
|
|
dir->i_ctime = dir->i_mtime = CURRENT_TIME;
|
|
|
|
|
2014-09-24 10:17:04 +00:00
|
|
|
if (inode)
|
|
|
|
f2fs_drop_nlink(dir, inode, NULL);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2015-08-12 09:48:21 +00:00
|
|
|
if (bit_pos == NR_DENTRY_IN_BLOCK &&
|
|
|
|
!truncate_hole(dir, page->index, page->index + 1)) {
|
2012-11-14 07:59:04 +00:00
|
|
|
clear_page_dirty_for_io(page);
|
2015-02-26 03:25:01 +00:00
|
|
|
ClearPagePrivate(page);
|
2012-11-14 07:59:04 +00:00
|
|
|
ClearPageUptodate(page);
|
2014-09-12 22:53:45 +00:00
|
|
|
inode_dec_dirty_pages(dir);
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
2012-12-08 05:54:35 +00:00
|
|
|
f2fs_put_page(page, 1);
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool f2fs_empty_dir(struct inode *dir)
|
|
|
|
{
|
|
|
|
unsigned long bidx;
|
|
|
|
struct page *dentry_page;
|
|
|
|
unsigned int bit_pos;
|
2014-09-24 10:17:04 +00:00
|
|
|
struct f2fs_dentry_block *dentry_blk;
|
2012-11-14 07:59:04 +00:00
|
|
|
unsigned long nblock = dir_blocks(dir);
|
|
|
|
|
2014-09-24 10:19:10 +00:00
|
|
|
if (f2fs_has_inline_dentry(dir))
|
|
|
|
return f2fs_empty_inline_dir(dir);
|
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
for (bidx = 0; bidx < nblock; bidx++) {
|
2015-10-09 22:11:38 +00:00
|
|
|
dentry_page = get_lock_data_page(dir, bidx, false);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (IS_ERR(dentry_page)) {
|
|
|
|
if (PTR_ERR(dentry_page) == -ENOENT)
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-06-27 09:57:04 +00:00
|
|
|
dentry_blk = kmap_atomic(dentry_page);
|
2012-11-14 07:59:04 +00:00
|
|
|
if (bidx == 0)
|
|
|
|
bit_pos = 2;
|
|
|
|
else
|
|
|
|
bit_pos = 0;
|
|
|
|
bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
|
|
|
|
NR_DENTRY_IN_BLOCK,
|
|
|
|
bit_pos);
|
2014-06-27 09:57:04 +00:00
|
|
|
kunmap_atomic(dentry_blk);
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
f2fs_put_page(dentry_page, 1);
|
|
|
|
|
|
|
|
if (bit_pos < NR_DENTRY_IN_BLOCK)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-10-19 05:52:52 +00:00
|
|
|
bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
|
2015-05-15 23:26:10 +00:00
|
|
|
unsigned int start_pos, struct fscrypt_str *fstr)
|
2014-10-16 04:29:51 +00:00
|
|
|
{
|
|
|
|
unsigned char d_type = DT_UNKNOWN;
|
|
|
|
unsigned int bit_pos;
|
|
|
|
struct f2fs_dir_entry *de = NULL;
|
2015-05-15 23:26:10 +00:00
|
|
|
struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
|
2014-10-16 04:29:51 +00:00
|
|
|
|
2014-10-19 05:52:52 +00:00
|
|
|
bit_pos = ((unsigned long)ctx->pos % d->max);
|
2014-10-16 04:29:51 +00:00
|
|
|
|
2014-10-19 05:52:52 +00:00
|
|
|
while (bit_pos < d->max) {
|
|
|
|
bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
|
|
|
|
if (bit_pos >= d->max)
|
2014-10-16 04:29:51 +00:00
|
|
|
break;
|
|
|
|
|
2014-10-19 05:52:52 +00:00
|
|
|
de = &d->dentry[bit_pos];
|
2016-02-12 22:29:28 +00:00
|
|
|
if (de->name_len == 0) {
|
|
|
|
bit_pos++;
|
|
|
|
ctx->pos = start_pos + bit_pos;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
f2fs: fix to convert inline directory correctly
With below serials, we will lose parts of dirents:
1) mount f2fs with inline_dentry option
2) echo 1 > /sys/fs/f2fs/sdX/dir_level
3) mkdir dir
4) touch 180 files named [1-180] in dir
5) touch 181 in dir
6) echo 3 > /proc/sys/vm/drop_caches
7) ll dir
ls: cannot access 2: No such file or directory
ls: cannot access 4: No such file or directory
ls: cannot access 5: No such file or directory
ls: cannot access 6: No such file or directory
ls: cannot access 8: No such file or directory
ls: cannot access 9: No such file or directory
...
total 360
drwxr-xr-x 2 root root 4096 Feb 19 15:12 ./
drwxr-xr-x 3 root root 4096 Feb 19 15:11 ../
-rw-r--r-- 1 root root 0 Feb 19 15:12 1
-rw-r--r-- 1 root root 0 Feb 19 15:12 10
-rw-r--r-- 1 root root 0 Feb 19 15:12 100
-????????? ? ? ? ? ? 101
-????????? ? ? ? ? ? 102
-????????? ? ? ? ? ? 103
...
The reason is: when doing the inline dir conversion, we didn't consider
that directory has hierarchical hash structure which can be configured
through sysfs interface 'dir_level'.
By default, dir_level of directory inode is 0, it means we have one bucket
in hash table located in first level, all dirents will be hashed in this
bucket, so it has no problem for us to do the duplication simply between
inline dentry page and converted normal dentry page.
However, if we configured dir_level with the value N (greater than 0), it
will expand the bucket number of first level hash table by 2^N - 1, it
hashs dirents into different buckets according their hash value, if we
still move all dirents to first bucket, it makes incorrent locating for
inline dirents, the result is, although we can iterate all dirents through
->readdir, we can't stat some of them in ->lookup which based on hash
table searching.
This patch fixes this issue by rehashing dirents into correct position
when converting inline directory.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 10:29:18 +00:00
|
|
|
d_type = get_de_type(de);
|
2015-04-27 23:26:24 +00:00
|
|
|
|
|
|
|
de_name.name = d->filename[bit_pos];
|
|
|
|
de_name.len = le16_to_cpu(de->name_len);
|
|
|
|
|
|
|
|
if (f2fs_encrypted_inode(d->inode)) {
|
|
|
|
int save_len = fstr->len;
|
|
|
|
int ret;
|
|
|
|
|
2016-04-29 22:16:42 +00:00
|
|
|
de_name.name = f2fs_kmalloc(de_name.len, GFP_NOFS);
|
2015-09-03 20:38:23 +00:00
|
|
|
if (!de_name.name)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
memcpy(de_name.name, d->filename[bit_pos], de_name.len);
|
|
|
|
|
2015-05-15 23:26:10 +00:00
|
|
|
ret = fscrypt_fname_disk_to_usr(d->inode,
|
|
|
|
(u32)de->hash_code, 0,
|
|
|
|
&de_name, fstr);
|
2015-09-03 20:38:23 +00:00
|
|
|
kfree(de_name.name);
|
2015-04-27 23:26:24 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return true;
|
2015-09-03 20:38:23 +00:00
|
|
|
|
|
|
|
de_name = *fstr;
|
|
|
|
fstr->len = save_len;
|
2015-04-27 23:26:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!dir_emit(ctx, de_name.name, de_name.len,
|
2014-10-16 04:29:51 +00:00
|
|
|
le32_to_cpu(de->ino), d_type))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
|
|
|
|
ctx->pos = start_pos + bit_pos;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-05-17 22:02:17 +00:00
|
|
|
static int f2fs_readdir(struct file *file, struct dir_context *ctx)
|
2012-11-14 07:59:04 +00:00
|
|
|
{
|
2013-01-23 22:07:38 +00:00
|
|
|
struct inode *inode = file_inode(file);
|
2012-11-14 07:59:04 +00:00
|
|
|
unsigned long npages = dir_blocks(inode);
|
|
|
|
struct f2fs_dentry_block *dentry_blk = NULL;
|
|
|
|
struct page *dentry_page = NULL;
|
2014-04-28 09:59:43 +00:00
|
|
|
struct file_ra_state *ra = &file->f_ra;
|
2013-05-17 22:02:17 +00:00
|
|
|
unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
|
2014-10-19 05:52:52 +00:00
|
|
|
struct f2fs_dentry_ptr d;
|
2015-05-15 23:26:10 +00:00
|
|
|
struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
|
2015-04-27 23:26:24 +00:00
|
|
|
int err = 0;
|
2012-11-14 07:59:04 +00:00
|
|
|
|
2015-04-27 23:26:24 +00:00
|
|
|
if (f2fs_encrypted_inode(inode)) {
|
2015-05-15 23:26:10 +00:00
|
|
|
err = fscrypt_get_encryption_info(inode);
|
2016-02-23 17:21:37 +00:00
|
|
|
if (err && err != -ENOKEY)
|
2015-05-20 05:26:54 +00:00
|
|
|
return err;
|
|
|
|
|
2015-05-15 23:26:10 +00:00
|
|
|
err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
|
2015-04-27 23:26:24 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f2fs_has_inline_dentry(inode)) {
|
|
|
|
err = f2fs_read_inline_dir(file, ctx, &fstr);
|
|
|
|
goto out;
|
|
|
|
}
|
2014-09-24 10:19:10 +00:00
|
|
|
|
2014-04-28 09:59:43 +00:00
|
|
|
/* readahead for multi pages of dir */
|
|
|
|
if (npages - n > 1 && !ra_has_index(ra, n))
|
|
|
|
page_cache_sync_readahead(inode->i_mapping, ra, file, n,
|
|
|
|
min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));
|
|
|
|
|
2014-01-17 20:44:39 +00:00
|
|
|
for (; n < npages; n++) {
|
2015-10-09 22:11:38 +00:00
|
|
|
dentry_page = get_lock_data_page(inode, n, false);
|
2015-11-19 08:09:07 +00:00
|
|
|
if (IS_ERR(dentry_page)) {
|
|
|
|
err = PTR_ERR(dentry_page);
|
|
|
|
if (err == -ENOENT)
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
goto out;
|
|
|
|
}
|
2012-11-14 07:59:04 +00:00
|
|
|
|
|
|
|
dentry_blk = kmap(dentry_page);
|
2013-07-05 08:28:12 +00:00
|
|
|
|
2015-04-27 23:26:24 +00:00
|
|
|
make_dentry_ptr(inode, &d, (void *)dentry_blk, 1);
|
2014-10-19 05:52:52 +00:00
|
|
|
|
2015-12-01 03:41:50 +00:00
|
|
|
if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK, &fstr)) {
|
|
|
|
kunmap(dentry_page);
|
|
|
|
f2fs_put_page(dentry_page, 1);
|
|
|
|
break;
|
|
|
|
}
|
2014-10-16 04:29:51 +00:00
|
|
|
|
2013-05-17 22:02:17 +00:00
|
|
|
ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;
|
2012-11-14 07:59:04 +00:00
|
|
|
kunmap(dentry_page);
|
|
|
|
f2fs_put_page(dentry_page, 1);
|
|
|
|
}
|
2016-04-27 12:32:37 +00:00
|
|
|
err = 0;
|
2015-04-27 23:26:24 +00:00
|
|
|
out:
|
2015-05-15 23:26:10 +00:00
|
|
|
fscrypt_fname_free_buffer(&fstr);
|
2015-04-27 23:26:24 +00:00
|
|
|
return err;
|
2012-11-14 07:59:04 +00:00
|
|
|
}
|
|
|
|
|
2016-02-14 10:56:55 +00:00
|
|
|
static int f2fs_dir_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
if (f2fs_encrypted_inode(inode))
|
2015-05-15 23:26:10 +00:00
|
|
|
return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
|
2016-02-14 10:56:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-14 07:59:04 +00:00
|
|
|
const struct file_operations f2fs_dir_operations = {
|
|
|
|
.llseek = generic_file_llseek,
|
|
|
|
.read = generic_read_dir,
|
2013-05-17 22:02:17 +00:00
|
|
|
.iterate = f2fs_readdir,
|
2012-11-14 07:59:04 +00:00
|
|
|
.fsync = f2fs_sync_file,
|
2016-02-14 10:56:55 +00:00
|
|
|
.open = f2fs_dir_open,
|
2012-11-14 07:59:04 +00:00
|
|
|
.unlocked_ioctl = f2fs_ioctl,
|
2015-05-12 08:05:57 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_ioctl = f2fs_compat_ioctl,
|
|
|
|
#endif
|
2012-11-14 07:59:04 +00:00
|
|
|
};
|