namei.c 102.0 KB
Newer Older
1
/*
2
 *  linux/fs/ext4/namei.c
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 * 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>
36 37
#include "ext4.h"
#include "ext4_jbd2.h"
38 39 40 41

#include "xattr.h"
#include "acl.h"

42
#include <trace/events/ext4.h>
43 44 45 46 47
/*
 * define how far ahead to read directories while searching them.
 */
#define NAMEI_RA_CHUNKS  2
#define NAMEI_RA_BLOCKS  4
D
Dave Kleikamp 已提交
48
#define NAMEI_RA_SIZE	     (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
49

50
static struct buffer_head *ext4_append(handle_t *handle,
51
					struct inode *inode,
52
					ext4_lblk_t *block)
53 54
{
	struct buffer_head *bh;
55
	int err;
56

57 58
	if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
		     ((inode->i_size >> 10) >=
59 60
		      EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
		return ERR_PTR(-ENOSPC);
61

62 63
	*block = inode->i_size >> inode->i_sb->s_blocksize_bits;

64
	bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
65 66
	if (IS_ERR(bh))
		return bh;
67 68
	inode->i_size += inode->i_sb->s_blocksize;
	EXT4_I(inode)->i_disksize = inode->i_size;
69
	BUFFER_TRACE(bh, "get_write_access");
70 71 72 73 74
	err = ext4_journal_get_write_access(handle, bh);
	if (err) {
		brelse(bh);
		ext4_std_error(inode->i_sb, err);
		return ERR_PTR(err);
C
Carlos Maiolino 已提交
75
	}
76 77 78
	return bh;
}

79 80 81 82 83 84 85 86
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) \
87
	__ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
88 89

static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
90 91 92 93
						ext4_lblk_t block,
						dirblock_type_t type,
						const char *func,
						unsigned int line)
94 95 96
{
	struct buffer_head *bh;
	struct ext4_dir_entry *dirent;
97
	int is_dx_block = 0;
98

99 100
	bh = ext4_bread(NULL, inode, block, 0);
	if (IS_ERR(bh)) {
101 102 103 104 105
		__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));
106 107 108 109

		return bh;
	}
	if (!bh) {
110 111
		ext4_error_inode(inode, func, line, block,
				 "Directory hole found");
112
		return ERR_PTR(-EFSCORRUPTED);
113 114 115 116 117 118 119 120 121 122 123 124
	}
	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) {
125
		ext4_error_inode(inode, func, line, block,
126
		       "directory leaf block found instead of index block");
127
		return ERR_PTR(-EFSCORRUPTED);
128
	}
129
	if (!ext4_has_metadata_csum(inode->i_sb) ||
130 131 132 133 134 135 136 137 138 139 140 141
	    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 {
142 143
			ext4_error_inode(inode, func, line, block,
					 "Directory index failed checksum");
144
			brelse(bh);
145
			return ERR_PTR(-EFSBADCRC);
146
		}
147
	}
148 149 150 151
	if (!is_dx_block) {
		if (ext4_dirent_csum_verify(inode, dirent))
			set_buffer_verified(bh);
		else {
152 153
			ext4_error_inode(inode, func, line, block,
					 "Directory block failed checksum");
154
			brelse(bh);
155
			return ERR_PTR(-EFSBADCRC);
156
		}
C
Carlos Maiolino 已提交
157
	}
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	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;
232 233
	u16 offs;
	u16 size;
234 235
};

236 237 238 239 240 241 242 243
/*
 * This goes at the end of each htree block.
 */
struct dx_tail {
	u32 dt_reserved;
	__le32 dt_checksum;	/* crc32c(uuid+inum+dirblock) */
};

A
Aneesh Kumar K.V 已提交
244 245
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);
246 247 248 249 250 251 252 253
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);
254
static struct dx_frame *dx_probe(struct ext4_filename *fname,
255 256
				 struct inode *dir,
				 struct dx_hash_info *hinfo,
257
				 struct dx_frame *frame);
258
static void dx_release(struct dx_frame *frames);
259 260 261
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[]);
262
static void dx_sort_map(struct dx_map_entry *map, unsigned count);
263
static struct ext4_dir_entry_2 *dx_move_dirents(char *from, char *to,
264
		struct dx_map_entry *offsets, int count, unsigned blocksize);
265
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize);
A
Aneesh Kumar K.V 已提交
266 267
static void dx_insert_block(struct dx_frame *frame,
					u32 hash, ext4_lblk_t block);
268
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
269 270 271
				 struct dx_frame *frame,
				 struct dx_frame *frames,
				 __u32 *start_hash);
272
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
273
		struct ext4_filename *fname,
274
		struct ext4_dir_entry_2 **res_dir);
275
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
276
			     struct inode *dir, struct inode *inode);
277

278
/* checksumming functions */
279 280
void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
			    unsigned int blocksize)
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
{
	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);
}

333 334 335 336 337
#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)
338
{
339 340
	__ext4_warning_inode(inode, func, line,
		"No space for directory leaf checksum. Please run e2fsck -D.");
341 342
}

343 344 345 346
int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
{
	struct ext4_dir_entry_tail *t;

347
	if (!ext4_has_metadata_csum(inode->i_sb))
348 349 350 351
		return 1;

	t = get_dirent_tail(inode, dirent);
	if (!t) {
352
		warn_no_space_for_csum(inode);
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
		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;

368
	if (!ext4_has_metadata_csum(inode->i_sb))
369 370 371 372
		return;

	t = get_dirent_tail(inode, dirent);
	if (!t) {
373
		warn_no_space_for_csum(inode);
374 375 376 377 378 379 380
		return;
	}

	t->det_checksum = ext4_dirent_csum(inode, dirent,
					   (void *)t - (void *)dirent);
}

381 382 383
int ext4_handle_dirty_dirent_node(handle_t *handle,
				  struct inode *inode,
				  struct buffer_head *bh)
384 385 386 387 388
{
	ext4_dirent_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
	return ext4_handle_dirty_metadata(handle, inode, bh);
}

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
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);
422
	__u32 csum;
423
	int size;
424 425
	__u32 dummy_csum = 0;
	int offset = offsetof(struct dx_tail, dt_checksum);
426 427 428

	size = count_offset + (count * sizeof(struct dx_entry));
	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
429 430
	csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
	csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
431 432 433 434 435 436 437 438 439 440 441

	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;

442
	if (!ext4_has_metadata_csum(inode->i_sb))
443 444 445 446 447
		return 1;

	c = get_dx_countlimit(inode, dirent, &count_offset);
	if (!c) {
		EXT4_ERROR_INODE(inode, "dir seems corrupt?  Run e2fsck -D.");
448
		return 0;
449 450 451 452 453
	}
	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)) {
454
		warn_no_space_for_csum(inode);
455
		return 0;
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
	}
	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;

471
	if (!ext4_has_metadata_csum(inode->i_sb))
472 473 474 475 476 477 478 479 480 481 482
		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)) {
483
		warn_no_space_for_csum(inode);
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
		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);
}

499 500 501 502
/*
 * p is at least 6 bytes before the end of page
 */
static inline struct ext4_dir_entry_2 *
503
ext4_next_entry(struct ext4_dir_entry_2 *p, unsigned long blocksize)
504 505
{
	return (struct ext4_dir_entry_2 *)((char *)p +
506
		ext4_rec_len_from_disk(p->rec_len, blocksize));
507 508
}

509 510 511 512 513
/*
 * Future: use high four bits of block for coalesce-on-delete flags
 * Mask them off for now.
 */

A
Aneesh Kumar K.V 已提交
514
static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
515 516 517 518
{
	return le32_to_cpu(entry->block) & 0x00ffffff;
}

A
Aneesh Kumar K.V 已提交
519
static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
520 521 522 523
{
	entry->block = cpu_to_le32(value);
}

524
static inline unsigned dx_get_hash(struct dx_entry *entry)
525 526 527 528
{
	return le32_to_cpu(entry->hash);
}

529
static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
530 531 532 533
{
	entry->hash = cpu_to_le32(value);
}

534
static inline unsigned dx_get_count(struct dx_entry *entries)
535 536 537 538
{
	return le16_to_cpu(((struct dx_countlimit *) entries)->count);
}

539
static inline unsigned dx_get_limit(struct dx_entry *entries)
540 541 542 543
{
	return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
}

544
static inline void dx_set_count(struct dx_entry *entries, unsigned value)
545 546 547 548
{
	((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
}

549
static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
550 551 552 553
{
	((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
}

554
static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
555
{
556 557
	unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
		EXT4_DIR_REC_LEN(2) - infosize;
558

559
	if (ext4_has_metadata_csum(dir->i_sb))
560
		entry_space -= sizeof(struct dx_tail);
561
	return entry_space / sizeof(struct dx_entry);
562 563
}

564
static inline unsigned dx_node_limit(struct inode *dir)
565
{
566
	unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
567

568
	if (ext4_has_metadata_csum(dir->i_sb))
569
		entry_space -= sizeof(struct dx_tail);
570
	return entry_space / sizeof(struct dx_entry);
571 572 573 574 575 576
}

/*
 * Debug
 */
#ifdef DX_DEBUG
577
static void dx_show_index(char * label, struct dx_entry *entries)
578
{
A
Andrew Morton 已提交
579
	int i, n = dx_get_count (entries);
580
	printk(KERN_DEBUG "%s index", label);
A
Andrew Morton 已提交
581
	for (i = 0; i < n; i++) {
582 583 584
		printk(KERN_CONT " %x->%lu",
		       i ? dx_get_hash(entries + i) : 0,
		       (unsigned long)dx_get_block(entries + i));
A
Andrew Morton 已提交
585
	}
586
	printk(KERN_CONT "\n");
587 588 589 590 591 592 593 594 595
}

struct stats
{
	unsigned names;
	unsigned space;
	unsigned bcount;
};

596 597 598 599
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)
600 601 602 603 604 605 606 607 608 609 610 611
{
	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)
			{
612 613 614
#ifdef CONFIG_EXT4_FS_ENCRYPTION
				int len;
				char *name;
615 616
				struct fscrypt_str fname_crypto_str =
					FSTR_INIT(NULL, 0);
617
				int res = 0;
618 619 620

				name  = de->name;
				len = de->name_len;
621 622
				if (ext4_encrypted_inode(dir))
					res = fscrypt_get_encryption_info(dir);
623 624 625
				if (res) {
					printk(KERN_WARNING "Error setting up"
					       " fname crypto: %d\n", res);
626
				}
627
				if (!fscrypt_has_encryption_key(dir)) {
628 629 630 631 632 633 634 635
					/* 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 {
636 637 638
					struct fscrypt_str de_name =
						FSTR_INIT(name, len);

639
					/* Directory is encrypted */
640 641
					res = fscrypt_fname_alloc_buffer(
						dir, len,
642
						&fname_crypto_str);
643
					if (res)
644 645 646 647
						printk(KERN_WARNING "Error "
							"allocating crypto "
							"buffer--skipping "
							"crypto\n");
648 649 650
					res = fscrypt_fname_disk_to_usr(dir,
						0, 0, &de_name,
						&fname_crypto_str);
651
					if (res) {
652 653 654 655 656 657 658 659 660 661
						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;
					}
662 663
					ext4fs_dirhash(de->name, de->name_len,
						       &h);
664 665 666
					printk("%*.s:(E)%x.%u ", len, name,
					       h.hash, (unsigned) ((char *) de
								   - base));
667 668
					fscrypt_fname_free_buffer(
							&fname_crypto_str);
669 670
				}
#else
671 672
				int len = de->name_len;
				char *name = de->name;
673
				ext4fs_dirhash(de->name, de->name_len, &h);
674
				printk("%*.s:%x.%u ", len, name, h.hash,
675
				       (unsigned) ((char *) de - base));
676
#endif
677
			}
678
			space += EXT4_DIR_REC_LEN(de->name_len);
679 680
			names++;
		}
681
		de = ext4_next_entry(de, size);
682
	}
683
	printk(KERN_CONT "(%i)\n", names);
684 685 686 687 688 689 690
	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;
691
	unsigned count = dx_get_count(entries), names = 0, space = 0, i;
692 693 694 695 696
	unsigned bcount = 0;
	struct buffer_head *bh;
	printk("%i indexed blocks...\n", count);
	for (i = 0; i < count; i++, entries++)
	{
A
Aneesh Kumar K.V 已提交
697 698
		ext4_lblk_t block = dx_get_block(entries);
		ext4_lblk_t hash  = i ? dx_get_hash(entries): 0;
699 700 701
		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);
702 703 704
		bh = ext4_bread(NULL,dir, block, 0);
		if (!bh || IS_ERR(bh))
			continue;
705 706
		stats = levels?
		   dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
707 708
		   dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
			bh->b_data, blocksize, 0);
