namei.c 103.9 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 65 66
	bh = ext4_bread(handle, inode, *block, 1);
	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 87 88 89 90 91 92 93 94 95
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) \
	__ext4_read_dirblock((inode), (block), (type), __LINE__)

static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
					      ext4_lblk_t block,
					      dirblock_type_t type,
					      unsigned int line)
{
	struct buffer_head *bh;
	struct ext4_dir_entry *dirent;
96
	int is_dx_block = 0;
97

98 99
	bh = ext4_bread(NULL, inode, block, 0);
	if (IS_ERR(bh)) {
100
		__ext4_warning(inode->i_sb, __func__, line,
101 102
			       "error %ld reading directory block "
			       "(ino %lu, block %lu)", PTR_ERR(bh), inode->i_ino,
103
			       (unsigned long) block);
104 105 106 107 108 109

		return bh;
	}
	if (!bh) {
		ext4_error_inode(inode, __func__, line, block, "Directory hole found");
		return ERR_PTR(-EIO);
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
	}
	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) {
		ext4_error_inode(inode, __func__, line, block,
		       "directory leaf block found instead of index block");
		return ERR_PTR(-EIO);
	}
126
	if (!ext4_has_metadata_csum(inode->i_sb) ||
127 128 129 130 131 132 133 134 135 136 137 138 139 140
	    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 {
			ext4_error_inode(inode, __func__, line, block,
				"Directory index failed checksum");
141
			brelse(bh);
142
			return ERR_PTR(-EIO);
143
		}
144
	}
145 146 147 148 149 150 151 152 153
	if (!is_dx_block) {
		if (ext4_dirent_csum_verify(inode, dirent))
			set_buffer_verified(bh);
		else {
			ext4_error_inode(inode, __func__, line, block,
				"Directory block failed checksum");
			brelse(bh);
			return ERR_PTR(-EIO);
		}
C
Carlos Maiolino 已提交
154
	}
155 156 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
	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;
229 230
	u16 offs;
	u16 size;
231 232
};

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

275
/* checksumming functions */
276 277
void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
			    unsigned int blocksize)
278 279 280 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
{
	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);
}

330 331 332 333 334 335
static void warn_no_space_for_csum(struct inode *inode)
{
	ext4_warning(inode->i_sb, "no space in directory inode %lu leaf for "
		     "checksum.  Please run e2fsck -D.", inode->i_ino);
}

336 337 338 339
int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
{
	struct ext4_dir_entry_tail *t;

340
	if (!ext4_has_metadata_csum(inode->i_sb))
341 342 343 344
		return 1;

	t = get_dirent_tail(inode, dirent);
	if (!t) {
345
		warn_no_space_for_csum(inode);
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
		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;

361
	if (!ext4_has_metadata_csum(inode->i_sb))
362 363 364 365
		return;

	t = get_dirent_tail(inode, dirent);
	if (!t) {
366
		warn_no_space_for_csum(inode);
367 368 369 370 371 372 373
		return;
	}

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

374 375 376
int ext4_handle_dirty_dirent_node(handle_t *handle,
				  struct inode *inode,
				  struct buffer_head *bh)
377 378 379 380 381
{
	ext4_dirent_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
	return ext4_handle_dirty_metadata(handle, inode, bh);
}

382 383 384 385 386 387 388 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
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);
415 416
	__u32 csum;
	__le32 save_csum;
417 418 419
	int size;

	size = count_offset + (count * sizeof(struct dx_entry));
420
	save_csum = t->dt_checksum;
421 422 423
	t->dt_checksum = 0;
	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
	csum = ext4_chksum(sbi, csum, (__u8 *)t, sizeof(struct dx_tail));
424
	t->dt_checksum = save_csum;
425 426 427 428 429 430 431 432 433 434 435

	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;

436
	if (!ext4_has_metadata_csum(inode->i_sb))
437 438 439 440 441 442 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.");
		return 1;
	}
	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)) {
448
		warn_no_space_for_csum(inode);
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
		return 1;
	}
	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;

465
	if (!ext4_has_metadata_csum(inode->i_sb))
466 467 468 469 470 471 472 473 474 475 476
		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)) {
477
		warn_no_space_for_csum(inode);
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
		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);
}

493 494 495 496
/*
 * p is at least 6 bytes before the end of page
 */
static inline struct ext4_dir_entry_2 *
497
ext4_next_entry(struct ext4_dir_entry_2 *p, unsigned long blocksize)
498 499
{
	return (struct ext4_dir_entry_2 *)((char *)p +
500
		ext4_rec_len_from_disk(p->rec_len, blocksize));
501 502
}

503 504 505 506 507
/*
 * Future: use high four bits of block for coalesce-on-delete flags
 * Mask them off for now.
 */

A
Aneesh Kumar K.V 已提交
508
static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
509 510 511 512
{
	return le32_to_cpu(entry->block) & 0x00ffffff;
}

A
Aneesh Kumar K.V 已提交
513
static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
514 515 516 517
{
	entry->block = cpu_to_le32(value);
}

518
static inline unsigned dx_get_hash(struct dx_entry *entry)
519 520 521 522
{
	return le32_to_cpu(entry->hash);
}

523
static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
524 525 526 527
{
	entry->hash = cpu_to_le32(value);
}

528
static inline unsigned dx_get_count(struct dx_entry *entries)
529 530 531 532
{
	return le16_to_cpu(((struct dx_countlimit *) entries)->count);
}

533
static inline unsigned dx_get_limit(struct dx_entry *entries)
534 535 536 537
{
	return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
}

538
static inline void dx_set_count(struct dx_entry *entries, unsigned value)
539 540 541 542
{
	((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
}

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

548
static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
549
{
550 551
	unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
		EXT4_DIR_REC_LEN(2) - infosize;
552

553
	if (ext4_has_metadata_csum(dir->i_sb))
554
		entry_space -= sizeof(struct dx_tail);
555
	return entry_space / sizeof(struct dx_entry);
556 557
}

558
static inline unsigned dx_node_limit(struct inode *dir)
559
{
560
	unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
561

562
	if (ext4_has_metadata_csum(dir->i_sb))
563
		entry_space -= sizeof(struct dx_tail);
564
	return entry_space / sizeof(struct dx_entry);
565 566 567 568 569 570
}

/*
 * Debug
 */
#ifdef DX_DEBUG
571
static void dx_show_index(char * label, struct dx_entry *entries)
572
{
A
Andrew Morton 已提交
573
	int i, n = dx_get_count (entries);
574
	printk(KERN_DEBUG "%s index ", label);
A
Andrew Morton 已提交
575
	for (i = 0; i < n; i++) {
576
		printk("%x->%lu ", i ? dx_get_hash(entries + i) :
A
Aneesh Kumar K.V 已提交
577
				0, (unsigned long)dx_get_block(entries + i));
A
Andrew Morton 已提交
578 579
	}
	printk("\n");
580 581 582 583 584 585 586 587 588
}

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

589 590 591 592
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)
593 594 595 596 597 598 599 600 601 602 603 604
{
	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)
			{
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
#ifdef CONFIG_EXT4_FS_ENCRYPTION
				int len;
				char *name;
				struct ext4_str fname_crypto_str
					= {.name = NULL, .len = 0};
				struct ext4_fname_crypto_ctx *ctx = NULL;
				int res;

				name  = de->name;
				len = de->name_len;
				ctx = ext4_get_fname_crypto_ctx(dir,
								EXT4_NAME_LEN);
				if (IS_ERR(ctx)) {
					printk(KERN_WARNING "Error acquiring"
					" crypto ctxt--skipping crypto\n");
					ctx = NULL;
				}
				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");
						ext4_put_fname_crypto_ctx(&ctx);
						ctx = NULL;
					}
					res = ext4_fname_disk_to_usr(ctx, de,
							&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;
					}
					res = ext4_fname_disk_to_hash(ctx, de,
								      &h);
					if (res < 0) {
						printk(KERN_WARNING "Error "
							"converting filename "
							"from disk to htree"
							"\n");
						h.hash = 0xDEADBEEF;
					}
					printk("%*.s:(E)%x.%u ", len, name,
					       h.hash, (unsigned) ((char *) de
								   - base));
					ext4_put_fname_crypto_ctx(&ctx);
					ext4_fname_crypto_free_buffer(
						&fname_crypto_str);
				}
#else
673 674
				int len = de->name_len;
				char *name = de->name;
675
				ext4fs_dirhash(de->name, de->name_len, &h);
676
				printk("%*.s:%x.%u ", len, name, h.hash,
677
				       (unsigned) ((char *) de - base));
678
#endif
679
			}
680
			space += EXT4_DIR_REC_LEN(de->name_len);
681 682
			names++;
		}
683
		de = ext4_next_entry(de, size);
684 685 686 687 688 689 690 691 692
	}
	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;
693
	unsigned count = dx_get_count(entries), names = 0, space = 0, i;
694 695 696 697 698
	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 已提交
699 700
		ext4_lblk_t block = dx_get_block(entries);
		ext4_lblk_t hash  = i ? dx_get_hash(entries): 0;
701 702 703
		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);
704 705 706
		bh = ext4_bread(NULL,dir, block, 0);
		if (!bh || IS_ERR(bh))
			continue;
707 708
		stats = levels?
		   dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
709 710
		   dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
			bh->b_data, blocksize, 0);
711 712 713
		names += stats.names;
		space += stats.space;
		bcount += stats.bcount;
714
		brelse(bh);
715 716
	}
	if (bcount)
717
		printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
718 719
		       levels ? "" : "   ", names, space/bcount,
		       (space/bcount)*100/blocksize);
720 721 722 723 724 725 726 727 728 729 730 731 732 733
	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 *
734
dx_probe(const struct qstr *d_name, struct inode *dir,
735
	 struct dx_hash_info *hinfo, struct dx_frame *frame_in)
736 737 738 739 740
{
	unsigned count, indirect;
	struct dx_entry *at, *entries, *p, *q, *m;
	struct dx_root *root;
	struct dx_frame *frame = frame_in;
741
	struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
742 743
	u32 hash;

744 745 746 747 748
	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;
749 750 751
	if (root->info.hash_version != DX_HASH_TEA &&
	    root->info.hash_version != DX_HASH_HALF_MD4 &&
	    root->info.hash_version != DX_HASH_LEGACY) {
752
		ext4_warning(dir->i_sb, "Unrecognised inode hash code %d",
753 754 755 756
			     root->info.hash_version);
		goto fail;
	}
	hinfo->hash_version = root->info.hash_version;
757 758
	if (hinfo->hash_version <= DX_HASH_TEA)
		hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
759
	hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (d_name) {
		struct ext4_fname_crypto_ctx *ctx = NULL;
		int res;

		/* Check if the directory is encrypted */
		ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
		if (IS_ERR(ctx)) {
			ret_err = ERR_PTR(PTR_ERR(ctx));
			goto fail;
		}
		res = ext4_fname_usr_to_hash(ctx, d_name, hinfo);
		if (res < 0) {
			ret_err = ERR_PTR(res);
			goto fail;
		}
		ext4_put_fname_crypto_ctx(&ctx);
	}
#else
779 780
	if (d_name)
		ext4fs_dirhash(d_name->name, d_name->len, hinfo);
781
#endif
782 783 784
	hash = hinfo->hash;

	if (root->info.unused_flags & 1) {
785
		ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x",
786 787 788 789 790
			     root->info.unused_flags);
		goto fail;
	}

	if ((indirect = root->info.indirect_levels) > 1) {
791
		ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
792 793 794 795 796 797
			     root->info.indirect_levels);
		goto fail;
	}

	entries = (struct dx_entry *) (((char *)&root->info) +
				       root->info.info_length);
