namei.c 102.3 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 614 615
#ifdef CONFIG_EXT4_FS_ENCRYPTION
				int len;
				char *name;
				struct ext4_str fname_crypto_str
					= {.name = NULL, .len = 0};
616
				int res = 0;
617 618 619

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

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

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

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

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

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

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

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

806
		if (0) { // linear search cross check
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
			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;
822 823
		dxtrace(printk(" %x->%u\n", at == entries ? 0 : dx_get_hash(at),
			       dx_get_block(at)));
824 825
		frame->entries = entries;
		frame->at = at;
826 827 828 829 830 831 832 833
		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;
834
		}
835
		entries = ((struct dx_node *) frame->bh->b_data)->entries;
836

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

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

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

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

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

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

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

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

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

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

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

1159 1160 1161 1162
/*
 * Directory block splitting, compacting
 */

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

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

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

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

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

1244 1245
	if (!de->inode)
		return 0;
1246 1247

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

/*
 * Returns 0 if not found, -1 on failure, and 1 on success
 */
1269 1270 1271 1272
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)
1273
{
1274
	struct ext4_dir_entry_2 * de;
1275 1276
	char * dlimit;
	int de_len;
1277 1278
	int res;

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

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

	res = 0;
return_result:
	return res;
1319 1320
}

1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
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;
}
1336 1337

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

	*res_dir = NULL;
	sb = dir->i_sb;
1369
	namelen = d_name->len;
1370
	if (namelen > EXT4_NAME_LEN)
1371
		return NULL;
1372

1373 1374 1375 1376
	retval = ext4_fname_setup_filename(dir, d_name, 1, &fname);
	if (retval)
		return ERR_PTR(retval);

1377 1378
	if (ext4_has_inline_data(dir)) {
		int has_inline_data = 1;
1379
		ret = ext4_find_inline_entry(dir, &fname, d_name, res_dir,
1380
					     &has_inline_data);
T
Tao Ma 已提交
1381 1382 1383
		if (has_inline_data) {
			if (inlined)
				*inlined = 1;
1384
			goto cleanup_and_exit;
T
Tao Ma 已提交
1385
		}
1386 1387
	}

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

cleanup_and_exit:
	/* Clean up the read-ahead blocks */
	for (; ra_ptr < ra_max; ra_ptr++)
1500
		brelse(bh_use[ra_ptr]);
1501
	ext4_fname_free_filename(&fname);
1502 1503 1504
	return ret;
}

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

1516 1517 1518
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	*res_dir = NULL;
#endif
1519
	frame = dx_probe(fname, dir, NULL, frames);
1520 1521
	if (IS_ERR(frame))
		return (struct buffer_head *) frame;
1522 1523
	do {
		block = dx_get_block(frame->at);
1524
		bh = ext4_read_dirblock(dir, block, DIRENT);
1525
		if (IS_ERR(bh))
1526
			goto errout;
1527

1528
		retval = search_dirblock(bh, dir, fname, d_name,
1529 1530
					 block << EXT4_BLOCK_SIZE_BITS(sb),
					 res_dir);
1531 1532
		if (retval == 1)
			goto success;
1533
		brelse(bh);
1534
		if (retval == -1) {
1535
			bh = ERR_PTR(ERR_BAD_DX_DIR);
1536 1537 1538
			goto errout;
		}

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

1551
	bh = NULL;
1552
errout:
1553
	dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
1554 1555 1556
success:
	dx_release(frames);
	return bh;
1557 1558
}

A
Al Viro 已提交
1559
static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1560
{
1561 1562 1563
	struct inode *inode;
	struct ext4_dir_entry_2 *de;
	struct buffer_head *bh;
1564

1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
       if (ext4_encrypted_inode(dir)) {
               int res = ext4_get_encryption_info(dir);

		/*
		 * This should be a properly defined flag for
		 * dentry->d_flags when we uplift this to the VFS.
		 * d_fsdata is set to (void *) 1 if if the dentry is
		 * created while the directory was encrypted and we
		 * don't have access to the key.
		 */
	       dentry->d_fsdata = NULL;
	       if (ext4_encryption_info(dir))
		       dentry->d_fsdata = (void *) 1;
	       d_set_d_op(dentry, &ext4_encrypted_d_ops);
	       if (res && res != -ENOKEY)
		       return ERR_PTR(res);
       }

1583
	if (dentry->d_name.len > EXT4_NAME_LEN)
1584 1585
		return ERR_PTR(-ENAMETOOLONG);

T
Tao Ma 已提交
1586
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
1587 1588
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1589 1590
	inode = NULL;
	if (bh) {
1591
		__u32 ino = le32_to_cpu(de->inode);
1592
		brelse(bh);
1593
		if (!ext4_valid_inum(dir->i_sb, ino)) {
1594
			EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1595
			return ERR_PTR(-EFSCORRUPTED);
1596
		}
1597
		if (unlikely(ino == dir->i_ino)) {
D
David Howells 已提交
1598 1599
			EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
					 dentry);
1600
			return ERR_PTR(-EFSCORRUPTED);
1601
		}
1602
		inode = ext4_iget_normal(dir->i_sb, ino);
1603 1604 1605 1606
		if (inode == ERR_PTR(-ESTALE)) {
			EXT4_ERROR_INODE(dir,
					 "deleted inode referenced: %u",
					 ino);
1607
			return ERR_PTR(-EFSCORRUPTED);
1608
		}
1609
		if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
1610
		    (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
1611 1612
		    !ext4_is_child_context_consistent_with_parent(dir,
								  inode)) {
1613 1614 1615
			int nokey = ext4_encrypted_inode(inode) &&
				!ext4_encryption_info(inode);

1616
			iput(inode);
1617 1618
			if (nokey)
				return ERR_PTR(-ENOKEY);
1619
			ext4_warning(inode->i_sb,
1620
				     "Inconsistent encryption contexts: %lu/%lu",
1621 1622 1623 1624
				     (unsigned long) dir->i_ino,
				     (unsigned long) inode->i_ino);
			return ERR_PTR(-EPERM);
		}
1625 1626 1627 1628 1629
	}
	return d_splice_alias(inode, dentry);
}


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

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

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

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

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

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

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

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

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

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

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

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

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

	data2 = bh2->b_data;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2048 2049 2050 2051 2052 2053
	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;	