709 710 711
		names += stats.names;
		space += stats.space;
		bcount += stats.bcount;
712
		brelse(bh);
713 714
	}
	if (bcount)
715
		printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
716 717
		       levels ? "" : "   ", names, space/bcount,
		       (space/bcount)*100/blocksize);
718 719 720 721 722 723 724 725 726 727 728 729 730 731
	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 *
732
dx_probe(struct ext4_filename *fname, struct inode *dir,
733
	 struct dx_hash_info *hinfo, struct dx_frame *frame_in)
734 735 736 737 738
{
	unsigned count, indirect;
	struct dx_entry *at, *entries, *p, *q, *m;
	struct dx_root *root;
	struct dx_frame *frame = frame_in;
739
	struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
740 741
	u32 hash;

742 743 744 745 746
	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;
747 748 749
	if (root->info.hash_version != DX_HASH_TEA &&
	    root->info.hash_version != DX_HASH_HALF_MD4 &&
	    root->info.hash_version != DX_HASH_LEGACY) {
750 751
		ext4_warning_inode(dir, "Unrecognised inode hash code %u",
				   root->info.hash_version);
752 753
		goto fail;
	}
754 755
	if (fname)
		hinfo = &fname->hinfo;
756
	hinfo->hash_version = root->info.hash_version;
757 758
	if (hinfo->hash_version <= DX_HASH_TEA)
		hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
759
	hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
760 761
	if (fname && fname_name(fname))
		ext4fs_dirhash(fname_name(fname), fname_len(fname), hinfo);
762 763 764
	hash = hinfo->hash;

	if (root->info.unused_flags & 1) {
765 766
		ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
				   root->info.unused_flags);
767 768 769
		goto fail;
	}

770 771 772 773
	indirect = root->info.indirect_levels;
	if (indirect > 1) {
		ext4_warning_inode(dir, "Unimplemented hash depth: %#06x",
				   root->info.indirect_levels);
774 775 776
		goto fail;
	}

777 778
	entries = (struct dx_entry *)(((char *)&root->info) +
				      root->info.info_length);
779 780 781

	if (dx_get_limit(entries) != dx_root_limit(dir,
						   root->info.info_length)) {
782 783 784
		ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
				   dx_get_limit(entries),
				   dx_root_limit(dir, root->info.info_length));
785 786 787
		goto fail;
	}

788
	dxtrace(printk("Look up %x", hash));
789
	while (1) {
790
		count = dx_get_count(entries);
791
		if (!count || count > dx_get_limit(entries)) {
792 793 794
			ext4_warning_inode(dir,
					   "dx entry: count %u beyond limit %u",
					   count, dx_get_limit(entries));
795
			goto fail;
796 797
		}

798 799
		p = entries + 1;
		q = entries + count - 1;
800
		while (p <= q) {
801
			m = p + (q - p) / 2;
802
			dxtrace(printk(KERN_CONT "."));
803 804 805 806 807 808
			if (dx_get_hash(m) > hash)
				q = m - 1;
			else
				p = m + 1;
		}

809
		if (0) { // linear search cross check
810 811 812 813
			unsigned n = count - 1;
			at = entries;
			while (n--)
			{
814
				dxtrace(printk(KERN_CONT ","));
815 816 817 818 819 820 821 822 823 824
				if (dx_get_hash(++at) > hash)
				{
					at--;
					break;
				}
			}
			assert (at == p - 1);
		}

		at = p - 1;
825 826
		dxtrace(printk(KERN_CONT " %x->%u\n",
			       at == entries ? 0 : dx_get_hash(at),
827
			       dx_get_block(at)));
828 829
		frame->entries = entries;
		frame->at = at;
830 831 832 833 834 835 836 837
		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;
838
		}
839
		entries = ((struct dx_node *) frame->bh->b_data)->entries;
840

841 842 843 844
		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));
845
			goto fail;
846
		}
847
	}
848
fail:
849 850 851 852
	while (frame >= frame_in) {
		brelse(frame->bh);
		frame--;
	}
853

854
	if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
855 856
		ext4_warning_inode(dir,
			"Corrupt directory, running e2fsck is recommended");
857
	return ret_err;
858 859
}

860
static void dx_release(struct dx_frame *frames)
861 862 863 864
{
	if (frames[0].bh == NULL)
		return;

865
	if (((struct dx_root *)frames[0].bh->b_data)->info.indirect_levels)
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
		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.
 */
887
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
888 889 890 891 892 893
				 struct dx_frame *frame,
				 struct dx_frame *frames,
				 __u32 *start_hash)
{
	struct dx_frame *p;
	struct buffer_head *bh;
894
	int num_frames = 0;
895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
	__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--) {
933 934 935
		bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
		if (IS_ERR(bh))
			return PTR_ERR(bh);
936
		p++;
937
		brelse(p->bh);
938 939 940 941 942 943 944 945 946 947 948 949 950
		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,
A
Aneesh Kumar K.V 已提交
951
				  struct inode *dir, ext4_lblk_t block,
952 953 954 955
				  struct dx_hash_info *hinfo,
				  __u32 start_hash, __u32 start_minor_hash)
{
	struct buffer_head *bh;
956
	struct ext4_dir_entry_2 *de, *top;
957
	int err = 0, count = 0;
958
	struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
959

A
Aneesh Kumar K.V 已提交
960 961
	dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
							(unsigned long)block));
962 963 964
	bh = ext4_read_dirblock(dir, block, DIRENT);
	if (IS_ERR(bh))
		return PTR_ERR(bh);
965

966 967
	de = (struct ext4_dir_entry_2 *) bh->b_data;
	top = (struct ext4_dir_entry_2 *) ((char *) de +
968
					   dir->i_sb->s_blocksize -
969
					   EXT4_DIR_REC_LEN(0));
970 971
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	/* Check if the directory is encrypted */
972
	if (ext4_encrypted_inode(dir)) {
973
		err = fscrypt_get_encryption_info(dir);
974 975 976 977
		if (err < 0) {
			brelse(bh);
			return err;
		}
978
		err = fscrypt_fname_alloc_buffer(dir, EXT4_NAME_LEN,
979 980 981 982 983 984 985
						     &fname_crypto_str);
		if (err < 0) {
			brelse(bh);
			return err;
		}
	}
#endif
986
	for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
987
		if (ext4_check_dir_entry(dir, NULL, de, bh,
988
				bh->b_data, bh->b_size,
989 990
				(block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
					 + ((char *)de - bh->b_data))) {
991 992
			/* silently ignore the rest of the block */
			break;
993
		}
994
		ext4fs_dirhash(de->name, de->name_len, hinfo);
995 996 997 998 999 1000
		if ((hinfo->hash < start_hash) ||
		    ((hinfo->hash == start_hash) &&
		     (hinfo->minor_hash < start_minor_hash)))
			continue;
		if (de->inode == 0)
			continue;
1001
		if (!ext4_encrypted_inode(dir)) {
1002 1003 1004 1005 1006 1007
			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 {
1008
			int save_len = fname_crypto_str.len;
1009 1010
			struct fscrypt_str de_name = FSTR_INIT(de->name,
								de->name_len);
1011

1012
			/* Directory is encrypted */
1013 1014 1015
			err = fscrypt_fname_disk_to_usr(dir, hinfo->hash,
					hinfo->minor_hash, &de_name,
					&fname_crypto_str);
1016
			if (err) {
1017 1018 1019 1020 1021 1022
				count = err;
				goto errout;
			}
			err = ext4_htree_store_dirent(dir_file,
				   hinfo->hash, hinfo->minor_hash, de,
					&fname_crypto_str);
1023
			fname_crypto_str.len = save_len;
1024
		}
1025
		if (err != 0) {
1026 1027
			count = err;
			goto errout;
1028 1029 1030
		}
		count++;
	}
1031
errout:
1032
	brelse(bh);
1033
#ifdef CONFIG_EXT4_FS_ENCRYPTION
1034
	fscrypt_fname_free_buffer(&fname_crypto_str);
1035
#endif
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
	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.
 */
1048
int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
1049 1050 1051
			 __u32 start_minor_hash, __u32 *next_hash)
{
	struct dx_hash_info hinfo;
1052
	struct ext4_dir_entry_2 *de;
1053 1054
	struct dx_frame frames[2], *frame;
	struct inode *dir;
A
Aneesh Kumar K.V 已提交
1055
	ext4_lblk_t block;
1056
	int count = 0;
A
Aneesh Kumar K.V 已提交
1057
	int ret, err;
1058
	__u32 hashval;
1059
	struct fscrypt_str tmp_str;
1060

1061
	dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1062
		       start_hash, start_minor_hash));
A
Al Viro 已提交
1063
	dir = file_inode(dir_file);
1064
	if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1065
		hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1066 1067 1068
		if (hinfo.hash_version <= DX_HASH_TEA)
			hinfo.hash_version +=
				EXT4_SB(dir->i_sb)->s_hash_unsigned;
1069
		hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
		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;
			}
		}
1081 1082 1083 1084 1085 1086 1087
		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;
1088 1089 1090
	frame = dx_probe(NULL, dir, &hinfo, frames);
	if (IS_ERR(frame))
		return PTR_ERR(frame);
1091 1092 1093

	/* Add '.' and '..' from the htree header */
	if (!start_hash && !start_minor_hash) {
1094
		de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1095 1096 1097 1098 1099
		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)
1100 1101 1102 1103
			goto errout;
		count++;
	}
	if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1104
		de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1105
		de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1106 1107 1108 1109 1110
		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)
1111 1112 1113 1114 1115
			goto errout;
		count++;
	}

	while (1) {
1116 1117 1118 1119 1120
		if (fatal_signal_pending(current)) {
			err = -ERESTARTSYS;
			goto errout;
		}
		cond_resched();
1121 1122 1123 1124 1125 1126 1127 1128 1129
		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;
1130
		ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
					    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);
1147 1148
	dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
		       "next hash: %x\n", count, *next_hash));
1149 1150 1151 1152 1153 1154
	return count;
errout:
	dx_release(frames);
	return (err);
}

T
Tao Ma 已提交
1155 1156
static inline int search_dirblock(struct buffer_head *bh,
				  struct inode *dir,
1157
				  struct ext4_filename *fname,
T
Tao Ma 已提交
1158 1159 1160 1161
				  const struct qstr *d_name,
				  unsigned int offset,
				  struct ext4_dir_entry_2 **res_dir)
{
1162 1163
	return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
			       fname, d_name, offset, res_dir);