798 799 800

	if (dx_get_limit(entries) != dx_root_limit(dir,
						   root->info.info_length)) {
801
		ext4_warning(dir->i_sb, "dx entry: limit != root limit");
802 803 804
		goto fail;
	}

805
	dxtrace(printk("Look up %x", hash));
806
	while (1) {
807
		count = dx_get_count(entries);
808
		if (!count || count > dx_get_limit(entries)) {
809
			ext4_warning(dir->i_sb,
810
				     "dx entry: no count or count > limit");
811
			goto fail;
812 813
		}

814 815
		p = entries + 1;
		q = entries + count - 1;
816
		while (p <= q) {
817 818 819 820 821 822 823 824
			m = p + (q - p)/2;
			dxtrace(printk("."));
			if (dx_get_hash(m) > hash)
				q = m - 1;
			else
				p = m + 1;
		}

825
		if (0) { // linear search cross check
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
			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;
		dxtrace(printk(" %x->%u\n", at == entries? 0: dx_get_hash(at), dx_get_block(at)));
		frame->entries = entries;
		frame->at = at;
844 845 846 847 848 849 850 851
		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;
852
		}
853
		entries = ((struct dx_node *) frame->bh->b_data)->entries;
854

855
		if (dx_get_limit(entries) != dx_node_limit (dir)) {
856
			ext4_warning(dir->i_sb,
857
				     "dx entry: limit != node limit");
858
			goto fail;
859
		}
860
	}
861
fail:
862 863 864 865
	while (frame >= frame_in) {
		brelse(frame->bh);
		frame--;
	}
866

867
	if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
868
		ext4_warning(dir->i_sb,
Z
Zheng Liu 已提交
869
			     "Corrupt dir inode %lu, running e2fsck is "
870
			     "recommended.", dir->i_ino);
871
	return ret_err;
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
}

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

	if (((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels)
		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.
 */
901
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
902 903 904 905 906 907
				 struct dx_frame *frame,
				 struct dx_frame *frames,
				 __u32 *start_hash)
{
	struct dx_frame *p;
	struct buffer_head *bh;
908
	int num_frames = 0;
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
	__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--) {
947 948 949
		bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
		if (IS_ERR(bh))
			return PTR_ERR(bh);
950
		p++;
951
		brelse(p->bh);
952 953 954 955 956 957 958 959 960 961 962 963 964
		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 已提交
965
				  struct inode *dir, ext4_lblk_t block,
966 967 968 969
				  struct dx_hash_info *hinfo,
				  __u32 start_hash, __u32 start_minor_hash)
{
	struct buffer_head *bh;
970
	struct ext4_dir_entry_2 *de, *top;
971
	int err = 0, count = 0;
972 973
	struct ext4_fname_crypto_ctx *ctx = NULL;
	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0}, tmp_str;
974

A
Aneesh Kumar K.V 已提交
975 976
	dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
							(unsigned long)block));
977 978 979
	bh = ext4_read_dirblock(dir, block, DIRENT);
	if (IS_ERR(bh))
		return PTR_ERR(bh);
980

981 982
	de = (struct ext4_dir_entry_2 *) bh->b_data;
	top = (struct ext4_dir_entry_2 *) ((char *) de +
983
					   dir->i_sb->s_blocksize -
984
					   EXT4_DIR_REC_LEN(0));
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	/* Check if the directory is encrypted */
	ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
	if (IS_ERR(ctx)) {
		err = PTR_ERR(ctx);
		brelse(bh);
		return err;
	}
	if (ctx != NULL) {
		err = ext4_fname_crypto_alloc_buffer(ctx, EXT4_NAME_LEN,
						     &fname_crypto_str);
		if (err < 0) {
			ext4_put_fname_crypto_ctx(&ctx);
			brelse(bh);
			return err;
		}
	}
#endif
1003
	for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
1004
		if (ext4_check_dir_entry(dir, NULL, de, bh,
1005
				bh->b_data, bh->b_size,
1006 1007
				(block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
					 + ((char *)de - bh->b_data))) {
1008 1009
			/* silently ignore the rest of the block */
			break;
1010
		}
1011 1012 1013 1014 1015 1016 1017
#ifdef CONFIG_EXT4_FS_ENCRYPTION
		err = ext4_fname_disk_to_hash(ctx, de, hinfo);
		if (err < 0) {
			count = err;
			goto errout;
		}
#else
1018
		ext4fs_dirhash(de->name, de->name_len, hinfo);
1019
#endif
1020 1021 1022 1023 1024 1025
		if ((hinfo->hash < start_hash) ||
		    ((hinfo->hash == start_hash) &&
		     (hinfo->minor_hash < start_minor_hash)))
			continue;
		if (de->inode == 0)
			continue;
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
		if (ctx == NULL) {
			/* Directory is not encrypted */
			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 {
			/* Directory is encrypted */
			err = ext4_fname_disk_to_usr(ctx, de,
						     &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);
		}
1045
		if (err != 0) {
1046 1047
			count = err;
			goto errout;
1048 1049 1050
		}
		count++;
	}
1051
errout:
1052
	brelse(bh);
1053 1054 1055 1056
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ext4_put_fname_crypto_ctx(&ctx);
	ext4_fname_crypto_free_buffer(&fname_crypto_str);
#endif
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
	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.
 */
1069
int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
1070 1071 1072
			 __u32 start_minor_hash, __u32 *next_hash)
{
	struct dx_hash_info hinfo;
1073
	struct ext4_dir_entry_2 *de;
1074 1075
	struct dx_frame frames[2], *frame;
	struct inode *dir;
A
Aneesh Kumar K.V 已提交
1076
	ext4_lblk_t block;
1077
	int count = 0;
A
Aneesh Kumar K.V 已提交
1078
	int ret, err;
1079
	__u32 hashval;
1080
	struct ext4_str tmp_str;
1081

1082
	dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1083
		       start_hash, start_minor_hash));
A
Al Viro 已提交
1084
	dir = file_inode(dir_file);
1085
	if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1086
		hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1087 1088 1089
		if (hinfo.hash_version <= DX_HASH_TEA)
			hinfo.hash_version +=
				EXT4_SB(dir->i_sb)->s_hash_unsigned;
1090
		hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
		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;
			}
		}
1102 1103 1104 1105 1106 1107 1108
		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;
1109 1110 1111
	frame = dx_probe(NULL, dir, &hinfo, frames);
	if (IS_ERR(frame))
		return PTR_ERR(frame);
1112 1113 1114

	/* Add '.' and '..' from the htree header */
	if (!start_hash && !start_minor_hash) {
1115
		de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1116 1117 1118 1119 1120
		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)
1121 1122 1123 1124
			goto errout;
		count++;
	}
	if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1125
		de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1126
		de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1127 1128 1129 1130 1131
		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)
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
			goto errout;
		count++;
	}

	while (1) {
		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;
1146
		ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
					    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);
1163 1164
	dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
		       "next hash: %x\n", count, *next_hash));
1165 1166 1167 1168 1169 1170
	return count;
errout:
	dx_release(frames);
	return (err);
}

T
Tao Ma 已提交
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
static inline int search_dirblock(struct buffer_head *bh,
				  struct inode *dir,
				  const struct qstr *d_name,
				  unsigned int offset,
				  struct ext4_dir_entry_2 **res_dir)
{
	return search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
			  d_name, offset, res_dir);
}

1181 1182 1183 1184
/*
 * Directory block splitting, compacting
 */

1185 1186 1187 1188
/*
 * Create map of hash values, offsets, and sizes, stored at end of block.
 * Returns number of entries mapped.
 */
1189 1190
static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
		       unsigned blocksize, struct dx_hash_info *hinfo,
1191
		       struct dx_map_entry *map_tail)
1192 1193 1194 1195
{
	int count = 0;
	char *base = (char *) de;
	struct dx_hash_info h = *hinfo;
1196 1197 1198 1199 1200 1201 1202 1203
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	struct ext4_fname_crypto_ctx *ctx = NULL;
	int err;

	ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);
#endif
1204

1205
	while ((char *) de < base + blocksize) {
1206
		if (de->name_len && de->inode) {
1207 1208 1209 1210 1211 1212 1213
#ifdef CONFIG_EXT4_FS_ENCRYPTION
			err = ext4_fname_disk_to_hash(ctx, de, &h);
			if (err < 0) {
				ext4_put_fname_crypto_ctx(&ctx);
				return err;
			}
#else
1214
			ext4fs_dirhash(de->name, de->name_len, &h);
1215
#endif
1216 1217
			map_tail--;
			map_tail->hash = h.hash;
1218
			map_tail->offs = ((char *) de - base)>>2;
1219
			map_tail->size = le16_to_cpu(de->rec_len);
1220 1221 1222 1223
			count++;
			cond_resched();
		}
		/* XXX: do we need to check rec_len == 0 case? -Chris */
1224
		de = ext4_next_entry(de, blocksize);
1225
	}
1226 1227 1228
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ext4_put_fname_crypto_ctx(&ctx);
#endif
1229 1230 1231
	return count;
}

1232
/* Sort map by hash value */
1233 1234
static void dx_sort_map (struct dx_map_entry *map, unsigned count)
{
A
Andrew Morton 已提交
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
	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)
1252
				continue;
A
Andrew Morton 已提交
1253 1254
			swap(*(q+1), *q);
			more = 1;
1255 1256 1257 1258
		}
	} while(more);
}

A
Aneesh Kumar K.V 已提交
1259
static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
{
	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);
}

/*
1274
 * NOTE! unlike strncmp, ext4_match returns 1 for success, 0 for failure.
1275
 *
1276
 * `len <= EXT4_NAME_LEN' is guaranteed by caller.
1277 1278
 * `de != NULL' is guaranteed by caller.
 */
1279 1280 1281 1282
static inline int ext4_match(struct ext4_fname_crypto_ctx *ctx,
			     struct ext4_str *fname_crypto_str,
			     int len, const char * const name,
			     struct ext4_dir_entry_2 *de)
1283
{
1284 1285
	int res;

1286 1287
	if (!de->inode)
		return 0;
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ctx) {
		/* Directory is encrypted */
		res = ext4_fname_disk_to_usr(ctx, de, fname_crypto_str);
		if (res < 0)
			return res;
		if (len != res)
			return 0;
		res = memcmp(name, fname_crypto_str->name, len);
		return (res == 0) ? 1 : 0;
	}
#endif
	if (len != de->name_len)
		return 0;
	res = memcmp(name, de->name, len);
	return (res == 0) ? 1 : 0;
1305 1306 1307 1308 1309
}

/*
 * Returns 0 if not found, -1 on failure, and 1 on success
 */