2054

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

2062
	retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2063 2064
	brelse(bh);
	return retval;
2065 2066 2067 2068 2069 2070 2071 2072 2073
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;
2074 2075 2076
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

2559 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
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)
2589
{
2590
	struct buffer_head *dir_block = NULL;
2591
	struct ext4_dir_entry_2 *de;
2592
	struct ext4_dir_entry_tail *t;
2593
	ext4_lblk_t block = 0;
2594
	unsigned int blocksize = dir->i_sb->s_blocksize;
2595
	int csum_size = 0;
2596
	int err;
2597

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

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

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

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

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

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

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

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

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

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

		err = empty_inline_dir(inode, &has_inline_data);
		if (has_inline_data)
			return err;
	}

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

2717
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2718
	de1 = ext4_next_entry(de, sb->s_blocksize);
2719
	if (le32_to_cpu(de->inode) != inode->i_ino ||
2720 2721 2722
			le32_to_cpu(de1->inode) == 0 ||
			strcmp(".", de->name) || strcmp("..", de1->name)) {
		ext4_warning_inode(inode, "directory missing '.' and/or '..'");
2723
		brelse(bh);
2724 2725
		return 1;
	}
2726 2727 2728
	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);
2729
	while (offset < inode->i_size) {
D
Dmitry Monakhov 已提交
2730
		if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
2731
			unsigned int lblock;
2732
			err = 0;
2733
			brelse(bh);
2734
			lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
2735 2736 2737
			bh = ext4_read_dirblock(inode, lblock, EITHER);
			if (IS_ERR(bh))
				return 1;
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 2750
			return 0;
		}
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 2756 2757
	return 1;
}

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 3078 3079
	bool encryption_required;
	struct ext4_str disk_link;
	struct ext4_encrypted_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 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102
	if (encryption_required) {
		err = ext4_get_encryption_info(dir);
		if (err)
			return err;
		if (ext4_encryption_info(dir) == NULL)
			return -EPERM;
		disk_link.len = (ext4_fname_encrypted_size(dir, len) +
				 sizeof(struct ext4_encrypted_symlink_data));
		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 3141 3142 3143 3144 3145
	}

	if (encryption_required) {
		struct qstr istr;
		struct ext4_str ostr;

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

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

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

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

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

       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;

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

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

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

K
Kalpak Shah 已提交
3258
	inode->i_ctime = ext4_current_time(inode);
3259
	ext4_inc_count(handle, inode);
A
Al Viro 已提交
3260
	ihold(inode);
3261

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

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

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

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

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

3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
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)
3339
		return -EFSCORRUPTED;
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 3380
	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);
3381
	if (ext4_has_feature_filetype(ent->dir->i_sb))
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 3409
		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);
3410 3411
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3412 3413 3414 3415 3416 3417 3418
	if (bh) {
		retval = ext4_delete_entry(handle, dir, de, bh);
		brelse(bh);
	}
	return retval;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

L
Li Xi 已提交
3738 3739 3740 3741 3742 3743 3744 3745
	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;

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

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

	/* 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));
3782 3783 3784 3785 3786
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rename;
	}
M
Miklos Szeredi 已提交
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 3855 3856 3857 3858

	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 已提交
3859 3860 3861 3862
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 已提交
3863
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
M
Miklos Szeredi 已提交
3864 3865
		return -EINVAL;

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

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

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

3898
const struct inode_operations ext4_special_inode_operations = {
3899
	.setattr	= ext4_setattr,
3900 3901
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3902
	.listxattr	= ext4_listxattr,
3903
	.removexattr	= generic_removexattr,
3904
	.get_acl	= ext4_get_acl,
3905
	.set_acl	= ext4_set_acl,
3906
};