T
Tao Ma 已提交
1164 1165
}

1166 1167 1168 1169
/*
 * Directory block splitting, compacting
 */

1170 1171 1172 1173
/*
 * Create map of hash values, offsets, and sizes, stored at end of block.
 * Returns number of entries mapped.
 */
1174 1175
static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
		       unsigned blocksize, struct dx_hash_info *hinfo,
1176
		       struct dx_map_entry *map_tail)
1177 1178 1179 1180 1181
{
	int count = 0;
	char *base = (char *) de;
	struct dx_hash_info h = *hinfo;

1182
	while ((char *) de < base + blocksize) {
1183
		if (de->name_len && de->inode) {
1184
			ext4fs_dirhash(de->name, de->name_len, &h);
1185 1186
			map_tail--;
			map_tail->hash = h.hash;
1187
			map_tail->offs = ((char *) de - base)>>2;
1188
			map_tail->size = le16_to_cpu(de->rec_len);
1189 1190 1191 1192
			count++;
			cond_resched();
		}
		/* XXX: do we need to check rec_len == 0 case? -Chris */
1193
		de = ext4_next_entry(de, blocksize);
1194 1195 1196 1197
	}
	return count;
}

1198
/* Sort map by hash value */
1199 1200
static void dx_sort_map (struct dx_map_entry *map, unsigned count)
{
A
Andrew Morton 已提交
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
	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)
1218
				continue;
A
Andrew Morton 已提交
1219 1220
			swap(*(q+1), *q);
			more = 1;
1221 1222 1223 1224
		}
	} while(more);
}

A
Aneesh Kumar K.V 已提交
1225
static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
{
	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);
}

/*
1240
 * NOTE! unlike strncmp, ext4_match returns 1 for success, 0 for failure.
1241
 *
1242
 * `len <= EXT4_NAME_LEN' is guaranteed by caller.
1243 1244
 * `de != NULL' is guaranteed by caller.
 */
1245
static inline int ext4_match(struct ext4_filename *fname,
1246
			     struct ext4_dir_entry_2 *de)
1247
{
1248 1249
	const void *name = fname_name(fname);
	u32 len = fname_len(fname);
1250

1251 1252
	if (!de->inode)
		return 0;
1253 1254

#ifdef CONFIG_EXT4_FS_ENCRYPTION
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
	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;
	}
1267
#endif
1268
	if (de->name_len != len)
1269
		return 0;
1270
	return (memcmp(de->name, name, len) == 0) ? 1 : 0;
1271 1272 1273 1274 1275
}

/*
 * Returns 0 if not found, -1 on failure, and 1 on success
 */
1276 1277 1278 1279
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)
1280
{
1281
	struct ext4_dir_entry_2 * de;
1282 1283
	char * dlimit;
	int de_len;
1284 1285
	int res;

T
Tao Ma 已提交
1286 1287
	de = (struct ext4_dir_entry_2 *)search_buf;
	dlimit = search_buf + buf_size;
1288 1289 1290
	while ((char *) de < dlimit) {
		/* this code is executed quadratically often */
		/* do minimal checking `by hand' */
1291
		if ((char *) de + de->name_len <= dlimit) {
1292
			res = ext4_match(fname, de);
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
			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;
			}
1310 1311 1312

		}
		/* prevent looping on a bad block */
1313 1314
		de_len = ext4_rec_len_from_disk(de->rec_len,
						dir->i_sb->s_blocksize);
1315 1316 1317 1318
		if (de_len <= 0) {
			res = -1;
			goto return_result;
		}
1319
		offset += de_len;
1320
		de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1321
	}
1322 1323 1324 1325

	res = 0;
return_result:
	return res;
1326 1327
}

1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
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;
}
1343 1344

/*
1345
 *	ext4_find_entry()
1346 1347 1348 1349 1350 1351 1352 1353 1354
 *
 * 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.
 */
1355 1356
static struct buffer_head * ext4_find_entry (struct inode *dir,
					const struct qstr *d_name,
T
Tao Ma 已提交
1357 1358
					struct ext4_dir_entry_2 **res_dir,
					int *inlined)
1359
{
1360 1361 1362
	struct super_block *sb;
	struct buffer_head *bh_use[NAMEI_RA_SIZE];
	struct buffer_head *bh, *ret = NULL;
A
Aneesh Kumar K.V 已提交
1363
	ext4_lblk_t start, block, b;
1364
	const u8 *name = d_name->name;
1365 1366 1367 1368 1369
	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;
A
Aneesh Kumar K.V 已提交
1370
	ext4_lblk_t  nblocks;
1371 1372
	int i, namelen, retval;
	struct ext4_filename fname;
1373 1374 1375

	*res_dir = NULL;
	sb = dir->i_sb;
1376
	namelen = d_name->len;
1377
	if (namelen > EXT4_NAME_LEN)
1378
		return NULL;
1379

1380 1381 1382 1383
	retval = ext4_fname_setup_filename(dir, d_name, 1, &fname);
	if (retval)
		return ERR_PTR(retval);

1384 1385
	if (ext4_has_inline_data(dir)) {
		int has_inline_data = 1;
1386
		ret = ext4_find_inline_entry(dir, &fname, d_name, res_dir,
1387
					     &has_inline_data);
T
Tao Ma 已提交
1388 1389 1390
		if (has_inline_data) {
			if (inlined)
				*inlined = 1;
1391
			goto cleanup_and_exit;
T
Tao Ma 已提交
1392
		}
1393 1394
	}

1395
	if ((namelen <= 2) && (name[0] == '.') &&
1396
	    (name[1] == '.' || name[1] == '\0')) {
1397 1398 1399 1400 1401 1402 1403 1404
		/*
		 * "." 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;
	}
1405
	if (is_dx(dir)) {
1406
		ret = ext4_dx_find_entry(dir, &fname, res_dir);
1407 1408 1409 1410 1411
		/*
		 * On success, or if the error was file not found,
		 * return.  Otherwise, fall back to doing a search the
		 * old fashioned way.
		 */
1412 1413
		if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
			goto cleanup_and_exit;
1414 1415
		dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
			       "falling back\n"));
1416
	}
1417 1418
	nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
	start = EXT4_I(dir)->i_dir_start_lookup;
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
	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++;
1442
				bh = ext4_getblk(NULL, dir, b++, 0);
1443
				if (IS_ERR(bh)) {
1444 1445 1446 1447
					if (ra_max == 0) {
						ret = bh;
						goto cleanup_and_exit;
					}
1448 1449
					break;
				}
1450 1451
				bh_use[ra_max] = bh;
				if (bh)
1452 1453
					ll_rw_block(REQ_OP_READ,
						    REQ_META | REQ_PRIO,
1454
						    1, &bh);
1455 1456 1457 1458 1459 1460 1461
			}
		}
		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 */
1462 1463
			EXT4_ERROR_INODE(dir, "reading directory lblock %lu",
					 (unsigned long) block);
1464 1465 1466
			brelse(bh);
			goto next;
		}
1467
		if (!buffer_verified(bh) &&
1468 1469
		    !is_dx_internal_node(dir, block,
					 (struct ext4_dir_entry *)bh->b_data) &&
1470 1471 1472 1473 1474 1475 1476 1477
		    !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);
1478
		i = search_dirblock(bh, dir, &fname, d_name,
1479
			    block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
1480
		if (i == 1) {
1481
			EXT4_I(dir)->i_dir_start_lookup = block;
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
			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;
1499
	nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1500 1501 1502 1503 1504 1505 1506 1507
	if (block < nblocks) {
		start = 0;
		goto restart;
	}

cleanup_and_exit:
	/* Clean up the read-ahead blocks */
	for (; ra_ptr < ra_max; ra_ptr++)
1508
		brelse(bh_use[ra_ptr]);
1509
	ext4_fname_free_filename(&fname);
1510 1511 1512
	return ret;
}

1513 1514 1515
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
			struct ext4_filename *fname,
			struct ext4_dir_entry_2 **res_dir)
1516
{
1517
	struct super_block * sb = dir->i_sb;
1518
	struct dx_frame frames[2], *frame;
1519
	const struct qstr *d_name = fname->usr_fname;
1520
	struct buffer_head *bh;
A
Aneesh Kumar K.V 已提交
1521
	ext4_lblk_t block;
1522 1523
	int retval;

1524 1525 1526
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	*res_dir = NULL;
#endif
1527
	frame = dx_probe(fname, dir, NULL, frames);
1528 1529
	if (IS_ERR(frame))
		return (struct buffer_head *) frame;
1530 1531
	do {
		block = dx_get_block(frame->at);
1532
		bh = ext4_read_dirblock(dir, block, DIRENT);
1533
		if (IS_ERR(bh))
1534
			goto errout;
1535

1536
		retval = search_dirblock(bh, dir, fname, d_name,
1537 1538
					 block << EXT4_BLOCK_SIZE_BITS(sb),
					 res_dir);
1539 1540
		if (retval == 1)
			goto success;
1541
		brelse(bh);
1542
		if (retval == -1) {
1543
			bh = ERR_PTR(ERR_BAD_DX_DIR);
1544 1545 1546
			goto errout;
		}

1547
		/* Check to see if we should continue to search */
1548
		retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1549 1550
					       frames, NULL);
		if (retval < 0) {
1551 1552 1553
			ext4_warning_inode(dir,
				"error %d reading directory index block",
				retval);
1554
			bh = ERR_PTR(retval);
1555 1556 1557 1558
			goto errout;
		}
	} while (retval == 1);

1559
	bh = NULL;
1560
errout:
1561
	dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
1562 1563 1564
success:
	dx_release(frames);
	return bh;
1565 1566
}

A
Al Viro 已提交
1567
static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1568
{
1569 1570 1571
	struct inode *inode;
	struct ext4_dir_entry_2 *de;
	struct buffer_head *bh;
1572

1573 1574
	if (ext4_encrypted_inode(dir)) {
		int res = fscrypt_get_encryption_info(dir);
1575 1576

		/*
1577
		 * DCACHE_ENCRYPTED_WITH_KEY is set if the dentry is
1578
		 * created while the directory was encrypted and we
1579
		 * have access to the key.
1580
		 */
1581 1582 1583 1584 1585 1586
		if (fscrypt_has_encryption_key(dir))
			fscrypt_set_encrypted_dentry(dentry);
		fscrypt_set_d_op(dentry);
		if (res && res != -ENOKEY)
			return ERR_PTR(res);
	}
1587

1588 1589
       if (dentry->d_name.len > EXT4_NAME_LEN)
	       return ERR_PTR(-ENAMETOOLONG);
1590

T
Tao Ma 已提交
1591
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
1592 1593
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1594 1595
	inode = NULL;
	if (bh) {
1596
		__u32 ino = le32_to_cpu(de->inode);
1597
		brelse(bh);
1598
		if (!ext4_valid_inum(dir->i_sb, ino)) {
1599
			EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1600
			return ERR_PTR(-EFSCORRUPTED);
1601
		}
1602
		if (unlikely(ino == dir->i_ino)) {
D
David Howells 已提交
1603 1604
			EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
					 dentry);
1605
			return ERR_PTR(-EFSCORRUPTED);
1606
		}
1607
		inode = ext4_iget_normal(dir->i_sb, ino);
1608 1609 1610 1611
		if (inode == ERR_PTR(-ESTALE)) {
			EXT4_ERROR_INODE(dir,
					 "deleted inode referenced: %u",
					 ino);
1612
			return ERR_PTR(-EFSCORRUPTED);
1613
		}
1614
		if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
1615
		    (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
1616
		    !fscrypt_has_permitted_context(dir, inode)) {
1617
			int nokey = ext4_encrypted_inode(inode) &&
1618
				!fscrypt_has_encryption_key(inode);
1619
			iput(inode);
1620 1621
			if (nokey)
				return ERR_PTR(-ENOKEY);
1622
			ext4_warning(inode->i_sb,
1623
				     "Inconsistent encryption contexts: %lu/%lu",
1624 1625 1626 1627
				     (unsigned long) dir->i_ino,
				     (unsigned long) inode->i_ino);
			return ERR_PTR(-EPERM);
		}
1628 1629 1630 1631 1632
	}
	return d_splice_alias(inode, dentry);
}