1310 1311 1312
int search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
	       struct inode *dir, const struct qstr *d_name,
	       unsigned int offset, struct ext4_dir_entry_2 **res_dir)
1313
{
1314
	struct ext4_dir_entry_2 * de;
1315 1316
	char * dlimit;
	int de_len;
1317 1318
	const char *name = d_name->name;
	int namelen = d_name->len;
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
	struct ext4_fname_crypto_ctx *ctx = NULL;
	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0};
	int res;

	ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
	if (IS_ERR(ctx))
		return -1;

	if (ctx != NULL) {
		/* Allocate buffer to hold maximum name length */
		res = ext4_fname_crypto_alloc_buffer(ctx, EXT4_NAME_LEN,
						     &fname_crypto_str);
		if (res < 0) {
			ext4_put_fname_crypto_ctx(&ctx);
			return -1;
		}
	}
1336

T
Tao Ma 已提交
1337 1338
	de = (struct ext4_dir_entry_2 *)search_buf;
	dlimit = search_buf + buf_size;
1339 1340 1341
	while ((char *) de < dlimit) {
		/* this code is executed quadratically often */
		/* do minimal checking `by hand' */
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
		if ((char *) de + de->name_len <= dlimit) {
			res = ext4_match(ctx, &fname_crypto_str, namelen,
					 name, de);
			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;
			}
1362 1363 1364

		}
		/* prevent looping on a bad block */
1365 1366
		de_len = ext4_rec_len_from_disk(de->rec_len,
						dir->i_sb->s_blocksize);
1367 1368 1369 1370
		if (de_len <= 0) {
			res = -1;
			goto return_result;
		}
1371
		offset += de_len;
1372
		de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1373
	}
1374 1375 1376 1377 1378 1379

	res = 0;
return_result:
	ext4_put_fname_crypto_ctx(&ctx);
	ext4_fname_crypto_free_buffer(&fname_crypto_str);
	return res;
1380 1381
}

1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
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;
}
1397 1398

/*
1399
 *	ext4_find_entry()
1400 1401 1402 1403 1404 1405 1406 1407 1408
 *
 * 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.
 */
1409 1410
static struct buffer_head * ext4_find_entry (struct inode *dir,
					const struct qstr *d_name,
T
Tao Ma 已提交
1411 1412
					struct ext4_dir_entry_2 **res_dir,
					int *inlined)
1413
{
1414 1415 1416
	struct super_block *sb;
	struct buffer_head *bh_use[NAMEI_RA_SIZE];
	struct buffer_head *bh, *ret = NULL;
A
Aneesh Kumar K.V 已提交
1417
	ext4_lblk_t start, block, b;
1418
	const u8 *name = d_name->name;
1419 1420 1421 1422 1423
	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 已提交
1424
	ext4_lblk_t  nblocks;
1425
	int i, namelen;
1426 1427 1428

	*res_dir = NULL;
	sb = dir->i_sb;
1429
	namelen = d_name->len;
1430
	if (namelen > EXT4_NAME_LEN)
1431
		return NULL;
1432 1433 1434 1435 1436

	if (ext4_has_inline_data(dir)) {
		int has_inline_data = 1;
		ret = ext4_find_inline_entry(dir, d_name, res_dir,
					     &has_inline_data);
T
Tao Ma 已提交
1437 1438 1439
		if (has_inline_data) {
			if (inlined)
				*inlined = 1;
1440
			return ret;
T
Tao Ma 已提交
1441
		}
1442 1443
	}

1444
	if ((namelen <= 2) && (name[0] == '.') &&
1445
	    (name[1] == '.' || name[1] == '\0')) {
1446 1447 1448 1449 1450 1451 1452 1453
		/*
		 * "." 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;
	}
1454
	if (is_dx(dir)) {
1455
		bh = ext4_dx_find_entry(dir, d_name, res_dir);
1456 1457 1458 1459 1460
		/*
		 * On success, or if the error was file not found,
		 * return.  Otherwise, fall back to doing a search the
		 * old fashioned way.
		 */
1461
		if (!IS_ERR(bh) || PTR_ERR(bh) != ERR_BAD_DX_DIR)
1462
			return bh;
1463 1464
		dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
			       "falling back\n"));
1465
	}
1466 1467
	nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
	start = EXT4_I(dir)->i_dir_start_lookup;
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
	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++;
1491 1492
				bh = ext4_getblk(NULL, dir, b++, 0);
				if (unlikely(IS_ERR(bh))) {
1493
					if (ra_max == 0)
1494
						return bh;
1495 1496
					break;
				}
1497 1498
				bh_use[ra_max] = bh;
				if (bh)
1499 1500
					ll_rw_block(READ | REQ_META | REQ_PRIO,
						    1, &bh);
1501 1502 1503 1504 1505 1506 1507
			}
		}
		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 */
1508 1509
			EXT4_ERROR_INODE(dir, "reading directory lblock %lu",
					 (unsigned long) block);
1510 1511 1512
			brelse(bh);
			goto next;
		}
1513
		if (!buffer_verified(bh) &&
1514 1515
		    !is_dx_internal_node(dir, block,
					 (struct ext4_dir_entry *)bh->b_data) &&
1516 1517 1518 1519 1520 1521 1522 1523
		    !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);
1524
		i = search_dirblock(bh, dir, d_name,
1525
			    block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
1526
		if (i == 1) {
1527
			EXT4_I(dir)->i_dir_start_lookup = block;
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544
			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;
1545
	nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1546 1547 1548 1549 1550 1551 1552 1553
	if (block < nblocks) {
		start = 0;
		goto restart;
	}

cleanup_and_exit:
	/* Clean up the read-ahead blocks */
	for (; ra_ptr < ra_max; ra_ptr++)
1554
		brelse(bh_use[ra_ptr]);
1555 1556 1557
	return ret;
}

1558
static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct qstr *d_name,
1559
		       struct ext4_dir_entry_2 **res_dir)
1560
{
1561
	struct super_block * sb = dir->i_sb;
1562 1563 1564
	struct dx_hash_info	hinfo;
	struct dx_frame frames[2], *frame;
	struct buffer_head *bh;
A
Aneesh Kumar K.V 已提交
1565
	ext4_lblk_t block;
1566 1567
	int retval;

1568 1569 1570
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	*res_dir = NULL;
#endif
1571 1572 1573
	frame = dx_probe(d_name, dir, &hinfo, frames);
	if (IS_ERR(frame))
		return (struct buffer_head *) frame;
1574 1575
	do {
		block = dx_get_block(frame->at);
1576
		bh = ext4_read_dirblock(dir, block, DIRENT);
1577
		if (IS_ERR(bh))
1578
			goto errout;
1579

1580 1581 1582
		retval = search_dirblock(bh, dir, d_name,
					 block << EXT4_BLOCK_SIZE_BITS(sb),
					 res_dir);
1583 1584
		if (retval == 1)
			goto success;
1585
		brelse(bh);
1586
		if (retval == -1) {
1587
			bh = ERR_PTR(ERR_BAD_DX_DIR);
1588 1589 1590
			goto errout;
		}

1591
		/* Check to see if we should continue to search */
1592
		retval = ext4_htree_next_block(dir, hinfo.hash, frame,
1593 1594
					       frames, NULL);
		if (retval < 0) {
1595
			ext4_warning(sb,
1596 1597 1598
			     "error %d reading index page in directory #%lu",
			     retval, dir->i_ino);
			bh = ERR_PTR(retval);
1599 1600 1601 1602
			goto errout;
		}
	} while (retval == 1);

1603
	bh = NULL;
1604
errout:
1605
	dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
1606 1607 1608
success:
	dx_release(frames);
	return bh;
1609 1610
}

A
Al Viro 已提交
1611
static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1612
{
1613 1614 1615
	struct inode *inode;
	struct ext4_dir_entry_2 *de;
	struct buffer_head *bh;
1616

1617
	if (dentry->d_name.len > EXT4_NAME_LEN)
1618 1619
		return ERR_PTR(-ENAMETOOLONG);

T
Tao Ma 已提交
1620
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
1621 1622
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1623 1624
	inode = NULL;
	if (bh) {
1625
		__u32 ino = le32_to_cpu(de->inode);
1626
		brelse(bh);
1627
		if (!ext4_valid_inum(dir->i_sb, ino)) {
1628
			EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1629
			return ERR_PTR(-EIO);
1630
		}
1631
		if (unlikely(ino == dir->i_ino)) {
D
David Howells 已提交
1632 1633
			EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
					 dentry);
1634 1635
			return ERR_PTR(-EIO);
		}
1636
		inode = ext4_iget_normal(dir->i_sb, ino);
1637 1638 1639 1640 1641
		if (inode == ERR_PTR(-ESTALE)) {
			EXT4_ERROR_INODE(dir,
					 "deleted inode referenced: %u",
					 ino);
			return ERR_PTR(-EIO);
1642
		}
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
		if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
		    (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		     S_ISLNK(inode->i_mode)) &&
		    !ext4_is_child_context_consistent_with_parent(dir,
								  inode)) {
			iput(inode);
			ext4_warning(inode->i_sb,
				     "Inconsistent encryption contexts: %lu/%lu\n",
				     (unsigned long) dir->i_ino,
				     (unsigned long) inode->i_ino);
			return ERR_PTR(-EPERM);
		}
1655 1656 1657 1658 1659
	}
	return d_splice_alias(inode, dentry);
}


1660
struct dentry *ext4_get_parent(struct dentry *child)
1661
{
1662
	__u32 ino;
1663
	static const struct qstr dotdot = QSTR_INIT("..", 2);
1664
	struct ext4_dir_entry_2 * de;
1665 1666
	struct buffer_head *bh;

T
Tao Ma 已提交
1667
	bh = ext4_find_entry(child->d_inode, &dotdot, &de, NULL);
1668 1669
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1670 1671 1672 1673 1674
	if (!bh)
		return ERR_PTR(-ENOENT);
	ino = le32_to_cpu(de->inode);
	brelse(bh);

1675
	if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
1676 1677
		EXT4_ERROR_INODE(child->d_inode,
				 "bad parent inode number: %u", ino);
1678
		return ERR_PTR(-EIO);
1679 1680
	}

1681
	return d_obtain_alias(ext4_iget_normal(child->d_inode->i_sb, ino));
1682 1683
}

1684 1685 1686 1687
/*
 * Move count entries from end of map between two memory locations.
 * Returns pointer to last entry moved.
 */
1688
static struct ext4_dir_entry_2 *
1689 1690
dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
		unsigned blocksize)
1691 1692 1693 1694
{
	unsigned rec_len = 0;

	while (count--) {
1695
		struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1696
						(from + (map->offs<<2));
1697
		rec_len = EXT4_DIR_REC_LEN(de->name_len);
1698
		memcpy (to, de, rec_len);
1699
		((struct ext4_dir_entry_2 *) to)->rec_len =
1700
				ext4_rec_len_to_disk(rec_len, blocksize);
1701 1702 1703 1704
		de->inode = 0;
		map++;
		to += rec_len;
	}
1705
	return (struct ext4_dir_entry_2 *) (to - rec_len);
1706 1707
}

