2006-10-11 15:20:50 +07:00
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* linux/fs/ext4/namei.c
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1993, 1994, 1995
|
|
|
|
* Remy Card (card@masi.ibp.fr)
|
|
|
|
* Laboratoire MASI - Institut Blaise Pascal
|
|
|
|
* Universite Pierre et Marie Curie (Paris VI)
|
|
|
|
*
|
|
|
|
* from
|
|
|
|
*
|
|
|
|
* linux/fs/minix/namei.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Big-endian to little-endian byte-swapping/bitmaps by
|
|
|
|
* David S. Miller (davem@caip.rutgers.edu), 1995
|
|
|
|
* Directory entry file type support and forward compatibility hooks
|
|
|
|
* for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
|
|
|
|
* Hash Tree Directory indexing (c)
|
|
|
|
* Daniel Phillips, 2001
|
|
|
|
* Hash Tree Directory indexing porting
|
|
|
|
* Christopher Li, 2002
|
|
|
|
* Hash Tree Directory indexing cleanup
|
|
|
|
* Theodore Ts'o, 2002
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/quotaops.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/bio.h>
|
2008-04-30 05:13:32 +07:00
|
|
|
#include "ext4.h"
|
|
|
|
#include "ext4_jbd2.h"
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
#include "xattr.h"
|
|
|
|
#include "acl.h"
|
|
|
|
|
2011-03-22 08:38:05 +07:00
|
|
|
#include <trace/events/ext4.h>
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* define how far ahead to read directories while searching them.
|
|
|
|
*/
|
|
|
|
#define NAMEI_RA_CHUNKS 2
|
|
|
|
#define NAMEI_RA_BLOCKS 4
|
2007-05-25 00:04:54 +07:00
|
|
|
#define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
static struct buffer_head *ext4_append(handle_t *handle,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct inode *inode,
|
2013-02-15 15:35:57 +07:00
|
|
|
ext4_lblk_t *block)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
2014-08-30 07:52:15 +07:00
|
|
|
int err;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2012-08-17 20:48:17 +07:00
|
|
|
if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
|
|
|
|
((inode->i_size >> 10) >=
|
2013-02-15 15:35:57 +07:00
|
|
|
EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
|
|
|
|
return ERR_PTR(-ENOSPC);
|
2012-08-17 20:48:17 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
*block = inode->i_size >> inode->i_sb->s_blocksize_bits;
|
|
|
|
|
2015-06-21 12:25:29 +07:00
|
|
|
bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
|
2014-08-30 07:52:15 +07:00
|
|
|
if (IS_ERR(bh))
|
|
|
|
return bh;
|
2013-02-15 15:35:57 +07:00
|
|
|
inode->i_size += inode->i_sb->s_blocksize;
|
|
|
|
EXT4_I(inode)->i_disksize = inode->i_size;
|
2014-05-13 09:06:43 +07:00
|
|
|
BUFFER_TRACE(bh, "get_write_access");
|
2013-02-15 15:35:57 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, bh);
|
|
|
|
if (err) {
|
|
|
|
brelse(bh);
|
|
|
|
ext4_std_error(inode->i_sb, err);
|
|
|
|
return ERR_PTR(err);
|
2012-09-27 20:31:33 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
|
2013-02-15 11:59:26 +07:00
|
|
|
static int ext4_dx_csum_verify(struct inode *inode,
|
|
|
|
struct ext4_dir_entry *dirent);
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
EITHER, INDEX, DIRENT
|
|
|
|
} dirblock_type_t;
|
|
|
|
|
|
|
|
#define ext4_read_dirblock(inode, block, type) \
|
2015-06-16 01:50:26 +07:00
|
|
|
__ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
|
2013-02-15 11:59:26 +07:00
|
|
|
|
|
|
|
static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_lblk_t block,
|
|
|
|
dirblock_type_t type,
|
|
|
|
const char *func,
|
|
|
|
unsigned int line)
|
2013-02-15 11:59:26 +07:00
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct ext4_dir_entry *dirent;
|
2014-08-30 07:52:15 +07:00
|
|
|
int is_dx_block = 0;
|
2013-02-15 11:59:26 +07:00
|
|
|
|
2014-08-30 07:52:15 +07:00
|
|
|
bh = ext4_bread(NULL, inode, block, 0);
|
|
|
|
if (IS_ERR(bh)) {
|
2015-06-16 01:50:26 +07:00
|
|
|
__ext4_warning(inode->i_sb, func, line,
|
|
|
|
"inode #%lu: lblock %lu: comm %s: "
|
|
|
|
"error %ld reading directory block",
|
|
|
|
inode->i_ino, (unsigned long)block,
|
|
|
|
current->comm, PTR_ERR(bh));
|
2014-08-30 07:52:15 +07:00
|
|
|
|
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
if (!bh) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_error_inode(inode, func, line, block,
|
|
|
|
"Directory hole found");
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSCORRUPTED);
|
2013-02-15 11:59:26 +07:00
|
|
|
}
|
|
|
|
dirent = (struct ext4_dir_entry *) bh->b_data;
|
|
|
|
/* Determine whether or not we have an index block */
|
|
|
|
if (is_dx(inode)) {
|
|
|
|
if (block == 0)
|
|
|
|
is_dx_block = 1;
|
|
|
|
else if (ext4_rec_len_from_disk(dirent->rec_len,
|
|
|
|
inode->i_sb->s_blocksize) ==
|
|
|
|
inode->i_sb->s_blocksize)
|
|
|
|
is_dx_block = 1;
|
|
|
|
}
|
|
|
|
if (!is_dx_block && type == INDEX) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_error_inode(inode, func, line, block,
|
2013-02-15 11:59:26 +07:00
|
|
|
"directory leaf block found instead of index block");
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSCORRUPTED);
|
2013-02-15 11:59:26 +07:00
|
|
|
}
|
2014-10-13 14:36:16 +07:00
|
|
|
if (!ext4_has_metadata_csum(inode->i_sb) ||
|
2013-02-15 11:59:26 +07:00
|
|
|
buffer_verified(bh))
|
|
|
|
return bh;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* An empty leaf block can get mistaken for a index block; for
|
|
|
|
* this reason, we can only check the index checksum when the
|
|
|
|
* caller is sure it should be an index block.
|
|
|
|
*/
|
|
|
|
if (is_dx_block && type == INDEX) {
|
|
|
|
if (ext4_dx_csum_verify(inode, dirent))
|
|
|
|
set_buffer_verified(bh);
|
|
|
|
else {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_error_inode(inode, func, line, block,
|
|
|
|
"Directory index failed checksum");
|
2008-04-17 21:38:59 +07:00
|
|
|
brelse(bh);
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSBADCRC);
|
2008-04-17 21:38:59 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2013-02-15 11:59:26 +07:00
|
|
|
if (!is_dx_block) {
|
|
|
|
if (ext4_dirent_csum_verify(inode, dirent))
|
|
|
|
set_buffer_verified(bh);
|
|
|
|
else {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_error_inode(inode, func, line, block,
|
|
|
|
"Directory block failed checksum");
|
2013-02-15 11:59:26 +07:00
|
|
|
brelse(bh);
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSBADCRC);
|
2013-02-15 11:59:26 +07:00
|
|
|
}
|
2012-09-27 20:31:33 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef assert
|
|
|
|
#define assert(test) J_ASSERT(test)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef DX_DEBUG
|
|
|
|
#define dxtrace(command) command
|
|
|
|
#else
|
|
|
|
#define dxtrace(command)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct fake_dirent
|
|
|
|
{
|
|
|
|
__le32 inode;
|
|
|
|
__le16 rec_len;
|
|
|
|
u8 name_len;
|
|
|
|
u8 file_type;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dx_countlimit
|
|
|
|
{
|
|
|
|
__le16 limit;
|
|
|
|
__le16 count;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dx_entry
|
|
|
|
{
|
|
|
|
__le32 hash;
|
|
|
|
__le32 block;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dx_root_info is laid out so that if it should somehow get overlaid by a
|
|
|
|
* dirent the two low bits of the hash version will be zero. Therefore, the
|
|
|
|
* hash version mod 4 should never be 0. Sincerely, the paranoia department.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct dx_root
|
|
|
|
{
|
|
|
|
struct fake_dirent dot;
|
|
|
|
char dot_name[4];
|
|
|
|
struct fake_dirent dotdot;
|
|
|
|
char dotdot_name[4];
|
|
|
|
struct dx_root_info
|
|
|
|
{
|
|
|
|
__le32 reserved_zero;
|
|
|
|
u8 hash_version;
|
|
|
|
u8 info_length; /* 8 */
|
|
|
|
u8 indirect_levels;
|
|
|
|
u8 unused_flags;
|
|
|
|
}
|
|
|
|
info;
|
|
|
|
struct dx_entry entries[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dx_node
|
|
|
|
{
|
|
|
|
struct fake_dirent fake;
|
|
|
|
struct dx_entry entries[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct dx_frame
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct dx_entry *entries;
|
|
|
|
struct dx_entry *at;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dx_map_entry
|
|
|
|
{
|
|
|
|
u32 hash;
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
u16 offs;
|
|
|
|
u16 size;
|
2006-10-11 15:20:50 +07:00
|
|
|
};
|
|
|
|
|
2012-04-30 05:23:10 +07:00
|
|
|
/*
|
|
|
|
* This goes at the end of each htree block.
|
|
|
|
*/
|
|
|
|
struct dx_tail {
|
|
|
|
u32 dt_reserved;
|
|
|
|
__le32 dt_checksum; /* crc32c(uuid+inum+dirblock) */
|
|
|
|
};
|
|
|
|
|
2008-01-29 11:58:27 +07:00
|
|
|
static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
|
|
|
|
static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline unsigned dx_get_hash(struct dx_entry *entry);
|
|
|
|
static void dx_set_hash(struct dx_entry *entry, unsigned value);
|
|
|
|
static unsigned dx_get_count(struct dx_entry *entries);
|
|
|
|
static unsigned dx_get_limit(struct dx_entry *entries);
|
|
|
|
static void dx_set_count(struct dx_entry *entries, unsigned value);
|
|
|
|
static void dx_set_limit(struct dx_entry *entries, unsigned value);
|
|
|
|
static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
|
|
|
|
static unsigned dx_node_limit(struct inode *dir);
|
2015-05-19 00:14:47 +07:00
|
|
|
static struct dx_frame *dx_probe(struct ext4_filename *fname,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct inode *dir,
|
|
|
|
struct dx_hash_info *hinfo,
|
2014-08-30 07:52:17 +07:00
|
|
|
struct dx_frame *frame);
|
2008-09-09 09:25:24 +07:00
|
|
|
static void dx_release(struct dx_frame *frames);
|
2015-04-12 12:09:03 +07:00
|
|
|
static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
|
|
|
|
unsigned blocksize, struct dx_hash_info *hinfo,
|
|
|
|
struct dx_map_entry map[]);
|
2006-10-11 15:20:50 +07:00
|
|
|
static void dx_sort_map(struct dx_map_entry *map, unsigned count);
|
2008-09-09 09:25:24 +07:00
|
|
|
static struct ext4_dir_entry_2 *dx_move_dirents(char *from, char *to,
|
2009-02-15 11:01:36 +07:00
|
|
|
struct dx_map_entry *offsets, int count, unsigned blocksize);
|
2009-02-15 09:46:54 +07:00
|
|
|
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize);
|
2008-01-29 11:58:27 +07:00
|
|
|
static void dx_insert_block(struct dx_frame *frame,
|
|
|
|
u32 hash, ext4_lblk_t block);
|
2006-10-11 15:20:53 +07:00
|
|
|
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct dx_frame *frame,
|
|
|
|
struct dx_frame *frames,
|
|
|
|
__u32 *start_hash);
|
2008-09-23 02:21:01 +07:00
|
|
|
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
|
2015-05-19 00:14:47 +07:00
|
|
|
struct ext4_filename *fname,
|
2014-08-30 07:49:51 +07:00
|
|
|
struct ext4_dir_entry_2 **res_dir);
|
2015-05-19 00:14:47 +07:00
|
|
|
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
|
2016-01-09 04:00:31 +07:00
|
|
|
struct inode *dir, struct inode *inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2012-04-30 05:39:10 +07:00
|
|
|
/* checksumming functions */
|
2012-12-11 02:05:59 +07:00
|
|
|
void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
|
|
|
|
unsigned int blocksize)
|
2012-04-30 05:41:10 +07:00
|
|
|
{
|
|
|
|
memset(t, 0, sizeof(struct ext4_dir_entry_tail));
|
|
|
|
t->det_rec_len = ext4_rec_len_to_disk(
|
|
|
|
sizeof(struct ext4_dir_entry_tail), blocksize);
|
|
|
|
t->det_reserved_ft = EXT4_FT_DIR_CSUM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Walk through a dirent block to find a checksum "dirent" at the tail */
|
|
|
|
static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
|
|
|
|
struct ext4_dir_entry *de)
|
|
|
|
{
|
|
|
|
struct ext4_dir_entry_tail *t;
|
|
|
|
|
|
|
|
#ifdef PARANOID
|
|
|
|
struct ext4_dir_entry *d, *top;
|
|
|
|
|
|
|
|
d = de;
|
|
|
|
top = (struct ext4_dir_entry *)(((void *)de) +
|
|
|
|
(EXT4_BLOCK_SIZE(inode->i_sb) -
|
|
|
|
sizeof(struct ext4_dir_entry_tail)));
|
|
|
|
while (d < top && d->rec_len)
|
|
|
|
d = (struct ext4_dir_entry *)(((void *)d) +
|
|
|
|
le16_to_cpu(d->rec_len));
|
|
|
|
|
|
|
|
if (d != top)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
t = (struct ext4_dir_entry_tail *)d;
|
|
|
|
#else
|
|
|
|
t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode->i_sb));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (t->det_reserved_zero1 ||
|
|
|
|
le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
|
|
|
|
t->det_reserved_zero2 ||
|
|
|
|
t->det_reserved_ft != EXT4_FT_DIR_CSUM)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __le32 ext4_dirent_csum(struct inode *inode,
|
|
|
|
struct ext4_dir_entry *dirent, int size)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
|
|
|
__u32 csum;
|
|
|
|
|
|
|
|
csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
|
|
|
|
return cpu_to_le32(csum);
|
|
|
|
}
|
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
#define warn_no_space_for_csum(inode) \
|
|
|
|
__warn_no_space_for_csum((inode), __func__, __LINE__)
|
|
|
|
|
|
|
|
static void __warn_no_space_for_csum(struct inode *inode, const char *func,
|
|
|
|
unsigned int line)
|
2012-11-11 10:20:05 +07:00
|
|
|
{
|
2015-06-16 01:50:26 +07:00
|
|
|
__ext4_warning_inode(inode, func, line,
|
|
|
|
"No space for directory leaf checksum. Please run e2fsck -D.");
|
2012-11-11 10:20:05 +07:00
|
|
|
}
|
|
|
|
|
2012-04-30 05:41:10 +07:00
|
|
|
int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
|
|
|
|
{
|
|
|
|
struct ext4_dir_entry_tail *t;
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (!ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
t = get_dirent_tail(inode, dirent);
|
|
|
|
if (!t) {
|
2012-11-11 10:20:05 +07:00
|
|
|
warn_no_space_for_csum(inode);
|
2012-04-30 05:41:10 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t->det_checksum != ext4_dirent_csum(inode, dirent,
|
|
|
|
(void *)t - (void *)dirent))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ext4_dirent_csum_set(struct inode *inode,
|
|
|
|
struct ext4_dir_entry *dirent)
|
|
|
|
{
|
|
|
|
struct ext4_dir_entry_tail *t;
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (!ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
t = get_dirent_tail(inode, dirent);
|
|
|
|
if (!t) {
|
2012-11-11 10:20:05 +07:00
|
|
|
warn_no_space_for_csum(inode);
|
2012-04-30 05:41:10 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
t->det_checksum = ext4_dirent_csum(inode, dirent,
|
|
|
|
(void *)t - (void *)dirent);
|
|
|
|
}
|
|
|
|
|
2012-12-11 02:05:59 +07:00
|
|
|
int ext4_handle_dirty_dirent_node(handle_t *handle,
|
|
|
|
struct inode *inode,
|
|
|
|
struct buffer_head *bh)
|
2012-04-30 05:41:10 +07:00
|
|
|
{
|
|
|
|
ext4_dirent_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
|
|
|
|
return ext4_handle_dirty_metadata(handle, inode, bh);
|
|
|
|
}
|
|
|
|
|
2012-04-30 05:39:10 +07:00
|
|
|
static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
|
|
|
|
struct ext4_dir_entry *dirent,
|
|
|
|
int *offset)
|
|
|
|
{
|
|
|
|
struct ext4_dir_entry *dp;
|
|
|
|
struct dx_root_info *root;
|
|
|
|
int count_offset;
|
|
|
|
|
|
|
|
if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
|
|
|
|
count_offset = 8;
|
|
|
|
else if (le16_to_cpu(dirent->rec_len) == 12) {
|
|
|
|
dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
|
|
|
|
if (le16_to_cpu(dp->rec_len) !=
|
|
|
|
EXT4_BLOCK_SIZE(inode->i_sb) - 12)
|
|
|
|
return NULL;
|
|
|
|
root = (struct dx_root_info *)(((void *)dp + 12));
|
|
|
|
if (root->reserved_zero ||
|
|
|
|
root->info_length != sizeof(struct dx_root_info))
|
|
|
|
return NULL;
|
|
|
|
count_offset = 32;
|
|
|
|
} else
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (offset)
|
|
|
|
*offset = count_offset;
|
|
|
|
return (struct dx_countlimit *)(((void *)dirent) + count_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
|
|
|
|
int count_offset, int count, struct dx_tail *t)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
2013-04-10 10:59:55 +07:00
|
|
|
__u32 csum;
|
2012-04-30 05:39:10 +07:00
|
|
|
int size;
|
2016-07-04 04:51:39 +07:00
|
|
|
__u32 dummy_csum = 0;
|
|
|
|
int offset = offsetof(struct dx_tail, dt_checksum);
|
2012-04-30 05:39:10 +07:00
|
|
|
|
|
|
|
size = count_offset + (count * sizeof(struct dx_entry));
|
|
|
|
csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
|
2016-07-04 04:51:39 +07:00
|
|
|
csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
|
|
|
|
csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
|
2012-04-30 05:39:10 +07:00
|
|
|
|
|
|
|
return cpu_to_le32(csum);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_dx_csum_verify(struct inode *inode,
|
|
|
|
struct ext4_dir_entry *dirent)
|
|
|
|
{
|
|
|
|
struct dx_countlimit *c;
|
|
|
|
struct dx_tail *t;
|
|
|
|
int count_offset, limit, count;
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (!ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:39:10 +07:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
c = get_dx_countlimit(inode, dirent, &count_offset);
|
|
|
|
if (!c) {
|
|
|
|
EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
|
2016-07-04 08:11:08 +07:00
|
|
|
return 0;
|
2012-04-30 05:39:10 +07:00
|
|
|
}
|
|
|
|
limit = le16_to_cpu(c->limit);
|
|
|
|
count = le16_to_cpu(c->count);
|
|
|
|
if (count_offset + (limit * sizeof(struct dx_entry)) >
|
|
|
|
EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
|
2012-11-11 10:20:05 +07:00
|
|
|
warn_no_space_for_csum(inode);
|
2016-07-04 08:11:08 +07:00
|
|
|
return 0;
|
2012-04-30 05:39:10 +07:00
|
|
|
}
|
|
|
|
t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
|
|
|
|
|
|
|
|
if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
|
|
|
|
count, t))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
|
|
|
|
{
|
|
|
|
struct dx_countlimit *c;
|
|
|
|
struct dx_tail *t;
|
|
|
|
int count_offset, limit, count;
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (!ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:39:10 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
c = get_dx_countlimit(inode, dirent, &count_offset);
|
|
|
|
if (!c) {
|
|
|
|
EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
limit = le16_to_cpu(c->limit);
|
|
|
|
count = le16_to_cpu(c->count);
|
|
|
|
if (count_offset + (limit * sizeof(struct dx_entry)) >
|
|
|
|
EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
|
2012-11-11 10:20:05 +07:00
|
|
|
warn_no_space_for_csum(inode);
|
2012-04-30 05:39:10 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
|
|
|
|
|
|
|
|
t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ext4_handle_dirty_dx_node(handle_t *handle,
|
|
|
|
struct inode *inode,
|
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
|
|
|
|
return ext4_handle_dirty_metadata(handle, inode, bh);
|
|
|
|
}
|
|
|
|
|
2008-07-12 06:27:31 +07:00
|
|
|
/*
|
|
|
|
* p is at least 6 bytes before the end of page
|
|
|
|
*/
|
|
|
|
static inline struct ext4_dir_entry_2 *
|
2009-02-15 11:01:36 +07:00
|
|
|
ext4_next_entry(struct ext4_dir_entry_2 *p, unsigned long blocksize)
|
2008-07-12 06:27:31 +07:00
|
|
|
{
|
|
|
|
return (struct ext4_dir_entry_2 *)((char *)p +
|
2009-02-15 11:01:36 +07:00
|
|
|
ext4_rec_len_from_disk(p->rec_len, blocksize));
|
2008-07-12 06:27:31 +07:00
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* Future: use high four bits of block for coalesce-on-delete flags
|
|
|
|
* Mask them off for now.
|
|
|
|
*/
|
|
|
|
|
2008-01-29 11:58:27 +07:00
|
|
|
static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
return le32_to_cpu(entry->block) & 0x00ffffff;
|
|
|
|
}
|
|
|
|
|
2008-01-29 11:58:27 +07:00
|
|
|
static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
entry->block = cpu_to_le32(value);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline unsigned dx_get_hash(struct dx_entry *entry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
return le32_to_cpu(entry->hash);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
entry->hash = cpu_to_le32(value);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline unsigned dx_get_count(struct dx_entry *entries)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
return le16_to_cpu(((struct dx_countlimit *) entries)->count);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline unsigned dx_get_limit(struct dx_entry *entries)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline void dx_set_count(struct dx_entry *entries, unsigned value)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
|
|
|
|
EXT4_DIR_REC_LEN(2) - infosize;
|
2012-04-30 05:39:10 +07:00
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(dir->i_sb))
|
2012-04-30 05:39:10 +07:00
|
|
|
entry_space -= sizeof(struct dx_tail);
|
2008-07-12 06:27:31 +07:00
|
|
|
return entry_space / sizeof(struct dx_entry);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static inline unsigned dx_node_limit(struct inode *dir)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
|
2012-04-30 05:39:10 +07:00
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(dir->i_sb))
|
2012-04-30 05:39:10 +07:00
|
|
|
entry_space -= sizeof(struct dx_tail);
|
2008-07-12 06:27:31 +07:00
|
|
|
return entry_space / sizeof(struct dx_entry);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Debug
|
|
|
|
*/
|
|
|
|
#ifdef DX_DEBUG
|
2008-09-09 10:00:52 +07:00
|
|
|
static void dx_show_index(char * label, struct dx_entry *entries)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:21:24 +07:00
|
|
|
int i, n = dx_get_count (entries);
|
2016-10-15 20:57:31 +07:00
|
|
|
printk(KERN_DEBUG "%s index", label);
|
2006-10-11 15:21:24 +07:00
|
|
|
for (i = 0; i < n; i++) {
|
2016-10-15 20:57:31 +07:00
|
|
|
printk(KERN_CONT " %x->%lu",
|
|
|
|
i ? dx_get_hash(entries + i) : 0,
|
|
|
|
(unsigned long)dx_get_block(entries + i));
|
2006-10-11 15:21:24 +07:00
|
|
|
}
|
2016-10-15 20:57:31 +07:00
|
|
|
printk(KERN_CONT "\n");
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
struct stats
|
|
|
|
{
|
|
|
|
unsigned names;
|
|
|
|
unsigned space;
|
|
|
|
unsigned bcount;
|
|
|
|
};
|
|
|
|
|
2015-04-12 12:07:01 +07:00
|
|
|
static struct stats dx_show_leaf(struct inode *dir,
|
|
|
|
struct dx_hash_info *hinfo,
|
|
|
|
struct ext4_dir_entry_2 *de,
|
|
|
|
int size, int show_names)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
unsigned names = 0, space = 0;
|
|
|
|
char *base = (char *) de;
|
|
|
|
struct dx_hash_info h = *hinfo;
|
|
|
|
|
|
|
|
printk("names: ");
|
|
|
|
while ((char *) de < base + size)
|
|
|
|
{
|
|
|
|
if (de->inode)
|
|
|
|
{
|
|
|
|
if (show_names)
|
|
|
|
{
|
2015-04-12 12:07:01 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_ENCRYPTION
|
|
|
|
int len;
|
|
|
|
char *name;
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str fname_crypto_str =
|
|
|
|
FSTR_INIT(NULL, 0);
|
2015-06-01 00:34:22 +07:00
|
|
|
int res = 0;
|
2015-04-12 12:07:01 +07:00
|
|
|
|
|
|
|
name = de->name;
|
|
|
|
len = de->name_len;
|
2016-07-11 01:01:03 +07:00
|
|
|
if (ext4_encrypted_inode(dir))
|
|
|
|
res = fscrypt_get_encryption_info(dir);
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 00:17:47 +07:00
|
|
|
if (res) {
|
|
|
|
printk(KERN_WARNING "Error setting up"
|
|
|
|
" fname crypto: %d\n", res);
|
2015-04-12 12:07:01 +07:00
|
|
|
}
|
2016-07-11 01:01:03 +07:00
|
|
|
if (!fscrypt_has_encryption_key(dir)) {
|
2015-04-12 12:07:01 +07:00
|
|
|
/* Directory is not encrypted */
|
|
|
|
ext4fs_dirhash(de->name,
|
|
|
|
de->name_len, &h);
|
|
|
|
printk("%*.s:(U)%x.%u ", len,
|
|
|
|
name, h.hash,
|
|
|
|
(unsigned) ((char *) de
|
|
|
|
- base));
|
|
|
|
} else {
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str de_name =
|
|
|
|
FSTR_INIT(name, len);
|
|
|
|
|
2015-04-12 12:07:01 +07:00
|
|
|
/* Directory is encrypted */
|
2016-07-11 01:01:03 +07:00
|
|
|
res = fscrypt_fname_alloc_buffer(
|
|
|
|
dir, len,
|
2015-04-12 12:07:01 +07:00
|
|
|
&fname_crypto_str);
|
2016-09-16 04:25:55 +07:00
|
|
|
if (res)
|
2015-04-12 12:07:01 +07:00
|
|
|
printk(KERN_WARNING "Error "
|
|
|
|
"allocating crypto "
|
|
|
|
"buffer--skipping "
|
|
|
|
"crypto\n");
|
2016-07-11 01:01:03 +07:00
|
|
|
res = fscrypt_fname_disk_to_usr(dir,
|
|
|
|
0, 0, &de_name,
|
|
|
|
&fname_crypto_str);
|
2016-09-16 04:25:55 +07:00
|
|
|
if (res) {
|
2015-04-12 12:07:01 +07:00
|
|
|
printk(KERN_WARNING "Error "
|
|
|
|
"converting filename "
|
|
|
|
"from disk to usr"
|
|
|
|
"\n");
|
|
|
|
name = "??";
|
|
|
|
len = 2;
|
|
|
|
} else {
|
|
|
|
name = fname_crypto_str.name;
|
|
|
|
len = fname_crypto_str.len;
|
|
|
|
}
|
2015-05-02 03:56:45 +07:00
|
|
|
ext4fs_dirhash(de->name, de->name_len,
|
|
|
|
&h);
|
2015-04-12 12:07:01 +07:00
|
|
|
printk("%*.s:(E)%x.%u ", len, name,
|
|
|
|
h.hash, (unsigned) ((char *) de
|
|
|
|
- base));
|
2016-07-11 01:01:03 +07:00
|
|
|
fscrypt_fname_free_buffer(
|
|
|
|
&fname_crypto_str);
|
2015-04-12 12:07:01 +07:00
|
|
|
}
|
|
|
|
#else
|
2006-10-11 15:20:50 +07:00
|
|
|
int len = de->name_len;
|
|
|
|
char *name = de->name;
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4fs_dirhash(de->name, de->name_len, &h);
|
2015-04-12 12:07:01 +07:00
|
|
|
printk("%*.s:%x.%u ", len, name, h.hash,
|
2011-07-17 06:41:23 +07:00
|
|
|
(unsigned) ((char *) de - base));
|
2015-04-12 12:07:01 +07:00
|
|
|
#endif
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
space += EXT4_DIR_REC_LEN(de->name_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
names++;
|
|
|
|
}
|
2009-02-15 11:01:36 +07:00
|
|
|
de = ext4_next_entry(de, size);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2016-10-15 20:57:31 +07:00
|
|
|
printk(KERN_CONT "(%i)\n", names);
|
2006-10-11 15:20:50 +07:00
|
|
|
return (struct stats) { names, space, 1 };
|
|
|
|
}
|
|
|
|
|
|
|
|
struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
|
|
|
|
struct dx_entry *entries, int levels)
|
|
|
|
{
|
|
|
|
unsigned blocksize = dir->i_sb->s_blocksize;
|
2008-09-09 09:25:24 +07:00
|
|
|
unsigned count = dx_get_count(entries), names = 0, space = 0, i;
|
2006-10-11 15:20:50 +07:00
|
|
|
unsigned bcount = 0;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
printk("%i indexed blocks...\n", count);
|
|
|
|
for (i = 0; i < count; i++, entries++)
|
|
|
|
{
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t block = dx_get_block(entries);
|
|
|
|
ext4_lblk_t hash = i ? dx_get_hash(entries): 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash;
|
|
|
|
struct stats stats;
|
|
|
|
printk("%s%3u:%03u hash %8x/%8x ",levels?"":" ", i, block, hash, range);
|
2014-08-30 07:52:15 +07:00
|
|
|
bh = ext4_bread(NULL,dir, block, 0);
|
|
|
|
if (!bh || IS_ERR(bh))
|
|
|
|
continue;
|
2006-10-11 15:20:50 +07:00
|
|
|
stats = levels?
|
|
|
|
dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
|
2015-04-12 12:07:01 +07:00
|
|
|
dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
|
|
|
|
bh->b_data, blocksize, 0);
|
2006-10-11 15:20:50 +07:00
|
|
|
names += stats.names;
|
|
|
|
space += stats.space;
|
|
|
|
bcount += stats.bcount;
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
if (bcount)
|
2010-05-17 18:00:00 +07:00
|
|
|
printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
|
2008-09-09 10:00:52 +07:00
|
|
|
levels ? "" : " ", names, space/bcount,
|
|
|
|
(space/bcount)*100/blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
return (struct stats) { names, space, bcount};
|
|
|
|
}
|
|
|
|
#endif /* DX_DEBUG */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe for a directory leaf block to search.
|
|
|
|
*
|
|
|
|
* dx_probe can return ERR_BAD_DX_DIR, which means there was a format
|
|
|
|
* error in the directory index, and the caller should fall back to
|
|
|
|
* searching the directory normally. The callers of dx_probe **MUST**
|
|
|
|
* check for this error code, and make sure it never gets reflected
|
|
|
|
* back to userspace.
|
|
|
|
*/
|
|
|
|
static struct dx_frame *
|
2015-05-19 00:14:47 +07:00
|
|
|
dx_probe(struct ext4_filename *fname, struct inode *dir,
|
2014-08-30 07:52:17 +07:00
|
|
|
struct dx_hash_info *hinfo, struct dx_frame *frame_in)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
unsigned count, indirect;
|
|
|
|
struct dx_entry *at, *entries, *p, *q, *m;
|
|
|
|
struct dx_root *root;
|
|
|
|
struct dx_frame *frame = frame_in;
|
2014-08-30 07:52:17 +07:00
|
|
|
struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
|
2006-10-11 15:20:50 +07:00
|
|
|
u32 hash;
|
|
|
|
|
2014-08-30 07:52:17 +07:00
|
|
|
frame->bh = ext4_read_dirblock(dir, 0, INDEX);
|
|
|
|
if (IS_ERR(frame->bh))
|
|
|
|
return (struct dx_frame *) frame->bh;
|
|
|
|
|
|
|
|
root = (struct dx_root *) frame->bh->b_data;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (root->info.hash_version != DX_HASH_TEA &&
|
|
|
|
root->info.hash_version != DX_HASH_HALF_MD4 &&
|
|
|
|
root->info.hash_version != DX_HASH_LEGACY) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir, "Unrecognised inode hash code %u",
|
|
|
|
root->info.hash_version);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
2015-05-19 00:14:47 +07:00
|
|
|
if (fname)
|
|
|
|
hinfo = &fname->hinfo;
|
2006-10-11 15:20:50 +07:00
|
|
|
hinfo->hash_version = root->info.hash_version;
|
2008-10-29 00:21:44 +07:00
|
|
|
if (hinfo->hash_version <= DX_HASH_TEA)
|
|
|
|
hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
|
2006-10-11 15:20:53 +07:00
|
|
|
hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
|
2015-05-19 00:14:47 +07:00
|
|
|
if (fname && fname_name(fname))
|
|
|
|
ext4fs_dirhash(fname_name(fname), fname_len(fname), hinfo);
|
2006-10-11 15:20:50 +07:00
|
|
|
hash = hinfo->hash;
|
|
|
|
|
|
|
|
if (root->info.unused_flags & 1) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
|
|
|
|
root->info.unused_flags);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
indirect = root->info.indirect_levels;
|
|
|
|
if (indirect > 1) {
|
|
|
|
ext4_warning_inode(dir, "Unimplemented hash depth: %#06x",
|
|
|
|
root->info.indirect_levels);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
entries = (struct dx_entry *)(((char *)&root->info) +
|
|
|
|
root->info.info_length);
|
2007-09-19 12:46:38 +07:00
|
|
|
|
|
|
|
if (dx_get_limit(entries) != dx_root_limit(dir,
|
|
|
|
root->info.info_length)) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
|
|
|
|
dx_get_limit(entries),
|
|
|
|
dx_root_limit(dir, root->info.info_length));
|
2007-09-19 12:46:38 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
dxtrace(printk("Look up %x", hash));
|
2014-08-30 07:52:17 +07:00
|
|
|
while (1) {
|
2006-10-11 15:20:50 +07:00
|
|
|
count = dx_get_count(entries);
|
2007-09-19 12:46:38 +07:00
|
|
|
if (!count || count > dx_get_limit(entries)) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir,
|
|
|
|
"dx entry: count %u beyond limit %u",
|
|
|
|
count, dx_get_limit(entries));
|
2014-08-30 07:52:17 +07:00
|
|
|
goto fail;
|
2007-09-19 12:46:38 +07:00
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
p = entries + 1;
|
|
|
|
q = entries + count - 1;
|
2014-08-30 07:52:17 +07:00
|
|
|
while (p <= q) {
|
2015-06-16 01:50:26 +07:00
|
|
|
m = p + (q - p) / 2;
|
2016-10-15 20:57:31 +07:00
|
|
|
dxtrace(printk(KERN_CONT "."));
|
2006-10-11 15:20:50 +07:00
|
|
|
if (dx_get_hash(m) > hash)
|
|
|
|
q = m - 1;
|
|
|
|
else
|
|
|
|
p = m + 1;
|
|
|
|
}
|
|
|
|
|
2014-08-30 07:52:17 +07:00
|
|
|
if (0) { // linear search cross check
|
2006-10-11 15:20:50 +07:00
|
|
|
unsigned n = count - 1;
|
|
|
|
at = entries;
|
|
|
|
while (n--)
|
|
|
|
{
|
2016-10-15 20:57:31 +07:00
|
|
|
dxtrace(printk(KERN_CONT ","));
|
2006-10-11 15:20:50 +07:00
|
|
|
if (dx_get_hash(++at) > hash)
|
|
|
|
{
|
|
|
|
at--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert (at == p - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
at = p - 1;
|
2016-10-15 20:57:31 +07:00
|
|
|
dxtrace(printk(KERN_CONT " %x->%u\n",
|
|
|
|
at == entries ? 0 : dx_get_hash(at),
|
2015-06-16 01:50:26 +07:00
|
|
|
dx_get_block(at)));
|
2006-10-11 15:20:50 +07:00
|
|
|
frame->entries = entries;
|
|
|
|
frame->at = at;
|
2014-08-30 07:52:17 +07:00
|
|
|
if (!indirect--)
|
|
|
|
return frame;
|
|
|
|
frame++;
|
|
|
|
frame->bh = ext4_read_dirblock(dir, dx_get_block(at), INDEX);
|
|
|
|
if (IS_ERR(frame->bh)) {
|
|
|
|
ret_err = (struct dx_frame *) frame->bh;
|
|
|
|
frame->bh = NULL;
|
|
|
|
goto fail;
|
2012-04-30 05:39:10 +07:00
|
|
|
}
|
2014-08-30 07:52:17 +07:00
|
|
|
entries = ((struct dx_node *) frame->bh->b_data)->entries;
|
2012-04-30 05:39:10 +07:00
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
if (dx_get_limit(entries) != dx_node_limit(dir)) {
|
|
|
|
ext4_warning_inode(dir,
|
|
|
|
"dx entry: limit %u != node limit %u",
|
|
|
|
dx_get_limit(entries), dx_node_limit(dir));
|
2014-08-30 07:52:17 +07:00
|
|
|
goto fail;
|
2007-09-19 12:46:38 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-08-30 07:52:17 +07:00
|
|
|
fail:
|
2006-10-11 15:20:50 +07:00
|
|
|
while (frame >= frame_in) {
|
|
|
|
brelse(frame->bh);
|
|
|
|
frame--;
|
|
|
|
}
|
2015-04-12 12:07:01 +07:00
|
|
|
|
2014-08-30 07:52:17 +07:00
|
|
|
if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir,
|
|
|
|
"Corrupt directory, running e2fsck is recommended");
|
2014-08-30 07:52:17 +07:00
|
|
|
return ret_err;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
static void dx_release(struct dx_frame *frames)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
if (frames[0].bh == NULL)
|
|
|
|
return;
|
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
if (((struct dx_root *)frames[0].bh->b_data)->info.indirect_levels)
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(frames[1].bh);
|
|
|
|
brelse(frames[0].bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function increments the frame pointer to search the next leaf
|
|
|
|
* block, and reads in the necessary intervening nodes if the search
|
|
|
|
* should be necessary. Whether or not the search is necessary is
|
|
|
|
* controlled by the hash parameter. If the hash value is even, then
|
|
|
|
* the search is only continued if the next block starts with that
|
|
|
|
* hash value. This is used if we are searching for a specific file.
|
|
|
|
*
|
|
|
|
* If the hash value is HASH_NB_ALWAYS, then always go to the next block.
|
|
|
|
*
|
|
|
|
* This function returns 1 if the caller should continue to search,
|
|
|
|
* or 0 if it should not. If there is an error reading one of the
|
|
|
|
* index blocks, it will a negative error code.
|
|
|
|
*
|
|
|
|
* If start_hash is non-null, it will be filled in with the starting
|
|
|
|
* hash of the next page.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct dx_frame *frame,
|
|
|
|
struct dx_frame *frames,
|
|
|
|
__u32 *start_hash)
|
|
|
|
{
|
|
|
|
struct dx_frame *p;
|
|
|
|
struct buffer_head *bh;
|
2013-02-15 11:59:26 +07:00
|
|
|
int num_frames = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
__u32 bhash;
|
|
|
|
|
|
|
|
p = frame;
|
|
|
|
/*
|
|
|
|
* Find the next leaf page by incrementing the frame pointer.
|
|
|
|
* If we run out of entries in the interior node, loop around and
|
|
|
|
* increment pointer in the parent node. When we break out of
|
|
|
|
* this loop, num_frames indicates the number of interior
|
|
|
|
* nodes need to be read.
|
|
|
|
*/
|
|
|
|
while (1) {
|
|
|
|
if (++(p->at) < p->entries + dx_get_count(p->entries))
|
|
|
|
break;
|
|
|
|
if (p == frames)
|
|
|
|
return 0;
|
|
|
|
num_frames++;
|
|
|
|
p--;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the hash is 1, then continue only if the next page has a
|
|
|
|
* continuation hash of any value. This is used for readdir
|
|
|
|
* handling. Otherwise, check to see if the hash matches the
|
|
|
|
* desired contiuation hash. If it doesn't, return since
|
|
|
|
* there's no point to read in the successive index pages.
|
|
|
|
*/
|
|
|
|
bhash = dx_get_hash(p->at);
|
|
|
|
if (start_hash)
|
|
|
|
*start_hash = bhash;
|
|
|
|
if ((hash & 1) == 0) {
|
|
|
|
if ((bhash & ~1) != hash)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If the hash is HASH_NB_ALWAYS, we always go to the next
|
|
|
|
* block so no check is necessary
|
|
|
|
*/
|
|
|
|
while (num_frames--) {
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
|
|
|
|
if (IS_ERR(bh))
|
|
|
|
return PTR_ERR(bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
p++;
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(p->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
p->bh = bh;
|
|
|
|
p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function fills a red-black tree with information from a
|
|
|
|
* directory block. It returns the number directory entries loaded
|
|
|
|
* into the tree. If there is an error it is returned in err.
|
|
|
|
*/
|
|
|
|
static int htree_dirblock_to_tree(struct file *dir_file,
|
2008-01-29 11:58:27 +07:00
|
|
|
struct inode *dir, ext4_lblk_t block,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct dx_hash_info *hinfo,
|
|
|
|
__u32 start_hash, __u32 start_minor_hash)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *de, *top;
|
ext4: fix possible non-initialized variable in htree_dirblock_to_tree()
htree_dirblock_to_tree() declares a non-initialized 'err' variable,
which is passed as a reference to another functions expecting them to
set this variable with their error codes.
It's passed to ext4_bread(), which then passes it to ext4_getblk(). If
ext4_map_blocks() returns 0 due to a lookup failure, leaving the
ext4_getblk() buffer_head uninitialized, it will make ext4_getblk()
return to ext4_bread() without initialize the 'err' variable, and
ext4_bread() will return to htree_dirblock_to_tree() with this variable
still uninitialized. htree_dirblock_to_tree() will pass this variable
with garbage back to ext4_htree_fill_tree(), which expects a number of
directory entries added to the rb-tree. which, in case, might return a
fake non-zero value due the garbage left in the 'err' variable, leading
the kernel to an Oops in ext4_dx_readdir(), once this is expecting a
filled rb-tree node, when in turn it will have a NULL-ed one, causing an
invalid page request when trying to get a fname struct from this NULL-ed
rb-tree node in this line:
fname = rb_entry(info->curr_node, struct fname, rb_hash);
The patch itself initializes the err variable in
htree_dirblock_to_tree() to avoid usage mistakes by the called
functions, and also fix ext4_getblk() to return a initialized 'err'
variable when ext4_map_blocks() fails a lookup.
Signed-off-by: Carlos Maiolino <cmaiolino@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2012-09-18 10:39:12 +07:00
|
|
|
int err = 0, count = 0;
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2008-01-29 11:58:27 +07:00
|
|
|
dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
|
|
|
|
(unsigned long)block));
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(dir, block, DIRENT);
|
|
|
|
if (IS_ERR(bh))
|
|
|
|
return PTR_ERR(bh);
|
2012-04-30 05:41:10 +07:00
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
|
|
|
top = (struct ext4_dir_entry_2 *) ((char *) de +
|
2006-10-11 15:20:50 +07:00
|
|
|
dir->i_sb->s_blocksize -
|
2006-10-11 15:20:53 +07:00
|
|
|
EXT4_DIR_REC_LEN(0));
|
2015-04-12 12:09:03 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_ENCRYPTION
|
|
|
|
/* Check if the directory is encrypted */
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 00:17:47 +07:00
|
|
|
if (ext4_encrypted_inode(dir)) {
|
2016-07-11 01:01:03 +07:00
|
|
|
err = fscrypt_get_encryption_info(dir);
|
2015-06-01 00:34:22 +07:00
|
|
|
if (err < 0) {
|
|
|
|
brelse(bh);
|
|
|
|
return err;
|
|
|
|
}
|
2016-07-11 01:01:03 +07:00
|
|
|
err = fscrypt_fname_alloc_buffer(dir, EXT4_NAME_LEN,
|
2015-04-12 12:09:03 +07:00
|
|
|
&fname_crypto_str);
|
|
|
|
if (err < 0) {
|
|
|
|
brelse(bh);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2009-02-15 11:01:36 +07:00
|
|
|
for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
|
2011-01-11 00:10:55 +07:00
|
|
|
if (ext4_check_dir_entry(dir, NULL, de, bh,
|
2012-12-11 02:05:58 +07:00
|
|
|
bh->b_data, bh->b_size,
|
2010-12-20 10:07:02 +07:00
|
|
|
(block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
|
|
|
|
+ ((char *)de - bh->b_data))) {
|
2013-07-01 19:12:38 +07:00
|
|
|
/* silently ignore the rest of the block */
|
|
|
|
break;
|
[PATCH] handle ext4 directory corruption better
I've been using Steve Grubb's purely evil "fsfuzzer" tool, at
http://people.redhat.com/sgrubb/files/fsfuzzer-0.4.tar.gz
Basically it makes a filesystem, splats some random bits over it, then
tries to mount it and do some simple filesystem actions.
At best, the filesystem catches the corruption gracefully. At worst,
things spin out of control.
As you might guess, we found a couple places in ext4 where things spin out
of control :)
First, we had a corrupted directory that was never checked for
consistency... it was corrupt, and pointed to another bad "entry" of
length 0. The for() loop looped forever, since the length of
ext4_next_entry(de) was 0, and we kept looking at the same pointer over and
over and over and over... I modeled this check and subsequent action on
what is done for other directory types in ext4_readdir...
(adding this check adds some computational expense; I am testing a followup
patch to reduce the number of times we check and re-check these directory
entries, in all cases. Thanks for the idea, Andreas).
Next we had a root directory inode which had a corrupted size, claimed to
be > 200M on a 4M filesystem. There was only really 1 block in the
directory, but because the size was so large, readdir kept coming back for
more, spewing thousands of printk's along the way.
Per Andreas' suggestion, if we're in this read error condition and we're
trying to read an offset which is greater than i_blocks worth of bytes,
stop trying, and break out of the loop.
With these two changes fsfuzz test survives quite well on ext4.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Cc: <linux-ext4@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 11:36:28 +07:00
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4fs_dirhash(de->name, de->name_len, hinfo);
|
2006-10-11 15:20:50 +07:00
|
|
|
if ((hinfo->hash < start_hash) ||
|
|
|
|
((hinfo->hash == start_hash) &&
|
|
|
|
(hinfo->minor_hash < start_minor_hash)))
|
|
|
|
continue;
|
|
|
|
if (de->inode == 0)
|
|
|
|
continue;
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 00:17:47 +07:00
|
|
|
if (!ext4_encrypted_inode(dir)) {
|
2015-04-12 12:09:03 +07:00
|
|
|
tmp_str.name = de->name;
|
|
|
|
tmp_str.len = de->name_len;
|
|
|
|
err = ext4_htree_store_dirent(dir_file,
|
|
|
|
hinfo->hash, hinfo->minor_hash, de,
|
|
|
|
&tmp_str);
|
|
|
|
} else {
|
2015-05-19 00:15:47 +07:00
|
|
|
int save_len = fname_crypto_str.len;
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str de_name = FSTR_INIT(de->name,
|
|
|
|
de->name_len);
|
2015-05-19 00:15:47 +07:00
|
|
|
|
2015-04-12 12:09:03 +07:00
|
|
|
/* Directory is encrypted */
|
2016-07-11 01:01:03 +07:00
|
|
|
err = fscrypt_fname_disk_to_usr(dir, hinfo->hash,
|
|
|
|
hinfo->minor_hash, &de_name,
|
|
|
|
&fname_crypto_str);
|
2016-09-16 04:25:55 +07:00
|
|
|
if (err) {
|
2015-04-12 12:09:03 +07:00
|
|
|
count = err;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
err = ext4_htree_store_dirent(dir_file,
|
|
|
|
hinfo->hash, hinfo->minor_hash, de,
|
|
|
|
&fname_crypto_str);
|
2015-05-19 00:15:47 +07:00
|
|
|
fname_crypto_str.len = save_len;
|
2015-04-12 12:09:03 +07:00
|
|
|
}
|
2015-04-12 11:56:26 +07:00
|
|
|
if (err != 0) {
|
2015-04-12 12:09:03 +07:00
|
|
|
count = err;
|
|
|
|
goto errout;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
count++;
|
|
|
|
}
|
2015-04-12 12:09:03 +07:00
|
|
|
errout:
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(bh);
|
2015-04-12 12:09:03 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_ENCRYPTION
|
2016-07-11 01:01:03 +07:00
|
|
|
fscrypt_fname_free_buffer(&fname_crypto_str);
|
2015-04-12 12:09:03 +07:00
|
|
|
#endif
|
2006-10-11 15:20:50 +07:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function fills a red-black tree with information from a
|
|
|
|
* directory. We start scanning the directory in hash order, starting
|
|
|
|
* at start_hash and start_minor_hash.
|
|
|
|
*
|
|
|
|
* This function returns the number of entries inserted into the tree,
|
|
|
|
* or a negative error code.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
|
2006-10-11 15:20:50 +07:00
|
|
|
__u32 start_minor_hash, __u32 *next_hash)
|
|
|
|
{
|
|
|
|
struct dx_hash_info hinfo;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *de;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct dx_frame frames[2], *frame;
|
|
|
|
struct inode *dir;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t block;
|
2006-10-11 15:20:50 +07:00
|
|
|
int count = 0;
|
2008-01-29 11:58:27 +07:00
|
|
|
int ret, err;
|
2006-10-11 15:20:50 +07:00
|
|
|
__u32 hashval;
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str tmp_str;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2010-05-17 18:00:00 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
|
2008-09-09 10:00:52 +07:00
|
|
|
start_hash, start_minor_hash));
|
2013-01-24 05:07:38 +07:00
|
|
|
dir = file_inode(dir_file);
|
2010-05-17 09:00:00 +07:00
|
|
|
if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
|
2006-10-11 15:20:53 +07:00
|
|
|
hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
|
2008-10-29 00:21:44 +07:00
|
|
|
if (hinfo.hash_version <= DX_HASH_TEA)
|
|
|
|
hinfo.hash_version +=
|
|
|
|
EXT4_SB(dir->i_sb)->s_hash_unsigned;
|
2006-10-11 15:20:53 +07:00
|
|
|
hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
|
2013-04-20 04:53:09 +07:00
|
|
|
if (ext4_has_inline_data(dir)) {
|
|
|
|
int has_inline_data = 1;
|
|
|
|
count = htree_inlinedir_to_tree(dir_file, dir, 0,
|
|
|
|
&hinfo, start_hash,
|
|
|
|
start_minor_hash,
|
|
|
|
&has_inline_data);
|
|
|
|
if (has_inline_data) {
|
|
|
|
*next_hash = ~0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
|
|
|
|
start_hash, start_minor_hash);
|
|
|
|
*next_hash = ~0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
hinfo.hash = start_hash;
|
|
|
|
hinfo.minor_hash = 0;
|
2014-08-30 07:52:17 +07:00
|
|
|
frame = dx_probe(NULL, dir, &hinfo, frames);
|
|
|
|
if (IS_ERR(frame))
|
|
|
|
return PTR_ERR(frame);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Add '.' and '..' from the htree header */
|
|
|
|
if (!start_hash && !start_minor_hash) {
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
|
2015-04-12 11:56:26 +07:00
|
|
|
tmp_str.name = de->name;
|
|
|
|
tmp_str.len = de->name_len;
|
|
|
|
err = ext4_htree_store_dirent(dir_file, 0, 0,
|
|
|
|
de, &tmp_str);
|
|
|
|
if (err != 0)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto errout;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
|
2009-02-15 11:01:36 +07:00
|
|
|
de = ext4_next_entry(de, dir->i_sb->s_blocksize);
|
2015-04-12 11:56:26 +07:00
|
|
|
tmp_str.name = de->name;
|
|
|
|
tmp_str.len = de->name_len;
|
|
|
|
err = ext4_htree_store_dirent(dir_file, 2, 0,
|
|
|
|
de, &tmp_str);
|
|
|
|
if (err != 0)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto errout;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (1) {
|
2016-04-24 09:50:07 +07:00
|
|
|
if (fatal_signal_pending(current)) {
|
|
|
|
err = -ERESTARTSYS;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
cond_resched();
|
2006-10-11 15:20:50 +07:00
|
|
|
block = dx_get_block(frame->at);
|
|
|
|
ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
|
|
|
|
start_hash, start_minor_hash);
|
|
|
|
if (ret < 0) {
|
|
|
|
err = ret;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
count += ret;
|
|
|
|
hashval = ~0;
|
2006-10-11 15:20:53 +07:00
|
|
|
ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
|
2006-10-11 15:20:50 +07:00
|
|
|
frame, frames, &hashval);
|
|
|
|
*next_hash = hashval;
|
|
|
|
if (ret < 0) {
|
|
|
|
err = ret;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Stop if: (a) there are no more entries, or
|
|
|
|
* (b) we have inserted at least one entry and the
|
|
|
|
* next hash value is not a continuation
|
|
|
|
*/
|
|
|
|
if ((ret == 0) ||
|
|
|
|
(count && ((hashval & 1) == 0)))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dx_release(frames);
|
2008-09-09 10:00:52 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
|
|
|
|
"next hash: %x\n", count, *next_hash));
|
2006-10-11 15:20:50 +07:00
|
|
|
return count;
|
|
|
|
errout:
|
|
|
|
dx_release(frames);
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
2012-12-11 02:05:59 +07:00
|
|
|
static inline int search_dirblock(struct buffer_head *bh,
|
|
|
|
struct inode *dir,
|
2015-05-19 00:14:47 +07:00
|
|
|
struct ext4_filename *fname,
|
2012-12-11 02:05:59 +07:00
|
|
|
const struct qstr *d_name,
|
|
|
|
unsigned int offset,
|
|
|
|
struct ext4_dir_entry_2 **res_dir)
|
|
|
|
{
|
2015-05-19 00:14:47 +07:00
|
|
|
return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
|
|
|
|
fname, d_name, offset, res_dir);
|
2012-12-11 02:05:59 +07:00
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* Directory block splitting, compacting
|
|
|
|
*/
|
|
|
|
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
/*
|
|
|
|
* Create map of hash values, offsets, and sizes, stored at end of block.
|
|
|
|
* Returns number of entries mapped.
|
|
|
|
*/
|
2015-04-12 12:09:03 +07:00
|
|
|
static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
|
|
|
|
unsigned blocksize, struct dx_hash_info *hinfo,
|
2009-02-15 09:46:54 +07:00
|
|
|
struct dx_map_entry *map_tail)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
int count = 0;
|
|
|
|
char *base = (char *) de;
|
|
|
|
struct dx_hash_info h = *hinfo;
|
|
|
|
|
2009-02-15 09:46:54 +07:00
|
|
|
while ((char *) de < base + blocksize) {
|
2006-10-11 15:20:50 +07:00
|
|
|
if (de->name_len && de->inode) {
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4fs_dirhash(de->name, de->name_len, &h);
|
2006-10-11 15:20:50 +07:00
|
|
|
map_tail--;
|
|
|
|
map_tail->hash = h.hash;
|
2009-06-08 23:41:35 +07:00
|
|
|
map_tail->offs = ((char *) de - base)>>2;
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
map_tail->size = le16_to_cpu(de->rec_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
count++;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
/* XXX: do we need to check rec_len == 0 case? -Chris */
|
2009-02-15 11:01:36 +07:00
|
|
|
de = ext4_next_entry(de, blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
/* Sort map by hash value */
|
2006-10-11 15:20:50 +07:00
|
|
|
static void dx_sort_map (struct dx_map_entry *map, unsigned count)
|
|
|
|
{
|
2006-10-11 15:21:24 +07:00
|
|
|
struct dx_map_entry *p, *q, *top = map + count - 1;
|
|
|
|
int more;
|
|
|
|
/* Combsort until bubble sort doesn't suck */
|
|
|
|
while (count > 2) {
|
|
|
|
count = count*10/13;
|
|
|
|
if (count - 9 < 2) /* 9, 10 -> 11 */
|
|
|
|
count = 11;
|
|
|
|
for (p = top, q = p - count; q >= map; p--, q--)
|
|
|
|
if (p->hash < q->hash)
|
|
|
|
swap(*p, *q);
|
|
|
|
}
|
|
|
|
/* Garden variety bubble sort */
|
|
|
|
do {
|
|
|
|
more = 0;
|
|
|
|
q = top;
|
|
|
|
while (q-- > map) {
|
|
|
|
if (q[1].hash >= q[0].hash)
|
2006-10-11 15:20:50 +07:00
|
|
|
continue;
|
2006-10-11 15:21:24 +07:00
|
|
|
swap(*(q+1), *q);
|
|
|
|
more = 1;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
} while(more);
|
|
|
|
}
|
|
|
|
|
2008-01-29 11:58:27 +07:00
|
|
|
static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct dx_entry *entries = frame->entries;
|
|
|
|
struct dx_entry *old = frame->at, *new = old + 1;
|
|
|
|
int count = dx_get_count(entries);
|
|
|
|
|
|
|
|
assert(count < dx_get_limit(entries));
|
|
|
|
assert(old < entries + count);
|
|
|
|
memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
|
|
|
|
dx_set_hash(new, hash);
|
|
|
|
dx_set_block(new, block);
|
|
|
|
dx_set_count(entries, count + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* NOTE! unlike strncmp, ext4_match returns 1 for success, 0 for failure.
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
2006-10-11 15:20:53 +07:00
|
|
|
* `len <= EXT4_NAME_LEN' is guaranteed by caller.
|
2006-10-11 15:20:50 +07:00
|
|
|
* `de != NULL' is guaranteed by caller.
|
|
|
|
*/
|
2015-05-19 00:14:47 +07:00
|
|
|
static inline int ext4_match(struct ext4_filename *fname,
|
2015-04-12 12:09:03 +07:00
|
|
|
struct ext4_dir_entry_2 *de)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2015-05-19 00:14:47 +07:00
|
|
|
const void *name = fname_name(fname);
|
|
|
|
u32 len = fname_len(fname);
|
2015-04-12 12:09:03 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!de->inode)
|
|
|
|
return 0;
|
2015-04-12 12:09:03 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_EXT4_FS_ENCRYPTION
|
2015-05-19 00:14:47 +07:00
|
|
|
if (unlikely(!name)) {
|
|
|
|
if (fname->usr_fname->name[0] == '_') {
|
|
|
|
int ret;
|
|
|
|
if (de->name_len < 16)
|
|
|
|
return 0;
|
|
|
|
ret = memcmp(de->name + de->name_len - 16,
|
|
|
|
fname->crypto_buf.name + 8, 16);
|
|
|
|
return (ret == 0) ? 1 : 0;
|
|
|
|
}
|
|
|
|
name = fname->crypto_buf.name;
|
|
|
|
len = fname->crypto_buf.len;
|
|
|
|
}
|
2015-04-12 12:09:03 +07:00
|
|
|
#endif
|
2015-05-19 00:14:47 +07:00
|
|
|
if (de->name_len != len)
|
2015-04-12 12:09:03 +07:00
|
|
|
return 0;
|
2015-05-19 00:14:47 +07:00
|
|
|
return (memcmp(de->name, name, len) == 0) ? 1 : 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns 0 if not found, -1 on failure, and 1 on success
|
|
|
|
*/
|
2015-05-19 00:14:47 +07:00
|
|
|
int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
|
|
|
|
struct inode *dir, struct ext4_filename *fname,
|
|
|
|
const struct qstr *d_name,
|
|
|
|
unsigned int offset, struct ext4_dir_entry_2 **res_dir)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 * de;
|
2006-10-11 15:20:50 +07:00
|
|
|
char * dlimit;
|
|
|
|
int de_len;
|
2015-04-12 12:09:03 +07:00
|
|
|
int res;
|
|
|
|
|
2012-12-11 02:05:59 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *)search_buf;
|
|
|
|
dlimit = search_buf + buf_size;
|
2006-10-11 15:20:50 +07:00
|
|
|
while ((char *) de < dlimit) {
|
|
|
|
/* this code is executed quadratically often */
|
|
|
|
/* do minimal checking `by hand' */
|
2015-04-12 12:09:03 +07:00
|
|
|
if ((char *) de + de->name_len <= dlimit) {
|
2015-05-19 00:14:47 +07:00
|
|
|
res = ext4_match(fname, de);
|
2015-04-12 12:09:03 +07:00
|
|
|
if (res < 0) {
|
|
|
|
res = -1;
|
|
|
|
goto return_result;
|
|
|
|
}
|
|
|
|
if (res > 0) {
|
|
|
|
/* found a match - just to be sure, do
|
|
|
|
* a full check */
|
|
|
|
if (ext4_check_dir_entry(dir, NULL, de, bh,
|
|
|
|
bh->b_data,
|
|
|
|
bh->b_size, offset)) {
|
|
|
|
res = -1;
|
|
|
|
goto return_result;
|
|
|
|
}
|
|
|
|
*res_dir = de;
|
|
|
|
res = 1;
|
|
|
|
goto return_result;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
}
|
|
|
|
/* prevent looping on a bad block */
|
2009-02-15 11:01:36 +07:00
|
|
|
de_len = ext4_rec_len_from_disk(de->rec_len,
|
|
|
|
dir->i_sb->s_blocksize);
|
2015-04-12 12:09:03 +07:00
|
|
|
if (de_len <= 0) {
|
|
|
|
res = -1;
|
|
|
|
goto return_result;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
offset += de_len;
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2015-04-12 12:09:03 +07:00
|
|
|
|
|
|
|
res = 0;
|
|
|
|
return_result:
|
|
|
|
return res;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2012-11-13 11:51:02 +07:00
|
|
|
static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
|
|
|
|
struct ext4_dir_entry *de)
|
|
|
|
{
|
|
|
|
struct super_block *sb = dir->i_sb;
|
|
|
|
|
|
|
|
if (!is_dx(dir))
|
|
|
|
return 0;
|
|
|
|
if (block == 0)
|
|
|
|
return 1;
|
|
|
|
if (de->inode == 0 &&
|
|
|
|
ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) ==
|
|
|
|
sb->s_blocksize)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_find_entry()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* finds an entry in the specified directory with the wanted name. It
|
|
|
|
* returns the cache buffer in which the entry was found, and the entry
|
|
|
|
* itself (as a parameter - res_dir). It does NOT read the inode of the
|
|
|
|
* entry - you'll have to do that yourself if you want to.
|
|
|
|
*
|
|
|
|
* The returned buffer_head has ->b_count elevated. The caller is expected
|
|
|
|
* to brelse() it when appropriate.
|
|
|
|
*/
|
2008-09-23 02:21:01 +07:00
|
|
|
static struct buffer_head * ext4_find_entry (struct inode *dir,
|
|
|
|
const struct qstr *d_name,
|
2012-12-11 02:06:01 +07:00
|
|
|
struct ext4_dir_entry_2 **res_dir,
|
|
|
|
int *inlined)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2008-09-09 09:25:24 +07:00
|
|
|
struct super_block *sb;
|
|
|
|
struct buffer_head *bh_use[NAMEI_RA_SIZE];
|
|
|
|
struct buffer_head *bh, *ret = NULL;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t start, block, b;
|
2010-10-28 08:30:08 +07:00
|
|
|
const u8 *name = d_name->name;
|
2006-10-11 15:20:50 +07:00
|
|
|
int ra_max = 0; /* Number of bh's in the readahead
|
|
|
|
buffer, bh_use[] */
|
|
|
|
int ra_ptr = 0; /* Current index into readahead
|
|
|
|
buffer */
|
|
|
|
int num = 0;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t nblocks;
|
2015-05-19 00:14:47 +07:00
|
|
|
int i, namelen, retval;
|
|
|
|
struct ext4_filename fname;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
*res_dir = NULL;
|
|
|
|
sb = dir->i_sb;
|
2008-09-23 02:21:01 +07:00
|
|
|
namelen = d_name->len;
|
2006-10-11 15:20:53 +07:00
|
|
|
if (namelen > EXT4_NAME_LEN)
|
2006-10-11 15:20:50 +07:00
|
|
|
return NULL;
|
2012-12-11 02:06:00 +07:00
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
retval = ext4_fname_setup_filename(dir, d_name, 1, &fname);
|
|
|
|
if (retval)
|
|
|
|
return ERR_PTR(retval);
|
|
|
|
|
2012-12-11 02:06:00 +07:00
|
|
|
if (ext4_has_inline_data(dir)) {
|
|
|
|
int has_inline_data = 1;
|
2015-05-19 00:14:47 +07:00
|
|
|
ret = ext4_find_inline_entry(dir, &fname, d_name, res_dir,
|
2012-12-11 02:06:00 +07:00
|
|
|
&has_inline_data);
|
2012-12-11 02:06:01 +07:00
|
|
|
if (has_inline_data) {
|
|
|
|
if (inlined)
|
|
|
|
*inlined = 1;
|
2015-05-19 00:14:47 +07:00
|
|
|
goto cleanup_and_exit;
|
2012-12-11 02:06:01 +07:00
|
|
|
}
|
2012-12-11 02:06:00 +07:00
|
|
|
}
|
|
|
|
|
2010-10-28 08:30:08 +07:00
|
|
|
if ((namelen <= 2) && (name[0] == '.') &&
|
2010-12-15 09:45:31 +07:00
|
|
|
(name[1] == '.' || name[1] == '\0')) {
|
2010-10-28 08:30:08 +07:00
|
|
|
/*
|
|
|
|
* "." or ".." will only be in the first block
|
|
|
|
* NFS may look up ".."; "." should be handled by the VFS
|
|
|
|
*/
|
|
|
|
block = start = 0;
|
|
|
|
nblocks = 1;
|
|
|
|
goto restart;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
if (is_dx(dir)) {
|
2015-05-19 00:14:47 +07:00
|
|
|
ret = ext4_dx_find_entry(dir, &fname, res_dir);
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* On success, or if the error was file not found,
|
|
|
|
* return. Otherwise, fall back to doing a search the
|
|
|
|
* old fashioned way.
|
|
|
|
*/
|
2015-05-19 00:14:47 +07:00
|
|
|
if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
|
|
|
|
goto cleanup_and_exit;
|
2008-09-09 10:00:52 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
|
|
|
|
"falling back\n"));
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
|
|
|
|
start = EXT4_I(dir)->i_dir_start_lookup;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (start >= nblocks)
|
|
|
|
start = 0;
|
|
|
|
block = start;
|
|
|
|
restart:
|
|
|
|
do {
|
|
|
|
/*
|
|
|
|
* We deal with the read-ahead logic here.
|
|
|
|
*/
|
|
|
|
if (ra_ptr >= ra_max) {
|
|
|
|
/* Refill the readahead buffer */
|
|
|
|
ra_ptr = 0;
|
|
|
|
b = block;
|
|
|
|
for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
|
|
|
|
/*
|
|
|
|
* Terminate if we reach the end of the
|
|
|
|
* directory and must wrap, or if our
|
|
|
|
* search has finished at this block.
|
|
|
|
*/
|
|
|
|
if (b >= nblocks || (num && block == start)) {
|
|
|
|
bh_use[ra_max] = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
num++;
|
2014-08-30 07:51:32 +07:00
|
|
|
bh = ext4_getblk(NULL, dir, b++, 0);
|
2015-08-12 17:29:44 +07:00
|
|
|
if (IS_ERR(bh)) {
|
2015-05-19 00:14:47 +07:00
|
|
|
if (ra_max == 0) {
|
|
|
|
ret = bh;
|
|
|
|
goto cleanup_and_exit;
|
|
|
|
}
|
2014-08-24 04:47:19 +07:00
|
|
|
break;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
bh_use[ra_max] = bh;
|
|
|
|
if (bh)
|
2016-06-06 02:31:44 +07:00
|
|
|
ll_rw_block(REQ_OP_READ,
|
|
|
|
REQ_META | REQ_PRIO,
|
2011-08-23 19:50:29 +07:00
|
|
|
1, &bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((bh = bh_use[ra_ptr++]) == NULL)
|
|
|
|
goto next;
|
|
|
|
wait_on_buffer(bh);
|
|
|
|
if (!buffer_uptodate(bh)) {
|
|
|
|
/* read error, skip block & hope for the best */
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(dir, "reading directory lblock %lu",
|
|
|
|
(unsigned long) block);
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(bh);
|
|
|
|
goto next;
|
|
|
|
}
|
2012-04-30 05:41:10 +07:00
|
|
|
if (!buffer_verified(bh) &&
|
2012-11-13 11:51:02 +07:00
|
|
|
!is_dx_internal_node(dir, block,
|
|
|
|
(struct ext4_dir_entry *)bh->b_data) &&
|
2012-04-30 05:41:10 +07:00
|
|
|
!ext4_dirent_csum_verify(dir,
|
|
|
|
(struct ext4_dir_entry *)bh->b_data)) {
|
|
|
|
EXT4_ERROR_INODE(dir, "checksumming directory "
|
|
|
|
"block %lu", (unsigned long)block);
|
|
|
|
brelse(bh);
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
set_buffer_verified(bh);
|
2015-05-19 00:14:47 +07:00
|
|
|
i = search_dirblock(bh, dir, &fname, d_name,
|
2006-10-11 15:20:53 +07:00
|
|
|
block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (i == 1) {
|
2006-10-11 15:20:53 +07:00
|
|
|
EXT4_I(dir)->i_dir_start_lookup = block;
|
2006-10-11 15:20:50 +07:00
|
|
|
ret = bh;
|
|
|
|
goto cleanup_and_exit;
|
|
|
|
} else {
|
|
|
|
brelse(bh);
|
|
|
|
if (i < 0)
|
|
|
|
goto cleanup_and_exit;
|
|
|
|
}
|
|
|
|
next:
|
|
|
|
if (++block >= nblocks)
|
|
|
|
block = 0;
|
|
|
|
} while (block != start);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the directory has grown while we were searching, then
|
|
|
|
* search the last part of the directory before giving up.
|
|
|
|
*/
|
|
|
|
block = nblocks;
|
2006-10-11 15:20:53 +07:00
|
|
|
nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (block < nblocks) {
|
|
|
|
start = 0;
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup_and_exit:
|
|
|
|
/* Clean up the read-ahead blocks */
|
|
|
|
for (; ra_ptr < ra_max; ra_ptr++)
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh_use[ra_ptr]);
|
2015-05-19 00:14:47 +07:00
|
|
|
ext4_fname_free_filename(&fname);
|
2006-10-11 15:20:50 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
|
|
|
|
struct ext4_filename *fname,
|
|
|
|
struct ext4_dir_entry_2 **res_dir)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2010-10-28 08:30:08 +07:00
|
|
|
struct super_block * sb = dir->i_sb;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct dx_frame frames[2], *frame;
|
2015-05-19 00:14:47 +07:00
|
|
|
const struct qstr *d_name = fname->usr_fname;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct buffer_head *bh;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t block;
|
2006-10-11 15:20:50 +07:00
|
|
|
int retval;
|
|
|
|
|
2015-04-12 12:09:03 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_ENCRYPTION
|
|
|
|
*res_dir = NULL;
|
|
|
|
#endif
|
2015-05-19 00:14:47 +07:00
|
|
|
frame = dx_probe(fname, dir, NULL, frames);
|
2014-08-30 07:52:17 +07:00
|
|
|
if (IS_ERR(frame))
|
|
|
|
return (struct buffer_head *) frame;
|
2006-10-11 15:20:50 +07:00
|
|
|
do {
|
|
|
|
block = dx_get_block(frame->at);
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(dir, block, DIRENT);
|
2014-08-30 07:49:51 +07:00
|
|
|
if (IS_ERR(bh))
|
2012-04-30 05:41:10 +07:00
|
|
|
goto errout;
|
2014-08-30 07:49:51 +07:00
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
retval = search_dirblock(bh, dir, fname, d_name,
|
2010-10-28 08:30:08 +07:00
|
|
|
block << EXT4_BLOCK_SIZE_BITS(sb),
|
|
|
|
res_dir);
|
2014-08-30 07:49:51 +07:00
|
|
|
if (retval == 1)
|
|
|
|
goto success;
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2010-10-28 08:30:08 +07:00
|
|
|
if (retval == -1) {
|
2014-08-30 07:49:51 +07:00
|
|
|
bh = ERR_PTR(ERR_BAD_DX_DIR);
|
2010-10-28 08:30:08 +07:00
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/* Check to see if we should continue to search */
|
2015-05-19 00:14:47 +07:00
|
|
|
retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
|
2006-10-11 15:20:50 +07:00
|
|
|
frames, NULL);
|
|
|
|
if (retval < 0) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir,
|
|
|
|
"error %d reading directory index block",
|
|
|
|
retval);
|
2014-08-30 07:49:51 +07:00
|
|
|
bh = ERR_PTR(retval);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
} while (retval == 1);
|
|
|
|
|
2014-08-30 07:49:51 +07:00
|
|
|
bh = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
errout:
|
2011-07-17 06:41:23 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
|
2014-08-30 07:49:51 +07:00
|
|
|
success:
|
|
|
|
dx_release(frames);
|
|
|
|
return bh;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2012-06-11 04:13:09 +07:00
|
|
|
static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2008-09-09 09:25:24 +07:00
|
|
|
struct inode *inode;
|
|
|
|
struct ext4_dir_entry_2 *de;
|
|
|
|
struct buffer_head *bh;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2016-07-11 01:01:03 +07:00
|
|
|
if (ext4_encrypted_inode(dir)) {
|
|
|
|
int res = fscrypt_get_encryption_info(dir);
|
2016-02-08 07:35:05 +07:00
|
|
|
|
|
|
|
/*
|
2016-07-11 01:01:03 +07:00
|
|
|
* DCACHE_ENCRYPTED_WITH_KEY is set if the dentry is
|
2016-02-08 07:35:05 +07:00
|
|
|
* created while the directory was encrypted and we
|
2016-07-11 01:01:03 +07:00
|
|
|
* have access to the key.
|
2016-02-08 07:35:05 +07:00
|
|
|
*/
|
2016-07-11 01:01:03 +07:00
|
|
|
if (fscrypt_has_encryption_key(dir))
|
|
|
|
fscrypt_set_encrypted_dentry(dentry);
|
|
|
|
fscrypt_set_d_op(dentry);
|
|
|
|
if (res && res != -ENOKEY)
|
|
|
|
return ERR_PTR(res);
|
|
|
|
}
|
2016-02-08 07:35:05 +07:00
|
|
|
|
2016-07-11 01:01:03 +07:00
|
|
|
if (dentry->d_name.len > EXT4_NAME_LEN)
|
|
|
|
return ERR_PTR(-ENAMETOOLONG);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2012-12-11 02:06:01 +07:00
|
|
|
bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(bh))
|
|
|
|
return (struct dentry *) bh;
|
2006-10-11 15:20:50 +07:00
|
|
|
inode = NULL;
|
|
|
|
if (bh) {
|
2008-11-05 12:14:04 +07:00
|
|
|
__u32 ino = le32_to_cpu(de->inode);
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2006-10-11 15:20:53 +07:00
|
|
|
if (!ext4_valid_inum(dir->i_sb, ino)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSCORRUPTED);
|
2007-07-16 13:40:46 +07:00
|
|
|
}
|
2012-05-29 04:02:25 +07:00
|
|
|
if (unlikely(ino == dir->i_ino)) {
|
2014-01-07 02:04:23 +07:00
|
|
|
EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
|
|
|
|
dentry);
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSCORRUPTED);
|
2012-05-29 04:02:25 +07:00
|
|
|
}
|
ext4: add ext4_iget_normal() which is to be used for dir tree lookups
If there is a corrupted file system which has directory entries that
point at reserved, metadata inodes, prohibit them from being used by
treating them the same way we treat Boot Loader inodes --- that is,
mark them to be bad inodes. This prohibits them from being opened,
deleted, or modified via chmod, chown, utimes, etc.
In particular, this prevents a corrupted file system which has a
directory entry which points at the journal inode from being deleted
and its blocks released, after which point Much Hilarity Ensues.
Reported-by: Sami Liedes <sami.liedes@iki.fi>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-06 09:56:00 +07:00
|
|
|
inode = ext4_iget_normal(dir->i_sb, ino);
|
2011-07-09 08:20:11 +07:00
|
|
|
if (inode == ERR_PTR(-ESTALE)) {
|
|
|
|
EXT4_ERROR_INODE(dir,
|
|
|
|
"deleted inode referenced: %u",
|
|
|
|
ino);
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSCORRUPTED);
|
2009-02-23 09:20:25 +07:00
|
|
|
}
|
2015-04-12 11:55:08 +07:00
|
|
|
if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
|
2016-02-08 12:54:26 +07:00
|
|
|
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
|
2016-07-11 01:01:03 +07:00
|
|
|
!fscrypt_has_permitted_context(dir, inode)) {
|
2016-02-08 12:54:26 +07:00
|
|
|
int nokey = ext4_encrypted_inode(inode) &&
|
2016-07-11 01:01:03 +07:00
|
|
|
!fscrypt_has_encryption_key(inode);
|
2015-04-12 11:55:08 +07:00
|
|
|
iput(inode);
|
2016-02-08 12:54:26 +07:00
|
|
|
if (nokey)
|
|
|
|
return ERR_PTR(-ENOKEY);
|
2015-04-12 11:55:08 +07:00
|
|
|
ext4_warning(inode->i_sb,
|
2016-04-27 12:11:21 +07:00
|
|
|
"Inconsistent encryption contexts: %lu/%lu",
|
2015-04-12 11:55:08 +07:00
|
|
|
(unsigned long) dir->i_ino,
|
|
|
|
(unsigned long) inode->i_ino);
|
|
|
|
return ERR_PTR(-EPERM);
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
return d_splice_alias(inode, dentry);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
struct dentry *ext4_get_parent(struct dentry *child)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2008-11-05 12:14:04 +07:00
|
|
|
__u32 ino;
|
2012-05-11 03:14:12 +07:00
|
|
|
static const struct qstr dotdot = QSTR_INIT("..", 2);
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 * de;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct buffer_head *bh;
|
|
|
|
|
2015-03-18 05:25:59 +07:00
|
|
|
bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(bh))
|
|
|
|
return (struct dentry *) bh;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!bh)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
ino = le32_to_cpu(de->inode);
|
|
|
|
brelse(bh);
|
|
|
|
|
2016-04-10 12:33:30 +07:00
|
|
|
if (!ext4_valid_inum(child->d_sb, ino)) {
|
2015-03-18 05:25:59 +07:00
|
|
|
EXT4_ERROR_INODE(d_inode(child),
|
2010-05-17 08:00:00 +07:00
|
|
|
"bad parent inode number: %u", ino);
|
2015-10-18 03:16:04 +07:00
|
|
|
return ERR_PTR(-EFSCORRUPTED);
|
2007-07-16 13:40:46 +07:00
|
|
|
}
|
|
|
|
|
2016-04-10 12:33:30 +07:00
|
|
|
return d_obtain_alias(ext4_iget_normal(child->d_sb, ino));
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
/*
|
|
|
|
* Move count entries from end of map between two memory locations.
|
|
|
|
* Returns pointer to last entry moved.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
static struct ext4_dir_entry_2 *
|
2009-02-15 11:01:36 +07:00
|
|
|
dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
|
|
|
|
unsigned blocksize)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
unsigned rec_len = 0;
|
|
|
|
|
|
|
|
while (count--) {
|
2010-05-17 18:00:00 +07:00
|
|
|
struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
|
2009-06-08 23:41:35 +07:00
|
|
|
(from + (map->offs<<2));
|
2006-10-11 15:20:53 +07:00
|
|
|
rec_len = EXT4_DIR_REC_LEN(de->name_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
memcpy (to, de, rec_len);
|
2006-10-11 15:20:53 +07:00
|
|
|
((struct ext4_dir_entry_2 *) to)->rec_len =
|
2009-02-15 11:01:36 +07:00
|
|
|
ext4_rec_len_to_disk(rec_len, blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
de->inode = 0;
|
|
|
|
map++;
|
|
|
|
to += rec_len;
|
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
return (struct ext4_dir_entry_2 *) (to - rec_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
/*
|
|
|
|
* Compact each dir entry in the range to the minimal rec_len.
|
|
|
|
* Returns pointer to last entry in range.
|
|
|
|
*/
|
2009-02-15 09:46:54 +07:00
|
|
|
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
|
2006-10-11 15:20:50 +07:00
|
|
|
unsigned rec_len = 0;
|
|
|
|
|
|
|
|
prev = to = de;
|
2009-02-15 09:46:54 +07:00
|
|
|
while ((char*)de < base + blocksize) {
|
2009-02-15 11:01:36 +07:00
|
|
|
next = ext4_next_entry(de, blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (de->inode && de->name_len) {
|
2006-10-11 15:20:53 +07:00
|
|
|
rec_len = EXT4_DIR_REC_LEN(de->name_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (de > to)
|
|
|
|
memmove(to, de, rec_len);
|
2009-02-15 11:01:36 +07:00
|
|
|
to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
prev = to;
|
2006-10-11 15:20:53 +07:00
|
|
|
to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
de = next;
|
|
|
|
}
|
|
|
|
return prev;
|
|
|
|
}
|
|
|
|
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
/*
|
|
|
|
* Split a full leaf block to make room for a new dir entry.
|
|
|
|
* Allocate a new block, and move entries so that they are approx. equally full.
|
|
|
|
* Returns pointer to de in block into which the new entry will be inserted.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct buffer_head **bh,struct dx_frame *frame,
|
2014-08-30 07:52:18 +07:00
|
|
|
struct dx_hash_info *hinfo)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
unsigned blocksize = dir->i_sb->s_blocksize;
|
|
|
|
unsigned count, continued;
|
|
|
|
struct buffer_head *bh2;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t newblock;
|
2006-10-11 15:20:50 +07:00
|
|
|
u32 hash2;
|
|
|
|
struct dx_map_entry *map;
|
|
|
|
char *data1 = (*bh)->b_data, *data2;
|
2008-12-07 04:58:39 +07:00
|
|
|
unsigned split, move, size;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *de = NULL, *de2;
|
2012-04-30 05:41:10 +07:00
|
|
|
struct ext4_dir_entry_tail *t;
|
|
|
|
int csum_size = 0;
|
2008-12-07 04:58:39 +07:00
|
|
|
int err = 0, i;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(dir->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
csum_size = sizeof(struct ext4_dir_entry_tail);
|
|
|
|
|
2013-02-15 15:35:57 +07:00
|
|
|
bh2 = ext4_append(handle, dir, &newblock);
|
|
|
|
if (IS_ERR(bh2)) {
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(*bh);
|
|
|
|
*bh = NULL;
|
2014-08-30 07:52:18 +07:00
|
|
|
return (struct ext4_dir_entry_2 *) bh2;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
BUFFER_TRACE(*bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, *bh);
|
2007-05-08 14:25:34 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
BUFFER_TRACE(frame->bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, frame->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
|
|
|
|
data2 = bh2->b_data;
|
|
|
|
|
|
|
|
/* create map in the end of data2 block */
|
|
|
|
map = (struct dx_map_entry *) (data2 + blocksize);
|
2015-04-12 12:09:03 +07:00
|
|
|
count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
|
2006-10-11 15:20:50 +07:00
|
|
|
blocksize, hinfo, map);
|
|
|
|
map -= count;
|
2008-09-09 09:25:24 +07:00
|
|
|
dx_sort_map(map, count);
|
ext34: ensure do_split leaves enough free space in both blocks
The do_split() function for htree dir blocks is intended to split a leaf
block to make room for a new entry. It sorts the entries in the original
block by hash value, then moves the last half of the entries to the new
block - without accounting for how much space this actually moves. (IOW,
it moves half of the entry *count* not half of the entry *space*). If by
chance we have both large & small entries, and we move only the smallest
entries, and we have a large new entry to insert, we may not have created
enough space for it.
The patch below stores each record size when calculating the dx_map, and
then walks the hash-sorted dx_map, calculating how many entries must be
moved to more evenly split the existing entries between the old block and
the new block, guaranteeing enough space for the new entry.
The dx_map "offs" member is reduced to u16 so that the overall map size
does not change - it is temporarily stored at the end of the new block, and
if it grows too large it may be overwritten. By making offs and size both
u16, we won't grow the map size.
Also add a few comments to the functions involved.
This fixes the testcase reported by hooanon05@yahoo.co.jp on the
linux-ext4 list, "ext3 dir_index causes an error"
Thanks to Andreas Dilger for discussing the problem & solution with me.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Tested-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: <linux-ext4@vger.kernel.org>
Cc: <stable@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 12:46:42 +07:00
|
|
|
/* Split the existing block in the middle, size-wise */
|
|
|
|
size = 0;
|
|
|
|
move = 0;
|
|
|
|
for (i = count-1; i >= 0; i--) {
|
|
|
|
/* is more than half of this entry in 2nd half of the block? */
|
|
|
|
if (size + map[i].size/2 > blocksize/2)
|
|
|
|
break;
|
|
|
|
size += map[i].size;
|
|
|
|
move++;
|
|
|
|
}
|
|
|
|
/* map index at which we will split */
|
|
|
|
split = count - move;
|
2006-10-11 15:20:50 +07:00
|
|
|
hash2 = map[split].hash;
|
|
|
|
continued = hash2 == map[split - 1].hash;
|
2008-01-29 11:58:27 +07:00
|
|
|
dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
|
|
|
|
(unsigned long)dx_get_block(frame->at),
|
|
|
|
hash2, split, count-split));
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Fancy dance to stay within two buffers */
|
2015-04-12 12:09:03 +07:00
|
|
|
de2 = dx_move_dirents(data1, data2, map + split, count - split,
|
|
|
|
blocksize);
|
2008-09-09 09:25:24 +07:00
|
|
|
de = dx_pack_dirents(data1, blocksize);
|
2012-04-30 05:41:10 +07:00
|
|
|
de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
|
|
|
|
(char *) de,
|
2009-02-15 11:01:36 +07:00
|
|
|
blocksize);
|
2012-04-30 05:41:10 +07:00
|
|
|
de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
|
|
|
|
(char *) de2,
|
2009-02-15 11:01:36 +07:00
|
|
|
blocksize);
|
2012-04-30 05:41:10 +07:00
|
|
|
if (csum_size) {
|
|
|
|
t = EXT4_DIRENT_TAIL(data2, blocksize);
|
|
|
|
initialize_dirent_tail(t, blocksize);
|
|
|
|
|
|
|
|
t = EXT4_DIRENT_TAIL(data1, blocksize);
|
|
|
|
initialize_dirent_tail(t, blocksize);
|
|
|
|
}
|
|
|
|
|
2015-04-12 12:07:01 +07:00
|
|
|
dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
|
|
|
|
blocksize, 1));
|
|
|
|
dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
|
|
|
|
blocksize, 1));
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Which block gets the new entry? */
|
2014-08-30 07:52:18 +07:00
|
|
|
if (hinfo->hash >= hash2) {
|
2006-10-11 15:20:50 +07:00
|
|
|
swap(*bh, bh2);
|
|
|
|
de = de2;
|
|
|
|
}
|
2008-09-09 09:25:24 +07:00
|
|
|
dx_insert_block(frame, hash2 + continued, newblock);
|
2012-04-30 05:41:10 +07:00
|
|
|
err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
2012-04-30 05:39:10 +07:00
|
|
|
err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh2);
|
|
|
|
dxtrace(dx_show_index("frame", frame->entries));
|
2006-10-11 15:20:50 +07:00
|
|
|
return de;
|
2007-05-08 14:25:34 +07:00
|
|
|
|
|
|
|
journal_error:
|
|
|
|
brelse(*bh);
|
|
|
|
brelse(bh2);
|
|
|
|
*bh = NULL;
|
|
|
|
ext4_std_error(dir->i_sb, err);
|
2014-08-30 07:52:18 +07:00
|
|
|
return ERR_PTR(err);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2012-12-11 02:05:58 +07:00
|
|
|
int ext4_find_dest_de(struct inode *dir, struct inode *inode,
|
|
|
|
struct buffer_head *bh,
|
|
|
|
void *buf, int buf_size,
|
2015-05-19 00:14:47 +07:00
|
|
|
struct ext4_filename *fname,
|
2012-12-11 02:05:58 +07:00
|
|
|
struct ext4_dir_entry_2 **dest_de)
|
|
|
|
{
|
|
|
|
struct ext4_dir_entry_2 *de;
|
2015-05-19 00:14:47 +07:00
|
|
|
unsigned short reclen = EXT4_DIR_REC_LEN(fname_len(fname));
|
2012-12-11 02:05:58 +07:00
|
|
|
int nlen, rlen;
|
|
|
|
unsigned int offset = 0;
|
|
|
|
char *top;
|
2015-04-12 12:09:03 +07:00
|
|
|
int res;
|
|
|
|
|
2012-12-11 02:05:58 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *)buf;
|
|
|
|
top = buf + buf_size - reclen;
|
|
|
|
while ((char *) de <= top) {
|
|
|
|
if (ext4_check_dir_entry(dir, NULL, de, bh,
|
2015-04-12 12:09:03 +07:00
|
|
|
buf, buf_size, offset)) {
|
2015-10-18 03:16:04 +07:00
|
|
|
res = -EFSCORRUPTED;
|
2015-04-12 12:09:03 +07:00
|
|
|
goto return_result;
|
|
|
|
}
|
|
|
|
/* Provide crypto context and crypto buffer to ext4 match */
|
2015-05-19 00:14:47 +07:00
|
|
|
res = ext4_match(fname, de);
|
2015-04-12 12:09:03 +07:00
|
|
|
if (res < 0)
|
|
|
|
goto return_result;
|
|
|
|
if (res > 0) {
|
|
|
|
res = -EEXIST;
|
|
|
|
goto return_result;
|
|
|
|
}
|
2012-12-11 02:05:58 +07:00
|
|
|
nlen = EXT4_DIR_REC_LEN(de->name_len);
|
|
|
|
rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
|
|
|
|
if ((de->inode ? rlen - nlen : rlen) >= reclen)
|
|
|
|
break;
|
|
|
|
de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
|
|
|
|
offset += rlen;
|
|
|
|
}
|
|
|
|
|
2015-04-12 12:09:03 +07:00
|
|
|
if ((char *) de > top)
|
|
|
|
res = -ENOSPC;
|
|
|
|
else {
|
|
|
|
*dest_de = de;
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
return_result:
|
|
|
|
return res;
|
2012-12-11 02:05:58 +07:00
|
|
|
}
|
|
|
|
|
2015-04-12 11:56:28 +07:00
|
|
|
int ext4_insert_dentry(struct inode *dir,
|
|
|
|
struct inode *inode,
|
|
|
|
struct ext4_dir_entry_2 *de,
|
|
|
|
int buf_size,
|
2015-05-19 00:14:47 +07:00
|
|
|
struct ext4_filename *fname)
|
2012-12-11 02:05:58 +07:00
|
|
|
{
|
|
|
|
|
|
|
|
int nlen, rlen;
|
|
|
|
|
|
|
|
nlen = EXT4_DIR_REC_LEN(de->name_len);
|
|
|
|
rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
|
|
|
|
if (de->inode) {
|
|
|
|
struct ext4_dir_entry_2 *de1 =
|
2015-04-12 11:56:28 +07:00
|
|
|
(struct ext4_dir_entry_2 *)((char *)de + nlen);
|
2012-12-11 02:05:58 +07:00
|
|
|
de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
|
|
|
|
de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
|
|
|
|
de = de1;
|
|
|
|
}
|
|
|
|
de->file_type = EXT4_FT_UNKNOWN;
|
|
|
|
de->inode = cpu_to_le32(inode->i_ino);
|
|
|
|
ext4_set_de_type(inode->i_sb, de, inode->i_mode);
|
2015-05-19 00:14:47 +07:00
|
|
|
de->name_len = fname_len(fname);
|
|
|
|
memcpy(de->name, fname_name(fname), fname_len(fname));
|
2015-04-12 11:56:28 +07:00
|
|
|
return 0;
|
2012-12-11 02:05:58 +07:00
|
|
|
}
|
2015-04-12 11:56:28 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* Add a new entry into a directory (leaf) block. If de is non-NULL,
|
|
|
|
* it points to a directory entry which is guaranteed to be large
|
|
|
|
* enough for new directory entry. If de is NULL, then
|
|
|
|
* add_dirent_to_buf will attempt search the directory block for
|
|
|
|
* space. It will return -ENOSPC if no space is available, and -EIO
|
|
|
|
* and -EEXIST if directory entry already exists.
|
|
|
|
*/
|
2015-05-19 00:14:47 +07:00
|
|
|
static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
|
|
|
|
struct inode *dir,
|
2006-10-11 15:20:53 +07:00
|
|
|
struct inode *inode, struct ext4_dir_entry_2 *de,
|
2008-09-09 09:25:24 +07:00
|
|
|
struct buffer_head *bh)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2009-02-15 11:01:36 +07:00
|
|
|
unsigned int blocksize = dir->i_sb->s_blocksize;
|
2012-04-30 05:41:10 +07:00
|
|
|
int csum_size = 0;
|
2012-12-11 02:05:58 +07:00
|
|
|
int err;
|
2012-04-30 05:41:10 +07:00
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
csum_size = sizeof(struct ext4_dir_entry_tail);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
if (!de) {
|
2015-05-19 00:14:47 +07:00
|
|
|
err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
|
|
|
|
blocksize - csum_size, fname, &de);
|
2012-12-11 02:05:58 +07:00
|
|
|
if (err)
|
|
|
|
return err;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
BUFFER_TRACE(bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err) {
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_std_error(dir->i_sb, err);
|
2006-10-11 15:20:50 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-04-12 11:56:28 +07:00
|
|
|
/* By now the buffer is marked for journaling. Due to crypto operations,
|
|
|
|
* the following function call may fail */
|
2015-05-19 00:14:47 +07:00
|
|
|
err = ext4_insert_dentry(dir, inode, de, blocksize, fname);
|
2015-04-12 11:56:28 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2012-12-11 02:05:58 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* XXX shouldn't update any times until successful
|
|
|
|
* completion of syscall, but too many callers depend
|
|
|
|
* on this.
|
|
|
|
*
|
|
|
|
* XXX similarly, too many callers depend on
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_new_inode() setting the times, but error
|
2006-10-11 15:20:50 +07:00
|
|
|
* recovery deletes the inode, so the worst that can
|
|
|
|
* happen is that the times are slightly out of date
|
|
|
|
* and/or different from the directory change time.
|
|
|
|
*/
|
2007-07-18 20:15:20 +07:00
|
|
|
dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_update_dx_flag(dir);
|
2006-10-11 15:20:50 +07:00
|
|
|
dir->i_version++;
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_mark_inode_dirty(handle, dir);
|
2009-01-07 12:06:22 +07:00
|
|
|
BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
|
2012-04-30 05:41:10 +07:00
|
|
|
err = ext4_handle_dirty_dirent_node(handle, dir, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_std_error(dir->i_sb, err);
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This converts a one block unindexed directory to a 3 block indexed
|
|
|
|
* directory, and adds the dentry to the indexed directory.
|
|
|
|
*/
|
2015-05-19 00:14:47 +07:00
|
|
|
static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
|
2016-01-09 04:00:31 +07:00
|
|
|
struct inode *dir,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct inode *inode, struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh2;
|
|
|
|
struct dx_root *root;
|
|
|
|
struct dx_frame frames[2], *frame;
|
|
|
|
struct dx_entry *entries;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *de, *de2;
|
2012-04-30 05:41:10 +07:00
|
|
|
struct ext4_dir_entry_tail *t;
|
2006-10-11 15:20:50 +07:00
|
|
|
char *data1, *top;
|
|
|
|
unsigned len;
|
|
|
|
int retval;
|
|
|
|
unsigned blocksize;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t block;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct fake_dirent *fde;
|
2015-04-12 11:56:28 +07:00
|
|
|
int csum_size = 0;
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
csum_size = sizeof(struct ext4_dir_entry_tail);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
blocksize = dir->i_sb->s_blocksize;
|
2009-01-16 23:13:40 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
|
2014-05-13 09:06:43 +07:00
|
|
|
BUFFER_TRACE(bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
retval = ext4_journal_get_write_access(handle, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (retval) {
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_std_error(dir->i_sb, retval);
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(bh);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
root = (struct dx_root *) bh->b_data;
|
|
|
|
|
2009-01-16 23:13:40 +07:00
|
|
|
/* The 0th block becomes the root, move the dirents out */
|
|
|
|
fde = &root->dotdot;
|
|
|
|
de = (struct ext4_dir_entry_2 *)((char *)fde +
|
2009-02-15 11:01:36 +07:00
|
|
|
ext4_rec_len_from_disk(fde->rec_len, blocksize));
|
2009-01-16 23:13:40 +07:00
|
|
|
if ((char *) de >= (((char *) root) + blocksize)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
|
2009-01-16 23:13:40 +07:00
|
|
|
brelse(bh);
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2009-01-16 23:13:40 +07:00
|
|
|
}
|
2012-04-30 05:41:10 +07:00
|
|
|
len = ((char *) root) + (blocksize - csum_size) - (char *) de;
|
2009-01-16 23:13:40 +07:00
|
|
|
|
|
|
|
/* Allocate new block for the 0th block's dirents */
|
2013-02-15 15:35:57 +07:00
|
|
|
bh2 = ext4_append(handle, dir, &block);
|
|
|
|
if (IS_ERR(bh2)) {
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(bh);
|
2013-02-15 15:35:57 +07:00
|
|
|
return PTR_ERR(bh2);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2010-05-17 09:00:00 +07:00
|
|
|
ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
|
2006-10-11 15:20:50 +07:00
|
|
|
data1 = bh2->b_data;
|
|
|
|
|
|
|
|
memcpy (data1, de, len);
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) data1;
|
2006-10-11 15:20:50 +07:00
|
|
|
top = data1 + len;
|
2009-02-15 11:01:36 +07:00
|
|
|
while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
|
2006-10-11 15:20:50 +07:00
|
|
|
de = de2;
|
2012-04-30 05:41:10 +07:00
|
|
|
de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
|
|
|
|
(char *) de,
|
2009-02-15 11:01:36 +07:00
|
|
|
blocksize);
|
2012-04-30 05:41:10 +07:00
|
|
|
|
|
|
|
if (csum_size) {
|
|
|
|
t = EXT4_DIRENT_TAIL(data1, blocksize);
|
|
|
|
initialize_dirent_tail(t, blocksize);
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/* Initialize the root; the dot dirents already exist */
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) (&root->dotdot);
|
2009-02-15 11:01:36 +07:00
|
|
|
de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
|
|
|
|
blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
memset (&root->info, 0, sizeof(root->info));
|
|
|
|
root->info.info_length = sizeof(root->info);
|
2006-10-11 15:20:53 +07:00
|
|
|
root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
|
2006-10-11 15:20:50 +07:00
|
|
|
entries = root->entries;
|
2008-09-09 09:25:24 +07:00
|
|
|
dx_set_block(entries, 1);
|
|
|
|
dx_set_count(entries, 1);
|
|
|
|
dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Initialize as for dx_probe */
|
2015-05-19 00:14:47 +07:00
|
|
|
fname->hinfo.hash_version = root->info.hash_version;
|
|
|
|
if (fname->hinfo.hash_version <= DX_HASH_TEA)
|
|
|
|
fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
|
|
|
|
fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
|
|
|
|
ext4fs_dirhash(fname_name(fname), fname_len(fname), &fname->hinfo);
|
|
|
|
|
2014-10-30 21:53:17 +07:00
|
|
|
memset(frames, 0, sizeof(frames));
|
2006-10-11 15:20:50 +07:00
|
|
|
frame = frames;
|
|
|
|
frame->entries = entries;
|
|
|
|
frame->at = entries;
|
|
|
|
frame->bh = bh;
|
2011-05-15 11:19:41 +07:00
|
|
|
|
2014-10-30 21:53:17 +07:00
|
|
|
retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
|
|
|
|
if (retval)
|
|
|
|
goto out_frames;
|
2016-09-30 12:33:37 +07:00
|
|
|
retval = ext4_handle_dirty_dirent_node(handle, dir, bh2);
|
2014-10-30 21:53:17 +07:00
|
|
|
if (retval)
|
|
|
|
goto out_frames;
|
2011-05-15 11:19:41 +07:00
|
|
|
|
2016-09-30 12:33:37 +07:00
|
|
|
de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
|
2014-08-30 07:52:18 +07:00
|
|
|
if (IS_ERR(de)) {
|
2014-10-30 21:53:17 +07:00
|
|
|
retval = PTR_ERR(de);
|
|
|
|
goto out_frames;
|
2011-05-03 22:05:55 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2016-09-30 12:33:37 +07:00
|
|
|
retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
|
2014-10-30 21:53:17 +07:00
|
|
|
out_frames:
|
|
|
|
/*
|
|
|
|
* Even if the block split failed, we have to properly write
|
|
|
|
* out all the changes we did so far. Otherwise we can end up
|
|
|
|
* with corrupted filesystem.
|
|
|
|
*/
|
2016-09-30 12:33:37 +07:00
|
|
|
if (retval)
|
|
|
|
ext4_mark_inode_dirty(handle, dir);
|
2014-10-30 21:53:17 +07:00
|
|
|
dx_release(frames);
|
2016-09-30 12:33:37 +07:00
|
|
|
brelse(bh2);
|
2014-10-30 21:53:17 +07:00
|
|
|
return retval;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_add_entry()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* adds a file entry to the specified directory, using the same
|
2006-10-11 15:20:53 +07:00
|
|
|
* semantics as ext4_find_entry(). It returns NULL if it failed.
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* NOTE!! The inode part of 'de' is left at 0 - which means you
|
|
|
|
* may not sleep between calling this and putting something into
|
|
|
|
* the entry, as someone else might have used it while you slept.
|
|
|
|
*/
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
|
|
|
|
struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2015-03-18 05:25:59 +07:00
|
|
|
struct inode *dir = d_inode(dentry->d_parent);
|
2015-04-03 21:46:58 +07:00
|
|
|
struct buffer_head *bh = NULL;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *de;
|
2012-04-30 05:41:10 +07:00
|
|
|
struct ext4_dir_entry_tail *t;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct super_block *sb;
|
2015-05-19 00:14:47 +07:00
|
|
|
struct ext4_filename fname;
|
2006-10-11 15:20:50 +07:00
|
|
|
int retval;
|
|
|
|
int dx_fallback=0;
|
|
|
|
unsigned blocksize;
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t block, blocks;
|
2012-04-30 05:41:10 +07:00
|
|
|
int csum_size = 0;
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
csum_size = sizeof(struct ext4_dir_entry_tail);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
sb = dir->i_sb;
|
|
|
|
blocksize = sb->s_blocksize;
|
|
|
|
if (!dentry->d_name.len)
|
|
|
|
return -EINVAL;
|
2012-12-11 02:05:59 +07:00
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
2012-12-11 02:05:59 +07:00
|
|
|
if (ext4_has_inline_data(dir)) {
|
2016-01-09 04:00:31 +07:00
|
|
|
retval = ext4_try_add_inline_entry(handle, &fname, dir, inode);
|
2012-12-11 02:05:59 +07:00
|
|
|
if (retval < 0)
|
2015-05-19 00:14:47 +07:00
|
|
|
goto out;
|
2012-12-11 02:05:59 +07:00
|
|
|
if (retval == 1) {
|
|
|
|
retval = 0;
|
2015-04-03 21:46:58 +07:00
|
|
|
goto out;
|
2012-12-11 02:05:59 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
if (is_dx(dir)) {
|
2016-01-09 04:00:31 +07:00
|
|
|
retval = ext4_dx_add_entry(handle, &fname, dir, inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!retval || (retval != ERR_BAD_DX_DIR))
|
2015-04-03 21:46:58 +07:00
|
|
|
goto out;
|
2010-05-17 09:00:00 +07:00
|
|
|
ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
|
2006-10-11 15:20:50 +07:00
|
|
|
dx_fallback++;
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_mark_inode_dirty(handle, dir);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
blocks = dir->i_size >> sb->s_blocksize_bits;
|
2008-11-05 12:14:04 +07:00
|
|
|
for (block = 0; block < blocks; block++) {
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(dir, block, DIRENT);
|
2015-05-19 00:14:47 +07:00
|
|
|
if (IS_ERR(bh)) {
|
|
|
|
retval = PTR_ERR(bh);
|
|
|
|
bh = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
retval = add_dirent_to_buf(handle, &fname, dir, inode,
|
|
|
|
NULL, bh);
|
2015-04-03 21:46:58 +07:00
|
|
|
if (retval != -ENOSPC)
|
|
|
|
goto out;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
if (blocks == 1 && !dx_fallback &&
|
2015-10-18 03:18:43 +07:00
|
|
|
ext4_has_feature_dir_index(sb)) {
|
2016-01-09 04:00:31 +07:00
|
|
|
retval = make_indexed_dir(handle, &fname, dir,
|
2015-05-19 00:14:47 +07:00
|
|
|
inode, bh);
|
2015-04-03 21:46:58 +07:00
|
|
|
bh = NULL; /* make_indexed_dir releases bh */
|
|
|
|
goto out;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(bh);
|
|
|
|
}
|
2013-02-15 15:35:57 +07:00
|
|
|
bh = ext4_append(handle, dir, &block);
|
2015-05-19 00:14:47 +07:00
|
|
|
if (IS_ERR(bh)) {
|
|
|
|
retval = PTR_ERR(bh);
|
|
|
|
bh = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
2006-10-11 15:20:50 +07:00
|
|
|
de->inode = 0;
|
2012-04-30 05:41:10 +07:00
|
|
|
de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize);
|
|
|
|
|
|
|
|
if (csum_size) {
|
|
|
|
t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
|
|
|
|
initialize_dirent_tail(t, blocksize);
|
|
|
|
}
|
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
|
2015-04-03 21:46:58 +07:00
|
|
|
out:
|
2015-05-19 00:14:47 +07:00
|
|
|
ext4_fname_free_filename(&fname);
|
2009-11-23 19:25:49 +07:00
|
|
|
brelse(bh);
|
2010-05-17 19:00:00 +07:00
|
|
|
if (retval == 0)
|
|
|
|
ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
|
2009-11-23 19:25:49 +07:00
|
|
|
return retval;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns 0 for success, or a negative error value
|
|
|
|
*/
|
2015-05-19 00:14:47 +07:00
|
|
|
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
|
2016-01-09 04:00:31 +07:00
|
|
|
struct inode *dir, struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct dx_frame frames[2], *frame;
|
|
|
|
struct dx_entry *entries, *at;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct super_block *sb = dir->i_sb;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_dir_entry_2 *de;
|
2006-10-11 15:20:50 +07:00
|
|
|
int err;
|
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
frame = dx_probe(fname, dir, NULL, frames);
|
2014-08-30 07:52:17 +07:00
|
|
|
if (IS_ERR(frame))
|
|
|
|
return PTR_ERR(frame);
|
2006-10-11 15:20:50 +07:00
|
|
|
entries = frame->entries;
|
|
|
|
at = frame->at;
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
|
|
|
|
if (IS_ERR(bh)) {
|
|
|
|
err = PTR_ERR(bh);
|
|
|
|
bh = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2012-09-27 20:31:33 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
BUFFER_TRACE(bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
|
2015-05-19 00:14:47 +07:00
|
|
|
err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
|
2009-11-23 19:25:49 +07:00
|
|
|
if (err != -ENOSPC)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/* Block full, should compress but for now just split */
|
2008-09-09 10:00:52 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
|
2006-10-11 15:20:50 +07:00
|
|
|
dx_get_count(entries), dx_get_limit(entries)));
|
|
|
|
/* Need to split index? */
|
|
|
|
if (dx_get_count(entries) == dx_get_limit(entries)) {
|
2008-01-29 11:58:27 +07:00
|
|
|
ext4_lblk_t newblock;
|
2006-10-11 15:20:50 +07:00
|
|
|
unsigned icount = dx_get_count(entries);
|
|
|
|
int levels = frame - frames;
|
|
|
|
struct dx_entry *entries2;
|
|
|
|
struct dx_node *node2;
|
|
|
|
struct buffer_head *bh2;
|
|
|
|
|
|
|
|
if (levels && (dx_get_count(frames->entries) ==
|
|
|
|
dx_get_limit(frames->entries))) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(dir, "Directory index full!");
|
2006-10-11 15:20:50 +07:00
|
|
|
err = -ENOSPC;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2013-02-15 15:35:57 +07:00
|
|
|
bh2 = ext4_append(handle, dir, &newblock);
|
|
|
|
if (IS_ERR(bh2)) {
|
|
|
|
err = PTR_ERR(bh2);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2013-02-15 15:35:57 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
node2 = (struct dx_node *)(bh2->b_data);
|
|
|
|
entries2 = node2->entries;
|
2009-09-11 10:16:07 +07:00
|
|
|
memset(&node2->fake, 0, sizeof(struct fake_dirent));
|
2009-02-15 11:01:36 +07:00
|
|
|
node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
|
|
|
|
sb->s_blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
BUFFER_TRACE(frame->bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, frame->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
if (levels) {
|
|
|
|
unsigned icount1 = icount/2, icount2 = icount - icount1;
|
|
|
|
unsigned hash2 = dx_get_hash(entries + icount1);
|
2008-09-09 10:00:52 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
|
|
|
|
icount1, icount2));
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle,
|
2006-10-11 15:20:50 +07:00
|
|
|
frames[0].bh);
|
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
memcpy((char *) entries2, (char *) (entries + icount1),
|
|
|
|
icount2 * sizeof(struct dx_entry));
|
|
|
|
dx_set_count(entries, icount1);
|
|
|
|
dx_set_count(entries2, icount2);
|
|
|
|
dx_set_limit(entries2, dx_node_limit(dir));
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Which index block gets the new entry? */
|
|
|
|
if (at - entries >= icount1) {
|
|
|
|
frame->at = at = at - entries - icount1 + entries2;
|
|
|
|
frame->entries = entries = entries2;
|
|
|
|
swap(frame->bh, bh2);
|
|
|
|
}
|
2008-09-09 09:25:24 +07:00
|
|
|
dx_insert_block(frames + 0, hash2, newblock);
|
|
|
|
dxtrace(dx_show_index("node", frames[1].entries));
|
|
|
|
dxtrace(dx_show_index("node",
|
2006-10-11 15:20:50 +07:00
|
|
|
((struct dx_node *) bh2->b_data)->entries));
|
2012-04-30 05:39:10 +07:00
|
|
|
err = ext4_handle_dirty_dx_node(handle, dir, bh2);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
brelse (bh2);
|
|
|
|
} else {
|
2008-09-09 10:00:52 +07:00
|
|
|
dxtrace(printk(KERN_DEBUG
|
|
|
|
"Creating second level index...\n"));
|
2006-10-11 15:20:50 +07:00
|
|
|
memcpy((char *) entries2, (char *) entries,
|
|
|
|
icount * sizeof(struct dx_entry));
|
|
|
|
dx_set_limit(entries2, dx_node_limit(dir));
|
|
|
|
|
|
|
|
/* Set up root */
|
|
|
|
dx_set_count(entries, 1);
|
|
|
|
dx_set_block(entries + 0, newblock);
|
|
|
|
((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels = 1;
|
|
|
|
|
|
|
|
/* Add new access path frame */
|
|
|
|
frame = frames + 1;
|
|
|
|
frame->at = at = at - entries + entries2;
|
|
|
|
frame->entries = entries = entries2;
|
|
|
|
frame->bh = bh2;
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle,
|
2006-10-11 15:20:50 +07:00
|
|
|
frame->bh);
|
|
|
|
if (err)
|
|
|
|
goto journal_error;
|
|
|
|
}
|
2012-04-30 05:39:10 +07:00
|
|
|
err = ext4_handle_dirty_dx_node(handle, dir, frames[0].bh);
|
2011-01-11 00:46:59 +07:00
|
|
|
if (err) {
|
|
|
|
ext4_std_error(inode->i_sb, err);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2015-05-19 00:14:47 +07:00
|
|
|
de = do_split(handle, dir, &bh, frame, &fname->hinfo);
|
2014-08-30 07:52:18 +07:00
|
|
|
if (IS_ERR(de)) {
|
|
|
|
err = PTR_ERR(de);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2014-08-30 07:52:18 +07:00
|
|
|
}
|
2015-05-19 00:14:47 +07:00
|
|
|
err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
journal_error:
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_std_error(dir->i_sb, err);
|
2006-10-11 15:20:50 +07:00
|
|
|
cleanup:
|
2013-01-29 09:41:02 +07:00
|
|
|
brelse(bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
dx_release(frames);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-12-11 02:06:00 +07:00
|
|
|
* ext4_generic_delete_entry deletes a directory entry by merging it
|
|
|
|
* with the previous entry
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
2012-12-11 02:06:00 +07:00
|
|
|
int ext4_generic_delete_entry(handle_t *handle,
|
|
|
|
struct inode *dir,
|
|
|
|
struct ext4_dir_entry_2 *de_del,
|
|
|
|
struct buffer_head *bh,
|
|
|
|
void *entry_buf,
|
|
|
|
int buf_size,
|
|
|
|
int csum_size)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2008-09-09 09:25:24 +07:00
|
|
|
struct ext4_dir_entry_2 *de, *pde;
|
2009-02-15 11:01:36 +07:00
|
|
|
unsigned int blocksize = dir->i_sb->s_blocksize;
|
2012-12-11 02:06:00 +07:00
|
|
|
int i;
|
2012-04-30 05:41:10 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
i = 0;
|
|
|
|
pde = NULL;
|
2012-12-11 02:06:00 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *)entry_buf;
|
|
|
|
while (i < buf_size - csum_size) {
|
2012-12-11 02:05:58 +07:00
|
|
|
if (ext4_check_dir_entry(dir, NULL, de, bh,
|
|
|
|
bh->b_data, bh->b_size, i))
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (de == de_del) {
|
|
|
|
if (pde)
|
2008-01-29 11:58:27 +07:00
|
|
|
pde->rec_len = ext4_rec_len_to_disk(
|
2009-02-15 11:01:36 +07:00
|
|
|
ext4_rec_len_from_disk(pde->rec_len,
|
|
|
|
blocksize) +
|
|
|
|
ext4_rec_len_from_disk(de->rec_len,
|
|
|
|
blocksize),
|
|
|
|
blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
else
|
|
|
|
de->inode = 0;
|
|
|
|
dir->i_version++;
|
|
|
|
return 0;
|
|
|
|
}
|
2009-02-15 11:01:36 +07:00
|
|
|
i += ext4_rec_len_from_disk(de->rec_len, blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
pde = de;
|
2009-02-15 11:01:36 +07:00
|
|
|
de = ext4_next_entry(de, blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2012-12-11 02:06:00 +07:00
|
|
|
static int ext4_delete_entry(handle_t *handle,
|
|
|
|
struct inode *dir,
|
|
|
|
struct ext4_dir_entry_2 *de_del,
|
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
int err, csum_size = 0;
|
|
|
|
|
2012-12-11 02:06:00 +07:00
|
|
|
if (ext4_has_inline_data(dir)) {
|
|
|
|
int has_inline_data = 1;
|
|
|
|
err = ext4_delete_inline_entry(handle, dir, de_del, bh,
|
|
|
|
&has_inline_data);
|
|
|
|
if (has_inline_data)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(dir->i_sb))
|
2012-12-11 02:06:00 +07:00
|
|
|
csum_size = sizeof(struct ext4_dir_entry_tail);
|
|
|
|
|
|
|
|
BUFFER_TRACE(bh, "get_write_access");
|
|
|
|
err = ext4_journal_get_write_access(handle, bh);
|
|
|
|
if (unlikely(err))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = ext4_generic_delete_entry(handle, dir, de_del,
|
|
|
|
bh, bh->b_data,
|
|
|
|
dir->i_sb->s_blocksize, csum_size);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
|
|
|
|
err = ext4_handle_dirty_dirent_node(handle, dir, bh);
|
|
|
|
if (unlikely(err))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
out:
|
|
|
|
if (err != -ENOENT)
|
|
|
|
ext4_std_error(dir->i_sb, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-07-18 19:38:01 +07:00
|
|
|
/*
|
|
|
|
* DIR_NLINK feature is set if 1) nlinks > EXT4_LINK_MAX or 2) nlinks == 2,
|
|
|
|
* since this indicates that nlinks count was previously 1.
|
|
|
|
*/
|
|
|
|
static void ext4_inc_count(handle_t *handle, struct inode *inode)
|
|
|
|
{
|
|
|
|
inc_nlink(inode);
|
|
|
|
if (is_dx(inode) && inode->i_nlink > 1) {
|
|
|
|
/* limit is 16-bit i_links_count */
|
|
|
|
if (inode->i_nlink >= EXT4_LINK_MAX || inode->i_nlink == 2) {
|
2011-10-28 19:13:29 +07:00
|
|
|
set_nlink(inode, 1);
|
2015-10-18 03:18:43 +07:00
|
|
|
ext4_set_feature_dir_nlink(inode->i_sb);
|
2007-07-18 19:38:01 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a directory had nlink == 1, then we should let it be 1. This indicates
|
|
|
|
* directory has >EXT4_LINK_MAX subdirs.
|
|
|
|
*/
|
|
|
|
static void ext4_dec_count(handle_t *handle, struct inode *inode)
|
|
|
|
{
|
2011-10-26 14:22:31 +07:00
|
|
|
if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
|
|
|
|
drop_nlink(inode);
|
2007-07-18 19:38:01 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
static int ext4_add_nondir(handle_t *handle,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct dentry *dentry, struct inode *inode)
|
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
int err = ext4_add_entry(handle, dentry, inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!err) {
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_mark_inode_dirty(handle, inode);
|
2008-12-30 14:03:31 +07:00
|
|
|
unlock_new_inode(inode);
|
2012-07-19 12:18:15 +07:00
|
|
|
d_instantiate(dentry, inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2007-02-10 16:46:16 +07:00
|
|
|
drop_nlink(inode);
|
2008-12-30 14:03:31 +07:00
|
|
|
unlock_new_inode(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
iput(inode);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* By the time this is called, we already have created
|
|
|
|
* the directory cache entry for the new file, but it
|
|
|
|
* is so far negative - it has no inode.
|
|
|
|
*
|
|
|
|
* If the create succeeds, we fill in the inode information
|
|
|
|
* with d_instantiate().
|
|
|
|
*/
|
2011-07-26 12:42:34 +07:00
|
|
|
static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
|
2012-06-11 05:05:36 +07:00
|
|
|
bool excl)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
handle_t *handle;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct inode *inode;
|
2013-02-10 04:27:09 +07:00
|
|
|
int err, credits, retries = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
err = dquot_initialize(dir);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2013-02-10 04:27:09 +07:00
|
|
|
credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
|
2013-04-20 00:38:14 +07:00
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
|
2006-10-11 15:20:50 +07:00
|
|
|
retry:
|
2013-02-10 04:27:09 +07:00
|
|
|
inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
|
|
|
|
NULL, EXT4_HT_DIR, credits);
|
|
|
|
handle = ext4_journal_current_handle();
|
2006-10-11 15:20:50 +07:00
|
|
|
err = PTR_ERR(inode);
|
|
|
|
if (!IS_ERR(inode)) {
|
2006-10-11 15:20:53 +07:00
|
|
|
inode->i_op = &ext4_file_inode_operations;
|
2015-04-16 06:15:17 +07:00
|
|
|
inode->i_fop = &ext4_file_operations;
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_set_aops(inode);
|
2015-06-01 00:35:02 +07:00
|
|
|
err = ext4_add_nondir(handle, dentry, inode);
|
2013-02-10 04:27:09 +07:00
|
|
|
if (!err && IS_DIRSYNC(dir))
|
|
|
|
ext4_handle_sync(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2013-02-10 04:27:09 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2006-10-11 15:20:53 +07:00
|
|
|
if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto retry;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_mknod(struct inode *dir, struct dentry *dentry,
|
2011-07-26 12:52:52 +07:00
|
|
|
umode_t mode, dev_t rdev)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
handle_t *handle;
|
|
|
|
struct inode *inode;
|
2013-02-10 04:27:09 +07:00
|
|
|
int err, credits, retries = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
err = dquot_initialize(dir);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2013-02-10 04:27:09 +07:00
|
|
|
credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
|
2013-04-20 00:38:14 +07:00
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
|
2006-10-11 15:20:50 +07:00
|
|
|
retry:
|
2013-02-10 04:27:09 +07:00
|
|
|
inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
|
|
|
|
NULL, EXT4_HT_DIR, credits);
|
|
|
|
handle = ext4_journal_current_handle();
|
2006-10-11 15:20:50 +07:00
|
|
|
err = PTR_ERR(inode);
|
|
|
|
if (!IS_ERR(inode)) {
|
|
|
|
init_special_inode(inode, inode->i_mode, rdev);
|
2006-10-11 15:20:53 +07:00
|
|
|
inode->i_op = &ext4_special_inode_operations;
|
|
|
|
err = ext4_add_nondir(handle, dentry, inode);
|
2013-02-10 04:27:09 +07:00
|
|
|
if (!err && IS_DIRSYNC(dir))
|
|
|
|
ext4_handle_sync(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2013-02-10 04:27:09 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2006-10-11 15:20:53 +07:00
|
|
|
if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto retry;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-06-29 16:23:08 +07:00
|
|
|
static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
|
|
|
|
{
|
|
|
|
handle_t *handle;
|
|
|
|
struct inode *inode;
|
|
|
|
int err, retries = 0;
|
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
err = dquot_initialize(dir);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2013-06-29 16:23:08 +07:00
|
|
|
|
|
|
|
retry:
|
|
|
|
inode = ext4_new_inode_start_handle(dir, mode,
|
|
|
|
NULL, 0, NULL,
|
|
|
|
EXT4_HT_DIR,
|
|
|
|
EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
|
|
|
|
4 + EXT4_XATTR_TRANS_BLOCKS);
|
|
|
|
handle = ext4_journal_current_handle();
|
|
|
|
err = PTR_ERR(inode);
|
|
|
|
if (!IS_ERR(inode)) {
|
|
|
|
inode->i_op = &ext4_file_inode_operations;
|
2015-04-16 06:15:17 +07:00
|
|
|
inode->i_fop = &ext4_file_operations;
|
2013-06-29 16:23:08 +07:00
|
|
|
ext4_set_aops(inode);
|
2013-07-21 08:58:38 +07:00
|
|
|
d_tmpfile(dentry, inode);
|
2013-06-29 16:23:08 +07:00
|
|
|
err = ext4_orphan_add(handle, inode);
|
|
|
|
if (err)
|
2013-10-10 21:48:19 +07:00
|
|
|
goto err_unlock_inode;
|
2013-06-29 16:23:08 +07:00
|
|
|
mark_inode_dirty(inode);
|
|
|
|
unlock_new_inode(inode);
|
|
|
|
}
|
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
|
|
|
if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
|
|
|
|
goto retry;
|
|
|
|
return err;
|
2013-10-10 21:48:19 +07:00
|
|
|
err_unlock_inode:
|
2013-06-29 16:23:08 +07:00
|
|
|
ext4_journal_stop(handle);
|
|
|
|
unlock_new_inode(inode);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-11 02:05:57 +07:00
|
|
|
struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
|
|
|
|
struct ext4_dir_entry_2 *de,
|
|
|
|
int blocksize, int csum_size,
|
|
|
|
unsigned int parent_ino, int dotdot_real_len)
|
|
|
|
{
|
|
|
|
de->inode = cpu_to_le32(inode->i_ino);
|
|
|
|
de->name_len = 1;
|
|
|
|
de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len),
|
|
|
|
blocksize);
|
|
|
|
strcpy(de->name, ".");
|
|
|
|
ext4_set_de_type(inode->i_sb, de, S_IFDIR);
|
|
|
|
|
|
|
|
de = ext4_next_entry(de, blocksize);
|
|
|
|
de->inode = cpu_to_le32(parent_ino);
|
|
|
|
de->name_len = 2;
|
|
|
|
if (!dotdot_real_len)
|
|
|
|
de->rec_len = ext4_rec_len_to_disk(blocksize -
|
|
|
|
(csum_size + EXT4_DIR_REC_LEN(1)),
|
|
|
|
blocksize);
|
|
|
|
else
|
|
|
|
de->rec_len = ext4_rec_len_to_disk(
|
|
|
|
EXT4_DIR_REC_LEN(de->name_len), blocksize);
|
|
|
|
strcpy(de->name, "..");
|
|
|
|
ext4_set_de_type(inode->i_sb, de, S_IFDIR);
|
|
|
|
|
|
|
|
return ext4_next_entry(de, blocksize);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_init_new_dir(handle_t *handle, struct inode *dir,
|
|
|
|
struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2011-01-11 00:11:16 +07:00
|
|
|
struct buffer_head *dir_block = NULL;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct ext4_dir_entry_2 *de;
|
2012-04-30 05:41:10 +07:00
|
|
|
struct ext4_dir_entry_tail *t;
|
2013-02-15 11:59:26 +07:00
|
|
|
ext4_lblk_t block = 0;
|
2009-02-15 11:01:36 +07:00
|
|
|
unsigned int blocksize = dir->i_sb->s_blocksize;
|
2012-04-30 05:41:10 +07:00
|
|
|
int csum_size = 0;
|
2012-12-11 02:05:57 +07:00
|
|
|
int err;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(dir->i_sb))
|
2012-04-30 05:41:10 +07:00
|
|
|
csum_size = sizeof(struct ext4_dir_entry_tail);
|
|
|
|
|
2012-12-11 02:05:59 +07:00
|
|
|
if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
|
|
|
|
err = ext4_try_create_inline_dir(handle, dir, inode);
|
|
|
|
if (err < 0 && err != -ENOSPC)
|
|
|
|
goto out;
|
|
|
|
if (!err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-02-15 11:59:26 +07:00
|
|
|
inode->i_size = 0;
|
2013-02-15 15:35:57 +07:00
|
|
|
dir_block = ext4_append(handle, inode, &block);
|
|
|
|
if (IS_ERR(dir_block))
|
|
|
|
return PTR_ERR(dir_block);
|
2012-12-11 02:05:57 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *)dir_block->b_data;
|
|
|
|
ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
|
|
|
|
set_nlink(inode, 2);
|
|
|
|
if (csum_size) {
|
|
|
|
t = EXT4_DIRENT_TAIL(dir_block->b_data, blocksize);
|
|
|
|
initialize_dirent_tail(t, blocksize);
|
|
|
|
}
|
|
|
|
|
|
|
|
BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
|
|
|
|
err = ext4_handle_dirty_dirent_node(handle, inode, dir_block);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
set_buffer_verified(dir_block);
|
|
|
|
out:
|
|
|
|
brelse(dir_block);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
|
|
|
{
|
|
|
|
handle_t *handle;
|
|
|
|
struct inode *inode;
|
2013-02-10 04:27:09 +07:00
|
|
|
int err, credits, retries = 0;
|
2012-12-11 02:05:57 +07:00
|
|
|
|
2007-07-18 19:38:01 +07:00
|
|
|
if (EXT4_DIR_LINK_MAX(dir))
|
2006-10-11 15:20:50 +07:00
|
|
|
return -EMLINK;
|
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
err = dquot_initialize(dir);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2013-02-10 04:27:09 +07:00
|
|
|
credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
|
2013-04-20 00:38:14 +07:00
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
|
2006-10-11 15:20:50 +07:00
|
|
|
retry:
|
2013-02-10 04:27:09 +07:00
|
|
|
inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
|
|
|
|
&dentry->d_name,
|
|
|
|
0, NULL, EXT4_HT_DIR, credits);
|
|
|
|
handle = ext4_journal_current_handle();
|
2006-10-11 15:20:50 +07:00
|
|
|
err = PTR_ERR(inode);
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
goto out_stop;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
inode->i_op = &ext4_dir_inode_operations;
|
|
|
|
inode->i_fop = &ext4_dir_operations;
|
2012-12-11 02:05:57 +07:00
|
|
|
err = ext4_init_new_dir(handle, dir, inode);
|
2011-01-11 00:11:16 +07:00
|
|
|
if (err)
|
|
|
|
goto out_clear_inode;
|
|
|
|
err = ext4_mark_inode_dirty(handle, inode);
|
|
|
|
if (!err)
|
|
|
|
err = ext4_add_entry(handle, dentry, inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err) {
|
2008-02-22 18:17:31 +07:00
|
|
|
out_clear_inode:
|
|
|
|
clear_nlink(inode);
|
2008-12-30 14:03:31 +07:00
|
|
|
unlock_new_inode(inode);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_mark_inode_dirty(handle, inode);
|
2008-09-09 09:25:24 +07:00
|
|
|
iput(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto out_stop;
|
|
|
|
}
|
2007-07-18 19:38:01 +07:00
|
|
|
ext4_inc_count(handle, dir);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_update_dx_flag(dir);
|
2011-01-11 00:11:16 +07:00
|
|
|
err = ext4_mark_inode_dirty(handle, dir);
|
|
|
|
if (err)
|
|
|
|
goto out_clear_inode;
|
2008-12-30 14:03:31 +07:00
|
|
|
unlock_new_inode(inode);
|
2012-07-19 12:18:15 +07:00
|
|
|
d_instantiate(dentry, inode);
|
2013-02-10 04:27:09 +07:00
|
|
|
if (IS_DIRSYNC(dir))
|
|
|
|
ext4_handle_sync(handle);
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
out_stop:
|
2013-02-10 04:27:09 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2006-10-11 15:20:53 +07:00
|
|
|
if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto retry;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* routine to check that the specified directory is empty (for rmdir)
|
|
|
|
*/
|
2016-07-11 01:01:03 +07:00
|
|
|
bool ext4_empty_dir(struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2008-11-05 12:14:04 +07:00
|
|
|
unsigned int offset;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct ext4_dir_entry_2 *de, *de1;
|
|
|
|
struct super_block *sb;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2012-12-11 02:06:01 +07:00
|
|
|
if (ext4_has_inline_data(inode)) {
|
|
|
|
int has_inline_data = 1;
|
2016-07-11 01:01:03 +07:00
|
|
|
int ret;
|
2012-12-11 02:06:01 +07:00
|
|
|
|
2016-07-11 01:01:03 +07:00
|
|
|
ret = empty_inline_dir(inode, &has_inline_data);
|
2012-12-11 02:06:01 +07:00
|
|
|
if (has_inline_data)
|
2016-07-11 01:01:03 +07:00
|
|
|
return ret;
|
2012-12-11 02:06:01 +07:00
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
sb = inode->i_sb;
|
2013-02-15 11:59:26 +07:00
|
|
|
if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
|
|
|
|
EXT4_ERROR_INODE(inode, "invalid size");
|
2016-07-11 01:01:03 +07:00
|
|
|
return true;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(inode, 0, EITHER);
|
|
|
|
if (IS_ERR(bh))
|
2016-07-11 01:01:03 +07:00
|
|
|
return true;
|
2013-02-15 11:59:26 +07:00
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
2009-02-15 11:01:36 +07:00
|
|
|
de1 = ext4_next_entry(de, sb->s_blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (le32_to_cpu(de->inode) != inode->i_ino ||
|
2015-06-16 01:50:26 +07:00
|
|
|
le32_to_cpu(de1->inode) == 0 ||
|
|
|
|
strcmp(".", de->name) || strcmp("..", de1->name)) {
|
|
|
|
ext4_warning_inode(inode, "directory missing '.' and/or '..'");
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2016-07-11 01:01:03 +07:00
|
|
|
return true;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2009-02-15 11:01:36 +07:00
|
|
|
offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) +
|
|
|
|
ext4_rec_len_from_disk(de1->rec_len, sb->s_blocksize);
|
|
|
|
de = ext4_next_entry(de1, sb->s_blocksize);
|
2008-09-09 09:25:24 +07:00
|
|
|
while (offset < inode->i_size) {
|
2014-04-22 01:38:14 +07:00
|
|
|
if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
unsigned int lblock;
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2010-05-17 08:00:00 +07:00
|
|
|
lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(inode, lblock, EITHER);
|
|
|
|
if (IS_ERR(bh))
|
2016-07-11 01:01:03 +07:00
|
|
|
return true;
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2012-12-11 02:05:58 +07:00
|
|
|
if (ext4_check_dir_entry(inode, NULL, de, bh,
|
|
|
|
bh->b_data, bh->b_size, offset)) {
|
2006-10-11 15:20:53 +07:00
|
|
|
de = (struct ext4_dir_entry_2 *)(bh->b_data +
|
2006-10-11 15:20:50 +07:00
|
|
|
sb->s_blocksize);
|
|
|
|
offset = (offset | (sb->s_blocksize - 1)) + 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (le32_to_cpu(de->inode)) {
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2016-07-11 01:01:03 +07:00
|
|
|
return false;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2009-02-15 11:01:36 +07:00
|
|
|
offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
|
|
|
|
de = ext4_next_entry(de, sb->s_blocksize);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2016-07-11 01:01:03 +07:00
|
|
|
return true;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
/*
|
|
|
|
* ext4_orphan_add() links an unlinked or truncated inode into a list of
|
2006-10-11 15:20:50 +07:00
|
|
|
* such inodes, starting at the superblock, in case we crash before the
|
|
|
|
* file is closed/deleted, or in case the inode truncate spans multiple
|
|
|
|
* transactions and the last transaction is not recovered after a crash.
|
|
|
|
*
|
|
|
|
* At filesystem recovery time, we walk this list deleting unlinked
|
2006-10-11 15:20:53 +07:00
|
|
|
* inodes and truncating linked inodes in ext4_orphan_cleanup().
|
2014-05-26 22:56:53 +07:00
|
|
|
*
|
|
|
|
* Orphan list manipulation functions must be called under i_mutex unless
|
|
|
|
* we are just creating the inode or deleting it.
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
int ext4_orphan_add(handle_t *handle, struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
2014-05-26 22:39:17 +07:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_iloc iloc;
|
2006-10-11 15:20:50 +07:00
|
|
|
int err = 0, rc;
|
2014-05-26 22:56:53 +07:00
|
|
|
bool dirty = false;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
ext4: don't orphan or truncate the boot loader inode
The boot loader inode (inode #5) should never be visible in the
directory hierarchy, but it's possible if the file system is corrupted
that there will be a directory entry that points at inode #5. In
order to avoid accidentally trashing it, when such a directory inode
is opened, the inode will be marked as a bad inode, so that it's not
possible to modify (or read) the inode from userspace.
Unfortunately, when we unlink this (invalid/illegal) directory entry,
we will put the bad inode on the ophan list, and then when try to
unlink the directory, we don't actually remove the bad inode from the
orphan list before freeing in-memory inode structure. This means the
in-memory orphan list is corrupted, leading to a kernel oops.
In addition, avoid truncating a bad inode in ext4_destroy_inode(),
since truncating the boot loader inode is not a smart thing to do.
Reported-by: Sami Liedes <sami.liedes@iki.fi>
Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-06 09:47:07 +07:00
|
|
|
if (!sbi->s_journal || is_bad_inode(inode))
|
2009-01-07 12:06:22 +07:00
|
|
|
return 0;
|
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
|
2016-01-23 03:40:57 +07:00
|
|
|
!inode_is_locked(inode));
|
2014-05-26 22:56:53 +07:00
|
|
|
/*
|
|
|
|
* Exit early if inode already is on orphan list. This is a big speedup
|
|
|
|
* since we don't have to contend on the global s_orphan_lock.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
if (!list_empty(&EXT4_I(inode)->i_orphan))
|
2014-05-26 22:56:53 +07:00
|
|
|
return 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2011-07-12 05:47:04 +07:00
|
|
|
/*
|
|
|
|
* Orphan handling is only valid for files with data blocks
|
|
|
|
* being truncated, or files being unlinked. Note that we either
|
|
|
|
* hold i_mutex, or the inode can not be referenced from outside,
|
|
|
|
* so i_nlink should not be bumped due to race
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
2008-09-09 09:25:24 +07:00
|
|
|
J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
|
|
|
|
S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-05-26 22:39:17 +07:00
|
|
|
BUFFER_TRACE(sbi->s_sbh, "get_write_access");
|
|
|
|
err = ext4_journal_get_write_access(handle, sbi->s_sbh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
2014-05-26 22:56:53 +07:00
|
|
|
goto out;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_reserve_inode_write(handle, inode, &iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (err)
|
2014-05-26 22:56:53 +07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
mutex_lock(&sbi->s_orphan_lock);
|
2010-03-02 11:29:39 +07:00
|
|
|
/*
|
|
|
|
* Due to previous errors inode may be already a part of on-disk
|
|
|
|
* orphan list. If so skip on-disk list modification.
|
|
|
|
*/
|
2014-05-26 22:56:53 +07:00
|
|
|
if (!NEXT_ORPHAN(inode) || NEXT_ORPHAN(inode) >
|
|
|
|
(le32_to_cpu(sbi->s_es->s_inodes_count))) {
|
|
|
|
/* Insert this inode at the head of the on-disk orphan list */
|
|
|
|
NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan);
|
|
|
|
sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
|
|
|
|
dirty = true;
|
|
|
|
}
|
|
|
|
list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan);
|
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
if (dirty) {
|
|
|
|
err = ext4_handle_dirty_super(handle, sb);
|
|
|
|
rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
|
|
|
|
if (!err)
|
|
|
|
err = rc;
|
|
|
|
if (err) {
|
|
|
|
/*
|
|
|
|
* We have to remove inode from in-memory list if
|
|
|
|
* addition to on disk orphan list failed. Stray orphan
|
|
|
|
* list entries can cause panics at unmount time.
|
|
|
|
*/
|
|
|
|
mutex_lock(&sbi->s_orphan_lock);
|
2016-05-05 22:10:15 +07:00
|
|
|
list_del_init(&EXT4_I(inode)->i_orphan);
|
2014-05-26 22:56:53 +07:00
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
|
|
|
}
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
jbd_debug(4, "superblock will point to %lu\n", inode->i_ino);
|
|
|
|
jbd_debug(4, "orphan inode %lu will point to %d\n",
|
|
|
|
inode->i_ino, NEXT_ORPHAN(inode));
|
2014-05-26 22:56:53 +07:00
|
|
|
out:
|
2014-05-26 22:39:17 +07:00
|
|
|
ext4_std_error(sb, err);
|
2006-10-11 15:20:50 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_orphan_del() removes an unlinked or truncated inode from the list
|
2006-10-11 15:20:50 +07:00
|
|
|
* of such inodes stored on disk, because it is finally being cleaned up.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
int ext4_orphan_del(handle_t *handle, struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct list_head *prev;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
2014-05-26 22:39:17 +07:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
2008-11-05 12:14:04 +07:00
|
|
|
__u32 ino_next;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_iloc iloc;
|
2006-10-11 15:20:50 +07:00
|
|
|
int err = 0;
|
|
|
|
|
2014-05-26 22:39:17 +07:00
|
|
|
if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
|
2009-01-07 12:06:22 +07:00
|
|
|
return 0;
|
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
|
2016-01-23 03:40:57 +07:00
|
|
|
!inode_is_locked(inode));
|
2014-05-26 22:56:53 +07:00
|
|
|
/* Do this quick check before taking global s_orphan_lock. */
|
2009-04-26 09:54:04 +07:00
|
|
|
if (list_empty(&ei->i_orphan))
|
2014-05-26 22:56:53 +07:00
|
|
|
return 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
if (handle) {
|
|
|
|
/* Grab inode buffer early before taking global s_orphan_lock */
|
|
|
|
err = ext4_reserve_inode_write(handle, inode, &iloc);
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
mutex_lock(&sbi->s_orphan_lock);
|
2006-10-11 15:20:50 +07:00
|
|
|
jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
|
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
prev = ei->i_orphan.prev;
|
2006-10-11 15:20:50 +07:00
|
|
|
list_del_init(&ei->i_orphan);
|
|
|
|
|
|
|
|
/* If we're on an error path, we may not have a valid
|
|
|
|
* transaction handle with which to update the orphan list on
|
|
|
|
* disk, but we still need to remove the inode from the linked
|
|
|
|
* list in memory. */
|
2014-05-26 22:56:53 +07:00
|
|
|
if (!handle || err) {
|
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto out_err;
|
2014-05-26 22:56:53 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-05-26 22:56:53 +07:00
|
|
|
ino_next = NEXT_ORPHAN(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (prev == &sbi->s_orphan) {
|
2008-11-05 12:14:04 +07:00
|
|
|
jbd_debug(4, "superblock will point to %u\n", ino_next);
|
2006-10-11 15:20:50 +07:00
|
|
|
BUFFER_TRACE(sbi->s_sbh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_journal_get_write_access(handle, sbi->s_sbh);
|
2014-05-26 22:56:53 +07:00
|
|
|
if (err) {
|
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto out_brelse;
|
2014-05-26 22:56:53 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
|
2014-05-26 22:56:53 +07:00
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
2012-07-23 07:37:31 +07:00
|
|
|
err = ext4_handle_dirty_super(handle, inode->i_sb);
|
2006-10-11 15:20:50 +07:00
|
|
|
} else {
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_iloc iloc2;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct inode *i_prev =
|
2006-10-11 15:20:53 +07:00
|
|
|
&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2008-11-05 12:14:04 +07:00
|
|
|
jbd_debug(4, "orphan inode %lu will point to %u\n",
|
2006-10-11 15:20:50 +07:00
|
|
|
i_prev->i_ino, ino_next);
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
|
2014-05-26 22:56:53 +07:00
|
|
|
if (err) {
|
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto out_brelse;
|
2014-05-26 22:56:53 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
NEXT_ORPHAN(i_prev) = ino_next;
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
|
2014-05-26 22:56:53 +07:00
|
|
|
mutex_unlock(&sbi->s_orphan_lock);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
if (err)
|
|
|
|
goto out_brelse;
|
|
|
|
NEXT_ORPHAN(inode) = 0;
|
2006-10-11 15:20:53 +07:00
|
|
|
err = ext4_mark_iloc_dirty(handle, inode, &iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
out_err:
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_std_error(inode->i_sb, err);
|
2006-10-11 15:20:50 +07:00
|
|
|
return err;
|
|
|
|
|
|
|
|
out_brelse:
|
|
|
|
brelse(iloc.bh);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
int retval;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct inode *inode;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct ext4_dir_entry_2 *de;
|
2013-02-09 21:45:11 +07:00
|
|
|
handle_t *handle = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Initialize quotas before so that eventual writes go in
|
|
|
|
* separate transaction */
|
2015-06-29 21:22:54 +07:00
|
|
|
retval = dquot_initialize(dir);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
retval = dquot_initialize(d_inode(dentry));
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
retval = -ENOENT;
|
2012-12-11 02:06:01 +07:00
|
|
|
bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(bh))
|
|
|
|
return PTR_ERR(bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!bh)
|
|
|
|
goto end_rmdir;
|
|
|
|
|
2015-03-18 05:25:59 +07:00
|
|
|
inode = d_inode(dentry);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-10-18 03:16:04 +07:00
|
|
|
retval = -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (le32_to_cpu(de->inode) != inode->i_ino)
|
|
|
|
goto end_rmdir;
|
|
|
|
|
|
|
|
retval = -ENOTEMPTY;
|
2015-04-11 18:46:49 +07:00
|
|
|
if (!ext4_empty_dir(inode))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto end_rmdir;
|
|
|
|
|
2013-02-09 21:45:11 +07:00
|
|
|
handle = ext4_journal_start(dir, EXT4_HT_DIR,
|
2013-02-10 03:06:24 +07:00
|
|
|
EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
|
2013-02-09 21:45:11 +07:00
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
retval = PTR_ERR(handle);
|
|
|
|
handle = NULL;
|
|
|
|
goto end_rmdir;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_DIRSYNC(dir))
|
|
|
|
ext4_handle_sync(handle);
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
retval = ext4_delete_entry(handle, dir, de, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (retval)
|
|
|
|
goto end_rmdir;
|
2007-07-18 19:38:01 +07:00
|
|
|
if (!EXT4_DIR_LINK_EMPTY(inode))
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(inode,
|
|
|
|
"empty directory '%.*s' has too many links (%u)",
|
|
|
|
dentry->d_name.len, dentry->d_name.name,
|
2008-09-09 09:25:24 +07:00
|
|
|
inode->i_nlink);
|
2006-10-11 15:20:50 +07:00
|
|
|
inode->i_version++;
|
|
|
|
clear_nlink(inode);
|
|
|
|
/* There's no need to set i_disksize: the fact that i_nlink is
|
|
|
|
* zero will ensure that the right thing happens during any
|
|
|
|
* recovery. */
|
|
|
|
inode->i_size = 0;
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_orphan_add(handle, inode);
|
2007-07-18 20:15:20 +07:00
|
|
|
inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_mark_inode_dirty(handle, inode);
|
2007-07-18 19:38:01 +07:00
|
|
|
ext4_dec_count(handle, dir);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_update_dx_flag(dir);
|
|
|
|
ext4_mark_inode_dirty(handle, dir);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
end_rmdir:
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2013-02-09 21:45:11 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_unlink(struct inode *dir, struct dentry *dentry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
int retval;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct inode *inode;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct ext4_dir_entry_2 *de;
|
2013-02-09 21:43:39 +07:00
|
|
|
handle_t *handle = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2011-03-22 08:38:05 +07:00
|
|
|
trace_ext4_unlink_enter(dir, dentry);
|
2006-10-11 15:20:50 +07:00
|
|
|
/* Initialize quotas before so that eventual writes go
|
|
|
|
* in separate transaction */
|
2015-06-29 21:22:54 +07:00
|
|
|
retval = dquot_initialize(dir);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
retval = dquot_initialize(d_inode(dentry));
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
retval = -ENOENT;
|
2012-12-11 02:06:01 +07:00
|
|
|
bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(bh))
|
|
|
|
return PTR_ERR(bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!bh)
|
|
|
|
goto end_unlink;
|
|
|
|
|
2015-03-18 05:25:59 +07:00
|
|
|
inode = d_inode(dentry);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-10-18 03:16:04 +07:00
|
|
|
retval = -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (le32_to_cpu(de->inode) != inode->i_ino)
|
|
|
|
goto end_unlink;
|
|
|
|
|
2013-02-09 21:43:39 +07:00
|
|
|
handle = ext4_journal_start(dir, EXT4_HT_DIR,
|
2013-02-10 03:06:24 +07:00
|
|
|
EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
|
2013-02-09 21:43:39 +07:00
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
retval = PTR_ERR(handle);
|
|
|
|
handle = NULL;
|
|
|
|
goto end_unlink;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_DIRSYNC(dir))
|
|
|
|
ext4_handle_sync(handle);
|
|
|
|
|
2015-06-16 01:50:26 +07:00
|
|
|
if (inode->i_nlink == 0) {
|
|
|
|
ext4_warning_inode(inode, "Deleting file '%.*s' with no links",
|
|
|
|
dentry->d_name.len, dentry->d_name.name);
|
2011-10-28 19:13:29 +07:00
|
|
|
set_nlink(inode, 1);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
retval = ext4_delete_entry(handle, dir, de, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (retval)
|
|
|
|
goto end_unlink;
|
2007-07-18 20:15:20 +07:00
|
|
|
dir->i_ctime = dir->i_mtime = ext4_current_time(dir);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_update_dx_flag(dir);
|
|
|
|
ext4_mark_inode_dirty(handle, dir);
|
2008-02-16 03:00:38 +07:00
|
|
|
drop_nlink(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!inode->i_nlink)
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_orphan_add(handle, inode);
|
2007-07-18 20:15:20 +07:00
|
|
|
inode->i_ctime = ext4_current_time(inode);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_mark_inode_dirty(handle, inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
end_unlink:
|
2008-09-09 09:25:24 +07:00
|
|
|
brelse(bh);
|
2013-02-09 21:43:39 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2011-03-22 08:38:05 +07:00
|
|
|
trace_ext4_unlink_exit(dentry, retval);
|
2006-10-11 15:20:50 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_symlink(struct inode *dir,
|
|
|
|
struct dentry *dentry, const char *symname)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
handle_t *handle;
|
2008-09-09 09:25:24 +07:00
|
|
|
struct inode *inode;
|
2015-04-16 12:55:00 +07:00
|
|
|
int err, len = strlen(symname);
|
2011-05-03 22:12:58 +07:00
|
|
|
int credits;
|
2015-04-16 12:55:00 +07:00
|
|
|
bool encryption_required;
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str disk_link;
|
|
|
|
struct fscrypt_symlink_data *sd = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-04-16 12:55:00 +07:00
|
|
|
disk_link.len = len + 1;
|
|
|
|
disk_link.name = (char *) symname;
|
|
|
|
|
2015-04-16 12:56:00 +07:00
|
|
|
encryption_required = (ext4_encrypted_inode(dir) ||
|
|
|
|
DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb)));
|
2015-06-01 00:35:32 +07:00
|
|
|
if (encryption_required) {
|
2016-07-11 01:01:03 +07:00
|
|
|
err = fscrypt_get_encryption_info(dir);
|
2015-06-01 00:35:32 +07:00
|
|
|
if (err)
|
|
|
|
return err;
|
2016-07-11 01:01:03 +07:00
|
|
|
if (!fscrypt_has_encryption_key(dir))
|
2015-06-01 00:35:32 +07:00
|
|
|
return -EPERM;
|
2016-07-11 01:01:03 +07:00
|
|
|
disk_link.len = (fscrypt_fname_encrypted_size(dir, len) +
|
|
|
|
sizeof(struct fscrypt_symlink_data));
|
2015-06-01 00:35:32 +07:00
|
|
|
sd = kzalloc(disk_link.len, GFP_KERNEL);
|
|
|
|
if (!sd)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (disk_link.len > dir->i_sb->s_blocksize) {
|
|
|
|
err = -ENAMETOOLONG;
|
|
|
|
goto err_free_sd;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
err = dquot_initialize(dir);
|
|
|
|
if (err)
|
2015-07-24 18:05:33 +07:00
|
|
|
goto err_free_sd;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2015-04-16 12:55:00 +07:00
|
|
|
if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
|
2011-05-03 22:12:58 +07:00
|
|
|
/*
|
|
|
|
* For non-fast symlinks, we just allocate inode and put it on
|
|
|
|
* orphan list in the first transaction => we need bitmap,
|
2011-08-11 21:54:31 +07:00
|
|
|
* group descriptor, sb, inode block, quota blocks, and
|
|
|
|
* possibly selinux xattr blocks.
|
2011-05-03 22:12:58 +07:00
|
|
|
*/
|
2011-08-11 21:54:31 +07:00
|
|
|
credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
|
|
|
|
EXT4_XATTR_TRANS_BLOCKS;
|
2011-05-03 22:12:58 +07:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Fast symlink. We have to add entry to directory
|
|
|
|
* (EXT4_DATA_TRANS_BLOCKS + EXT4_INDEX_EXTRA_TRANS_BLOCKS),
|
|
|
|
* allocate new inode (bitmap, group descriptor, inode block,
|
|
|
|
* quota blocks, sb is already counted in previous macros).
|
|
|
|
*/
|
|
|
|
credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
|
2013-04-20 00:38:14 +07:00
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
|
2011-05-03 22:12:58 +07:00
|
|
|
}
|
2015-04-16 12:55:00 +07:00
|
|
|
|
2013-02-10 04:27:09 +07:00
|
|
|
inode = ext4_new_inode_start_handle(dir, S_IFLNK|S_IRWXUGO,
|
|
|
|
&dentry->d_name, 0, NULL,
|
|
|
|
EXT4_HT_DIR, credits);
|
|
|
|
handle = ext4_journal_current_handle();
|
2015-04-16 12:55:00 +07:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2015-06-01 00:35:32 +07:00
|
|
|
err = PTR_ERR(inode);
|
|
|
|
goto err_free_sd;
|
2015-04-16 12:55:00 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (encryption_required) {
|
|
|
|
struct qstr istr;
|
2016-07-11 01:01:03 +07:00
|
|
|
struct fscrypt_str ostr =
|
|
|
|
FSTR_INIT(sd->encrypted_path, disk_link.len);
|
2015-04-16 12:55:00 +07:00
|
|
|
|
|
|
|
istr.name = (const unsigned char *) symname;
|
|
|
|
istr.len = len;
|
2016-07-11 01:01:03 +07:00
|
|
|
err = fscrypt_fname_usr_to_disk(inode, &istr, &ostr);
|
2016-09-16 04:25:55 +07:00
|
|
|
if (err)
|
2015-04-16 12:55:00 +07:00
|
|
|
goto err_drop_inode;
|
|
|
|
sd->len = cpu_to_le16(ostr.len);
|
|
|
|
disk_link.name = (char *) sd;
|
2015-04-28 04:51:30 +07:00
|
|
|
inode->i_op = &ext4_encrypted_symlink_inode_operations;
|
2015-04-16 12:55:00 +07:00
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-04-16 12:55:00 +07:00
|
|
|
if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
|
2015-04-28 04:51:30 +07:00
|
|
|
if (!encryption_required)
|
|
|
|
inode->i_op = &ext4_symlink_inode_operations;
|
2015-11-17 13:07:57 +07:00
|
|
|
inode_nohighmem(inode);
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_set_aops(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
2011-05-03 22:12:58 +07:00
|
|
|
* We cannot call page_symlink() with transaction started
|
|
|
|
* because it calls into ext4_write_begin() which can wait
|
|
|
|
* for transaction commit if we are running out of space
|
|
|
|
* and thus we deadlock. So we have to stop transaction now
|
|
|
|
* and restart it when symlink contents is written.
|
|
|
|
*
|
|
|
|
* To keep fs consistent in case of crash, we have to put inode
|
|
|
|
* to orphan list in the mean time.
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
2011-05-03 22:12:58 +07:00
|
|
|
drop_nlink(inode);
|
|
|
|
err = ext4_orphan_add(handle, inode);
|
|
|
|
ext4_journal_stop(handle);
|
2015-04-16 12:55:00 +07:00
|
|
|
handle = NULL;
|
2011-05-03 22:12:58 +07:00
|
|
|
if (err)
|
|
|
|
goto err_drop_inode;
|
2015-04-16 12:55:00 +07:00
|
|
|
err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
|
2011-05-03 22:12:58 +07:00
|
|
|
if (err)
|
|
|
|
goto err_drop_inode;
|
|
|
|
/*
|
|
|
|
* Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS
|
|
|
|
* + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified
|
|
|
|
*/
|
2013-02-09 09:59:22 +07:00
|
|
|
handle = ext4_journal_start(dir, EXT4_HT_DIR,
|
2011-05-03 22:12:58 +07:00
|
|
|
EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
|
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
err = PTR_ERR(handle);
|
2015-04-16 12:55:00 +07:00
|
|
|
handle = NULL;
|
2011-05-03 22:12:58 +07:00
|
|
|
goto err_drop_inode;
|
|
|
|
}
|
2012-01-09 07:50:23 +07:00
|
|
|
set_nlink(inode, 1);
|
2011-05-03 22:12:58 +07:00
|
|
|
err = ext4_orphan_del(handle, inode);
|
2015-04-16 12:55:00 +07:00
|
|
|
if (err)
|
2011-05-03 22:12:58 +07:00
|
|
|
goto err_drop_inode;
|
2006-10-11 15:20:50 +07:00
|
|
|
} else {
|
2008-04-29 19:11:12 +07:00
|
|
|
/* clear the extent format for fast symlink */
|
2010-05-17 09:00:00 +07:00
|
|
|
ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
|
2015-05-02 21:13:58 +07:00
|
|
|
if (!encryption_required) {
|
2015-04-28 04:51:30 +07:00
|
|
|
inode->i_op = &ext4_fast_symlink_inode_operations;
|
2015-05-02 21:13:58 +07:00
|
|
|
inode->i_link = (char *)&EXT4_I(inode)->i_data;
|
|
|
|
}
|
2015-04-16 12:55:00 +07:00
|
|
|
memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
|
|
|
|
disk_link.len);
|
|
|
|
inode->i_size = disk_link.len - 1;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
EXT4_I(inode)->i_disksize = inode->i_size;
|
|
|
|
err = ext4_add_nondir(handle, dentry, inode);
|
2013-02-10 04:27:09 +07:00
|
|
|
if (!err && IS_DIRSYNC(dir))
|
|
|
|
ext4_handle_sync(handle);
|
|
|
|
|
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2015-04-16 12:55:00 +07:00
|
|
|
kfree(sd);
|
2006-10-11 15:20:50 +07:00
|
|
|
return err;
|
2011-05-03 22:12:58 +07:00
|
|
|
err_drop_inode:
|
2015-04-16 12:55:00 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
|
|
|
clear_nlink(inode);
|
2011-05-03 22:12:58 +07:00
|
|
|
unlock_new_inode(inode);
|
|
|
|
iput(inode);
|
2015-06-01 00:35:32 +07:00
|
|
|
err_free_sd:
|
|
|
|
kfree(sd);
|
2011-05-03 22:12:58 +07:00
|
|
|
return err;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_link(struct dentry *old_dentry,
|
|
|
|
struct inode *dir, struct dentry *dentry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
handle_t *handle;
|
2015-03-18 05:25:59 +07:00
|
|
|
struct inode *inode = d_inode(old_dentry);
|
2006-10-11 15:20:50 +07:00
|
|
|
int err, retries = 0;
|
|
|
|
|
2009-08-30 08:08:08 +07:00
|
|
|
if (inode->i_nlink >= EXT4_LINK_MAX)
|
2006-10-11 15:20:50 +07:00
|
|
|
return -EMLINK;
|
2015-04-12 11:55:08 +07:00
|
|
|
if (ext4_encrypted_inode(dir) &&
|
2016-07-11 01:01:03 +07:00
|
|
|
!fscrypt_has_permitted_context(dir, inode))
|
2015-04-12 11:55:08 +07:00
|
|
|
return -EPERM;
|
2016-01-09 04:01:21 +07:00
|
|
|
|
|
|
|
if ((ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT)) &&
|
|
|
|
(!projid_eq(EXT4_I(dir)->i_projid,
|
|
|
|
EXT4_I(old_dentry->d_inode)->i_projid)))
|
|
|
|
return -EXDEV;
|
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
err = dquot_initialize(dir);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
retry:
|
2013-02-09 09:59:22 +07:00
|
|
|
handle = ext4_journal_start(dir, EXT4_HT_DIR,
|
|
|
|
(EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
|
2013-06-29 16:23:08 +07:00
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (IS_ERR(handle))
|
|
|
|
return PTR_ERR(handle);
|
|
|
|
|
|
|
|
if (IS_DIRSYNC(dir))
|
2009-01-07 12:06:22 +07:00
|
|
|
ext4_handle_sync(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2007-07-18 20:15:20 +07:00
|
|
|
inode->i_ctime = ext4_current_time(inode);
|
2007-07-18 19:38:01 +07:00
|
|
|
ext4_inc_count(handle, inode);
|
2010-10-23 22:11:40 +07:00
|
|
|
ihold(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2008-12-30 14:03:31 +07:00
|
|
|
err = ext4_add_entry(handle, dentry, inode);
|
|
|
|
if (!err) {
|
|
|
|
ext4_mark_inode_dirty(handle, inode);
|
2013-06-29 16:23:08 +07:00
|
|
|
/* this can happen only for tmpfile being
|
|
|
|
* linked the first time
|
|
|
|
*/
|
|
|
|
if (inode->i_nlink == 1)
|
|
|
|
ext4_orphan_del(handle, inode);
|
2008-12-30 14:03:31 +07:00
|
|
|
d_instantiate(dentry, inode);
|
|
|
|
} else {
|
|
|
|
drop_nlink(inode);
|
|
|
|
iput(inode);
|
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_journal_stop(handle);
|
|
|
|
if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto retry;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-11 02:06:01 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to find buffer head where contains the parent block.
|
|
|
|
* It should be the inode block if it is inlined or the 1st block
|
|
|
|
* if it is a normal dir.
|
|
|
|
*/
|
|
|
|
static struct buffer_head *ext4_get_first_dir_block(handle_t *handle,
|
|
|
|
struct inode *inode,
|
|
|
|
int *retval,
|
|
|
|
struct ext4_dir_entry_2 **parent_de,
|
|
|
|
int *inlined)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
|
|
|
if (!ext4_has_inline_data(inode)) {
|
2013-02-15 11:59:26 +07:00
|
|
|
bh = ext4_read_dirblock(inode, 0, EITHER);
|
|
|
|
if (IS_ERR(bh)) {
|
|
|
|
*retval = PTR_ERR(bh);
|
2012-12-11 02:06:01 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
*parent_de = ext4_next_entry(
|
|
|
|
(struct ext4_dir_entry_2 *)bh->b_data,
|
|
|
|
inode->i_sb->s_blocksize);
|
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
|
|
|
|
*inlined = 1;
|
|
|
|
return ext4_get_first_inline_block(inode, parent_de, retval);
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
struct ext4_renament {
|
|
|
|
struct inode *dir;
|
|
|
|
struct dentry *dentry;
|
|
|
|
struct inode *inode;
|
2014-04-01 22:08:44 +07:00
|
|
|
bool is_dir;
|
|
|
|
int dir_nlink_delta;
|
2014-04-01 22:08:43 +07:00
|
|
|
|
|
|
|
/* entry for "dentry" */
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct ext4_dir_entry_2 *de;
|
|
|
|
int inlined;
|
|
|
|
|
|
|
|
/* entry for ".." in inode if it's a directory */
|
|
|
|
struct buffer_head *dir_bh;
|
|
|
|
struct ext4_dir_entry_2 *parent_de;
|
|
|
|
int dir_inlined;
|
|
|
|
};
|
|
|
|
|
2014-04-01 22:08:44 +07:00
|
|
|
static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode,
|
|
|
|
&retval, &ent->parent_de,
|
|
|
|
&ent->dir_inlined);
|
|
|
|
if (!ent->dir_bh)
|
|
|
|
return retval;
|
|
|
|
if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2014-04-01 22:08:44 +07:00
|
|
|
BUFFER_TRACE(ent->dir_bh, "get_write_access");
|
|
|
|
return ext4_journal_get_write_access(handle, ent->dir_bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent,
|
|
|
|
unsigned dir_ino)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
ent->parent_de->inode = cpu_to_le32(dir_ino);
|
|
|
|
BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata");
|
|
|
|
if (!ent->dir_inlined) {
|
|
|
|
if (is_dx(ent->inode)) {
|
|
|
|
retval = ext4_handle_dirty_dx_node(handle,
|
|
|
|
ent->inode,
|
|
|
|
ent->dir_bh);
|
|
|
|
} else {
|
|
|
|
retval = ext4_handle_dirty_dirent_node(handle,
|
|
|
|
ent->inode,
|
|
|
|
ent->dir_bh);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
retval = ext4_mark_inode_dirty(handle, ent->inode);
|
|
|
|
}
|
|
|
|
if (retval) {
|
|
|
|
ext4_std_error(ent->dir->i_sb, retval);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
|
|
|
|
unsigned ino, unsigned file_type)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
BUFFER_TRACE(ent->bh, "get write access");
|
|
|
|
retval = ext4_journal_get_write_access(handle, ent->bh);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
ent->de->inode = cpu_to_le32(ino);
|
2015-10-18 03:18:43 +07:00
|
|
|
if (ext4_has_feature_filetype(ent->dir->i_sb))
|
2014-04-01 22:08:44 +07:00
|
|
|
ent->de->file_type = file_type;
|
|
|
|
ent->dir->i_version++;
|
|
|
|
ent->dir->i_ctime = ent->dir->i_mtime =
|
|
|
|
ext4_current_time(ent->dir);
|
|
|
|
ext4_mark_inode_dirty(handle, ent->dir);
|
|
|
|
BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
|
|
|
|
if (!ent->inlined) {
|
|
|
|
retval = ext4_handle_dirty_dirent_node(handle,
|
|
|
|
ent->dir, ent->bh);
|
|
|
|
if (unlikely(retval)) {
|
|
|
|
ext4_std_error(ent->dir->i_sb, retval);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
brelse(ent->bh);
|
|
|
|
ent->bh = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
|
|
|
|
const struct qstr *d_name)
|
|
|
|
{
|
|
|
|
int retval = -ENOENT;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct ext4_dir_entry_2 *de;
|
|
|
|
|
|
|
|
bh = ext4_find_entry(dir, d_name, &de, NULL);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(bh))
|
|
|
|
return PTR_ERR(bh);
|
2014-04-01 22:08:44 +07:00
|
|
|
if (bh) {
|
|
|
|
retval = ext4_delete_entry(handle, dir, de, bh);
|
|
|
|
brelse(bh);
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-08-28 05:40:09 +07:00
|
|
|
static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
|
|
|
|
int force_reread)
|
2014-04-01 22:08:44 +07:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
/*
|
|
|
|
* ent->de could have moved from under us during htree split, so make
|
|
|
|
* sure that we are deleting the right entry. We might also be pointing
|
|
|
|
* to a stale entry in the unused part of ent->bh so just checking inum
|
|
|
|
* and the name isn't enough.
|
|
|
|
*/
|
|
|
|
if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino ||
|
|
|
|
ent->de->name_len != ent->dentry->d_name.len ||
|
|
|
|
strncmp(ent->de->name, ent->dentry->d_name.name,
|
2014-08-28 05:40:09 +07:00
|
|
|
ent->de->name_len) ||
|
|
|
|
force_reread) {
|
2014-04-01 22:08:44 +07:00
|
|
|
retval = ext4_find_delete_entry(handle, ent->dir,
|
|
|
|
&ent->dentry->d_name);
|
|
|
|
} else {
|
|
|
|
retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
|
|
|
|
if (retval == -ENOENT) {
|
|
|
|
retval = ext4_find_delete_entry(handle, ent->dir,
|
|
|
|
&ent->dentry->d_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (retval) {
|
2015-06-16 01:50:26 +07:00
|
|
|
ext4_warning_inode(ent->dir,
|
|
|
|
"Deleting old file: nlink %d, error=%d",
|
|
|
|
ent->dir->i_nlink, retval);
|
2014-04-01 22:08:44 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-01 22:08:44 +07:00
|
|
|
static void ext4_update_dir_count(handle_t *handle, struct ext4_renament *ent)
|
|
|
|
{
|
|
|
|
if (ent->dir_nlink_delta) {
|
|
|
|
if (ent->dir_nlink_delta == -1)
|
|
|
|
ext4_dec_count(handle, ent->dir);
|
|
|
|
else
|
|
|
|
ext4_inc_count(handle, ent->dir);
|
|
|
|
ext4_mark_inode_dirty(handle, ent->dir);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-24 05:14:37 +07:00
|
|
|
static struct inode *ext4_whiteout_for_rename(struct ext4_renament *ent,
|
|
|
|
int credits, handle_t **h)
|
|
|
|
{
|
|
|
|
struct inode *wh;
|
|
|
|
handle_t *handle;
|
|
|
|
int retries = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* for inode block, sb block, group summaries,
|
|
|
|
* and inode bitmap
|
|
|
|
*/
|
|
|
|
credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
|
|
|
|
EXT4_XATTR_TRANS_BLOCKS + 4);
|
|
|
|
retry:
|
|
|
|
wh = ext4_new_inode_start_handle(ent->dir, S_IFCHR | WHITEOUT_MODE,
|
|
|
|
&ent->dentry->d_name, 0, NULL,
|
|
|
|
EXT4_HT_DIR, credits);
|
|
|
|
|
|
|
|
handle = ext4_journal_current_handle();
|
|
|
|
if (IS_ERR(wh)) {
|
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
|
|
|
if (PTR_ERR(wh) == -ENOSPC &&
|
|
|
|
ext4_should_retry_alloc(ent->dir->i_sb, &retries))
|
|
|
|
goto retry;
|
|
|
|
} else {
|
|
|
|
*h = handle;
|
|
|
|
init_special_inode(wh, wh->i_mode, WHITEOUT_DEV);
|
|
|
|
wh->i_op = &ext4_special_inode_operations;
|
|
|
|
}
|
|
|
|
return wh;
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* Anybody can rename anything with this: the permission checks are left to the
|
|
|
|
* higher-level routines.
|
2013-08-17 09:06:53 +07:00
|
|
|
*
|
|
|
|
* n.b. old_{dentry,inode) refers to the source dentry/inode
|
|
|
|
* while new_{dentry,inode) refers to the destination dentry/inode
|
|
|
|
* This comes from rename(const char *oldpath, const char *newpath)
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
2008-09-09 09:25:24 +07:00
|
|
|
static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
|
2014-10-24 05:14:37 +07:00
|
|
|
struct inode *new_dir, struct dentry *new_dentry,
|
|
|
|
unsigned int flags)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2013-08-17 09:06:14 +07:00
|
|
|
handle_t *handle = NULL;
|
2014-04-01 22:08:43 +07:00
|
|
|
struct ext4_renament old = {
|
|
|
|
.dir = old_dir,
|
|
|
|
.dentry = old_dentry,
|
2015-03-18 05:25:59 +07:00
|
|
|
.inode = d_inode(old_dentry),
|
2014-04-01 22:08:43 +07:00
|
|
|
};
|
|
|
|
struct ext4_renament new = {
|
|
|
|
.dir = new_dir,
|
|
|
|
.dentry = new_dentry,
|
2015-03-18 05:25:59 +07:00
|
|
|
.inode = d_inode(new_dentry),
|
2014-04-01 22:08:43 +07:00
|
|
|
};
|
2014-08-28 05:40:09 +07:00
|
|
|
int force_reread;
|
2013-08-17 09:06:53 +07:00
|
|
|
int retval;
|
2014-10-24 05:14:37 +07:00
|
|
|
struct inode *whiteout = NULL;
|
|
|
|
int credits;
|
|
|
|
u8 old_file_type;
|
2010-03-03 21:05:06 +07:00
|
|
|
|
2016-01-09 04:01:21 +07:00
|
|
|
if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT)) &&
|
|
|
|
(!projid_eq(EXT4_I(new_dir)->i_projid,
|
|
|
|
EXT4_I(old_dentry->d_inode)->i_projid)))
|
|
|
|
return -EXDEV;
|
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
retval = dquot_initialize(old.dir);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
retval = dquot_initialize(new.dir);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Initialize quotas before so that eventual writes go
|
|
|
|
* in separate transaction */
|
2015-06-29 21:22:54 +07:00
|
|
|
if (new.inode) {
|
|
|
|
retval = dquot_initialize(new.inode);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(old.bh))
|
|
|
|
return PTR_ERR(old.bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* Check for inode number is _not_ due to possible IO errors.
|
|
|
|
* We might rmdir the source, keep it as pwd of some process
|
|
|
|
* and merrily kill the link to whatever was created under the
|
|
|
|
* same name. Goodbye sticky bit ;-<
|
|
|
|
*/
|
|
|
|
retval = -ENOENT;
|
2014-04-01 22:08:43 +07:00
|
|
|
if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto end_rename;
|
|
|
|
|
2015-04-12 11:55:08 +07:00
|
|
|
if ((old.dir != new.dir) &&
|
|
|
|
ext4_encrypted_inode(new.dir) &&
|
2016-07-11 01:01:03 +07:00
|
|
|
!fscrypt_has_permitted_context(new.dir, old.inode)) {
|
2015-04-12 11:55:08 +07:00
|
|
|
retval = -EPERM;
|
|
|
|
goto end_rename;
|
|
|
|
}
|
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
|
|
|
|
&new.de, &new.inlined);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(new.bh)) {
|
|
|
|
retval = PTR_ERR(new.bh);
|
2014-09-03 20:33:00 +07:00
|
|
|
new.bh = NULL;
|
2014-08-24 04:47:19 +07:00
|
|
|
goto end_rename;
|
|
|
|
}
|
2014-04-01 22:08:43 +07:00
|
|
|
if (new.bh) {
|
|
|
|
if (!new.inode) {
|
|
|
|
brelse(new.bh);
|
|
|
|
new.bh = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
}
|
2014-04-01 22:08:43 +07:00
|
|
|
if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
|
|
|
|
ext4_alloc_da_blocks(old.inode);
|
2013-08-17 09:06:14 +07:00
|
|
|
|
2014-10-24 05:14:37 +07:00
|
|
|
credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
|
|
|
|
EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
|
|
|
|
if (!(flags & RENAME_WHITEOUT)) {
|
|
|
|
handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
|
2015-04-03 03:32:15 +07:00
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
retval = PTR_ERR(handle);
|
|
|
|
handle = NULL;
|
|
|
|
goto end_rename;
|
|
|
|
}
|
2014-10-24 05:14:37 +07:00
|
|
|
} else {
|
|
|
|
whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
|
2015-04-03 03:32:15 +07:00
|
|
|
if (IS_ERR(whiteout)) {
|
|
|
|
retval = PTR_ERR(whiteout);
|
|
|
|
whiteout = NULL;
|
|
|
|
goto end_rename;
|
|
|
|
}
|
2014-10-24 05:14:37 +07:00
|
|
|
}
|
2013-08-17 09:06:14 +07:00
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
|
2013-08-17 09:06:14 +07:00
|
|
|
ext4_handle_sync(handle);
|
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
if (S_ISDIR(old.inode->i_mode)) {
|
|
|
|
if (new.inode) {
|
2006-10-11 15:20:50 +07:00
|
|
|
retval = -ENOTEMPTY;
|
2015-04-11 18:46:49 +07:00
|
|
|
if (!ext4_empty_dir(new.inode))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto end_rename;
|
2014-04-01 22:08:44 +07:00
|
|
|
} else {
|
|
|
|
retval = -EMLINK;
|
|
|
|
if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
|
|
|
|
goto end_rename;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-04-01 22:08:44 +07:00
|
|
|
retval = ext4_rename_dir_prepare(handle, &old);
|
2011-03-21 08:18:44 +07:00
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-08-28 05:40:09 +07:00
|
|
|
/*
|
|
|
|
* If we're renaming a file within an inline_data dir and adding or
|
|
|
|
* setting the new dirent causes a conversion from inline_data to
|
|
|
|
* extents/blockmap, we need to force the dirent delete code to
|
|
|
|
* re-read the directory, or else we end up trying to delete a dirent
|
|
|
|
* from what is now the extent tree root (or a block map).
|
|
|
|
*/
|
|
|
|
force_reread = (new.dir->i_ino == old.dir->i_ino &&
|
|
|
|
ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
|
2014-10-24 05:14:37 +07:00
|
|
|
|
|
|
|
old_file_type = old.de->file_type;
|
|
|
|
if (whiteout) {
|
|
|
|
/*
|
|
|
|
* Do this before adding a new entry, so the old entry is sure
|
|
|
|
* to be still pointing to the valid old entry.
|
|
|
|
*/
|
|
|
|
retval = ext4_setent(handle, &old, whiteout->i_ino,
|
|
|
|
EXT4_FT_CHRDEV);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
ext4_mark_inode_dirty(handle, whiteout);
|
|
|
|
}
|
2014-04-01 22:08:43 +07:00
|
|
|
if (!new.bh) {
|
|
|
|
retval = ext4_add_entry(handle, new.dentry, old.inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
} else {
|
2014-04-01 22:08:44 +07:00
|
|
|
retval = ext4_setent(handle, &new,
|
2014-10-24 05:14:37 +07:00
|
|
|
old.inode->i_ino, old_file_type);
|
2011-03-21 08:18:44 +07:00
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-08-28 05:40:09 +07:00
|
|
|
if (force_reread)
|
|
|
|
force_reread = !ext4_test_inode_flag(new.dir,
|
|
|
|
EXT4_INODE_INLINE_DATA);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Like most other Unix systems, set the ctime for inodes on a
|
|
|
|
* rename.
|
|
|
|
*/
|
2014-04-01 22:08:43 +07:00
|
|
|
old.inode->i_ctime = ext4_current_time(old.inode);
|
|
|
|
ext4_mark_inode_dirty(handle, old.inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-10-24 05:14:37 +07:00
|
|
|
if (!whiteout) {
|
|
|
|
/*
|
|
|
|
* ok, that's it
|
|
|
|
*/
|
|
|
|
ext4_rename_delete(handle, &old, force_reread);
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
if (new.inode) {
|
|
|
|
ext4_dec_count(handle, new.inode);
|
|
|
|
new.inode->i_ctime = ext4_current_time(new.inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-04-01 22:08:43 +07:00
|
|
|
old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir);
|
|
|
|
ext4_update_dx_flag(old.dir);
|
|
|
|
if (old.dir_bh) {
|
2014-04-01 22:08:44 +07:00
|
|
|
retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
|
|
|
|
if (retval)
|
2011-01-11 00:46:59 +07:00
|
|
|
goto end_rename;
|
2014-04-01 22:08:44 +07:00
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
ext4_dec_count(handle, old.dir);
|
|
|
|
if (new.inode) {
|
2015-04-11 18:46:49 +07:00
|
|
|
/* checked ext4_empty_dir above, can't have another
|
|
|
|
* parent, ext4_dec_count() won't work for many-linked
|
|
|
|
* dirs */
|
2014-04-01 22:08:43 +07:00
|
|
|
clear_nlink(new.inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
} else {
|
2014-04-01 22:08:43 +07:00
|
|
|
ext4_inc_count(handle, new.dir);
|
|
|
|
ext4_update_dx_flag(new.dir);
|
|
|
|
ext4_mark_inode_dirty(handle, new.dir);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
}
|
2014-04-01 22:08:43 +07:00
|
|
|
ext4_mark_inode_dirty(handle, old.dir);
|
|
|
|
if (new.inode) {
|
|
|
|
ext4_mark_inode_dirty(handle, new.inode);
|
|
|
|
if (!new.inode->i_nlink)
|
|
|
|
ext4_orphan_add(handle, new.inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
retval = 0;
|
|
|
|
|
|
|
|
end_rename:
|
2014-04-01 22:08:43 +07:00
|
|
|
brelse(old.dir_bh);
|
|
|
|
brelse(old.bh);
|
|
|
|
brelse(new.bh);
|
2014-10-24 05:14:37 +07:00
|
|
|
if (whiteout) {
|
|
|
|
if (retval)
|
|
|
|
drop_nlink(whiteout);
|
|
|
|
unlock_new_inode(whiteout);
|
|
|
|
iput(whiteout);
|
|
|
|
}
|
2013-08-17 09:06:14 +07:00
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-04-01 22:08:44 +07:00
|
|
|
static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
|
|
|
|
struct inode *new_dir, struct dentry *new_dentry)
|
|
|
|
{
|
|
|
|
handle_t *handle = NULL;
|
|
|
|
struct ext4_renament old = {
|
|
|
|
.dir = old_dir,
|
|
|
|
.dentry = old_dentry,
|
2015-03-18 05:25:59 +07:00
|
|
|
.inode = d_inode(old_dentry),
|
2014-04-01 22:08:44 +07:00
|
|
|
};
|
|
|
|
struct ext4_renament new = {
|
|
|
|
.dir = new_dir,
|
|
|
|
.dentry = new_dentry,
|
2015-03-18 05:25:59 +07:00
|
|
|
.inode = d_inode(new_dentry),
|
2014-04-01 22:08:44 +07:00
|
|
|
};
|
|
|
|
u8 new_file_type;
|
|
|
|
int retval;
|
|
|
|
|
2015-06-01 00:35:09 +07:00
|
|
|
if ((ext4_encrypted_inode(old_dir) ||
|
|
|
|
ext4_encrypted_inode(new_dir)) &&
|
|
|
|
(old_dir != new_dir) &&
|
2016-07-11 01:01:03 +07:00
|
|
|
(!fscrypt_has_permitted_context(new_dir, old.inode) ||
|
|
|
|
!fscrypt_has_permitted_context(old_dir, new.inode)))
|
2015-06-01 00:35:09 +07:00
|
|
|
return -EPERM;
|
|
|
|
|
2016-01-09 04:01:21 +07:00
|
|
|
if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT) &&
|
|
|
|
!projid_eq(EXT4_I(new_dir)->i_projid,
|
|
|
|
EXT4_I(old_dentry->d_inode)->i_projid)) ||
|
|
|
|
(ext4_test_inode_flag(old_dir, EXT4_INODE_PROJINHERIT) &&
|
|
|
|
!projid_eq(EXT4_I(old_dir)->i_projid,
|
|
|
|
EXT4_I(new_dentry->d_inode)->i_projid)))
|
|
|
|
return -EXDEV;
|
|
|
|
|
2015-06-29 21:22:54 +07:00
|
|
|
retval = dquot_initialize(old.dir);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
retval = dquot_initialize(new.dir);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2014-04-01 22:08:44 +07:00
|
|
|
|
|
|
|
old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
|
|
|
|
&old.de, &old.inlined);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(old.bh))
|
|
|
|
return PTR_ERR(old.bh);
|
2014-04-01 22:08:44 +07:00
|
|
|
/*
|
|
|
|
* Check for inode number is _not_ due to possible IO errors.
|
|
|
|
* We might rmdir the source, keep it as pwd of some process
|
|
|
|
* and merrily kill the link to whatever was created under the
|
|
|
|
* same name. Goodbye sticky bit ;-<
|
|
|
|
*/
|
|
|
|
retval = -ENOENT;
|
|
|
|
if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
|
|
|
|
goto end_rename;
|
|
|
|
|
|
|
|
new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
|
|
|
|
&new.de, &new.inlined);
|
2014-08-24 04:47:19 +07:00
|
|
|
if (IS_ERR(new.bh)) {
|
|
|
|
retval = PTR_ERR(new.bh);
|
2014-09-03 20:33:00 +07:00
|
|
|
new.bh = NULL;
|
2014-08-24 04:47:19 +07:00
|
|
|
goto end_rename;
|
|
|
|
}
|
2014-04-01 22:08:44 +07:00
|
|
|
|
|
|
|
/* RENAME_EXCHANGE case: old *and* new must both exist */
|
|
|
|
if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino)
|
|
|
|
goto end_rename;
|
|
|
|
|
|
|
|
handle = ext4_journal_start(old.dir, EXT4_HT_DIR,
|
|
|
|
(2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
|
|
|
|
2 * EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2));
|
2015-04-03 03:32:15 +07:00
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
retval = PTR_ERR(handle);
|
|
|
|
handle = NULL;
|
|
|
|
goto end_rename;
|
|
|
|
}
|
2014-04-01 22:08:44 +07:00
|
|
|
|
|
|
|
if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
|
|
|
|
ext4_handle_sync(handle);
|
|
|
|
|
|
|
|
if (S_ISDIR(old.inode->i_mode)) {
|
|
|
|
old.is_dir = true;
|
|
|
|
retval = ext4_rename_dir_prepare(handle, &old);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
}
|
|
|
|
if (S_ISDIR(new.inode->i_mode)) {
|
|
|
|
new.is_dir = true;
|
|
|
|
retval = ext4_rename_dir_prepare(handle, &new);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Other than the special case of overwriting a directory, parents'
|
|
|
|
* nlink only needs to be modified if this is a cross directory rename.
|
|
|
|
*/
|
|
|
|
if (old.dir != new.dir && old.is_dir != new.is_dir) {
|
|
|
|
old.dir_nlink_delta = old.is_dir ? -1 : 1;
|
|
|
|
new.dir_nlink_delta = -old.dir_nlink_delta;
|
|
|
|
retval = -EMLINK;
|
|
|
|
if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
|
|
|
|
(new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
|
|
|
|
goto end_rename;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_file_type = new.de->file_type;
|
|
|
|
retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
|
|
|
|
retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Like most other Unix systems, set the ctime for inodes on a
|
|
|
|
* rename.
|
|
|
|
*/
|
|
|
|
old.inode->i_ctime = ext4_current_time(old.inode);
|
|
|
|
new.inode->i_ctime = ext4_current_time(new.inode);
|
|
|
|
ext4_mark_inode_dirty(handle, old.inode);
|
|
|
|
ext4_mark_inode_dirty(handle, new.inode);
|
|
|
|
|
|
|
|
if (old.dir_bh) {
|
|
|
|
retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
}
|
|
|
|
if (new.dir_bh) {
|
|
|
|
retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
|
|
|
|
if (retval)
|
|
|
|
goto end_rename;
|
|
|
|
}
|
|
|
|
ext4_update_dir_count(handle, &old);
|
|
|
|
ext4_update_dir_count(handle, &new);
|
|
|
|
retval = 0;
|
|
|
|
|
|
|
|
end_rename:
|
|
|
|
brelse(old.dir_bh);
|
|
|
|
brelse(new.dir_bh);
|
|
|
|
brelse(old.bh);
|
|
|
|
brelse(new.bh);
|
|
|
|
if (handle)
|
|
|
|
ext4_journal_stop(handle);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-04-01 22:08:43 +07:00
|
|
|
static int ext4_rename2(struct inode *old_dir, struct dentry *old_dentry,
|
|
|
|
struct inode *new_dir, struct dentry *new_dentry,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
2014-10-24 05:14:37 +07:00
|
|
|
if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
|
2014-04-01 22:08:43 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-04-01 22:08:44 +07:00
|
|
|
if (flags & RENAME_EXCHANGE) {
|
|
|
|
return ext4_cross_rename(old_dir, old_dentry,
|
|
|
|
new_dir, new_dentry);
|
|
|
|
}
|
2014-10-24 05:14:37 +07:00
|
|
|
|
|
|
|
return ext4_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
|
2014-04-01 22:08:43 +07:00
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
|
|
|
* directories can handle most operations...
|
|
|
|
*/
|
2007-02-12 15:55:38 +07:00
|
|
|
const struct inode_operations ext4_dir_inode_operations = {
|
2006-10-11 15:20:53 +07:00
|
|
|
.create = ext4_create,
|
|
|
|
.lookup = ext4_lookup,
|
|
|
|
.link = ext4_link,
|
|
|
|
.unlink = ext4_unlink,
|
|
|
|
.symlink = ext4_symlink,
|
|
|
|
.mkdir = ext4_mkdir,
|
|
|
|
.rmdir = ext4_rmdir,
|
|
|
|
.mknod = ext4_mknod,
|
2013-06-29 16:23:08 +07:00
|
|
|
.tmpfile = ext4_tmpfile,
|
2016-09-27 16:03:58 +07:00
|
|
|
.rename = ext4_rename2,
|
2006-10-11 15:20:53 +07:00
|
|
|
.setattr = ext4_setattr,
|
|
|
|
.listxattr = ext4_listxattr,
|
2011-07-23 22:37:31 +07:00
|
|
|
.get_acl = ext4_get_acl,
|
2013-12-20 20:16:44 +07:00
|
|
|
.set_acl = ext4_set_acl,
|
2009-05-03 09:54:32 +07:00
|
|
|
.fiemap = ext4_fiemap,
|
2006-10-11 15:20:50 +07:00
|
|
|
};
|
|
|
|
|
2007-02-12 15:55:38 +07:00
|
|
|
const struct inode_operations ext4_special_inode_operations = {
|
2006-10-11 15:20:53 +07:00
|
|
|
.setattr = ext4_setattr,
|
|
|
|
.listxattr = ext4_listxattr,
|
2011-07-23 22:37:31 +07:00
|
|
|
.get_acl = ext4_get_acl,
|
2013-12-20 20:16:44 +07:00
|
|
|
.set_acl = ext4_set_acl,
|
2006-10-11 15:20:50 +07:00
|
|
|
};
|