1633
struct dentry *ext4_get_parent(struct dentry *child)
1634
{
1635
	__u32 ino;
1636
	static const struct qstr dotdot = QSTR_INIT("..", 2);
1637
	struct ext4_dir_entry_2 * de;
1638 1639
	struct buffer_head *bh;

1640
	bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
1641 1642
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1643 1644 1645 1646 1647
	if (!bh)
		return ERR_PTR(-ENOENT);
	ino = le32_to_cpu(de->inode);
	brelse(bh);

1648
	if (!ext4_valid_inum(child->d_sb, ino)) {
1649
		EXT4_ERROR_INODE(d_inode(child),
1650
				 "bad parent inode number: %u", ino);
1651
		return ERR_PTR(-EFSCORRUPTED);
1652 1653
	}

1654
	return d_obtain_alias(ext4_iget_normal(child->d_sb, ino));
1655 1656
}

1657 1658 1659 1660
/*
 * Move count entries from end of map between two memory locations.
 * Returns pointer to last entry moved.
 */
1661
static struct ext4_dir_entry_2 *
1662 1663
dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
		unsigned blocksize)
1664 1665 1666 1667
{
	unsigned rec_len = 0;

	while (count--) {
1668
		struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1669
						(from + (map->offs<<2));
1670
		rec_len = EXT4_DIR_REC_LEN(de->name_len);
1671
		memcpy (to, de, rec_len);
1672
		((struct ext4_dir_entry_2 *) to)->rec_len =
1673
				ext4_rec_len_to_disk(rec_len, blocksize);
1674 1675 1676 1677
		de->inode = 0;
		map++;
		to += rec_len;
	}
1678
	return (struct ext4_dir_entry_2 *) (to - rec_len);
1679 1680
}

1681 1682 1683 1684
/*
 * Compact each dir entry in the range to the minimal rec_len.
 * Returns pointer to last entry in range.
 */
1685
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
1686
{
1687
	struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1688 1689 1690
	unsigned rec_len = 0;

	prev = to = de;
1691
	while ((char*)de < base + blocksize) {
1692
		next = ext4_next_entry(de, blocksize);
1693
		if (de->inode && de->name_len) {
1694
			rec_len = EXT4_DIR_REC_LEN(de->name_len);
1695 1696
			if (de > to)
				memmove(to, de, rec_len);
1697
			to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1698
			prev = to;
1699
			to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1700 1701 1702 1703 1704 1705
		}
		de = next;
	}
	return prev;
}

1706 1707 1708 1709 1710
/*
 * 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.
 */
1711
static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1712
			struct buffer_head **bh,struct dx_frame *frame,
1713
			struct dx_hash_info *hinfo)
1714 1715 1716 1717
{
	unsigned blocksize = dir->i_sb->s_blocksize;
	unsigned count, continued;
	struct buffer_head *bh2;
A
Aneesh Kumar K.V 已提交
1718
	ext4_lblk_t newblock;
1719 1720 1721
	u32 hash2;
	struct dx_map_entry *map;
	char *data1 = (*bh)->b_data, *data2;
1722
	unsigned split, move, size;
1723
	struct ext4_dir_entry_2 *de = NULL, *de2;
1724 1725
	struct ext4_dir_entry_tail *t;
	int	csum_size = 0;
1726
	int	err = 0, i;
1727

1728
	if (ext4_has_metadata_csum(dir->i_sb))
1729 1730
		csum_size = sizeof(struct ext4_dir_entry_tail);

1731 1732
	bh2 = ext4_append(handle, dir, &newblock);
	if (IS_ERR(bh2)) {
1733 1734
		brelse(*bh);
		*bh = NULL;
1735
		return (struct ext4_dir_entry_2 *) bh2;
1736 1737 1738
	}

	BUFFER_TRACE(*bh, "get_write_access");
1739
	err = ext4_journal_get_write_access(handle, *bh);
1740 1741 1742
	if (err)
		goto journal_error;

1743
	BUFFER_TRACE(frame->bh, "get_write_access");
1744
	err = ext4_journal_get_write_access(handle, frame->bh);
1745 1746 1747 1748 1749 1750 1751
	if (err)
		goto journal_error;

	data2 = bh2->b_data;

	/* create map in the end of data2 block */
	map = (struct dx_map_entry *) (data2 + blocksize);
1752
	count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
1753 1754
			     blocksize, hinfo, map);
	map -= count;
1755
	dx_sort_map(map, count);
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
	/* 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;
1768 1769
	hash2 = map[split].hash;
	continued = hash2 == map[split - 1].hash;
A
Aneesh Kumar K.V 已提交
1770 1771 1772
	dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
			(unsigned long)dx_get_block(frame->at),
					hash2, split, count-split));
1773 1774

	/* Fancy dance to stay within two buffers */
1775 1776
	de2 = dx_move_dirents(data1, data2, map + split, count - split,
			      blocksize);
1777
	de = dx_pack_dirents(data1, blocksize);
1778 1779
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
1780
					   blocksize);
1781 1782
	de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
					    (char *) de2,
1783
					    blocksize);
1784 1785 1786 1787 1788 1789 1790 1791
	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);
	}

1792 1793 1794 1795
	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));
1796 1797

	/* Which block gets the new entry? */
1798
	if (hinfo->hash >= hash2) {
1799 1800 1801
		swap(*bh, bh2);
		de = de2;
	}
1802
	dx_insert_block(frame, hash2 + continued, newblock);
1803
	err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
1804 1805
	if (err)
		goto journal_error;
1806
	err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
1807 1808
	if (err)
		goto journal_error;
1809 1810
	brelse(bh2);
	dxtrace(dx_show_index("frame", frame->entries));
1811
	return de;
1812 1813 1814 1815 1816 1817

journal_error:
	brelse(*bh);
	brelse(bh2);
	*bh = NULL;
	ext4_std_error(dir->i_sb, err);
1818
	return ERR_PTR(err);
1819 1820
}

1821 1822 1823
int ext4_find_dest_de(struct inode *dir, struct inode *inode,
		      struct buffer_head *bh,
		      void *buf, int buf_size,
1824
		      struct ext4_filename *fname,
1825 1826 1827
		      struct ext4_dir_entry_2 **dest_de)
{
	struct ext4_dir_entry_2 *de;
1828
	unsigned short reclen = EXT4_DIR_REC_LEN(fname_len(fname));
1829 1830 1831
	int nlen, rlen;
	unsigned int offset = 0;
	char *top;
1832 1833
	int res;

1834 1835 1836 1837
	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,
1838
					 buf, buf_size, offset)) {
1839
			res = -EFSCORRUPTED;
1840 1841 1842
			goto return_result;
		}
		/* Provide crypto context and crypto buffer to ext4 match */
1843
		res = ext4_match(fname, de);
1844 1845 1846 1847 1848 1849
		if (res < 0)
			goto return_result;
		if (res > 0) {
			res = -EEXIST;
			goto return_result;
		}
1850 1851 1852 1853 1854 1855 1856 1857
		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;
	}

1858 1859 1860 1861 1862 1863 1864 1865
	if ((char *) de > top)
		res = -ENOSPC;
	else {
		*dest_de = de;
		res = 0;
	}
return_result:
	return res;
1866 1867
}

1868 1869 1870 1871
int ext4_insert_dentry(struct inode *dir,
		       struct inode *inode,
		       struct ext4_dir_entry_2 *de,
		       int buf_size,
1872
		       struct ext4_filename *fname)
1873 1874 1875 1876 1877 1878 1879 1880
{

	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 =
1881
			(struct ext4_dir_entry_2 *)((char *)de + nlen);
1882 1883 1884 1885 1886 1887 1888
		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);
1889 1890
	de->name_len = fname_len(fname);
	memcpy(de->name, fname_name(fname), fname_len(fname));
1891
	return 0;
1892
}
1893

1894 1895 1896 1897 1898 1899 1900 1901
/*
 * 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.
 */
1902 1903
static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
			     struct inode *dir,
1904
			     struct inode *inode, struct ext4_dir_entry_2 *de,
1905
			     struct buffer_head *bh)
1906
{
1907
	unsigned int	blocksize = dir->i_sb->s_blocksize;
1908
	int		csum_size = 0;
1909
	int		err;
1910

1911
	if (ext4_has_metadata_csum(inode->i_sb))
1912
		csum_size = sizeof(struct ext4_dir_entry_tail);
1913 1914

	if (!de) {
1915 1916
		err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
					blocksize - csum_size, fname, &de);
1917 1918
		if (err)
			return err;
1919 1920
	}
	BUFFER_TRACE(bh, "get_write_access");
1921
	err = ext4_journal_get_write_access(handle, bh);
1922
	if (err) {
1923
		ext4_std_error(dir->i_sb, err);
1924 1925 1926
		return err;
	}

1927 1928
	/* By now the buffer is marked for journaling. Due to crypto operations,
	 * the following function call may fail */
1929
	err = ext4_insert_dentry(dir, inode, de, blocksize, fname);
1930 1931
	if (err < 0)
		return err;
1932

1933 1934 1935 1936 1937 1938
	/*
	 * 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
1939
	 * ext4_new_inode() setting the times, but error
1940 1941 1942 1943
	 * 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.
	 */
1944
	dir->i_mtime = dir->i_ctime = current_time(dir);
1945
	ext4_update_dx_flag(dir);
1946
	dir->i_version++;
1947
	ext4_mark_inode_dirty(handle, dir);
1948
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1949
	err = ext4_handle_dirty_dirent_node(handle, dir, bh);
1950
	if (err)
1951
		ext4_std_error(dir->i_sb, err);
1952 1953 1954 1955 1956 1957 1958
	return 0;
}

/*
 * This converts a one block unindexed directory to a 3 block indexed
 * directory, and adds the dentry to the indexed directory.
 */
1959
static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
1960
			    struct inode *dir,
1961 1962 1963 1964 1965 1966
			    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;
1967
	struct ext4_dir_entry_2	*de, *de2;
1968
	struct ext4_dir_entry_tail *t;
1969 1970 1971 1972
	char		*data1, *top;
	unsigned	len;
	int		retval;
	unsigned	blocksize;
A
Aneesh Kumar K.V 已提交
1973
	ext4_lblk_t  block;
1974
	struct fake_dirent *fde;
1975 1976
	int csum_size = 0;

1977
	if (ext4_has_metadata_csum(inode->i_sb))
1978
		csum_size = sizeof(struct ext4_dir_entry_tail);
1979 1980

	blocksize =  dir->i_sb->s_blocksize;
1981
	dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
1982
	BUFFER_TRACE(bh, "get_write_access");
1983
	retval = ext4_journal_get_write_access(handle, bh);
1984
	if (retval) {
1985
		ext4_std_error(dir->i_sb, retval);
1986 1987 1988 1989 1990
		brelse(bh);
		return retval;
	}
	root = (struct dx_root *) bh->b_data;