1708 1709 1710 1711
/*
 * Compact each dir entry in the range to the minimal rec_len.
 * Returns pointer to last entry in range.
 */
1712
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
1713
{
1714
	struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1715 1716 1717
	unsigned rec_len = 0;

	prev = to = de;
1718
	while ((char*)de < base + blocksize) {
1719
		next = ext4_next_entry(de, blocksize);
1720
		if (de->inode && de->name_len) {
1721
			rec_len = EXT4_DIR_REC_LEN(de->name_len);
1722 1723
			if (de > to)
				memmove(to, de, rec_len);
1724
			to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1725
			prev = to;
1726
			to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1727 1728 1729 1730 1731 1732
		}
		de = next;
	}
	return prev;
}

1733 1734 1735 1736 1737
/*
 * 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.
 */
1738
static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1739
			struct buffer_head **bh,struct dx_frame *frame,
1740
			struct dx_hash_info *hinfo)
1741 1742 1743 1744
{
	unsigned blocksize = dir->i_sb->s_blocksize;
	unsigned count, continued;
	struct buffer_head *bh2;
A
Aneesh Kumar K.V 已提交
1745
	ext4_lblk_t newblock;
1746 1747 1748
	u32 hash2;
	struct dx_map_entry *map;
	char *data1 = (*bh)->b_data, *data2;
1749
	unsigned split, move, size;
1750
	struct ext4_dir_entry_2 *de = NULL, *de2;
1751 1752
	struct ext4_dir_entry_tail *t;
	int	csum_size = 0;
1753
	int	err = 0, i;
1754

1755
	if (ext4_has_metadata_csum(dir->i_sb))
1756 1757
		csum_size = sizeof(struct ext4_dir_entry_tail);

1758 1759
	bh2 = ext4_append(handle, dir, &newblock);
	if (IS_ERR(bh2)) {
1760 1761
		brelse(*bh);
		*bh = NULL;
1762
		return (struct ext4_dir_entry_2 *) bh2;
1763 1764 1765
	}

	BUFFER_TRACE(*bh, "get_write_access");
1766
	err = ext4_journal_get_write_access(handle, *bh);
1767 1768 1769
	if (err)
		goto journal_error;

1770
	BUFFER_TRACE(frame->bh, "get_write_access");
1771
	err = ext4_journal_get_write_access(handle, frame->bh);
1772 1773 1774 1775 1776 1777 1778
	if (err)
		goto journal_error;

	data2 = bh2->b_data;

	/* create map in the end of data2 block */
	map = (struct dx_map_entry *) (data2 + blocksize);
1779
	count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
1780 1781
			     blocksize, hinfo, map);
	map -= count;
1782
	dx_sort_map(map, count);
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
	/* 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;
1795 1796
	hash2 = map[split].hash;
	continued = hash2 == map[split - 1].hash;
A
Aneesh Kumar K.V 已提交
1797 1798 1799
	dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
			(unsigned long)dx_get_block(frame->at),
					hash2, split, count-split));
1800 1801

	/* Fancy dance to stay within two buffers */
1802 1803
	de2 = dx_move_dirents(data1, data2, map + split, count - split,
			      blocksize);
1804
	de = dx_pack_dirents(data1, blocksize);
1805 1806
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
1807
					   blocksize);
1808 1809
	de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
					    (char *) de2,
1810
					    blocksize);
1811 1812 1813 1814 1815 1816 1817 1818
	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);
	}

1819 1820 1821 1822
	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));
1823 1824

	/* Which block gets the new entry? */
1825
	if (hinfo->hash >= hash2) {
1826 1827 1828
		swap(*bh, bh2);
		de = de2;
	}
1829
	dx_insert_block(frame, hash2 + continued, newblock);
1830
	err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
1831 1832
	if (err)
		goto journal_error;
1833
	err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
1834 1835
	if (err)
		goto journal_error;
1836 1837
	brelse(bh2);
	dxtrace(dx_show_index("frame", frame->entries));
1838
	return de;
1839 1840 1841 1842 1843 1844

journal_error:
	brelse(*bh);
	brelse(bh2);
	*bh = NULL;
	ext4_std_error(dir->i_sb, err);
1845
	return ERR_PTR(err);
1846 1847
}

1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
int ext4_find_dest_de(struct inode *dir, struct inode *inode,
		      struct buffer_head *bh,
		      void *buf, int buf_size,
		      const char *name, int namelen,
		      struct ext4_dir_entry_2 **dest_de)
{
	struct ext4_dir_entry_2 *de;
	unsigned short reclen = EXT4_DIR_REC_LEN(namelen);
	int nlen, rlen;
	unsigned int offset = 0;
	char *top;
1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
	struct ext4_fname_crypto_ctx *ctx = NULL;
	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0};
	int res;

	ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
	if (IS_ERR(ctx))
		return -1;

	if (ctx != NULL) {
		/* Calculate record length needed to store the entry */
		res = ext4_fname_crypto_namelen_on_disk(ctx, namelen);
		if (res < 0) {
			ext4_put_fname_crypto_ctx(&ctx);
			return res;
		}
		reclen = EXT4_DIR_REC_LEN(res);

		/* Allocate buffer to hold maximum name length */
		res = ext4_fname_crypto_alloc_buffer(ctx, EXT4_NAME_LEN,
						     &fname_crypto_str);
		if (res < 0) {
			ext4_put_fname_crypto_ctx(&ctx);
			return -1;
		}
	}
1884 1885 1886 1887 1888

	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,
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
					 buf, buf_size, offset)) {
			res = -EIO;
			goto return_result;
		}
		/* Provide crypto context and crypto buffer to ext4 match */
		res = ext4_match(ctx, &fname_crypto_str, namelen, name, de);
		if (res < 0)
			goto return_result;
		if (res > 0) {
			res = -EEXIST;
			goto return_result;
		}
1901 1902 1903 1904 1905 1906 1907 1908
		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;
	}

1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
	if ((char *) de > top)
		res = -ENOSPC;
	else {
		*dest_de = de;
		res = 0;
	}
return_result:
	ext4_put_fname_crypto_ctx(&ctx);
	ext4_fname_crypto_free_buffer(&fname_crypto_str);
	return res;
1919 1920
}

1921 1922 1923 1924 1925 1926
int ext4_insert_dentry(struct inode *dir,
		       struct inode *inode,
		       struct ext4_dir_entry_2 *de,
		       int buf_size,
		       const struct qstr *iname,
		       const char *name, int namelen)
1927 1928 1929
{

	int nlen, rlen;
1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
	struct ext4_fname_crypto_ctx *ctx = NULL;
	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0};
	struct ext4_str tmp_str;
	int res;

	ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
	if (IS_ERR(ctx))
		return -EIO;
	/* By default, the input name would be written to the disk */
	tmp_str.name = (unsigned char *)name;
	tmp_str.len = namelen;
	if (ctx != NULL) {
		/* Directory is encrypted */
		res = ext4_fname_crypto_alloc_buffer(ctx, EXT4_NAME_LEN,
						     &fname_crypto_str);
		if (res < 0) {
			ext4_put_fname_crypto_ctx(&ctx);
			return -ENOMEM;
		}
		res = ext4_fname_usr_to_disk(ctx, iname, &fname_crypto_str);
		if (res < 0) {
			ext4_put_fname_crypto_ctx(&ctx);
			ext4_fname_crypto_free_buffer(&fname_crypto_str);
			return res;
		}
		tmp_str.name = fname_crypto_str.name;
		tmp_str.len = fname_crypto_str.len;
	}
1958 1959 1960 1961 1962

	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 =
1963
			(struct ext4_dir_entry_2 *)((char *)de + nlen);
1964 1965 1966 1967 1968 1969 1970
		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);
1971 1972 1973 1974 1975 1976
	de->name_len = tmp_str.len;

	memcpy(de->name, tmp_str.name, tmp_str.len);
	ext4_put_fname_crypto_ctx(&ctx);
	ext4_fname_crypto_free_buffer(&fname_crypto_str);
	return 0;
1977
}
1978

1979 1980 1981 1982 1983 1984 1985 1986 1987
/*
 * 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.
 */
static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
1988
			     struct inode *inode, struct ext4_dir_entry_2 *de,
1989
			     struct buffer_head *bh)
1990 1991 1992 1993
{
	struct inode	*dir = dentry->d_parent->d_inode;
	const char	*name = dentry->d_name.name;
	int		namelen = dentry->d_name.len;
1994
	unsigned int	blocksize = dir->i_sb->s_blocksize;
1995
	int		csum_size = 0;
1996
	int		err;
1997

1998
	if (ext4_has_metadata_csum(inode->i_sb))
1999
		csum_size = sizeof(struct ext4_dir_entry_tail);
2000 2001

	if (!de) {
2002 2003 2004 2005 2006
		err = ext4_find_dest_de(dir, inode,
					bh, bh->b_data, blocksize - csum_size,
					name, namelen, &de);
		if (err)
			return err;
2007 2008
	}
	BUFFER_TRACE(bh, "get_write_access");
2009
	err = ext4_journal_get_write_access(handle, bh);
2010
	if (err) {
2011
		ext4_std_error(dir->i_sb, err);
2012 2013 2014
		return err;
	}

2015 2016 2017 2018 2019 2020
	/* By now the buffer is marked for journaling. Due to crypto operations,
	 * the following function call may fail */
	err = ext4_insert_dentry(dir, inode, de, blocksize, &dentry->d_name,
				 name, namelen);
	if (err < 0)
		return err;
2021

2022 2023 2024 2025 2026 2027
	/*
	 * 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
2028
	 * ext4_new_inode() setting the times, but error
2029 2030 2031 2032
	 * 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 已提交
2033
	dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
2034
	ext4_update_dx_flag(dir);
2035
	dir->i_version++;
2036
	ext4_mark_inode_dirty(handle, dir);
2037
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2038
	err = ext4_handle_dirty_dirent_node(handle, dir, bh);
2039
	if (err)
2040
		ext4_std_error(dir->i_sb, err);
2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
	return 0;
}

/*
 * This converts a one block unindexed directory to a 3 block indexed
 * directory, and adds the dentry to the indexed directory.
 */
static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
			    struct inode *inode, struct buffer_head *bh)
{
	struct inode	*dir = dentry->d_parent->d_inode;
2052 2053 2054 2055
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	struct ext4_fname_crypto_ctx *ctx = NULL;
	int res;
#else
2056 2057
	const char	*name = dentry->d_name.name;
	int		namelen = dentry->d_name.len;
2058
#endif
2059 2060 2061 2062
	struct buffer_head *bh2;
	struct dx_root	*root;
	struct dx_frame	frames[2], *frame;
	struct dx_entry *entries;
2063
	struct ext4_dir_entry_2	*de, *de2;
2064
	struct ext4_dir_entry_tail *t;
2065 2066 2067 2068 2069
	char		*data1, *top;
	unsigned	len;
	int		retval;
	unsigned	blocksize;
	struct dx_hash_info hinfo;
A
Aneesh Kumar K.V 已提交
2070
	ext4_lblk_t  block;
2071
	struct fake_dirent *fde;
2072 2073 2074 2075 2076 2077 2078
	int csum_size = 0;

#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ctx = ext4_get_fname_crypto_ctx(dir, EXT4_NAME_LEN);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);
#endif
2079

2080
	if (ext4_has_metadata_csum(inode->i_sb))
2081
		csum_size = sizeof(struct ext4_dir_entry_tail);
2082 2083

