namei.c 102.2 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
		printk("%x->%lu ", i ? dx_get_hash(entries + i) :
A
Aneesh Kumar K.V 已提交
583
				0, (unsigned long)dx_get_block(entries + i));
A
Andrew Morton 已提交
584 585
	}
	printk("\n");
586 587 588 589 590 591 592 593 594
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

863
	if (((struct dx_root *)frames[0].bh->b_data)->info.indirect_levels)
864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
		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.
 */
885
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
886 887 888 889 890 891
				 struct dx_frame *frame,
				 struct dx_frame *frames,
				 __u32 *start_hash)
{
	struct dx_frame *p;
	struct buffer_head *bh;
892
	int num_frames = 0;
893 894 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
	__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--) {
931 932 933
		bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
		if (IS_ERR(bh))
			return PTR_ERR(bh);
934
		p++;
935
		brelse(p->bh);
936 937 938 939 940 941 942 943 944 945 946 947 948
		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 已提交
949
				  struct inode *dir, ext4_lblk_t block,
950 951 952 953
				  struct dx_hash_info *hinfo,
				  __u32 start_hash, __u32 start_minor_hash)
{
	struct buffer_head *bh;
954
	struct ext4_dir_entry_2 *de, *top;
955
	int err = 0, count = 0;
956
	struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
957

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

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

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

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

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

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

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

1164 1165 1166 1167
/*
 * Directory block splitting, compacting
 */

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

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

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

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

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

1249 1250
	if (!de->inode)
		return 0;
1251 1252

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

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

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

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

	res = 0;
return_result:
	return res;
1324 1325
}

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

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

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

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

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

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

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

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

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

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

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

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

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

1571 1572
	if (ext4_encrypted_inode(dir)) {
		int res = fscrypt_get_encryption_info(dir);
1573 1574

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

1586 1587
       if (dentry->d_name.len > EXT4_NAME_LEN)
	       return ERR_PTR(-ENAMETOOLONG);
1588

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


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

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

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

1652
	return d_obtain_alias(ext4_iget_normal(child->d_sb, ino));
1653 1654
}

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

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

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

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

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

1726
	if (ext4_has_metadata_csum(dir->i_sb))
1727 1728
		csum_size = sizeof(struct ext4_dir_entry_tail);

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

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

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

	data2 = bh2->b_data;

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

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

1790 1791 1792 1793
	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));
1794 1795

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2049 2050 2051 2052 2053 2054
	retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
	if (retval)
		goto out_frames;	
	retval = ext4_handle_dirty_dirent_node(handle, dir, bh);
	if (retval)
		goto out_frames;	
2055

2056
	de = do_split(handle,dir, &bh, frame, &fname->hinfo);
2057
	if (IS_ERR(de)) {
2058 2059
		retval = PTR_ERR(de);
		goto out_frames;
2060 2061
	}
	dx_release(frames);
2062

2063
	retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2064 2065
	brelse(bh);
	return retval;
2066 2067 2068 2069 2070 2071 2072 2073 2074
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.
	 */
	ext4_mark_inode_dirty(handle, dir);
	dx_release(frames);
	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);
K
Kalpak Shah 已提交
2990
	inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_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;
K
Kalpak Shah 已提交
3053
	dir->i_ctime = dir->i_mtime = ext4_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);
K
Kalpak Shah 已提交
3059
	inode->i_ctime = ext4_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 3148 3149 3150
		if (err < 0)
			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

K
Kalpak Shah 已提交
3257
	inode->i_ctime = ext4_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 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408
		ent->de->file_type = file_type;
	ent->dir->i_version++;
	ent->dir->i_ctime = ent->dir->i_mtime =
		ext4_current_time(ent->dir);
	ext4_mark_inode_dirty(handle, ent->dir);
	BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
	if (!ent->inlined) {
		retval = ext4_handle_dirty_dirent_node(handle,
						       ent->dir, ent->bh);
		if (unlikely(retval)) {
			ext4_std_error(ent->dir->i_sb, retval);
			return retval;
		}
	}
	brelse(ent->bh);
	ent->bh = NULL;

	return 0;
}

static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
				  const struct qstr *d_name)
{
	int retval = -ENOENT;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;

	bh = ext4_find_entry(dir, d_name, &de, NULL);
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 3655
	old.inode->i_ctime = ext4_current_time(old.inode);
	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 3666
	if (new.inode) {
		ext4_dec_count(handle, new.inode);
		new.inode->i_ctime = ext4_current_time(new.inode);
3667
	}
3668 3669 3670
	old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir);
	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 3726
	};
	u8 new_file_type;
	int retval;

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

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

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

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

	/* 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));
3778 3779 3780 3781 3782
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3783 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 3827 3828 3829 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

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

	if (S_ISDIR(old.inode->i_mode)) {
		old.is_dir = true;
		retval = ext4_rename_dir_prepare(handle, &old);
		if (retval)
			goto end_rename;
	}
	if (S_ISDIR(new.inode->i_mode)) {
		new.is_dir = true;
		retval = ext4_rename_dir_prepare(handle, &new);
		if (retval)
			goto end_rename;
	}

	/*
	 * Other than the special case of overwriting a directory, parents'
	 * nlink only needs to be modified if this is a cross directory rename.
	 */
	if (old.dir != new.dir && old.is_dir != new.is_dir) {
		old.dir_nlink_delta = old.is_dir ? -1 : 1;
		new.dir_nlink_delta = -old.dir_nlink_delta;
		retval = -EMLINK;
		if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
		    (new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
			goto end_rename;
	}

	new_file_type = new.de->file_type;
	retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
	if (retval)
		goto end_rename;

	retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
	if (retval)
		goto end_rename;

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

	if (old.dir_bh) {
		retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
		if (retval)
			goto end_rename;
	}
	if (new.dir_bh) {
		retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
		if (retval)
			goto end_rename;
	}
	ext4_update_dir_count(handle, &old);
	ext4_update_dir_count(handle, &new);
	retval = 0;

end_rename:
	brelse(old.dir_bh);
	brelse(new.dir_bh);
	brelse(old.bh);
	brelse(new.bh);
	if (handle)
		ext4_journal_stop(handle);
	return retval;
}

M
Miklos Szeredi 已提交
3855 3856 3857 3858
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 已提交
3859
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
M
Miklos Szeredi 已提交
3860 3861
		return -EINVAL;

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

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

3870 3871 3872
/*
 * directories can handle most operations...
 */
3873
const struct inode_operations ext4_dir_inode_operations = {
3874 3875 3876 3877 3878 3879 3880 3881
	.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 已提交
3882
	.tmpfile	= ext4_tmpfile,
M
Miklos Szeredi 已提交
3883
	.rename2	= ext4_rename2,
3884
	.setattr	= ext4_setattr,
3885 3886
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3887
	.listxattr	= ext4_listxattr,
3888
	.removexattr	= generic_removexattr,
3889
	.get_acl	= ext4_get_acl,
3890
	.set_acl	= ext4_set_acl,
3891
	.fiemap         = ext4_fiemap,
3892 3893
};

3894
const struct inode_operations ext4_special_inode_operations = {
3895
	.setattr	= ext4_setattr,
3896 3897
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3898
	.listxattr	= ext4_listxattr,
3899
	.removexattr	= generic_removexattr,
3900
	.get_acl	= ext4_get_acl,
3901
	.set_acl	= ext4_set_acl,
3902
};