1991 1992 1993
	/* The 0th block becomes the root, move the dirents out */
	fde = &root->dotdot;
	de = (struct ext4_dir_entry_2 *)((char *)fde +
1994
		ext4_rec_len_from_disk(fde->rec_len, blocksize));
1995
	if ((char *) de >= (((char *) root) + blocksize)) {
1996
		EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
1997
		brelse(bh);
1998
		return -EFSCORRUPTED;
1999
	}
2000
	len = ((char *) root) + (blocksize - csum_size) - (char *) de;
2001 2002

	/* Allocate new block for the 0th block's dirents */
2003 2004
	bh2 = ext4_append(handle, dir, &block);
	if (IS_ERR(bh2)) {
2005
		brelse(bh);
2006
		return PTR_ERR(bh2);
2007
	}
2008
	ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2009 2010 2011
	data1 = bh2->b_data;

	memcpy (data1, de, len);
2012
	de = (struct ext4_dir_entry_2 *) data1;
2013
	top = data1 + len;
2014
	while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
2015
		de = de2;
2016 2017
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
2018
					   blocksize);
2019 2020 2021 2022 2023 2024

	if (csum_size) {
		t = EXT4_DIRENT_TAIL(data1, blocksize);
		initialize_dirent_tail(t, blocksize);
	}

2025
	/* Initialize the root; the dot dirents already exist */
2026
	de = (struct ext4_dir_entry_2 *) (&root->dotdot);
2027 2028
	de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
					   blocksize);
2029 2030
	memset (&root->info, 0, sizeof(root->info));
	root->info.info_length = sizeof(root->info);
2031
	root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
2032
	entries = root->entries;
2033 2034 2035
	dx_set_block(entries, 1);
	dx_set_count(entries, 1);
	dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2036 2037

	/* Initialize as for dx_probe */
2038 2039 2040 2041 2042 2043
	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);

2044
	memset(frames, 0, sizeof(frames));
2045 2046 2047 2048
	frame = frames;
	frame->entries = entries;
	frame->at = entries;
	frame->bh = bh;
2049

2050 2051 2052
	retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
	if (retval)
		goto out_frames;	
G
gmail 已提交
2053
	retval = ext4_handle_dirty_dirent_node(handle, dir, bh2);
2054 2055
	if (retval)
		goto out_frames;	
2056

G
gmail 已提交
2057
	de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2058
	if (IS_ERR(de)) {
2059 2060
		retval = PTR_ERR(de);
		goto out_frames;
2061
	}
2062

G
gmail 已提交
2063
	retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2064 2065 2066 2067 2068 2069
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.
	 */
G
gmail 已提交
2070 2071
	if (retval)
		ext4_mark_inode_dirty(handle, dir);
2072
	dx_release(frames);
G
gmail 已提交
2073
	brelse(bh2);
2074
	return retval;
2075 2076 2077
}

/*
2078
 *	ext4_add_entry()
2079 2080
 *
 * adds a file entry to the specified directory, using the same
2081
 * semantics as ext4_find_entry(). It returns NULL if it failed.
2082 2083 2084 2085 2086
 *
 * 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.
 */
2087 2088
static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
			  struct inode *inode)
2089
{
2090
	struct inode *dir = d_inode(dentry->d_parent);
2091
	struct buffer_head *bh = NULL;
2092
	struct ext4_dir_entry_2 *de;
2093
	struct ext4_dir_entry_tail *t;
2094
	struct super_block *sb;
2095
	struct ext4_filename fname;
2096 2097 2098
	int	retval;
	int	dx_fallback=0;
	unsigned blocksize;
A
Aneesh Kumar K.V 已提交
2099
	ext4_lblk_t block, blocks;
2100 2101
	int	csum_size = 0;

2102
	if (ext4_has_metadata_csum(inode->i_sb))
2103
		csum_size = sizeof(struct ext4_dir_entry_tail);
2104 2105 2106 2107 2108

	sb = dir->i_sb;
	blocksize = sb->s_blocksize;
	if (!dentry->d_name.len)
		return -EINVAL;
2109

2110 2111 2112 2113
	retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
	if (retval)
		return retval;

2114
	if (ext4_has_inline_data(dir)) {
2115
		retval = ext4_try_add_inline_entry(handle, &fname, dir, inode);
2116
		if (retval < 0)
2117
			goto out;
2118 2119
		if (retval == 1) {
			retval = 0;
2120
			goto out;
2121 2122 2123
		}
	}

2124
	if (is_dx(dir)) {
2125
		retval = ext4_dx_add_entry(handle, &fname, dir, inode);
2126
		if (!retval || (retval != ERR_BAD_DX_DIR))
2127
			goto out;
2128
		ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2129
		dx_fallback++;
2130
		ext4_mark_inode_dirty(handle, dir);
2131 2132
	}
	blocks = dir->i_size >> sb->s_blocksize_bits;
2133
	for (block = 0; block < blocks; block++) {
2134
		bh = ext4_read_dirblock(dir, block, DIRENT);
2135 2136 2137 2138 2139 2140 2141
		if (IS_ERR(bh)) {
			retval = PTR_ERR(bh);
			bh = NULL;
			goto out;
		}
		retval = add_dirent_to_buf(handle, &fname, dir, inode,
					   NULL, bh);
2142 2143
		if (retval != -ENOSPC)
			goto out;
2144 2145

		if (blocks == 1 && !dx_fallback &&
2146
		    ext4_has_feature_dir_index(sb)) {
2147
			retval = make_indexed_dir(handle, &fname, dir,
2148
						  inode, bh);
2149 2150 2151
			bh = NULL; /* make_indexed_dir releases bh */
			goto out;
		}
2152 2153
		brelse(bh);
	}
2154
	bh = ext4_append(handle, dir, &block);
2155 2156 2157 2158 2159
	if (IS_ERR(bh)) {
		retval = PTR_ERR(bh);
		bh = NULL;
		goto out;
	}
2160
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2161
	de->inode = 0;
2162 2163 2164 2165 2166 2167 2168
	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);
	}

2169
	retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2170
out:
2171
	ext4_fname_free_filename(&fname);
2172
	brelse(bh);
2173 2174
	if (retval == 0)
		ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
2175
	return retval;
2176 2177 2178 2179 2180
}

/*
 * Returns 0 for success, or a negative error value
 */
2181
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
2182
			     struct inode *dir, struct inode *inode)
2183 2184 2185
{
	struct dx_frame frames[2], *frame;
	struct dx_entry *entries, *at;
2186 2187
	struct buffer_head *bh;
	struct super_block *sb = dir->i_sb;
2188
	struct ext4_dir_entry_2 *de;
2189 2190
	int err;

2191
	frame = dx_probe(fname, dir, NULL, frames);
2192 2193
	if (IS_ERR(frame))
		return PTR_ERR(frame);
2194 2195
	entries = frame->entries;
	at = frame->at;
2196 2197 2198 2199
	bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
	if (IS_ERR(bh)) {
		err = PTR_ERR(bh);
		bh = NULL;
2200
		goto cleanup;
C
Carlos Maiolino 已提交
2201
	}
2202 2203

	BUFFER_TRACE(bh, "get_write_access");
2204
	err = ext4_journal_get_write_access(handle, bh);
2205 2206 2207
	if (err)
		goto journal_error;

2208
	err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2209
	if (err != -ENOSPC)
2210 2211 2212
		goto cleanup;

	/* Block full, should compress but for now just split */
2213
	dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
2214 2215 2216
		       dx_get_count(entries), dx_get_limit(entries)));
	/* Need to split index? */
	if (dx_get_count(entries) == dx_get_limit(entries)) {
A
Aneesh Kumar K.V 已提交
2217
		ext4_lblk_t newblock;
2218 2219 2220 2221 2222 2223 2224 2225
		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))) {
2226
			ext4_warning_inode(dir, "Directory index full!");
2227 2228 2229
			err = -ENOSPC;
			goto cleanup;
		}
2230 2231 2232
		bh2 = ext4_append(handle, dir, &newblock);
		if (IS_ERR(bh2)) {
			err = PTR_ERR(bh2);
2233
			goto cleanup;
2234
		}
2235 2236
		node2 = (struct dx_node *)(bh2->b_data);
		entries2 = node2->entries;
2237
		memset(&node2->fake, 0, sizeof(struct fake_dirent));
2238 2239
		node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
							   sb->s_blocksize);
2240
		BUFFER_TRACE(frame->bh, "get_write_access");
2241
		err = ext4_journal_get_write_access(handle, frame->bh);
2242 2243 2244 2245 2246
		if (err)
			goto journal_error;
		if (levels) {
			unsigned icount1 = icount/2, icount2 = icount - icount1;
			unsigned hash2 = dx_get_hash(entries + icount1);
2247 2248
			dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
				       icount1, icount2));
2249 2250

			BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2251
			err = ext4_journal_get_write_access(handle,
2252 2253 2254 2255
							     frames[0].bh);
			if (err)
				goto journal_error;

2256 2257 2258 2259 2260
			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));
2261 2262 2263 2264 2265 2266 2267

			/* 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);
			}
2268 2269 2270
			dx_insert_block(frames + 0, hash2, newblock);
			dxtrace(dx_show_index("node", frames[1].entries));
			dxtrace(dx_show_index("node",
2271
			       ((struct dx_node *) bh2->b_data)->entries));
2272
			err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2273 2274 2275 2276
			if (err)
				goto journal_error;
			brelse (bh2);
		} else {
2277 2278
			dxtrace(printk(KERN_DEBUG
				       "Creating second level index...\n"));
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292
			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;
2293
			err = ext4_journal_get_write_access(handle,
2294 2295 2296 2297
							     frame->bh);
			if (err)
				goto journal_error;
		}
2298
		err = ext4_handle_dirty_dx_node(handle, dir, frames[0].bh);
2299 2300 2301 2302
		if (err) {
			ext4_std_error(inode->i_sb, err);
			goto cleanup;
		}
2303
	}
2304
	de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2305 2306
	if (IS_ERR(de)) {
		err = PTR_ERR(de);
2307
		goto cleanup;
2308
	}
2309
	err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2310 2311 2312
	goto cleanup;

journal_error:
2313
	ext4_std_error(dir->i_sb, err);
2314
cleanup:
2315
	brelse(bh);
2316 2317 2318 2319 2320
	dx_release(frames);
	return err;
}

/*
T
Tao Ma 已提交
2321 2322
 * ext4_generic_delete_entry deletes a directory entry by merging it
 * with the previous entry
2323
 */
T
Tao Ma 已提交
2324 2325 2326 2327 2328 2329 2330
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)
2331
{
2332
	struct ext4_dir_entry_2 *de, *pde;
2333
	unsigned int blocksize = dir->i_sb->s_blocksize;
T
Tao Ma 已提交
2334
	int i;
2335

2336 2337
	i = 0;
	pde = NULL;
T
Tao Ma 已提交
2338 2339
	de = (struct ext4_dir_entry_2 *)entry_buf;
	while (i < buf_size - csum_size) {
2340 2341
		if (ext4_check_dir_entry(dir, NULL, de, bh,
					 bh->b_data, bh->b_size, i))
2342
			return -EFSCORRUPTED;
2343 2344
		if (de == de_del)  {
			if (pde)
2345
				pde->rec_len = ext4_rec_len_to_disk(
2346 2347 2348 2349 2350
					ext4_rec_len_from_disk(pde->rec_len,
							       blocksize) +
					ext4_rec_len_from_disk(de->rec_len,
							       blocksize),
					blocksize);
2351 2352 2353 2354 2355
			else
				de->inode = 0;
			dir->i_version++;
			return 0;
		}
2356
		i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2357
		pde = de;
2358
		de = ext4_next_entry(de, blocksize);
2359 2360 2361 2362
	}
	return -ENOENT;
}