	blocksize =  dir->i_sb->s_blocksize;
2084
	dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2085
	BUFFER_TRACE(bh, "get_write_access");
2086
	retval = ext4_journal_get_write_access(handle, bh);
2087
	if (retval) {
2088
		ext4_std_error(dir->i_sb, retval);
2089 2090 2091 2092 2093
		brelse(bh);
		return retval;
	}
	root = (struct dx_root *) bh->b_data;

2094 2095 2096
	/* The 0th block becomes the root, move the dirents out */
	fde = &root->dotdot;
	de = (struct ext4_dir_entry_2 *)((char *)fde +
2097
		ext4_rec_len_from_disk(fde->rec_len, blocksize));
2098
	if ((char *) de >= (((char *) root) + blocksize)) {
2099
		EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
2100 2101 2102
		brelse(bh);
		return -EIO;
	}
2103
	len = ((char *) root) + (blocksize - csum_size) - (char *) de;
2104 2105

	/* Allocate new block for the 0th block's dirents */
2106 2107
	bh2 = ext4_append(handle, dir, &block);
	if (IS_ERR(bh2)) {
2108
		brelse(bh);
2109
		return PTR_ERR(bh2);
2110
	}
2111
	ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2112 2113 2114
	data1 = bh2->b_data;

	memcpy (data1, de, len);
2115
	de = (struct ext4_dir_entry_2 *) data1;
2116
	top = data1 + len;
2117
	while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
2118
		de = de2;
2119 2120
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
2121
					   blocksize);
2122 2123 2124 2125 2126 2127

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

2128
	/* Initialize the root; the dot dirents already exist */
2129
	de = (struct ext4_dir_entry_2 *) (&root->dotdot);
2130 2131
	de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
					   blocksize);
2132 2133
	memset (&root->info, 0, sizeof(root->info));
	root->info.info_length = sizeof(root->info);
2134
	root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
2135
	entries = root->entries;
2136 2137 2138
	dx_set_block(entries, 1);
	dx_set_count(entries, 1);
	dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2139 2140 2141

	/* Initialize as for dx_probe */
	hinfo.hash_version = root->info.hash_version;
2142 2143
	if (hinfo.hash_version <= DX_HASH_TEA)
		hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2144
	hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	res = ext4_fname_usr_to_hash(ctx, &dentry->d_name, &hinfo);
	if (res < 0) {
		ext4_put_fname_crypto_ctx(&ctx);
		ext4_mark_inode_dirty(handle, dir);
		brelse(bh);
		return res;
	}
	ext4_put_fname_crypto_ctx(&ctx);
#else
2155
	ext4fs_dirhash(name, namelen, &hinfo);
2156
#endif
2157
	memset(frames, 0, sizeof(frames));
2158 2159 2160 2161 2162
	frame = frames;
	frame->entries = entries;
	frame->at = entries;
	frame->bh = bh;
	bh = bh2;
2163

2164 2165 2166 2167 2168 2169
	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;	
2170

2171 2172
	de = do_split(handle,dir, &bh, frame, &hinfo);
	if (IS_ERR(de)) {
2173 2174
		retval = PTR_ERR(de);
		goto out_frames;
2175 2176
	}
	dx_release(frames);
2177

2178 2179 2180
	retval = add_dirent_to_buf(handle, dentry, inode, de, bh);
	brelse(bh);
	return retval;
2181 2182 2183 2184 2185 2186 2187 2188 2189
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;
2190 2191 2192
}

/*
2193
 *	ext4_add_entry()
2194 2195
 *
 * adds a file entry to the specified directory, using the same
2196
 * semantics as ext4_find_entry(). It returns NULL if it failed.
2197 2198 2199 2200 2201
 *
 * 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.
 */
2202 2203
static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
			  struct inode *inode)
2204 2205
{
	struct inode *dir = dentry->d_parent->d_inode;
2206
	struct buffer_head *bh = NULL;
2207
	struct ext4_dir_entry_2 *de;
2208
	struct ext4_dir_entry_tail *t;
2209
	struct super_block *sb;
2210 2211 2212
	int	retval;
	int	dx_fallback=0;
	unsigned blocksize;
A
Aneesh Kumar K.V 已提交
2213
	ext4_lblk_t block, blocks;
2214 2215
	int	csum_size = 0;

2216
	if (ext4_has_metadata_csum(inode->i_sb))
2217
		csum_size = sizeof(struct ext4_dir_entry_tail);
2218 2219 2220 2221 2222

	sb = dir->i_sb;
	blocksize = sb->s_blocksize;
	if (!dentry->d_name.len)
		return -EINVAL;
2223 2224 2225 2226 2227 2228 2229

	if (ext4_has_inline_data(dir)) {
		retval = ext4_try_add_inline_entry(handle, dentry, inode);
		if (retval < 0)
			return retval;
		if (retval == 1) {
			retval = 0;
2230
			goto out;
2231 2232 2233
		}
	}

2234
	if (is_dx(dir)) {
2235
		retval = ext4_dx_add_entry(handle, dentry, inode);
2236
		if (!retval || (retval != ERR_BAD_DX_DIR))
2237
			goto out;
2238
		ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2239
		dx_fallback++;
2240
		ext4_mark_inode_dirty(handle, dir);
2241 2242
	}
	blocks = dir->i_size >> sb->s_blocksize_bits;
2243
	for (block = 0; block < blocks; block++) {
2244 2245 2246 2247
		bh = ext4_read_dirblock(dir, block, DIRENT);
		if (IS_ERR(bh))
			return PTR_ERR(bh);

2248
		retval = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
2249 2250
		if (retval != -ENOSPC)
			goto out;
2251 2252

		if (blocks == 1 && !dx_fallback &&
2253 2254 2255 2256 2257
		    EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) {
			retval = make_indexed_dir(handle, dentry, inode, bh);
			bh = NULL; /* make_indexed_dir releases bh */
			goto out;
		}
2258 2259
		brelse(bh);
	}
2260 2261 2262
	bh = ext4_append(handle, dir, &block);
	if (IS_ERR(bh))
		return PTR_ERR(bh);
2263
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2264
	de->inode = 0;
2265 2266 2267 2268 2269 2270 2271
	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);
	}

2272
	retval = add_dirent_to_buf(handle, dentry, inode, de, bh);
2273
out:
2274
	brelse(bh);
2275 2276
	if (retval == 0)
		ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
2277
	return retval;
2278 2279 2280 2281 2282
}

/*
 * Returns 0 for success, or a negative error value
 */
2283
static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
2284 2285 2286 2287 2288
			     struct inode *inode)
{
	struct dx_frame frames[2], *frame;
	struct dx_entry *entries, *at;
	struct dx_hash_info hinfo;
2289
	struct buffer_head *bh;
2290
	struct inode *dir = dentry->d_parent->d_inode;
2291
	struct super_block *sb = dir->i_sb;
2292
	struct ext4_dir_entry_2 *de;
2293 2294
	int err;

2295 2296 2297
	frame = dx_probe(&dentry->d_name, dir, &hinfo, frames);
	if (IS_ERR(frame))
		return PTR_ERR(frame);
2298 2299
	entries = frame->entries;
	at = frame->at;
2300 2301 2302 2303
	bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
	if (IS_ERR(bh)) {
		err = PTR_ERR(bh);
		bh = NULL;
2304
		goto cleanup;
C
Carlos Maiolino 已提交
2305
	}
2306 2307

	BUFFER_TRACE(bh, "get_write_access");
2308
	err = ext4_journal_get_write_access(handle, bh);
2309 2310 2311 2312
	if (err)
		goto journal_error;

	err = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
2313
	if (err != -ENOSPC)
2314 2315 2316
		goto cleanup;

	/* Block full, should compress but for now just split */
2317
	dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
2318 2319 2320
		       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 已提交
2321
		ext4_lblk_t newblock;
2322 2323 2324 2325 2326 2327 2328 2329
		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))) {
2330
			ext4_warning(sb, "Directory index full!");
2331 2332 2333
			err = -ENOSPC;
			goto cleanup;
		}
2334 2335 2336
		bh2 = ext4_append(handle, dir, &newblock);
		if (IS_ERR(bh2)) {
			err = PTR_ERR(bh2);
2337
			goto cleanup;
2338
		}
2339 2340
		node2 = (struct dx_node *)(bh2->b_data);
		entries2 = node2->entries;
2341
		memset(&node2->fake, 0, sizeof(struct fake_dirent));
2342 2343
		node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
							   sb->s_blocksize);
2344
		BUFFER_TRACE(frame->bh, "get_write_access");
2345
		err = ext4_journal_get_write_access(handle, frame->bh);
2346 2347 2348 2349 2350
		if (err)
			goto journal_error;
		if (levels) {
			unsigned icount1 = icount/2, icount2 = icount - icount1;
			unsigned hash2 = dx_get_hash(entries + icount1);
2351 2352
			dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
				       icount1, icount2));
2353 2354

			BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2355
			err = ext4_journal_get_write_access(handle,
2356 2357 2358 2359
							     frames[0].bh);
			if (err)
				goto journal_error;

2360 2361 2362 2363 2364
			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));
2365 2366 2367 2368 2369 2370 2371

			/* 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);
			}
2372 2373 2374
			dx_insert_block(frames + 0, hash2, newblock);
			dxtrace(dx_show_index("node", frames[1].entries));
			dxtrace(dx_show_index("node",
2375
			       ((struct dx_node *) bh2->b_data)->entries));
2376
			err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2377 2378 2379 2380
			if (err)
				goto journal_error;
			brelse (bh2);
		} else {
2381 2382
			dxtrace(printk(KERN_DEBUG
				       "Creating second level index...\n"));
2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
			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;
2397
			err = ext4_journal_get_write_access(handle,
2398 2399 2400 2401
							     frame->bh);
			if (err)
				goto journal_error;
		}
2402
		err = ext4_handle_dirty_dx_node(handle, dir, frames[0].bh);
2403 2404 2405 2406
		if (err) {
			ext4_std_error(inode->i_sb, err);
			goto cleanup;
		}
2407
	}
2408 2409 2410
	de = do_split(handle, dir, &bh, frame, &hinfo);
	if (IS_ERR(de)) {
		err = PTR_ERR(de);
2411
		goto cleanup;
2412
	}
2413 2414 2415 2416
	err = add_dirent_to_buf(handle, dentry, inode, de, bh);
	goto cleanup;

journal_error:
2417
	ext4_std_error(dir->i_sb, err);
2418
cleanup:
2419
	brelse(bh);
2420 2421 2422 2423 2424
	dx_release(frames);
	return err;
}

/*
T
Tao Ma 已提交
2425 2426
 * ext4_generic_delete_entry deletes a directory entry by merging it
 * with the previous entry
2427
 */
T
Tao Ma 已提交
2428 2429 2430 2431 2432 2433 2434
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)
2435
{
2436
	struct ext4_dir_entry_2 *de, *pde;
2437
	unsigned int blocksize = dir->i_sb->s_blocksize;
T
Tao Ma 已提交
2438
	int i;
2439

2440 2441
	i = 0;
	pde = NULL;
T
Tao Ma 已提交
2442 2443
	de = (struct ext4_dir_entry_2 *)entry_buf;
	while (i < buf_size - csum_size) {
2444 2445
		if (ext4_check_dir_entry(dir, NULL, de, bh,
					 bh->b_data, bh->b_size, i))
2446 2447 2448
			return -EIO;
		if (de == de_del)  {
			if (pde)
2449
				pde->rec_len = ext4_rec_len_to_disk(
2450 2451 2452 2453 2454
					ext4_rec_len_from_disk(pde->rec_len,
							       blocksize) +
					ext4_rec_len_from_disk(de->rec_len,
							       blocksize),
					blocksize);
2455 2456 2457 2458 2459
			else
				de->inode = 0;
			dir->i_version++;
			return 0;
		}
2460
		i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2461
		pde = de;
2462
		de = ext4_next_entry(de, blocksize);
2463 2464 2465 2466
	}
	return -ENOENT;
}

T
Tao Ma 已提交
2467 2468 2469 2470 2471 2472 2473
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;

2474 2475 2476 2477 2478 2479 2480 2481
	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;
	}

2482
	if (ext4_has_metadata_csum(dir->i_sb))
T
Tao Ma 已提交
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507
		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;
}

2508 2509 2510 2511 2512 2513 2514 2515 2516 2517
/*
 * 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 已提交
2518
			set_nlink(inode, 1);
2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530
			EXT4_SET_RO_COMPAT_FEATURE(inode->i_sb,
					      EXT4_FEATURE_RO_COMPAT_DIR_NLINK);
		}
	}
}

/*
 * 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)
{
2531 2532
	if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
		drop_nlink(inode);
2533 2534 2535
}


2536
static int ext4_add_nondir(handle_t *handle,
2537 2538
		struct dentry *dentry, struct inode *inode)
{
2539
	int err = ext4_add_entry(handle, dentry, inode);
2540
	if (!err) {
2541
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
2542
		unlock_new_inode(inode);
2543
		d_instantiate(dentry, inode);
2544 2545
		return 0;
	}
2546
	drop_nlink(inode);
A
Al Viro 已提交
2547
	unlock_new_inode(inode);
2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559
	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 已提交
2560
static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
A
Al Viro 已提交
2561
		       bool excl)
2562 2563
{
	handle_t *handle;
2564
	struct inode *inode;
2565
	int err, credits, retries = 0;
2566

2567
	dquot_initialize(dir);
2568

2569
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2570
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2571
retry:
2572 2573 2574
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2575 2576
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
2577
		inode->i_op = &ext4_file_inode_operations;
R
Ross Zwisler 已提交
2578 2579 2580 2581
		if (test_opt(inode->i_sb, DAX))
			inode->i_fop = &ext4_dax_file_operations;
		else
			inode->i_fop = &ext4_file_operations;
2582
		ext4_set_aops(inode);
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
		err = 0;
#ifdef CONFIG_EXT4_FS_ENCRYPTION
		if (!err && ext4_encrypted_inode(dir)) {
			err = ext4_inherit_context(dir, inode);
			if (err) {
				clear_nlink(inode);
				unlock_new_inode(inode);
				iput(inode);
			}
		}
#endif
		if (!err)
			err = ext4_add_nondir(handle, dentry, inode);
2596 2597
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2598
	}
2599 2600
	if (handle)
		ext4_journal_stop(handle);
2601
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2602 2603 2604 2605
		goto retry;
	return err;
}

2606
static int ext4_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
2607
		      umode_t mode, dev_t rdev)
2608 2609 2610
{
	handle_t *handle;
	struct inode *inode;
2611
	int err, credits, retries = 0;
2612 2613 2614 2615

	if (!new_valid_dev(rdev))
		return -EINVAL;

2616
	dquot_initialize(dir);
2617

2618
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2619
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2620
retry:
2621 2622 2623
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2624 2625 2626
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
		init_special_inode(inode, inode->i_mode, rdev);
2627 2628
		inode->i_op = &ext4_special_inode_operations;
		err = ext4_add_nondir(handle, dentry, inode);
2629 2630
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2631
	}
2632 2633
	if (handle)
		ext4_journal_stop(handle);
2634
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2635 2636 2637 2638
		goto retry;
	return err;
}

A
Al Viro 已提交
2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
{
	handle_t *handle;
	struct inode *inode;
	int err, retries = 0;

	dquot_initialize(dir);

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;
R
Ross Zwisler 已提交
2657 2658 2659 2660
		if (test_opt(inode->i_sb, DAX))
			inode->i_fop = &ext4_dax_file_operations;
		else
			inode->i_fop = &ext4_file_operations;
A
Al Viro 已提交
2661
		ext4_set_aops(inode);
2662
		d_tmpfile(dentry, inode);
A
Al Viro 已提交
2663 2664
		err = ext4_orphan_add(handle, inode);
		if (err)
2665
			goto err_unlock_inode;
A
Al Viro 已提交
2666 2667 2668 2669 2670 2671 2672 2673
		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;
2674
err_unlock_inode:
A
Al Viro 已提交
2675 2676 2677 2678 2679
	ext4_journal_stop(handle);
	unlock_new_inode(inode);
	return err;
}

2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
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)
2710
{
2711
	struct buffer_head *dir_block = NULL;
2712
	struct ext4_dir_entry_2 *de;
2713
	struct ext4_dir_entry_tail *t;
2714
	ext4_lblk_t block = 0;
2715
	unsigned int blocksize = dir->i_sb->s_blocksize;
2716
	int csum_size = 0;
2717
	int err;
2718

2719
	if (ext4_has_metadata_csum(dir->i_sb))
2720 2721
		csum_size = sizeof(struct ext4_dir_entry_tail);

2722 2723 2724 2725 2726 2727 2728 2729
	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;
	}

2730
	inode->i_size = 0;
2731 2732 2733
	dir_block = ext4_append(handle, inode, &block);
	if (IS_ERR(dir_block))
		return PTR_ERR(dir_block);
2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
	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;
2756
	int err, credits, retries = 0;
2757

2758
	if (EXT4_DIR_LINK_MAX(dir))
2759 2760
		return -EMLINK;

2761
	dquot_initialize(dir);
2762

2763
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2764
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2765
retry:
2766 2767 2768 2769
	inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
					    &dentry->d_name,
					    0, NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2770 2771 2772 2773
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_stop;

2774 2775
	inode->i_op = &ext4_dir_inode_operations;
	inode->i_fop = &ext4_dir_operations;
2776
	err = ext4_init_new_dir(handle, dir, inode);
2777 2778
	if (err)
		goto out_clear_inode;
2779 2780 2781 2782 2783 2784 2785
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_encrypted_inode(dir)) {
		err = ext4_inherit_context(dir, inode);
		if (err)
			goto out_clear_inode;
	}
#endif
2786 2787 2788
	err = ext4_mark_inode_dirty(handle, inode);
	if (!err)
		err = ext4_add_entry(handle, dentry, inode);
2789
	if (err) {
2790 2791
out_clear_inode:
		clear_nlink(inode);
A
Al Viro 已提交
2792
		unlock_new_inode(inode);
2793
		ext4_mark_inode_dirty(handle, inode);
2794
		iput(inode);
2795 2796
		goto out_stop;
	}
2797
	ext4_inc_count(handle, dir);
2798
	ext4_update_dx_flag(dir);
2799 2800 2801
	err = ext4_mark_inode_dirty(handle, dir);
	if (err)
		goto out_clear_inode;
A
Al Viro 已提交
2802
	unlock_new_inode(inode);
2803
	d_instantiate(dentry, inode);
2804 2805 2806
	if (IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

2807
out_stop:
2808 2809
	if (handle)
		ext4_journal_stop(handle);
2810
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2811 2812 2813 2814 2815 2816 2817
		goto retry;
	return err;
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
2818
int ext4_empty_dir(struct inode *inode)
2819
{
2820
	unsigned int offset;
2821 2822 2823
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de, *de1;
	struct super_block *sb;
2824 2825
	int err = 0;

T
Tao Ma 已提交
2826 2827 2828 2829 2830 2831 2832 2833
	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;
	}

2834
	sb = inode->i_sb;
2835 2836
	if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
		EXT4_ERROR_INODE(inode, "invalid size");
2837 2838
		return 1;
	}
2839 2840 2841 2842
	bh = ext4_read_dirblock(inode, 0, EITHER);
	if (IS_ERR(bh))
		return 1;

2843
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2844
	de1 = ext4_next_entry(de, sb->s_blocksize);
2845 2846
	if (le32_to_cpu(de->inode) != inode->i_ino ||
			!le32_to_cpu(de1->inode) ||
2847 2848
			strcmp(".", de->name) ||
			strcmp("..", de1->name)) {
2849
		ext4_warning(inode->i_sb,
2850 2851 2852
			     "bad directory (dir #%lu) - no `.' or `..'",
			     inode->i_ino);
		brelse(bh);
2853 2854
		return 1;
	}
2855 2856 2857
	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);
2858
	while (offset < inode->i_size) {
D
Dmitry Monakhov 已提交
2859
		if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
2860
			unsigned int lblock;
2861
			err = 0;
2862
			brelse(bh);
2863
			lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
2864 2865 2866
			bh = ext4_read_dirblock(inode, lblock, EITHER);
			if (IS_ERR(bh))
				return 1;
2867
			de = (struct ext4_dir_entry_2 *) bh->b_data;
2868
		}
2869 2870
		if (ext4_check_dir_entry(inode, NULL, de, bh,
					 bh->b_data, bh->b_size, offset)) {
2871
			de = (struct ext4_dir_entry_2 *)(bh->b_data +
2872 2873 2874 2875 2876
							 sb->s_blocksize);
			offset = (offset | (sb->s_blocksize - 1)) + 1;
			continue;
		}
		if (le32_to_cpu(de->inode)) {
2877
			brelse(bh);
2878 2879
			return 0;
		}
2880 2881
		offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
		de = ext4_next_entry(de, sb->s_blocksize);
2882
	}
2883
	brelse(bh);
2884 2885 2886
	return 1;
}

2887 2888
/*
 * ext4_orphan_add() links an unlinked or truncated inode into a list of
2889 2890 2891 2892 2893
 * 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
2894
 * inodes and truncating linked inodes in ext4_orphan_cleanup().
2895 2896 2897
 *
 * Orphan list manipulation functions must be called under i_mutex unless
 * we are just creating the inode or deleting it.
2898
 */
2899
int ext4_orphan_add(handle_t *handle, struct inode *inode)
2900 2901
{
	struct super_block *sb = inode->i_sb;
2902
	struct ext4_sb_info *sbi = EXT4_SB(sb);
2903
	struct ext4_iloc iloc;
2904
	int err = 0, rc;
2905
	bool dirty = false;
2906

2907
	if (!sbi->s_journal || is_bad_inode(inode))
2908 2909
		return 0;

2910 2911 2912 2913 2914 2915
	WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
		     !mutex_is_locked(&inode->i_mutex));
	/*
	 * 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.
	 */