T
Tao Ma 已提交
2363 2364 2365 2366 2367 2368 2369
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;

2370 2371 2372 2373 2374 2375 2376 2377
	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;
	}

2378
	if (ext4_has_metadata_csum(dir->i_sb))
T
Tao Ma 已提交
2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
		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;
}

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
/*
 * 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) {
M
Miklos Szeredi 已提交
2414
			set_nlink(inode, 1);
2415
			ext4_set_feature_dir_nlink(inode->i_sb);
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425
		}
	}
}

/*
 * 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)
{
2426 2427
	if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
		drop_nlink(inode);
2428 2429 2430
}


2431
static int ext4_add_nondir(handle_t *handle,
2432 2433
		struct dentry *dentry, struct inode *inode)
{
2434
	int err = ext4_add_entry(handle, dentry, inode);
2435
	if (!err) {
2436
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
2437
		unlock_new_inode(inode);
2438
		d_instantiate(dentry, inode);
2439 2440
		return 0;
	}
2441
	drop_nlink(inode);
A
Al Viro 已提交
2442
	unlock_new_inode(inode);
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454
	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().
 */
A
Al Viro 已提交
2455
static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
A
Al Viro 已提交
2456
		       bool excl)
2457 2458
{
	handle_t *handle;
2459
	struct inode *inode;
2460
	int err, credits, retries = 0;
2461

2462 2463 2464
	err = dquot_initialize(dir);
	if (err)
		return err;
2465

2466
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2467
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2468
retry:
2469 2470 2471
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2472 2473
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
2474
		inode->i_op = &ext4_file_inode_operations;
2475
		inode->i_fop = &ext4_file_operations;
2476
		ext4_set_aops(inode);
2477
		err = ext4_add_nondir(handle, dentry, inode);
2478 2479
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2480
	}
2481 2482
	if (handle)
		ext4_journal_stop(handle);
2483
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2484 2485 2486 2487
		goto retry;
	return err;
}

2488
static int ext4_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
2489
		      umode_t mode, dev_t rdev)
2490 2491 2492
{
	handle_t *handle;
	struct inode *inode;
2493
	int err, credits, retries = 0;
2494

2495 2496 2497
	err = dquot_initialize(dir);
	if (err)
		return err;
2498

2499
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2500
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2501
retry:
2502 2503 2504
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2505 2506 2507
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
		init_special_inode(inode, inode->i_mode, rdev);
2508 2509
		inode->i_op = &ext4_special_inode_operations;
		err = ext4_add_nondir(handle, dentry, inode);
2510 2511
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2512
	}
2513 2514
	if (handle)
		ext4_journal_stop(handle);
2515
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2516 2517 2518 2519
		goto retry;
	return err;
}

A
Al Viro 已提交
2520 2521 2522 2523 2524 2525
static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
{
	handle_t *handle;
	struct inode *inode;
	int err, retries = 0;

2526 2527 2528
	err = dquot_initialize(dir);
	if (err)
		return err;
A
Al Viro 已提交
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539

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;
2540
		inode->i_fop = &ext4_file_operations;
A
Al Viro 已提交
2541
		ext4_set_aops(inode);
2542
		d_tmpfile(dentry, inode);
A
Al Viro 已提交
2543 2544
		err = ext4_orphan_add(handle, inode);
		if (err)
2545
			goto err_unlock_inode;
A
Al Viro 已提交
2546 2547 2548 2549 2550 2551 2552 2553
		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;
2554
err_unlock_inode:
A
Al Viro 已提交
2555 2556 2557 2558 2559
	ext4_journal_stop(handle);
	unlock_new_inode(inode);
	return err;
}

2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589
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)
2590
{
2591
	struct buffer_head *dir_block = NULL;
2592
	struct ext4_dir_entry_2 *de;
2593
	struct ext4_dir_entry_tail *t;
2594
	ext4_lblk_t block = 0;
2595
	unsigned int blocksize = dir->i_sb->s_blocksize;
2596
	int csum_size = 0;
2597
	int err;
2598

2599
	if (ext4_has_metadata_csum(dir->i_sb))
2600 2601
		csum_size = sizeof(struct ext4_dir_entry_tail);

2602 2603 2604 2605 2606 2607 2608 2609
	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;
	}

2610
	inode->i_size = 0;
2611 2612 2613
	dir_block = ext4_append(handle, inode, &block);
	if (IS_ERR(dir_block))
		return PTR_ERR(dir_block);
2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635
	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;
2636
	int err, credits, retries = 0;
2637

2638
	if (EXT4_DIR_LINK_MAX(dir))
2639 2640
		return -EMLINK;

2641 2642 2643
	err = dquot_initialize(dir);
	if (err)
		return err;
2644

2645
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2646
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2647
retry:
2648 2649 2650 2651
	inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
					    &dentry->d_name,
					    0, NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2652 2653 2654 2655
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_stop;

2656 2657
	inode->i_op = &ext4_dir_inode_operations;
	inode->i_fop = &ext4_dir_operations;
2658
	err = ext4_init_new_dir(handle, dir, inode);
2659 2660 2661 2662 2663
	if (err)
		goto out_clear_inode;
	err = ext4_mark_inode_dirty(handle, inode);
	if (!err)
		err = ext4_add_entry(handle, dentry, inode);
2664
	if (err) {
2665 2666
out_clear_inode:
		clear_nlink(inode);
A
Al Viro 已提交
2667
		unlock_new_inode(inode);
2668
		ext4_mark_inode_dirty(handle, inode);
2669
		iput(inode);
2670 2671
		goto out_stop;
	}
2672
	ext4_inc_count(handle, dir);
2673
	ext4_update_dx_flag(dir);
2674 2675 2676
	err = ext4_mark_inode_dirty(handle, dir);
	if (err)
		goto out_clear_inode;
A
Al Viro 已提交
2677
	unlock_new_inode(inode);
2678
	d_instantiate(dentry, inode);
2679 2680 2681
	if (IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

2682
out_stop:
2683 2684
	if (handle)
		ext4_journal_stop(handle);
2685
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2686 2687 2688 2689 2690 2691 2692
		goto retry;
	return err;
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
2693
bool ext4_empty_dir(struct inode *inode)
2694
{
2695
	unsigned int offset;
2696 2697 2698
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de, *de1;
	struct super_block *sb;
2699

T
Tao Ma 已提交
2700 2701
	if (ext4_has_inline_data(inode)) {
		int has_inline_data = 1;
2702
		int ret;
T
Tao Ma 已提交
2703

2704
		ret = empty_inline_dir(inode, &has_inline_data);
T
Tao Ma 已提交
2705
		if (has_inline_data)
2706
			return ret;
T
Tao Ma 已提交
2707 2708
	}

2709
	sb = inode->i_sb;
2710 2711
	if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
		EXT4_ERROR_INODE(inode, "invalid size");
2712
		return true;
2713
	}
2714 2715
	bh = ext4_read_dirblock(inode, 0, EITHER);
	if (IS_ERR(bh))
2716
		return true;
2717

2718
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2719
	de1 = ext4_next_entry(de, sb->s_blocksize);
2720
	if (le32_to_cpu(de->inode) != inode->i_ino ||
2721 2722 2723
			le32_to_cpu(de1->inode) == 0 ||
			strcmp(".", de->name) || strcmp("..", de1->name)) {
		ext4_warning_inode(inode, "directory missing '.' and/or '..'");
2724
		brelse(bh);
2725
		return true;
2726
	}
2727 2728 2729
	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);
2730
	while (offset < inode->i_size) {
D
Dmitry Monakhov 已提交
2731
		if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
2732
			unsigned int lblock;
2733
			brelse(bh);
2734
			lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
2735 2736
			bh = ext4_read_dirblock(inode, lblock, EITHER);
			if (IS_ERR(bh))
2737
				return true;
2738
			de = (struct ext4_dir_entry_2 *) bh->b_data;
2739
		}
2740 2741
		if (ext4_check_dir_entry(inode, NULL, de, bh,
					 bh->b_data, bh->b_size, offset)) {
2742
			de = (struct ext4_dir_entry_2 *)(bh->b_data +
2743 2744 2745 2746 2747
							 sb->s_blocksize);
			offset = (offset | (sb->s_blocksize - 1)) + 1;
			continue;
		}
		if (le32_to_cpu(de->inode)) {
2748
			brelse(bh);
2749
			return false;
2750
		}
2751 2752
		offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
		de = ext4_next_entry(de, sb->s_blocksize);
2753
	}
2754
	brelse(bh);
2755
	return true;
2756 2757
}

2758 2759
/*
 * ext4_orphan_add() links an unlinked or truncated inode into a list of
2760 2761 2762 2763 2764
 * 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
2765
 * inodes and truncating linked inodes in ext4_orphan_cleanup().
2766 2767 2768
 *
 * Orphan list manipulation functions must be called under i_mutex unless
 * we are just creating the inode or deleting it.
2769
 */
2770
int ext4_orphan_add(handle_t *handle, struct inode *inode)
2771 2772
{
	struct super_block *sb = inode->i_sb;
2773
	struct ext4_sb_info *sbi = EXT4_SB(sb);
2774
	struct ext4_iloc iloc;
2775
	int err = 0, rc;
2776
	bool dirty = false;
2777

2778
	if (!sbi->s_journal || is_bad_inode(inode))
2779 2780
		return 0;

2781
	WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
A
Al Viro 已提交
2782
		     !inode_is_locked(inode));
2783 2784 2785 2786
	/*
	 * 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.
	 */
2787
	if (!list_empty(&EXT4_I(inode)->i_orphan))
2788
		return 0;
2789

2790 2791 2792 2793 2794
	/*
	 * 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
2795
	 */
2796 2797
	J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		  S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
2798

2799 2800
	BUFFER_TRACE(sbi->s_sbh, "get_write_access");
	err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2801
	if (err)
2802
		goto out;
2803

2804
	err = ext4_reserve_inode_write(handle, inode, &iloc);
2805
	if (err)
2806 2807 2808
		goto out;

	mutex_lock(&sbi->s_orphan_lock);
2809 2810 2811 2812
	/*
	 * Due to previous errors inode may be already a part of on-disk
	 * orphan list. If so skip on-disk list modification.
	 */
2813 2814 2815 2816 2817 2818 2819 2820 2821
	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);
2822

2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834
	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);
2835
			list_del_init(&EXT4_I(inode)->i_orphan);
2836 2837 2838
			mutex_unlock(&sbi->s_orphan_lock);
		}
	}
2839 2840 2841
	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));
2842
out:
2843
	ext4_std_error(sb, err);
2844 2845 2846 2847
	return err;
}

/*
2848
 * ext4_orphan_del() removes an unlinked or truncated inode from the list
2849 2850
 * of such inodes stored on disk, because it is finally being cleaned up.
 */
2851
int ext4_orphan_del(handle_t *handle, struct inode *inode)
2852 2853
{
	struct list_head *prev;
2854
	struct ext4_inode_info *ei = EXT4_I(inode);
2855
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2856
	__u32 ino_next;
2857
	struct ext4_iloc iloc;
2858 2859
	int err = 0;

2860
	if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
2861 2862
		return 0;

2863
	WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
A
Al Viro 已提交
2864
		     !inode_is_locked(inode));
2865
	/* Do this quick check before taking global s_orphan_lock. */
2866
	if (list_empty(&ei->i_orphan))
2867
		return 0;
2868

2869 2870 2871 2872
	if (handle) {
		/* Grab inode buffer early before taking global s_orphan_lock */
		err = ext4_reserve_inode_write(handle, inode, &iloc);
	}
2873

2874
	mutex_lock(&sbi->s_orphan_lock);
2875 2876
	jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);

2877
	prev = ei->i_orphan.prev;
2878 2879 2880 2881 2882 2883
	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. */
2884 2885
	if (!handle || err) {
		mutex_unlock(&sbi->s_orphan_lock);
2886
		goto out_err;
2887
	}
2888

2889
	ino_next = NEXT_ORPHAN(inode);
2890
	if (prev == &sbi->s_orphan) {
2891
		jbd_debug(4, "superblock will point to %u\n", ino_next);
2892
		BUFFER_TRACE(sbi->s_sbh, "get_write_access");
2893
		err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2894 2895
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
2896
			goto out_brelse;
2897
		}
2898
		sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
2899
		mutex_unlock(&sbi->s_orphan_lock);
2900
		err = ext4_handle_dirty_super(handle, inode->i_sb);
2901
	} else {
2902
		struct ext4_iloc iloc2;
2903
		struct inode *i_prev =
2904
			&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
2905

2906
		jbd_debug(4, "orphan inode %lu will point to %u\n",
2907
			  i_prev->i_ino, ino_next);
2908
		err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
2909 2910
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
2911
			goto out_brelse;
2912
		}
2913
		NEXT_ORPHAN(i_prev) = ino_next;
2914
		err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
2915
		mutex_unlock(&sbi->s_orphan_lock);
2916 2917 2918 2919
	}
	if (err)
		goto out_brelse;
	NEXT_ORPHAN(inode) = 0;
2920
	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
2921
out_err:
2922
	ext4_std_error(inode->i_sb, err);
2923 2924 2925 2926 2927 2928 2929
	return err;

out_brelse:
	brelse(iloc.bh);
	goto out_err;
}

2930
static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
2931 2932
{
	int retval;
2933 2934 2935
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
2936
	handle_t *handle = NULL;
2937 2938 2939

	/* Initialize quotas before so that eventual writes go in
	 * separate transaction */
2940 2941 2942 2943 2944 2945
	retval = dquot_initialize(dir);
	if (retval)
		return retval;
	retval = dquot_initialize(d_inode(dentry));
	if (retval)
		return retval;
2946

2947
	retval = -ENOENT;
T
Tao Ma 已提交
2948
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
2949 2950
	if (IS_ERR(bh))
		return PTR_ERR(bh);
2951 2952 2953
	if (!bh)
		goto end_rmdir;

2954
	inode = d_inode(dentry);
2955

2956
	retval = -EFSCORRUPTED;
2957 2958 2959 2960
	if (le32_to_cpu(de->inode) != inode->i_ino)
		goto end_rmdir;

	retval = -ENOTEMPTY;
2961
	if (!ext4_empty_dir(inode))
2962 2963
		goto end_rmdir;

2964
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
2965
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
2966 2967 2968 2969 2970 2971 2972 2973 2974
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rmdir;
	}

	if (IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

2975
	retval = ext4_delete_entry(handle, dir, de, bh);
2976 2977
	if (retval)
		goto end_rmdir;
2978
	if (!EXT4_DIR_LINK_EMPTY(inode))
2979 2980 2981
		ext4_warning_inode(inode,
			     "empty directory '%.*s' has too many links (%u)",
			     dentry->d_name.len, dentry->d_name.name,
2982
			     inode->i_nlink);
2983 2984 2985 2986 2987 2988
	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;
2989
	ext4_orphan_add(handle, inode);
2990
	inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
2991
	ext4_mark_inode_dirty(handle, inode);
2992
	ext4_dec_count(handle, dir);
2993 2994
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
2995 2996

end_rmdir:
2997
	brelse(bh);
2998 2999
	if (handle)
		ext4_journal_stop(handle);
3000 3001 3002
	return retval;
}

3003
static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3004 3005
{
	int retval;
3006 3007 3008
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
3009
	handle_t *handle = NULL;
3010

3011
	trace_ext4_unlink_enter(dir, dentry);
3012 3013
	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
3014 3015 3016 3017 3018 3019
	retval = dquot_initialize(dir);
	if (retval)
		return retval;
	retval = dquot_initialize(d_inode(dentry));
	if (retval)
		return retval;
3020

3021
	retval = -ENOENT;
T
Tao Ma 已提交
3022
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3023 3024
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3025 3026 3027
	if (!bh)
		goto end_unlink;

3028
	inode = d_inode(dentry);
3029

3030
	retval = -EFSCORRUPTED;
3031 3032 3033
	if (le32_to_cpu(de->inode) != inode->i_ino)
		goto end_unlink;

3034
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
3035
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3036 3037 3038 3039 3040 3041 3042 3043 3044
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_unlink;
	}

	if (IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

3045 3046 3047
	if (inode->i_nlink == 0) {
		ext4_warning_inode(inode, "Deleting file '%.*s' with no links",
				   dentry->d_name.len, dentry->d_name.name);
M
Miklos Szeredi 已提交
3048
		set_nlink(inode, 1);
3049
	}
3050
	retval = ext4_delete_entry(handle, dir, de, bh);
3051 3052
	if (retval)
		goto end_unlink;
3053
	dir->i_ctime = dir->i_mtime = current_time(dir);
3054 3055
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
3056
	drop_nlink(inode);
3057
	if (!inode->i_nlink)
3058
		ext4_orphan_add(handle, inode);
3059
	inode->i_ctime = current_time(inode);
3060
	ext4_mark_inode_dirty(handle, inode);
3061 3062

end_unlink:
3063
	brelse(bh);
3064 3065
	if (handle)
		ext4_journal_stop(handle);
3066
	trace_ext4_unlink_exit(dentry, retval);
3067 3068 3069
	return retval;
}

3070 3071
static int ext4_symlink(struct inode *dir,
			struct dentry *dentry, const char *symname)
3072 3073
{
	handle_t *handle;
3074
	struct inode *inode;
3075
	int err, len = strlen(symname);
3076
	int credits;
3077
	bool encryption_required;
3078 3079
	struct fscrypt_str disk_link;
	struct fscrypt_symlink_data *sd = NULL;
3080

3081 3082 3083
	disk_link.len = len + 1;
	disk_link.name = (char *) symname;

3084 3085
	encryption_required = (ext4_encrypted_inode(dir) ||
			       DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb)));
3086
	if (encryption_required) {
3087
		err = fscrypt_get_encryption_info(dir);
3088 3089
		if (err)
			return err;
3090
		if (!fscrypt_has_encryption_key(dir))
3091
			return -EPERM;
3092 3093
		disk_link.len = (fscrypt_fname_encrypted_size(dir, len) +
				 sizeof(struct fscrypt_symlink_data));
3094 3095 3096 3097 3098 3099 3100 3101 3102
		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;
	}
3103

3104 3105
	err = dquot_initialize(dir);
	if (err)
3106
		goto err_free_sd;
3107

3108
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3109 3110 3111
		/*
		 * For non-fast symlinks, we just allocate inode and put it on
		 * orphan list in the first transaction => we need bitmap,
3112 3113
		 * group descriptor, sb, inode block, quota blocks, and
		 * possibly selinux xattr blocks.
3114
		 */
3115 3116
		credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
			  EXT4_XATTR_TRANS_BLOCKS;
3117 3118 3119 3120 3121 3122 3123 3124
	} 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) +
3125
			  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3126
	}
3127

3128 3129 3130 3131
	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();
3132 3133 3134
	if (IS_ERR(inode)) {
		if (handle)
			ext4_journal_stop(handle);
3135 3136
		err = PTR_ERR(inode);
		goto err_free_sd;
3137 3138 3139 3140
	}

	if (encryption_required) {
		struct qstr istr;
3141 3142
		struct fscrypt_str ostr =
			FSTR_INIT(sd->encrypted_path, disk_link.len);
3143 3144 3145

		istr.name = (const unsigned char *) symname;
		istr.len = len;
3146
		err = fscrypt_fname_usr_to_disk(inode, &istr, &ostr);
3147
		if (err)
3148 3149 3150
			goto err_drop_inode;
		sd->len = cpu_to_le16(ostr.len);
		disk_link.name = (char *) sd;
3151
		inode->i_op = &ext4_encrypted_symlink_inode_operations;
3152
	}
3153

3154
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3155 3156
		if (!encryption_required)
			inode->i_op = &ext4_symlink_inode_operations;
3157
		inode_nohighmem(inode);
3158
		ext4_set_aops(inode);
3159
		/*
3160 3161 3162 3163 3164 3165 3166 3167
		 * 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.
3168
		 */
3169 3170 3171
		drop_nlink(inode);
		err = ext4_orphan_add(handle, inode);
		ext4_journal_stop(handle);
3172
		handle = NULL;
3173 3174
		if (err)
			goto err_drop_inode;
3175
		err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
3176 3177 3178 3179 3180 3181
		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
		 */
3182
		handle = ext4_journal_start(dir, EXT4_HT_DIR,
3183 3184 3185 3186
				EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
				EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
		if (IS_ERR(handle)) {
			err = PTR_ERR(handle);
3187
			handle = NULL;
3188 3189
			goto err_drop_inode;
		}
3190
		set_nlink(inode, 1);
3191
		err = ext4_orphan_del(handle, inode);
3192
		if (err)
3193
			goto err_drop_inode;
3194
	} else {
3195
		/* clear the extent format for fast symlink */
3196
		ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
A
Al Viro 已提交
3197
		if (!encryption_required) {
3198
			inode->i_op = &ext4_fast_symlink_inode_operations;
A
Al Viro 已提交
3199 3200
			inode->i_link = (char *)&EXT4_I(inode)->i_data;
		}
3201 3202 3203
		memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
		       disk_link.len);
		inode->i_size = disk_link.len - 1;
3204
	}
3205 3206
	EXT4_I(inode)->i_disksize = inode->i_size;
	err = ext4_add_nondir(handle, dentry, inode);
3207 3208 3209 3210 3211
	if (!err && IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

	if (handle)
		ext4_journal_stop(handle);
3212
	kfree(sd);
3213
	return err;
3214
err_drop_inode:
3215 3216 3217
	if (handle)
		ext4_journal_stop(handle);
	clear_nlink(inode);
3218 3219
	unlock_new_inode(inode);
	iput(inode);
3220 3221
err_free_sd:
	kfree(sd);
3222
	return err;
3223 3224
}

3225 3226
static int ext4_link(struct dentry *old_dentry,
		     struct inode *dir, struct dentry *dentry)