2916
	if (!list_empty(&EXT4_I(inode)->i_orphan))
2917
		return 0;
2918

2919 2920 2921 2922 2923
	/*
	 * 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
2924
	 */
2925 2926
	J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		  S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
2927

2928 2929
	BUFFER_TRACE(sbi->s_sbh, "get_write_access");
	err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2930
	if (err)
2931
		goto out;
2932

2933
	err = ext4_reserve_inode_write(handle, inode, &iloc);
2934
	if (err)
2935 2936 2937
		goto out;

	mutex_lock(&sbi->s_orphan_lock);
2938 2939 2940 2941
	/*
	 * Due to previous errors inode may be already a part of on-disk
	 * orphan list. If so skip on-disk list modification.
	 */
2942 2943 2944 2945 2946 2947 2948 2949 2950
	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);
2951

2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
	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);
			list_del(&EXT4_I(inode)->i_orphan);
			mutex_unlock(&sbi->s_orphan_lock);
		}
	}
2968 2969 2970
	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));
2971
out:
2972
	ext4_std_error(sb, err);
2973 2974 2975 2976
	return err;
}

/*
2977
 * ext4_orphan_del() removes an unlinked or truncated inode from the list
2978 2979
 * of such inodes stored on disk, because it is finally being cleaned up.
 */
2980
int ext4_orphan_del(handle_t *handle, struct inode *inode)
2981 2982
{
	struct list_head *prev;
2983
	struct ext4_inode_info *ei = EXT4_I(inode);
2984
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2985
	__u32 ino_next;
2986
	struct ext4_iloc iloc;
2987 2988
	int err = 0;

2989
	if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
2990 2991
		return 0;

2992 2993 2994
	WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
		     !mutex_is_locked(&inode->i_mutex));
	/* Do this quick check before taking global s_orphan_lock. */
2995
	if (list_empty(&ei->i_orphan))
2996
		return 0;
2997

2998 2999 3000 3001
	if (handle) {
		/* Grab inode buffer early before taking global s_orphan_lock */
		err = ext4_reserve_inode_write(handle, inode, &iloc);
	}
3002

3003
	mutex_lock(&sbi->s_orphan_lock);
3004 3005
	jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);

3006
	prev = ei->i_orphan.prev;
3007 3008 3009 3010 3011 3012
	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. */
3013 3014
	if (!handle || err) {
		mutex_unlock(&sbi->s_orphan_lock);
3015
		goto out_err;
3016
	}
3017

3018
	ino_next = NEXT_ORPHAN(inode);
3019
	if (prev == &sbi->s_orphan) {
3020
		jbd_debug(4, "superblock will point to %u\n", ino_next);
3021
		BUFFER_TRACE(sbi->s_sbh, "get_write_access");
3022
		err = ext4_journal_get_write_access(handle, sbi->s_sbh);
3023 3024
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
3025
			goto out_brelse;
3026
		}
3027
		sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
3028
		mutex_unlock(&sbi->s_orphan_lock);
3029
		err = ext4_handle_dirty_super(handle, inode->i_sb);
3030
	} else {
3031
		struct ext4_iloc iloc2;
3032
		struct inode *i_prev =
3033
			&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
3034

3035
		jbd_debug(4, "orphan inode %lu will point to %u\n",
3036
			  i_prev->i_ino, ino_next);
3037
		err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
3038 3039
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
3040
			goto out_brelse;
3041
		}
3042
		NEXT_ORPHAN(i_prev) = ino_next;
3043
		err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
3044
		mutex_unlock(&sbi->s_orphan_lock);
3045 3046 3047 3048
	}
	if (err)
		goto out_brelse;
	NEXT_ORPHAN(inode) = 0;
3049
	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
3050
out_err:
3051
	ext4_std_error(inode->i_sb, err);
3052 3053 3054 3055 3056 3057 3058
	return err;

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

3059
static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
3060 3061
{
	int retval;
3062 3063 3064
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
3065
	handle_t *handle = NULL;
3066 3067 3068

	/* Initialize quotas before so that eventual writes go in
	 * separate transaction */
3069 3070
	dquot_initialize(dir);
	dquot_initialize(dentry->d_inode);
3071

3072
	retval = -ENOENT;
T
Tao Ma 已提交
3073
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3074 3075
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
	if (!bh)
		goto end_rmdir;

	inode = dentry->d_inode;

	retval = -EIO;
	if (le32_to_cpu(de->inode) != inode->i_ino)
		goto end_rmdir;

	retval = -ENOTEMPTY;
3086
	if (!ext4_empty_dir(inode))
3087 3088
		goto end_rmdir;

3089
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
3090
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3091 3092 3093 3094 3095 3096 3097 3098 3099
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rmdir;
	}

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

3100
	retval = ext4_delete_entry(handle, dir, de, bh);
3101 3102
	if (retval)
		goto end_rmdir;
3103
	if (!EXT4_DIR_LINK_EMPTY(inode))
3104
		ext4_warning(inode->i_sb,
3105 3106
			     "empty directory has too many links (%d)",
			     inode->i_nlink);
3107 3108 3109 3110 3111 3112
	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;
3113
	ext4_orphan_add(handle, inode);
K
Kalpak Shah 已提交
3114
	inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode);
3115
	ext4_mark_inode_dirty(handle, inode);
3116
	ext4_dec_count(handle, dir);
3117 3118
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
3119 3120

end_rmdir:
3121
	brelse(bh);
3122 3123
	if (handle)
		ext4_journal_stop(handle);
3124 3125 3126
	return retval;
}

3127
static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3128 3129
{
	int retval;
3130 3131 3132
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
3133
	handle_t *handle = NULL;
3134

3135
	trace_ext4_unlink_enter(dir, dentry);
3136 3137
	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
3138 3139
	dquot_initialize(dir);
	dquot_initialize(dentry->d_inode);
3140

3141
	retval = -ENOENT;
T
Tao Ma 已提交
3142
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3143 3144
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3145 3146 3147 3148 3149 3150 3151 3152 3153
	if (!bh)
		goto end_unlink;

	inode = dentry->d_inode;

	retval = -EIO;
	if (le32_to_cpu(de->inode) != inode->i_ino)
		goto end_unlink;

3154
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
3155
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3156 3157 3158 3159 3160 3161 3162 3163 3164
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_unlink;
	}

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

3165
	if (!inode->i_nlink) {
3166
		ext4_warning(inode->i_sb,
3167 3168
			     "Deleting nonexistent file (%lu), %d",
			     inode->i_ino, inode->i_nlink);
M
Miklos Szeredi 已提交
3169
		set_nlink(inode, 1);
3170
	}
3171
	retval = ext4_delete_entry(handle, dir, de, bh);
3172 3173
	if (retval)
		goto end_unlink;
K
Kalpak Shah 已提交
3174
	dir->i_ctime = dir->i_mtime = ext4_current_time(dir);
3175 3176
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
3177
	drop_nlink(inode);
3178
	if (!inode->i_nlink)
3179
		ext4_orphan_add(handle, inode);
K
Kalpak Shah 已提交
3180
	inode->i_ctime = ext4_current_time(inode);
3181
	ext4_mark_inode_dirty(handle, inode);
3182 3183

end_unlink:
3184
	brelse(bh);
3185 3186
	if (handle)
		ext4_journal_stop(handle);
3187
	trace_ext4_unlink_exit(dentry, retval);
3188 3189 3190
	return retval;
}

3191 3192
static int ext4_symlink(struct inode *dir,
			struct dentry *dentry, const char *symname)
3193 3194
{
	handle_t *handle;
3195
	struct inode *inode;
3196
	int err, len = strlen(symname);
3197
	int credits;
3198 3199 3200
	bool encryption_required;
	struct ext4_str disk_link;
	struct ext4_encrypted_symlink_data *sd = NULL;
3201

3202 3203 3204 3205 3206 3207 3208
	disk_link.len = len + 1;
	disk_link.name = (char *) symname;

	encryption_required = ext4_encrypted_inode(dir);
	if (encryption_required)
		disk_link.len = encrypted_symlink_data_len(len) + 1;
	if (disk_link.len > dir->i_sb->s_blocksize)
3209 3210
		return -ENAMETOOLONG;

3211
	dquot_initialize(dir);
3212

3213
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3214 3215 3216
		/*
		 * For non-fast symlinks, we just allocate inode and put it on
		 * orphan list in the first transaction => we need bitmap,
3217 3218
		 * group descriptor, sb, inode block, quota blocks, and
		 * possibly selinux xattr blocks.
3219
		 */
3220 3221
		credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
			  EXT4_XATTR_TRANS_BLOCKS;
3222 3223 3224 3225 3226 3227 3228 3229
	} 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) +
3230
			  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3231
	}
3232

3233 3234 3235 3236
	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();
3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272
	if (IS_ERR(inode)) {
		if (handle)
			ext4_journal_stop(handle);
		return PTR_ERR(inode);
	}

	if (encryption_required) {
		struct ext4_fname_crypto_ctx *ctx = NULL;
		struct qstr istr;
		struct ext4_str ostr;

		sd = kzalloc(disk_link.len, GFP_NOFS);
		if (!sd) {
			err = -ENOMEM;
			goto err_drop_inode;
		}
		err = ext4_inherit_context(dir, inode);
		if (err)
			goto err_drop_inode;
		ctx = ext4_get_fname_crypto_ctx(inode,
						inode->i_sb->s_blocksize);
		if (IS_ERR_OR_NULL(ctx)) {
			/* We just set the policy, so ctx should not be NULL */
			err = (ctx == NULL) ? -EIO : PTR_ERR(ctx);
			goto err_drop_inode;
		}
		istr.name = (const unsigned char *) symname;
		istr.len = len;
		ostr.name = sd->encrypted_path;
		err = ext4_fname_usr_to_disk(ctx, &istr, &ostr);
		ext4_put_fname_crypto_ctx(&ctx);
		if (err < 0)
			goto err_drop_inode;
		sd->len = cpu_to_le16(ostr.len);
		disk_link.name = (char *) sd;
	}
3273

3274
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3275 3276
		inode->i_op = &ext4_symlink_inode_operations;
		ext4_set_aops(inode);
3277
		/*
3278 3279 3280 3281 3282 3283 3284 3285
		 * 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.
3286
		 */
3287 3288 3289
		drop_nlink(inode);
		err = ext4_orphan_add(handle, inode);
		ext4_journal_stop(handle);
3290
		handle = NULL;
3291 3292
		if (err)
			goto err_drop_inode;
3293
		err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
3294 3295 3296 3297 3298 3299
		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
		 */
3300
		handle = ext4_journal_start(dir, EXT4_HT_DIR,
3301 3302 3303 3304
				EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
				EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
		if (IS_ERR(handle)) {
			err = PTR_ERR(handle);
3305
			handle = NULL;
3306 3307
			goto err_drop_inode;
		}
3308
		set_nlink(inode, 1);
3309
		err = ext4_orphan_del(handle, inode);
3310
		if (err)
3311
			goto err_drop_inode;
3312
	} else {
3313
		/* clear the extent format for fast symlink */
3314
		ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3315 3316 3317 3318 3319 3320
		inode->i_op = encryption_required ?
			&ext4_symlink_inode_operations :
			&ext4_fast_symlink_inode_operations;
		memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
		       disk_link.len);
		inode->i_size = disk_link.len - 1;
3321
	}
3322 3323
	EXT4_I(inode)->i_disksize = inode->i_size;
	err = ext4_add_nondir(handle, dentry, inode);
3324 3325 3326 3327 3328
	if (!err && IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

	if (handle)
		ext4_journal_stop(handle);
3329
	kfree(sd);
3330
	return err;
3331
err_drop_inode:
3332 3333 3334 3335
	if (handle)
		ext4_journal_stop(handle);
	kfree(sd);
	clear_nlink(inode);
3336 3337 3338
	unlock_new_inode(inode);
	iput(inode);
	return err;
3339 3340
}

3341 3342
static int ext4_link(struct dentry *old_dentry,
		     struct inode *dir, struct dentry *dentry)
3343 3344 3345 3346 3347
{
	handle_t *handle;
	struct inode *inode = old_dentry->d_inode;
	int err, retries = 0;

3348
	if (inode->i_nlink >= EXT4_LINK_MAX)
3349
		return -EMLINK;
3350 3351 3352
	if (ext4_encrypted_inode(dir) &&
	    !ext4_is_child_context_consistent_with_parent(dir, inode))
		return -EPERM;
3353
	dquot_initialize(dir);
3354

3355
retry:
3356 3357
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
		(EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
A
Al Viro 已提交
3358
		 EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3359 3360 3361 3362
	if (IS_ERR(handle))
		return PTR_ERR(handle);

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

K
Kalpak Shah 已提交
3365
	inode->i_ctime = ext4_current_time(inode);
3366
	ext4_inc_count(handle, inode);
A
Al Viro 已提交
3367
	ihold(inode);
3368

A
Al Viro 已提交
3369 3370 3371
	err = ext4_add_entry(handle, dentry, inode);
	if (!err) {
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
3372 3373 3374 3375 3376
		/* this can happen only for tmpfile being
		 * linked the first time
		 */
		if (inode->i_nlink == 1)
			ext4_orphan_del(handle, inode);
A
Al Viro 已提交
3377 3378 3379 3380 3381
		d_instantiate(dentry, inode);
	} else {
		drop_nlink(inode);
		iput(inode);
	}
3382 3383
	ext4_journal_stop(handle);
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3384 3385 3386 3387
		goto retry;
	return err;
}

T
Tao Ma 已提交
3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402

/*
 * 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)) {
3403 3404 3405
		bh = ext4_read_dirblock(inode, 0, EITHER);
		if (IS_ERR(bh)) {
			*retval = PTR_ERR(bh);
T
Tao Ma 已提交
3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416
			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);
}
3417

3418 3419 3420 3421
struct ext4_renament {
	struct inode *dir;
	struct dentry *dentry;
	struct inode *inode;
M
Miklos Szeredi 已提交
3422 3423
	bool is_dir;
	int dir_nlink_delta;
3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435

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

3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517
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)
		return -EIO;
	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);
	if (EXT4_HAS_INCOMPAT_FEATURE(ent->dir->i_sb,
				      EXT4_FEATURE_INCOMPAT_FILETYPE))
		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);
3518 3519
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3520 3521 3522 3523 3524 3525 3526
	if (bh) {
		retval = ext4_delete_entry(handle, dir, de, bh);
		brelse(bh);
	}
	return retval;
}

3527 3528
static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
			       int force_reread)
3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539
{
	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,
3540 3541
		    ent->de->name_len) ||
	    force_reread) {
3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558
		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) {
		ext4_warning(ent->dir->i_sb,
				"Deleting old file (%lu), %d, error=%d",
				ent->dir->i_ino, ent->dir->i_nlink, retval);
	}
}

M
Miklos Szeredi 已提交
3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569
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 已提交
3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
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;
}

3603 3604 3605
/*
 * Anybody can rename anything with this: the permission checks are left to the
 * higher-level routines.
3606 3607 3608 3609
 *
 * 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)
3610
 */
3611
static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
M
Miklos Szeredi 已提交
3612 3613
		       struct inode *new_dir, struct dentry *new_dentry,
		       unsigned int flags)
3614
{
3615
	handle_t *handle = NULL;
3616 3617 3618 3619 3620 3621 3622 3623 3624 3625
	struct ext4_renament old = {
		.dir = old_dir,
		.dentry = old_dentry,
		.inode = old_dentry->d_inode,
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
		.inode = new_dentry->d_inode,
	};
3626
	int force_reread;
3627
	int retval;
M
Miklos Szeredi 已提交
3628 3629 3630
	struct inode *whiteout = NULL;
	int credits;
	u8 old_file_type;
3631

3632 3633
	dquot_initialize(old.dir);
	dquot_initialize(new.dir);
3634 3635 3636

	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
3637 3638
	if (new.inode)
		dquot_initialize(new.inode);
3639

3640
	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
3641 3642
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
3643 3644 3645 3646 3647 3648 3649
	/*
	 *  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;
3650
	if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3651 3652
		goto end_rename;

3653 3654 3655 3656 3657 3658 3659 3660
	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;
	}

3661 3662
	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
				 &new.de, &new.inlined);
3663 3664
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3665
		new.bh = NULL;
3666 3667
		goto end_rename;
	}
3668 3669 3670 3671
	if (new.bh) {
		if (!new.inode) {
			brelse(new.bh);
			new.bh = NULL;
3672 3673
		}
	}
3674 3675
	if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
		ext4_alloc_da_blocks(old.inode);
3676

M
Miklos Szeredi 已提交
3677 3678 3679 3680
	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);
3681 3682 3683 3684 3685
		if (IS_ERR(handle)) {
			retval = PTR_ERR(handle);
			handle = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3686 3687
	} else {
		whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
3688 3689 3690 3691 3692
		if (IS_ERR(whiteout)) {
			retval = PTR_ERR(whiteout);
			whiteout = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3693
	}
3694

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

3698 3699
	if (S_ISDIR(old.inode->i_mode)) {
		if (new.inode) {
3700
			retval = -ENOTEMPTY;
3701
			if (!ext4_empty_dir(new.inode))
3702
				goto end_rename;
3703 3704 3705 3706
		} else {
			retval = -EMLINK;
			if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
				goto end_rename;
3707
		}
3708
		retval = ext4_rename_dir_prepare(handle, &old);
3709 3710
		if (retval)
			goto end_rename;
3711
	}
3712 3713 3714 3715 3716 3717 3718 3719 3720
	/*
	 * 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 已提交
3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733

	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);
	}
3734 3735
	if (!new.bh) {
		retval = ext4_add_entry(handle, new.dentry, old.inode);
3736 3737 3738
		if (retval)
			goto end_rename;
	} else {
3739
		retval = ext4_setent(handle, &new,
M
Miklos Szeredi 已提交
3740
				     old.inode->i_ino, old_file_type);
3741 3742
		if (retval)
			goto end_rename;
3743
	}
3744 3745 3746
	if (force_reread)
		force_reread = !ext4_test_inode_flag(new.dir,
						     EXT4_INODE_INLINE_DATA);
3747 3748 3749 3750 3751

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

M
Miklos Szeredi 已提交
3755 3756 3757 3758 3759 3760
	if (!whiteout) {
		/*
		 * ok, that's it
		 */
		ext4_rename_delete(handle, &old, force_reread);
	}
3761

3762 3763 3764
	if (new.inode) {
		ext4_dec_count(handle, new.inode);
		new.inode->i_ctime = ext4_current_time(new.inode);
3765
	}
3766 3767 3768
	old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir);
	ext4_update_dx_flag(old.dir);
	if (old.dir_bh) {
3769 3770
		retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
		if (retval)
3771
			goto end_rename;
3772

3773 3774
		ext4_dec_count(handle, old.dir);
		if (new.inode) {
3775 3776 3777
			/* checked ext4_empty_dir above, can't have another
			 * parent, ext4_dec_count() won't work for many-linked
			 * dirs */
3778
			clear_nlink(new.inode);
3779
		} else {
3780 3781 3782
			ext4_inc_count(handle, new.dir);
			ext4_update_dx_flag(new.dir);
			ext4_mark_inode_dirty(handle, new.dir);
3783 3784
		}
	}
3785 3786 3787 3788 3789
	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);
3790 3791 3792 3793
	}
	retval = 0;

end_rename:
3794 3795 3796
	brelse(old.dir_bh);
	brelse(old.bh);
	brelse(new.bh);
M
Miklos Szeredi 已提交
3797 3798 3799 3800 3801 3802
	if (whiteout) {
		if (retval)
			drop_nlink(whiteout);
		unlock_new_inode(whiteout);
		iput(whiteout);
	}
3803 3804
	if (handle)
		ext4_journal_stop(handle);
3805 3806 3807
	return retval;
}

M
Miklos Szeredi 已提交
3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829
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,
		.inode = old_dentry->d_inode,
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
		.inode = new_dentry->d_inode,
	};
	u8 new_file_type;
	int retval;

	dquot_initialize(old.dir);
	dquot_initialize(new.dir);

	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
				 &old.de, &old.inlined);
3830 3831
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
M
Miklos Szeredi 已提交
3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843
	/*
	 *  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);
3844 3845
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3846
		new.bh = NULL;
3847 3848
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3849 3850 3851 3852 3853 3854 3855 3856

	/* 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));
3857 3858 3859 3860 3861
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933

	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 已提交
3934 3935 3936 3937
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 已提交
3938
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
M
Miklos Szeredi 已提交
3939 3940
		return -EINVAL;

M
Miklos Szeredi 已提交
3941 3942 3943 3944
	if (flags & RENAME_EXCHANGE) {
		return ext4_cross_rename(old_dir, old_dentry,
					 new_dir, new_dentry);
	}
M
Miklos Szeredi 已提交
3945 3946

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

3949 3950 3951
/*
 * directories can handle most operations...
 */
3952
const struct inode_operations ext4_dir_inode_operations = {
3953 3954 3955 3956 3957 3958 3959 3960
	.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 已提交
3961
	.tmpfile	= ext4_tmpfile,
M
Miklos Szeredi 已提交
3962
	.rename2	= ext4_rename2,
3963
	.setattr	= ext4_setattr,
3964 3965
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3966
	.listxattr	= ext4_listxattr,
3967
	.removexattr	= generic_removexattr,
3968
	.get_acl	= ext4_get_acl,
3969
	.set_acl	= ext4_set_acl,
3970
	.fiemap         = ext4_fiemap,
3971 3972
};

3973
const struct inode_operations ext4_special_inode_operations = {
3974
	.setattr	= ext4_setattr,
3975 3976
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3977
	.listxattr	= ext4_listxattr,
3978
	.removexattr	= generic_removexattr,
3979
	.get_acl	= ext4_get_acl,
3980
	.set_acl	= ext4_set_acl,
3981
};