3227 3228
{
	handle_t *handle;
3229
	struct inode *inode = d_inode(old_dentry);
3230 3231
	int err, retries = 0;

3232
	if (inode->i_nlink >= EXT4_LINK_MAX)
3233
		return -EMLINK;
3234
	if (ext4_encrypted_inode(dir) &&
3235
			!fscrypt_has_permitted_context(dir, inode))
3236
		return -EPERM;
L
Li Xi 已提交
3237 3238 3239 3240 3241 3242

       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;

3243 3244 3245
	err = dquot_initialize(dir);
	if (err)
		return err;
3246

3247
retry:
3248 3249
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
		(EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
A
Al Viro 已提交
3250
		 EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3251 3252 3253 3254
	if (IS_ERR(handle))
		return PTR_ERR(handle);

	if (IS_DIRSYNC(dir))
3255
		ext4_handle_sync(handle);
3256

3257
	inode->i_ctime = current_time(inode);
3258
	ext4_inc_count(handle, inode);
A
Al Viro 已提交
3259
	ihold(inode);
3260

A
Al Viro 已提交
3261 3262 3263
	err = ext4_add_entry(handle, dentry, inode);
	if (!err) {
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
3264 3265 3266 3267 3268
		/* this can happen only for tmpfile being
		 * linked the first time
		 */
		if (inode->i_nlink == 1)
			ext4_orphan_del(handle, inode);
A
Al Viro 已提交
3269 3270 3271 3272 3273
		d_instantiate(dentry, inode);
	} else {
		drop_nlink(inode);
		iput(inode);
	}
3274 3275
	ext4_journal_stop(handle);
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3276 3277 3278 3279
		goto retry;
	return err;
}

T
Tao Ma 已提交
3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294

/*
 * 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)) {
3295 3296 3297
		bh = ext4_read_dirblock(inode, 0, EITHER);
		if (IS_ERR(bh)) {
			*retval = PTR_ERR(bh);
T
Tao Ma 已提交
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308
			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);
}
3309

3310 3311 3312 3313
struct ext4_renament {
	struct inode *dir;
	struct dentry *dentry;
	struct inode *inode;
M
Miklos Szeredi 已提交
3314 3315
	bool is_dir;
	int dir_nlink_delta;
3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327

	/* 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;
};

3328 3329 3330 3331 3332 3333 3334 3335 3336 3337
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)
3338
		return -EFSCORRUPTED;
3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379
	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);
3380
	if (ext4_has_feature_filetype(ent->dir->i_sb))
3381 3382 3383
		ent->de->file_type = file_type;
	ent->dir->i_version++;
	ent->dir->i_ctime = ent->dir->i_mtime =
3384
		current_time(ent->dir);
3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408
	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);
3409 3410
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3411 3412 3413 3414 3415 3416 3417
	if (bh) {
		retval = ext4_delete_entry(handle, dir, de, bh);
		brelse(bh);
	}
	return retval;
}

3418 3419
static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
			       int force_reread)
3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
{
	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,
3431 3432
		    ent->de->name_len) ||
	    force_reread) {
3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443
		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) {
3444 3445 3446
		ext4_warning_inode(ent->dir,
				   "Deleting old file: nlink %d, error=%d",
				   ent->dir->i_nlink, retval);
3447 3448 3449
	}
}

M
Miklos Szeredi 已提交
3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460
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);
	}
}

M
Miklos Szeredi 已提交
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493
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;
}

3494 3495 3496
/*
 * Anybody can rename anything with this: the permission checks are left to the
 * higher-level routines.
3497 3498 3499 3500
 *
 * 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)
3501
 */
3502
static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
M
Miklos Szeredi 已提交
3503 3504
		       struct inode *new_dir, struct dentry *new_dentry,
		       unsigned int flags)
3505
{
3506
	handle_t *handle = NULL;
3507 3508 3509
	struct ext4_renament old = {
		.dir = old_dir,
		.dentry = old_dentry,
3510
		.inode = d_inode(old_dentry),
3511 3512 3513 3514
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
3515
		.inode = d_inode(new_dentry),
3516
	};
3517
	int force_reread;
3518
	int retval;
M
Miklos Szeredi 已提交
3519 3520 3521
	struct inode *whiteout = NULL;
	int credits;
	u8 old_file_type;
3522

L
Li Xi 已提交
3523 3524 3525 3526 3527
	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;

3528 3529 3530 3531 3532 3533
	retval = dquot_initialize(old.dir);
	if (retval)
		return retval;
	retval = dquot_initialize(new.dir);
	if (retval)
		return retval;
3534 3535 3536

	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
3537 3538 3539 3540 3541
	if (new.inode) {
		retval = dquot_initialize(new.inode);
		if (retval)
			return retval;
	}
3542

3543
	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
3544 3545
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
3546 3547 3548 3549 3550 3551 3552
	/*
	 *  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;
3553
	if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3554 3555
		goto end_rename;

3556 3557
	if ((old.dir != new.dir) &&
	    ext4_encrypted_inode(new.dir) &&
3558
	    !fscrypt_has_permitted_context(new.dir, old.inode)) {
3559 3560 3561 3562
		retval = -EPERM;
		goto end_rename;
	}

3563 3564
	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
				 &new.de, &new.inlined);
3565 3566
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3567
		new.bh = NULL;
3568 3569
		goto end_rename;
	}
3570 3571 3572 3573
	if (new.bh) {
		if (!new.inode) {
			brelse(new.bh);
			new.bh = NULL;
3574 3575
		}
	}
3576 3577
	if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
		ext4_alloc_da_blocks(old.inode);
3578

M
Miklos Szeredi 已提交
3579 3580 3581 3582
	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);
3583 3584 3585 3586 3587
		if (IS_ERR(handle)) {
			retval = PTR_ERR(handle);
			handle = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3588 3589
	} else {
		whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
3590 3591 3592 3593 3594
		if (IS_ERR(whiteout)) {
			retval = PTR_ERR(whiteout);
			whiteout = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3595
	}
3596

3597
	if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3598 3599
		ext4_handle_sync(handle);

3600 3601
	if (S_ISDIR(old.inode->i_mode)) {
		if (new.inode) {
3602
			retval = -ENOTEMPTY;
3603
			if (!ext4_empty_dir(new.inode))
3604
				goto end_rename;
3605 3606 3607 3608
		} else {
			retval = -EMLINK;
			if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
				goto end_rename;
3609
		}
3610
		retval = ext4_rename_dir_prepare(handle, &old);
3611 3612
		if (retval)
			goto end_rename;
3613
	}
3614 3615 3616 3617 3618 3619 3620 3621 3622
	/*
	 * 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));
M
Miklos Szeredi 已提交
3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635

	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);
	}
3636 3637
	if (!new.bh) {
		retval = ext4_add_entry(handle, new.dentry, old.inode);
3638 3639 3640
		if (retval)
			goto end_rename;
	} else {
3641
		retval = ext4_setent(handle, &new,
M
Miklos Szeredi 已提交
3642
				     old.inode->i_ino, old_file_type);
3643 3644
		if (retval)
			goto end_rename;
3645
	}
3646 3647 3648
	if (force_reread)
		force_reread = !ext4_test_inode_flag(new.dir,
						     EXT4_INODE_INLINE_DATA);
3649 3650 3651 3652 3653

	/*
	 * Like most other Unix systems, set the ctime for inodes on a
	 * rename.
	 */
3654
	old.inode->i_ctime = current_time(old.inode);
3655
	ext4_mark_inode_dirty(handle, old.inode);
3656

M
Miklos Szeredi 已提交
3657 3658 3659 3660 3661 3662
	if (!whiteout) {
		/*
		 * ok, that's it
		 */
		ext4_rename_delete(handle, &old, force_reread);
	}
3663

3664 3665
	if (new.inode) {
		ext4_dec_count(handle, new.inode);
3666
		new.inode->i_ctime = current_time(new.inode);
3667
	}
3668
	old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
3669 3670
	ext4_update_dx_flag(old.dir);
	if (old.dir_bh) {
3671 3672
		retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
		if (retval)
3673
			goto end_rename;
3674

3675 3676
		ext4_dec_count(handle, old.dir);
		if (new.inode) {
3677 3678 3679
			/* checked ext4_empty_dir above, can't have another
			 * parent, ext4_dec_count() won't work for many-linked
			 * dirs */
3680
			clear_nlink(new.inode);
3681
		} else {
3682 3683 3684
			ext4_inc_count(handle, new.dir);
			ext4_update_dx_flag(new.dir);
			ext4_mark_inode_dirty(handle, new.dir);
3685 3686
		}
	}
3687 3688 3689 3690 3691
	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);
3692 3693 3694 3695
	}
	retval = 0;

end_rename:
3696 3697 3698
	brelse(old.dir_bh);
	brelse(old.bh);
	brelse(new.bh);
M
Miklos Szeredi 已提交
3699 3700 3701 3702 3703 3704
	if (whiteout) {
		if (retval)
			drop_nlink(whiteout);
		unlock_new_inode(whiteout);
		iput(whiteout);
	}
3705 3706
	if (handle)
		ext4_journal_stop(handle);
3707 3708 3709
	return retval;
}

M
Miklos Szeredi 已提交
3710 3711 3712 3713 3714 3715 3716
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,
3717
		.inode = d_inode(old_dentry),
M
Miklos Szeredi 已提交
3718 3719 3720 3721
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
3722
		.inode = d_inode(new_dentry),
M
Miklos Szeredi 已提交
3723 3724 3725
	};
	u8 new_file_type;
	int retval;
3726
	struct timespec ctime;
M
Miklos Szeredi 已提交
3727

3728 3729 3730
	if ((ext4_encrypted_inode(old_dir) ||
	     ext4_encrypted_inode(new_dir)) &&
	    (old_dir != new_dir) &&
3731 3732
	    (!fscrypt_has_permitted_context(new_dir, old.inode) ||
	     !fscrypt_has_permitted_context(old_dir, new.inode)))
3733 3734
		return -EPERM;

L
Li Xi 已提交
3735 3736 3737 3738 3739 3740 3741 3742
	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;

3743 3744 3745 3746 3747 3748
	retval = dquot_initialize(old.dir);
	if (retval)
		return retval;
	retval = dquot_initialize(new.dir);
	if (retval)
		return retval;
M
Miklos Szeredi 已提交
3749 3750 3751

	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
				 &old.de, &old.inlined);
3752 3753
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
M
Miklos Szeredi 已提交
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
	/*
	 *  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);
3766 3767
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3768
		new.bh = NULL;
3769 3770
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3771 3772 3773 3774 3775 3776 3777 3778

	/* 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));
3779 3780 3781 3782 3783
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826

	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.
	 */
3827 3828 3829
	ctime = current_time(old.inode);
	old.inode->i_ctime = ctime;
	new.inode->i_ctime = ctime;
M
Miklos Szeredi 已提交
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856
	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;
}

M
Miklos Szeredi 已提交
3857 3858 3859 3860
static int ext4_rename2(struct inode *old_dir, struct dentry *old_dentry,
			struct inode *new_dir, struct dentry *new_dentry,
			unsigned int flags)
{
M
Miklos Szeredi 已提交
3861
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
M
Miklos Szeredi 已提交
3862 3863
		return -EINVAL;

M
Miklos Szeredi 已提交
3864 3865 3866 3867
	if (flags & RENAME_EXCHANGE) {
		return ext4_cross_rename(old_dir, old_dentry,
					 new_dir, new_dentry);
	}
M
Miklos Szeredi 已提交
3868 3869

	return ext4_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
M
Miklos Szeredi 已提交
3870 3871
}

3872 3873 3874
/*
 * directories can handle most operations...
 */
3875
const struct inode_operations ext4_dir_inode_operations = {
3876 3877 3878 3879 3880 3881 3882 3883
	.create		= ext4_create,
	.lookup		= ext4_lookup,
	.link		= ext4_link,
	.unlink		= ext4_unlink,
	.symlink	= ext4_symlink,
	.mkdir		= ext4_mkdir,
	.rmdir		= ext4_rmdir,
	.mknod		= ext4_mknod,
A
Al Viro 已提交
3884
	.tmpfile	= ext4_tmpfile,
3885
	.rename		= ext4_rename2,
3886 3887
	.setattr	= ext4_setattr,
	.listxattr	= ext4_listxattr,
3888
	.get_acl	= ext4_get_acl,
3889
	.set_acl	= ext4_set_acl,
3890
	.fiemap         = ext4_fiemap,
3891 3892
};

3893
const struct inode_operations ext4_special_inode_operations = {
3894 3895
	.setattr	= ext4_setattr,
	.listxattr	= ext4_listxattr,
3896
	.get_acl	= ext4_get_acl,
3897
	.set_acl	= ext4_set_acl,
3898
};