namei.c 99.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(struct ext4_filename *fname,
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
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
270
		struct ext4_filename *fname,
271
		struct ext4_dir_entry_2 **res_dir);
272 273
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
			     struct dentry *dentry, struct inode *inode);
274

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
#ifdef CONFIG_EXT4_FS_ENCRYPTION
				int len;
				char *name;
				struct ext4_str fname_crypto_str
					= {.name = NULL, .len = 0};
610
				int res = 0;
611 612 613

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

733 734 735 736 737
	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;
738 739 740
	if (root->info.hash_version != DX_HASH_TEA &&
	    root->info.hash_version != DX_HASH_HALF_MD4 &&
	    root->info.hash_version != DX_HASH_LEGACY) {
741
		ext4_warning(dir->i_sb, "Unrecognised inode hash code %d",
742 743 744
			     root->info.hash_version);
		goto fail;
	}
745 746
	if (fname)
		hinfo = &fname->hinfo;
747
	hinfo->hash_version = root->info.hash_version;
748 749
	if (hinfo->hash_version <= DX_HASH_TEA)
		hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
750
	hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
751 752
	if (fname && fname_name(fname))
		ext4fs_dirhash(fname_name(fname), fname_len(fname), hinfo);
753 754 755
	hash = hinfo->hash;

	if (root->info.unused_flags & 1) {
756
		ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x",
757 758 759 760 761
			     root->info.unused_flags);
		goto fail;
	}

	if ((indirect = root->info.indirect_levels) > 1) {
762
		ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
763 764 765 766 767 768
			     root->info.indirect_levels);
		goto fail;
	}

	entries = (struct dx_entry *) (((char *)&root->info) +
				       root->info.info_length);
769 770 771

	if (dx_get_limit(entries) != dx_root_limit(dir,
						   root->info.info_length)) {
772
		ext4_warning(dir->i_sb, "dx entry: limit != root limit");
773 774 775
		goto fail;
	}

776
	dxtrace(printk("Look up %x", hash));
777
	while (1) {
778
		count = dx_get_count(entries);
779
		if (!count || count > dx_get_limit(entries)) {
780
			ext4_warning(dir->i_sb,
781
				     "dx entry: no count or count > limit");
782
			goto fail;
783 784
		}

785 786
		p = entries + 1;
		q = entries + count - 1;
787
		while (p <= q) {
788 789 790 791 792 793 794 795
			m = p + (q - p)/2;
			dxtrace(printk("."));
			if (dx_get_hash(m) > hash)
				q = m - 1;
			else
				p = m + 1;
		}

796
		if (0) { // linear search cross check
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
			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;
815 816 817 818 819 820 821 822
		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;
823
		}
824
		entries = ((struct dx_node *) frame->bh->b_data)->entries;
825

826
		if (dx_get_limit(entries) != dx_node_limit (dir)) {
827
			ext4_warning(dir->i_sb,
828
				     "dx entry: limit != node limit");
829
			goto fail;
830
		}
831
	}
832
fail:
833 834 835 836
	while (frame >= frame_in) {
		brelse(frame->bh);
		frame--;
	}
837

838
	if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
839
		ext4_warning(dir->i_sb,
Z
Zheng Liu 已提交
840
			     "Corrupt dir inode %lu, running e2fsck is "
841
			     "recommended.", dir->i_ino);
842
	return ret_err;
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
}

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.
 */
872
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
873 874 875 876 877 878
				 struct dx_frame *frame,
				 struct dx_frame *frames,
				 __u32 *start_hash)
{
	struct dx_frame *p;
	struct buffer_head *bh;
879
	int num_frames = 0;
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
	__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--) {
918 919 920
		bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
		if (IS_ERR(bh))
			return PTR_ERR(bh);
921
		p++;
922
		brelse(p->bh);
923 924 925 926 927 928 929 930 931 932 933 934 935
		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 已提交
936
				  struct inode *dir, ext4_lblk_t block,
937 938 939 940
				  struct dx_hash_info *hinfo,
				  __u32 start_hash, __u32 start_minor_hash)
{
	struct buffer_head *bh;
941
	struct ext4_dir_entry_2 *de, *top;
942
	int err = 0, count = 0;
943
	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0}, tmp_str;
944

A
Aneesh Kumar K.V 已提交
945 946
	dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
							(unsigned long)block));
947 948 949
	bh = ext4_read_dirblock(dir, block, DIRENT);
	if (IS_ERR(bh))
		return PTR_ERR(bh);
950

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

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

1043
	dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1044
		       start_hash, start_minor_hash));
A
Al Viro 已提交
1045
	dir = file_inode(dir_file);
1046
	if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1047
		hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1048 1049 1050
		if (hinfo.hash_version <= DX_HASH_TEA)
			hinfo.hash_version +=
				EXT4_SB(dir->i_sb)->s_hash_unsigned;
1051
		hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
		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;
			}
		}
1063 1064 1065 1066 1067 1068 1069
		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;
1070 1071 1072
	frame = dx_probe(NULL, dir, &hinfo, frames);
	if (IS_ERR(frame))
		return PTR_ERR(frame);
1073 1074 1075

	/* Add '.' and '..' from the htree header */
	if (!start_hash && !start_minor_hash) {
1076
		de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1077 1078 1079 1080 1081
		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)
1082 1083 1084 1085
			goto errout;
		count++;
	}
	if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1086
		de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1087
		de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1088 1089 1090 1091 1092
		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)
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
			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;
1107
		ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
					    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);
1124 1125
	dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
		       "next hash: %x\n", count, *next_hash));
1126 1127 1128 1129 1130 1131
	return count;
errout:
	dx_release(frames);
	return (err);
}

T
Tao Ma 已提交
1132 1133
static inline int search_dirblock(struct buffer_head *bh,
				  struct inode *dir,
1134
				  struct ext4_filename *fname,
T
Tao Ma 已提交
1135 1136 1137 1138
				  const struct qstr *d_name,
				  unsigned int offset,
				  struct ext4_dir_entry_2 **res_dir)
{
1139 1140
	return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
			       fname, d_name, offset, res_dir);
T
Tao Ma 已提交
1141 1142
}

1143 1144 1145 1146
/*
 * Directory block splitting, compacting
 */

1147 1148 1149 1150
/*
 * Create map of hash values, offsets, and sizes, stored at end of block.
 * Returns number of entries mapped.
 */
1151 1152
static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
		       unsigned blocksize, struct dx_hash_info *hinfo,
1153
		       struct dx_map_entry *map_tail)
1154 1155 1156 1157 1158
{
	int count = 0;
	char *base = (char *) de;
	struct dx_hash_info h = *hinfo;

1159
	while ((char *) de < base + blocksize) {
1160
		if (de->name_len && de->inode) {
1161
			ext4fs_dirhash(de->name, de->name_len, &h);
1162 1163
			map_tail--;
			map_tail->hash = h.hash;
1164
			map_tail->offs = ((char *) de - base)>>2;
1165
			map_tail->size = le16_to_cpu(de->rec_len);
1166 1167 1168 1169
			count++;
			cond_resched();
		}
		/* XXX: do we need to check rec_len == 0 case? -Chris */
1170
		de = ext4_next_entry(de, blocksize);
1171 1172 1173 1174
	}
	return count;
}

1175
/* Sort map by hash value */
1176 1177
static void dx_sort_map (struct dx_map_entry *map, unsigned count)
{
A
Andrew Morton 已提交
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
	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)
1195
				continue;
A
Andrew Morton 已提交
1196 1197
			swap(*(q+1), *q);
			more = 1;
1198 1199 1200 1201
		}
	} while(more);
}

A
Aneesh Kumar K.V 已提交
1202
static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
{
	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);
}

/*
1217
 * NOTE! unlike strncmp, ext4_match returns 1 for success, 0 for failure.
1218
 *
1219
 * `len <= EXT4_NAME_LEN' is guaranteed by caller.
1220 1221
 * `de != NULL' is guaranteed by caller.
 */
1222
static inline int ext4_match(struct ext4_filename *fname,
1223
			     struct ext4_dir_entry_2 *de)
1224
{
1225 1226
	const void *name = fname_name(fname);
	u32 len = fname_len(fname);
1227

1228 1229
	if (!de->inode)
		return 0;
1230 1231

#ifdef CONFIG_EXT4_FS_ENCRYPTION
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
	if (unlikely(!name)) {
		if (fname->usr_fname->name[0] == '_') {
			int ret;
			if (de->name_len < 16)
				return 0;
			ret = memcmp(de->name + de->name_len - 16,
				     fname->crypto_buf.name + 8, 16);
			return (ret == 0) ? 1 : 0;
		}
		name = fname->crypto_buf.name;
		len = fname->crypto_buf.len;
	}
1244
#endif
1245
	if (de->name_len != len)
1246
		return 0;
1247
	return (memcmp(de->name, name, len) == 0) ? 1 : 0;
1248 1249 1250 1251 1252
}

/*
 * Returns 0 if not found, -1 on failure, and 1 on success
 */
1253 1254 1255 1256
int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
		    struct inode *dir, struct ext4_filename *fname,
		    const struct qstr *d_name,
		    unsigned int offset, struct ext4_dir_entry_2 **res_dir)
1257
{
1258
	struct ext4_dir_entry_2 * de;
1259 1260
	char * dlimit;
	int de_len;
1261 1262
	int res;

T
Tao Ma 已提交
1263 1264
	de = (struct ext4_dir_entry_2 *)search_buf;
	dlimit = search_buf + buf_size;
1265 1266 1267
	while ((char *) de < dlimit) {
		/* this code is executed quadratically often */
		/* do minimal checking `by hand' */
1268
		if ((char *) de + de->name_len <= dlimit) {
1269
			res = ext4_match(fname, de);
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
			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;
			}
1287 1288 1289

		}
		/* prevent looping on a bad block */
1290 1291
		de_len = ext4_rec_len_from_disk(de->rec_len,
						dir->i_sb->s_blocksize);
1292 1293 1294 1295
		if (de_len <= 0) {
			res = -1;
			goto return_result;
		}
1296
		offset += de_len;
1297
		de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1298
	}
1299 1300 1301 1302

	res = 0;
return_result:
	return res;
1303 1304
}

1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
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;
}
1320 1321

/*
1322
 *	ext4_find_entry()
1323 1324 1325 1326 1327 1328 1329 1330 1331
 *
 * 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.
 */
1332 1333
static struct buffer_head * ext4_find_entry (struct inode *dir,
					const struct qstr *d_name,
T
Tao Ma 已提交
1334 1335
					struct ext4_dir_entry_2 **res_dir,
					int *inlined)
1336
{
1337 1338 1339
	struct super_block *sb;
	struct buffer_head *bh_use[NAMEI_RA_SIZE];
	struct buffer_head *bh, *ret = NULL;
A
Aneesh Kumar K.V 已提交
1340
	ext4_lblk_t start, block, b;
1341
	const u8 *name = d_name->name;
1342 1343 1344 1345 1346
	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 已提交
1347
	ext4_lblk_t  nblocks;
1348 1349
	int i, namelen, retval;
	struct ext4_filename fname;
1350 1351 1352

	*res_dir = NULL;
	sb = dir->i_sb;
1353
	namelen = d_name->len;
1354
	if (namelen > EXT4_NAME_LEN)
1355
		return NULL;
1356

1357 1358 1359 1360
	retval = ext4_fname_setup_filename(dir, d_name, 1, &fname);
	if (retval)
		return ERR_PTR(retval);

1361 1362
	if (ext4_has_inline_data(dir)) {
		int has_inline_data = 1;
1363
		ret = ext4_find_inline_entry(dir, &fname, d_name, res_dir,
1364
					     &has_inline_data);
T
Tao Ma 已提交
1365 1366 1367
		if (has_inline_data) {
			if (inlined)
				*inlined = 1;
1368
			goto cleanup_and_exit;
T
Tao Ma 已提交
1369
		}
1370 1371
	}

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

cleanup_and_exit:
	/* Clean up the read-ahead blocks */
	for (; ra_ptr < ra_max; ra_ptr++)
1484
		brelse(bh_use[ra_ptr]);
1485
	ext4_fname_free_filename(&fname);
1486 1487 1488
	return ret;
}

1489 1490 1491
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
			struct ext4_filename *fname,
			struct ext4_dir_entry_2 **res_dir)
1492
{
1493
	struct super_block * sb = dir->i_sb;
1494
	struct dx_frame frames[2], *frame;
1495
	const struct qstr *d_name = fname->usr_fname;
1496
	struct buffer_head *bh;
A
Aneesh Kumar K.V 已提交
1497
	ext4_lblk_t block;
1498 1499
	int retval;

1500 1501 1502
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	*res_dir = NULL;
#endif
1503
	frame = dx_probe(fname, dir, NULL, frames);
1504 1505
	if (IS_ERR(frame))
		return (struct buffer_head *) frame;
1506 1507
	do {
		block = dx_get_block(frame->at);
1508
		bh = ext4_read_dirblock(dir, block, DIRENT);
1509
		if (IS_ERR(bh))
1510
			goto errout;
1511

1512
		retval = search_dirblock(bh, dir, fname, d_name,
1513 1514
					 block << EXT4_BLOCK_SIZE_BITS(sb),
					 res_dir);
1515 1516
		if (retval == 1)
			goto success;
1517
		brelse(bh);
1518
		if (retval == -1) {
1519
			bh = ERR_PTR(ERR_BAD_DX_DIR);
1520 1521 1522
			goto errout;
		}

1523
		/* Check to see if we should continue to search */
1524
		retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1525 1526
					       frames, NULL);
		if (retval < 0) {
1527
			ext4_warning(sb,
1528 1529 1530
			     "error %d reading index page in directory #%lu",
			     retval, dir->i_ino);
			bh = ERR_PTR(retval);
1531 1532 1533 1534
			goto errout;
		}
	} while (retval == 1);

1535
	bh = NULL;
1536
errout:
1537
	dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
1538 1539 1540
success:
	dx_release(frames);
	return bh;
1541 1542
}

A
Al Viro 已提交
1543
static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1544
{
1545 1546 1547
	struct inode *inode;
	struct ext4_dir_entry_2 *de;
	struct buffer_head *bh;
1548

1549
	if (dentry->d_name.len > EXT4_NAME_LEN)
1550 1551
		return ERR_PTR(-ENAMETOOLONG);

T
Tao Ma 已提交
1552
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
1553 1554
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1555 1556
	inode = NULL;
	if (bh) {
1557
		__u32 ino = le32_to_cpu(de->inode);
1558
		brelse(bh);
1559
		if (!ext4_valid_inum(dir->i_sb, ino)) {
1560
			EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1561
			return ERR_PTR(-EIO);
1562
		}
1563
		if (unlikely(ino == dir->i_ino)) {
D
David Howells 已提交
1564 1565
			EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
					 dentry);
1566 1567
			return ERR_PTR(-EIO);
		}
1568
		inode = ext4_iget_normal(dir->i_sb, ino);
1569 1570 1571 1572 1573
		if (inode == ERR_PTR(-ESTALE)) {
			EXT4_ERROR_INODE(dir,
					 "deleted inode referenced: %u",
					 ino);
			return ERR_PTR(-EIO);
1574
		}
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
		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);
		}
1587 1588 1589 1590 1591
	}
	return d_splice_alias(inode, dentry);
}


1592
struct dentry *ext4_get_parent(struct dentry *child)
1593
{
1594
	__u32 ino;
1595
	static const struct qstr dotdot = QSTR_INIT("..", 2);
1596
	struct ext4_dir_entry_2 * de;
1597 1598
	struct buffer_head *bh;

1599
	bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
1600 1601
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1602 1603 1604 1605 1606
	if (!bh)
		return ERR_PTR(-ENOENT);
	ino = le32_to_cpu(de->inode);
	brelse(bh);

1607 1608
	if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
		EXT4_ERROR_INODE(d_inode(child),
1609
				 "bad parent inode number: %u", ino);
1610
		return ERR_PTR(-EIO);
1611 1612
	}

1613
	return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
1614 1615
}

1616 1617 1618 1619
/*
 * Move count entries from end of map between two memory locations.
 * Returns pointer to last entry moved.
 */
1620
static struct ext4_dir_entry_2 *
1621 1622
dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
		unsigned blocksize)
1623 1624 1625 1626
{
	unsigned rec_len = 0;

	while (count--) {
1627
		struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1628
						(from + (map->offs<<2));
1629
		rec_len = EXT4_DIR_REC_LEN(de->name_len);
1630
		memcpy (to, de, rec_len);
1631
		((struct ext4_dir_entry_2 *) to)->rec_len =
1632
				ext4_rec_len_to_disk(rec_len, blocksize);
1633 1634 1635 1636
		de->inode = 0;
		map++;
		to += rec_len;
	}
1637
	return (struct ext4_dir_entry_2 *) (to - rec_len);
1638 1639
}

1640 1641 1642 1643
/*
 * Compact each dir entry in the range to the minimal rec_len.
 * Returns pointer to last entry in range.
 */
1644
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
1645
{
1646
	struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1647 1648 1649
	unsigned rec_len = 0;

	prev = to = de;
1650
	while ((char*)de < base + blocksize) {
1651
		next = ext4_next_entry(de, blocksize);
1652
		if (de->inode && de->name_len) {
1653
			rec_len = EXT4_DIR_REC_LEN(de->name_len);
1654 1655
			if (de > to)
				memmove(to, de, rec_len);
1656
			to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1657
			prev = to;
1658
			to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1659 1660 1661 1662 1663 1664
		}
		de = next;
	}
	return prev;
}

1665 1666 1667 1668 1669
/*
 * 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.
 */
1670
static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1671
			struct buffer_head **bh,struct dx_frame *frame,
1672
			struct dx_hash_info *hinfo)
1673 1674 1675 1676
{
	unsigned blocksize = dir->i_sb->s_blocksize;
	unsigned count, continued;
	struct buffer_head *bh2;
A
Aneesh Kumar K.V 已提交
1677
	ext4_lblk_t newblock;
1678 1679 1680
	u32 hash2;
	struct dx_map_entry *map;
	char *data1 = (*bh)->b_data, *data2;
1681
	unsigned split, move, size;
1682
	struct ext4_dir_entry_2 *de = NULL, *de2;
1683 1684
	struct ext4_dir_entry_tail *t;
	int	csum_size = 0;
1685
	int	err = 0, i;
1686

1687
	if (ext4_has_metadata_csum(dir->i_sb))
1688 1689
		csum_size = sizeof(struct ext4_dir_entry_tail);

1690 1691
	bh2 = ext4_append(handle, dir, &newblock);
	if (IS_ERR(bh2)) {
1692 1693
		brelse(*bh);
		*bh = NULL;
1694
		return (struct ext4_dir_entry_2 *) bh2;
1695 1696 1697
	}

	BUFFER_TRACE(*bh, "get_write_access");
1698
	err = ext4_journal_get_write_access(handle, *bh);
1699 1700 1701
	if (err)
		goto journal_error;

1702
	BUFFER_TRACE(frame->bh, "get_write_access");
1703
	err = ext4_journal_get_write_access(handle, frame->bh);
1704 1705 1706 1707 1708 1709 1710
	if (err)
		goto journal_error;

	data2 = bh2->b_data;

	/* create map in the end of data2 block */
	map = (struct dx_map_entry *) (data2 + blocksize);
1711
	count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
1712 1713
			     blocksize, hinfo, map);
	map -= count;
1714
	dx_sort_map(map, count);
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
	/* 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;
1727 1728
	hash2 = map[split].hash;
	continued = hash2 == map[split - 1].hash;
A
Aneesh Kumar K.V 已提交
1729 1730 1731
	dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
			(unsigned long)dx_get_block(frame->at),
					hash2, split, count-split));
1732 1733

	/* Fancy dance to stay within two buffers */
1734 1735
	de2 = dx_move_dirents(data1, data2, map + split, count - split,
			      blocksize);
1736
	de = dx_pack_dirents(data1, blocksize);
1737 1738
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
1739
					   blocksize);
1740 1741
	de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
					    (char *) de2,
1742
					    blocksize);
1743 1744 1745 1746 1747 1748 1749 1750
	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);
	}

1751 1752 1753 1754
	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));
1755 1756

	/* Which block gets the new entry? */
1757
	if (hinfo->hash >= hash2) {
1758 1759 1760
		swap(*bh, bh2);
		de = de2;
	}
1761
	dx_insert_block(frame, hash2 + continued, newblock);
1762
	err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
1763 1764
	if (err)
		goto journal_error;
1765
	err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
1766 1767
	if (err)
		goto journal_error;
1768 1769
	brelse(bh2);
	dxtrace(dx_show_index("frame", frame->entries));
1770
	return de;
1771 1772 1773 1774 1775 1776

journal_error:
	brelse(*bh);
	brelse(bh2);
	*bh = NULL;
	ext4_std_error(dir->i_sb, err);
1777
	return ERR_PTR(err);
1778 1779
}

1780 1781 1782
int ext4_find_dest_de(struct inode *dir, struct inode *inode,
		      struct buffer_head *bh,
		      void *buf, int buf_size,
1783
		      struct ext4_filename *fname,
1784 1785 1786
		      struct ext4_dir_entry_2 **dest_de)
{
	struct ext4_dir_entry_2 *de;
1787
	unsigned short reclen = EXT4_DIR_REC_LEN(fname_len(fname));
1788 1789 1790
	int nlen, rlen;
	unsigned int offset = 0;
	char *top;
1791 1792
	int res;

1793 1794 1795 1796
	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,
1797 1798 1799 1800 1801
					 buf, buf_size, offset)) {
			res = -EIO;
			goto return_result;
		}
		/* Provide crypto context and crypto buffer to ext4 match */
1802
		res = ext4_match(fname, de);
1803 1804 1805 1806 1807 1808
		if (res < 0)
			goto return_result;
		if (res > 0) {
			res = -EEXIST;
			goto return_result;
		}
1809 1810 1811 1812 1813 1814 1815 1816
		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;
	}

1817 1818 1819 1820 1821 1822 1823 1824
	if ((char *) de > top)
		res = -ENOSPC;
	else {
		*dest_de = de;
		res = 0;
	}
return_result:
	return res;
1825 1826
}

1827 1828 1829 1830
int ext4_insert_dentry(struct inode *dir,
		       struct inode *inode,
		       struct ext4_dir_entry_2 *de,
		       int buf_size,
1831
		       struct ext4_filename *fname)
1832 1833 1834 1835 1836 1837 1838 1839
{

	int nlen, rlen;

	nlen = EXT4_DIR_REC_LEN(de->name_len);
	rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
	if (de->inode) {
		struct ext4_dir_entry_2 *de1 =
1840
			(struct ext4_dir_entry_2 *)((char *)de + nlen);
1841 1842 1843 1844 1845 1846 1847
		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);
1848 1849
	de->name_len = fname_len(fname);
	memcpy(de->name, fname_name(fname), fname_len(fname));
1850
	return 0;
1851
}
1852

1853 1854 1855 1856 1857 1858 1859 1860
/*
 * 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.
 */
1861 1862
static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
			     struct inode *dir,
1863
			     struct inode *inode, struct ext4_dir_entry_2 *de,
1864
			     struct buffer_head *bh)
1865
{
1866
	unsigned int	blocksize = dir->i_sb->s_blocksize;
1867
	int		csum_size = 0;
1868
	int		err;
1869

1870
	if (ext4_has_metadata_csum(inode->i_sb))
1871
		csum_size = sizeof(struct ext4_dir_entry_tail);
1872 1873

	if (!de) {
1874 1875
		err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
					blocksize - csum_size, fname, &de);
1876 1877
		if (err)
			return err;
1878 1879
	}
	BUFFER_TRACE(bh, "get_write_access");
1880
	err = ext4_journal_get_write_access(handle, bh);
1881
	if (err) {
1882
		ext4_std_error(dir->i_sb, err);
1883 1884 1885
		return err;
	}

1886 1887
	/* By now the buffer is marked for journaling. Due to crypto operations,
	 * the following function call may fail */
1888
	err = ext4_insert_dentry(dir, inode, de, blocksize, fname);
1889 1890
	if (err < 0)
		return err;
1891

1892 1893 1894 1895 1896 1897
	/*
	 * 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
1898
	 * ext4_new_inode() setting the times, but error
1899 1900 1901 1902
	 * 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 已提交
1903
	dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
1904
	ext4_update_dx_flag(dir);
1905
	dir->i_version++;
1906
	ext4_mark_inode_dirty(handle, dir);
1907
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1908
	err = ext4_handle_dirty_dirent_node(handle, dir, bh);
1909
	if (err)
1910
		ext4_std_error(dir->i_sb, err);
1911 1912 1913 1914 1915 1916 1917
	return 0;
}

/*
 * This converts a one block unindexed directory to a 3 block indexed
 * directory, and adds the dentry to the indexed directory.
 */
1918 1919
static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
			    struct dentry *dentry,
1920 1921
			    struct inode *inode, struct buffer_head *bh)
{
1922
	struct inode	*dir = d_inode(dentry->d_parent);
1923 1924 1925 1926
	struct buffer_head *bh2;
	struct dx_root	*root;
	struct dx_frame	frames[2], *frame;
	struct dx_entry *entries;
1927
	struct ext4_dir_entry_2	*de, *de2;
1928
	struct ext4_dir_entry_tail *t;
1929 1930 1931 1932
	char		*data1, *top;
	unsigned	len;
	int		retval;
	unsigned	blocksize;
A
Aneesh Kumar K.V 已提交
1933
	ext4_lblk_t  block;
1934
	struct fake_dirent *fde;
1935 1936
	int csum_size = 0;

1937
	if (ext4_has_metadata_csum(inode->i_sb))
1938
		csum_size = sizeof(struct ext4_dir_entry_tail);
1939 1940

	blocksize =  dir->i_sb->s_blocksize;
1941
	dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
1942
	BUFFER_TRACE(bh, "get_write_access");
1943
	retval = ext4_journal_get_write_access(handle, bh);
1944
	if (retval) {
1945
		ext4_std_error(dir->i_sb, retval);
1946 1947 1948 1949 1950
		brelse(bh);
		return retval;
	}
	root = (struct dx_root *) bh->b_data;

1951 1952 1953
	/* The 0th block becomes the root, move the dirents out */
	fde = &root->dotdot;
	de = (struct ext4_dir_entry_2 *)((char *)fde +
1954
		ext4_rec_len_from_disk(fde->rec_len, blocksize));
1955
	if ((char *) de >= (((char *) root) + blocksize)) {
1956
		EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
1957 1958 1959
		brelse(bh);
		return -EIO;
	}
1960
	len = ((char *) root) + (blocksize - csum_size) - (char *) de;
1961 1962

	/* Allocate new block for the 0th block's dirents */
1963 1964
	bh2 = ext4_append(handle, dir, &block);
	if (IS_ERR(bh2)) {
1965
		brelse(bh);
1966
		return PTR_ERR(bh2);
1967
	}
1968
	ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
1969 1970 1971
	data1 = bh2->b_data;

	memcpy (data1, de, len);
1972
	de = (struct ext4_dir_entry_2 *) data1;
1973
	top = data1 + len;
1974
	while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
1975
		de = de2;
1976 1977
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
1978
					   blocksize);
1979 1980 1981 1982 1983 1984

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

1985
	/* Initialize the root; the dot dirents already exist */
1986
	de = (struct ext4_dir_entry_2 *) (&root->dotdot);
1987 1988
	de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
					   blocksize);
1989 1990
	memset (&root->info, 0, sizeof(root->info));
	root->info.info_length = sizeof(root->info);
1991
	root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1992
	entries = root->entries;
1993 1994 1995
	dx_set_block(entries, 1);
	dx_set_count(entries, 1);
	dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
1996 1997

	/* Initialize as for dx_probe */
1998 1999 2000 2001 2002 2003
	fname->hinfo.hash_version = root->info.hash_version;
	if (fname->hinfo.hash_version <= DX_HASH_TEA)
		fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
	fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
	ext4fs_dirhash(fname_name(fname), fname_len(fname), &fname->hinfo);

2004
	memset(frames, 0, sizeof(frames));
2005 2006 2007 2008 2009
	frame = frames;
	frame->entries = entries;
	frame->at = entries;
	frame->bh = bh;
	bh = bh2;
2010

2011 2012 2013 2014 2015 2016
	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;	
2017

2018
	de = do_split(handle,dir, &bh, frame, &fname->hinfo);
2019
	if (IS_ERR(de)) {
2020 2021
		retval = PTR_ERR(de);
		goto out_frames;
2022 2023
	}
	dx_release(frames);
2024

2025
	retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2026 2027
	brelse(bh);
	return retval;
2028 2029 2030 2031 2032 2033 2034 2035 2036
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;
2037 2038 2039
}

/*
2040
 *	ext4_add_entry()
2041 2042
 *
 * adds a file entry to the specified directory, using the same
2043
 * semantics as ext4_find_entry(). It returns NULL if it failed.
2044 2045 2046 2047 2048
 *
 * 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.
 */
2049 2050
static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
			  struct inode *inode)
2051
{
2052
	struct inode *dir = d_inode(dentry->d_parent);
2053
	struct buffer_head *bh = NULL;
2054
	struct ext4_dir_entry_2 *de;
2055
	struct ext4_dir_entry_tail *t;
2056
	struct super_block *sb;
2057
	struct ext4_filename fname;
2058 2059 2060
	int	retval;
	int	dx_fallback=0;
	unsigned blocksize;
A
Aneesh Kumar K.V 已提交
2061
	ext4_lblk_t block, blocks;
2062 2063
	int	csum_size = 0;

2064
	if (ext4_has_metadata_csum(inode->i_sb))
2065
		csum_size = sizeof(struct ext4_dir_entry_tail);
2066 2067 2068 2069 2070

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

2072 2073 2074 2075
	retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
	if (retval)
		return retval;

2076
	if (ext4_has_inline_data(dir)) {
2077 2078
		retval = ext4_try_add_inline_entry(handle, &fname,
						   dentry, inode);
2079
		if (retval < 0)
2080
			goto out;
2081 2082
		if (retval == 1) {
			retval = 0;
2083
			goto out;
2084 2085 2086
		}
	}

2087
	if (is_dx(dir)) {
2088
		retval = ext4_dx_add_entry(handle, &fname, dentry, inode);
2089
		if (!retval || (retval != ERR_BAD_DX_DIR))
2090
			goto out;
2091
		ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2092
		dx_fallback++;
2093
		ext4_mark_inode_dirty(handle, dir);
2094 2095
	}
	blocks = dir->i_size >> sb->s_blocksize_bits;
2096
	for (block = 0; block < blocks; block++) {
2097
		bh = ext4_read_dirblock(dir, block, DIRENT);
2098 2099 2100 2101 2102 2103 2104
		if (IS_ERR(bh)) {
			retval = PTR_ERR(bh);
			bh = NULL;
			goto out;
		}
		retval = add_dirent_to_buf(handle, &fname, dir, inode,
					   NULL, bh);
2105 2106
		if (retval != -ENOSPC)
			goto out;
2107 2108

		if (blocks == 1 && !dx_fallback &&
2109
		    EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) {
2110 2111
			retval = make_indexed_dir(handle, &fname, dentry,
						  inode, bh);
2112 2113 2114
			bh = NULL; /* make_indexed_dir releases bh */
			goto out;
		}
2115 2116
		brelse(bh);
	}
2117
	bh = ext4_append(handle, dir, &block);
2118 2119 2120 2121 2122
	if (IS_ERR(bh)) {
		retval = PTR_ERR(bh);
		bh = NULL;
		goto out;
	}
2123
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2124
	de->inode = 0;
2125 2126 2127 2128 2129 2130 2131
	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);
	}

2132
	retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2133
out:
2134
	ext4_fname_free_filename(&fname);
2135
	brelse(bh);
2136 2137
	if (retval == 0)
		ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
2138
	return retval;
2139 2140 2141 2142 2143
}

/*
 * Returns 0 for success, or a negative error value
 */
2144 2145
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
			     struct dentry *dentry, struct inode *inode)
2146 2147 2148
{
	struct dx_frame frames[2], *frame;
	struct dx_entry *entries, *at;
2149
	struct buffer_head *bh;
2150
	struct inode *dir = d_inode(dentry->d_parent);
2151
	struct super_block *sb = dir->i_sb;
2152
	struct ext4_dir_entry_2 *de;
2153 2154
	int err;

2155
	frame = dx_probe(fname, dir, NULL, frames);
2156 2157
	if (IS_ERR(frame))
		return PTR_ERR(frame);
2158 2159
	entries = frame->entries;
	at = frame->at;
2160 2161 2162 2163
	bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
	if (IS_ERR(bh)) {
		err = PTR_ERR(bh);
		bh = NULL;
2164
		goto cleanup;
C
Carlos Maiolino 已提交
2165
	}
2166 2167

	BUFFER_TRACE(bh, "get_write_access");
2168
	err = ext4_journal_get_write_access(handle, bh);
2169 2170 2171
	if (err)
		goto journal_error;

2172
	err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2173
	if (err != -ENOSPC)
2174 2175 2176
		goto cleanup;

	/* Block full, should compress but for now just split */
2177
	dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
2178 2179 2180
		       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 已提交
2181
		ext4_lblk_t newblock;
2182 2183 2184 2185 2186 2187 2188 2189
		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))) {
2190
			ext4_warning(sb, "Directory index full!");
2191 2192 2193
			err = -ENOSPC;
			goto cleanup;
		}
2194 2195 2196
		bh2 = ext4_append(handle, dir, &newblock);
		if (IS_ERR(bh2)) {
			err = PTR_ERR(bh2);
2197
			goto cleanup;
2198
		}
2199 2200
		node2 = (struct dx_node *)(bh2->b_data);
		entries2 = node2->entries;
2201
		memset(&node2->fake, 0, sizeof(struct fake_dirent));
2202 2203
		node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
							   sb->s_blocksize);
2204
		BUFFER_TRACE(frame->bh, "get_write_access");
2205
		err = ext4_journal_get_write_access(handle, frame->bh);
2206 2207 2208 2209 2210
		if (err)
			goto journal_error;
		if (levels) {
			unsigned icount1 = icount/2, icount2 = icount - icount1;
			unsigned hash2 = dx_get_hash(entries + icount1);
2211 2212
			dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
				       icount1, icount2));
2213 2214

			BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2215
			err = ext4_journal_get_write_access(handle,
2216 2217 2218 2219
							     frames[0].bh);
			if (err)
				goto journal_error;

2220 2221 2222 2223 2224
			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));
2225 2226 2227 2228 2229 2230 2231

			/* 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);
			}
2232 2233 2234
			dx_insert_block(frames + 0, hash2, newblock);
			dxtrace(dx_show_index("node", frames[1].entries));
			dxtrace(dx_show_index("node",
2235
			       ((struct dx_node *) bh2->b_data)->entries));
2236
			err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2237 2238 2239 2240
			if (err)
				goto journal_error;
			brelse (bh2);
		} else {
2241 2242
			dxtrace(printk(KERN_DEBUG
				       "Creating second level index...\n"));
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
			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;
2257
			err = ext4_journal_get_write_access(handle,
2258 2259 2260 2261
							     frame->bh);
			if (err)
				goto journal_error;
		}
2262
		err = ext4_handle_dirty_dx_node(handle, dir, frames[0].bh);
2263 2264 2265 2266
		if (err) {
			ext4_std_error(inode->i_sb, err);
			goto cleanup;
		}
2267
	}
2268
	de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2269 2270
	if (IS_ERR(de)) {
		err = PTR_ERR(de);
2271
		goto cleanup;
2272
	}
2273
	err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2274 2275 2276
	goto cleanup;

journal_error:
2277
	ext4_std_error(dir->i_sb, err);
2278
cleanup:
2279
	brelse(bh);
2280 2281 2282 2283 2284
	dx_release(frames);
	return err;
}

/*
T
Tao Ma 已提交
2285 2286
 * ext4_generic_delete_entry deletes a directory entry by merging it
 * with the previous entry
2287
 */
T
Tao Ma 已提交
2288 2289 2290 2291 2292 2293 2294
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)
2295
{
2296
	struct ext4_dir_entry_2 *de, *pde;
2297
	unsigned int blocksize = dir->i_sb->s_blocksize;
T
Tao Ma 已提交
2298
	int i;
2299

2300 2301
	i = 0;
	pde = NULL;
T
Tao Ma 已提交
2302 2303
	de = (struct ext4_dir_entry_2 *)entry_buf;
	while (i < buf_size - csum_size) {
2304 2305
		if (ext4_check_dir_entry(dir, NULL, de, bh,
					 bh->b_data, bh->b_size, i))
2306 2307 2308
			return -EIO;
		if (de == de_del)  {
			if (pde)
2309
				pde->rec_len = ext4_rec_len_to_disk(
2310 2311 2312 2313 2314
					ext4_rec_len_from_disk(pde->rec_len,
							       blocksize) +
					ext4_rec_len_from_disk(de->rec_len,
							       blocksize),
					blocksize);
2315 2316 2317 2318 2319
			else
				de->inode = 0;
			dir->i_version++;
			return 0;
		}
2320
		i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2321
		pde = de;
2322
		de = ext4_next_entry(de, blocksize);
2323 2324 2325 2326
	}
	return -ENOENT;
}

T
Tao Ma 已提交
2327 2328 2329 2330 2331 2332 2333
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;

2334 2335 2336 2337 2338 2339 2340 2341
	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;
	}

2342
	if (ext4_has_metadata_csum(dir->i_sb))
T
Tao Ma 已提交
2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367
		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;
}

2368 2369 2370 2371 2372 2373 2374 2375 2376 2377
/*
 * 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 已提交
2378
			set_nlink(inode, 1);
2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
			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)
{
2391 2392
	if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
		drop_nlink(inode);
2393 2394 2395
}


2396
static int ext4_add_nondir(handle_t *handle,
2397 2398
		struct dentry *dentry, struct inode *inode)
{
2399
	int err = ext4_add_entry(handle, dentry, inode);
2400
	if (!err) {
2401
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
2402
		unlock_new_inode(inode);
2403
		d_instantiate(dentry, inode);
2404 2405
		return 0;
	}
2406
	drop_nlink(inode);
A
Al Viro 已提交
2407
	unlock_new_inode(inode);
2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
	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 已提交
2420
static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
A
Al Viro 已提交
2421
		       bool excl)
2422 2423
{
	handle_t *handle;
2424
	struct inode *inode;
2425
	int err, credits, retries = 0;
2426

2427
	dquot_initialize(dir);
2428

2429
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2430
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2431
retry:
2432 2433 2434
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2435 2436
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
2437
		inode->i_op = &ext4_file_inode_operations;
2438
		inode->i_fop = &ext4_file_operations;
2439
		ext4_set_aops(inode);
2440
		err = ext4_add_nondir(handle, dentry, inode);
2441 2442
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2443
	}
2444 2445
	if (handle)
		ext4_journal_stop(handle);
2446
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2447 2448 2449 2450
		goto retry;
	return err;
}

2451
static int ext4_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
2452
		      umode_t mode, dev_t rdev)
2453 2454 2455
{
	handle_t *handle;
	struct inode *inode;
2456
	int err, credits, retries = 0;
2457 2458 2459 2460

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

2461
	dquot_initialize(dir);
2462

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

A
Al Viro 已提交
2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501
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;
2502
		inode->i_fop = &ext4_file_operations;
A
Al Viro 已提交
2503
		ext4_set_aops(inode);
2504
		d_tmpfile(dentry, inode);
A
Al Viro 已提交
2505 2506
		err = ext4_orphan_add(handle, inode);
		if (err)
2507
			goto err_unlock_inode;
A
Al Viro 已提交
2508 2509 2510 2511 2512 2513 2514 2515
		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;
2516
err_unlock_inode:
A
Al Viro 已提交
2517 2518 2519 2520 2521
	ext4_journal_stop(handle);
	unlock_new_inode(inode);
	return err;
}

2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
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)
2552
{
2553
	struct buffer_head *dir_block = NULL;
2554
	struct ext4_dir_entry_2 *de;
2555
	struct ext4_dir_entry_tail *t;
2556
	ext4_lblk_t block = 0;
2557
	unsigned int blocksize = dir->i_sb->s_blocksize;
2558
	int csum_size = 0;
2559
	int err;
2560

2561
	if (ext4_has_metadata_csum(dir->i_sb))
2562 2563
		csum_size = sizeof(struct ext4_dir_entry_tail);

2564 2565 2566 2567 2568 2569 2570 2571
	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;
	}

2572
	inode->i_size = 0;
2573 2574 2575
	dir_block = ext4_append(handle, inode, &block);
	if (IS_ERR(dir_block))
		return PTR_ERR(dir_block);
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
	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;
2598
	int err, credits, retries = 0;
2599

2600
	if (EXT4_DIR_LINK_MAX(dir))
2601 2602
		return -EMLINK;

2603
	dquot_initialize(dir);
2604

2605
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2606
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2607
retry:
2608 2609 2610 2611
	inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
					    &dentry->d_name,
					    0, NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2612 2613 2614 2615
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_stop;

2616 2617
	inode->i_op = &ext4_dir_inode_operations;
	inode->i_fop = &ext4_dir_operations;
2618
	err = ext4_init_new_dir(handle, dir, inode);
2619 2620 2621 2622 2623
	if (err)
		goto out_clear_inode;
	err = ext4_mark_inode_dirty(handle, inode);
	if (!err)
		err = ext4_add_entry(handle, dentry, inode);
2624
	if (err) {
2625 2626
out_clear_inode:
		clear_nlink(inode);
A
Al Viro 已提交
2627
		unlock_new_inode(inode);
2628
		ext4_mark_inode_dirty(handle, inode);
2629
		iput(inode);
2630 2631
		goto out_stop;
	}
2632
	ext4_inc_count(handle, dir);
2633
	ext4_update_dx_flag(dir);
2634 2635 2636
	err = ext4_mark_inode_dirty(handle, dir);
	if (err)
		goto out_clear_inode;
A
Al Viro 已提交
2637
	unlock_new_inode(inode);
2638
	d_instantiate(dentry, inode);
2639 2640 2641
	if (IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

2642
out_stop:
2643 2644
	if (handle)
		ext4_journal_stop(handle);
2645
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2646 2647 2648 2649 2650 2651 2652
		goto retry;
	return err;
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
2653
int ext4_empty_dir(struct inode *inode)
2654
{
2655
	unsigned int offset;
2656 2657 2658
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de, *de1;
	struct super_block *sb;
2659 2660
	int err = 0;

T
Tao Ma 已提交
2661 2662 2663 2664 2665 2666 2667 2668
	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;
	}

2669
	sb = inode->i_sb;
2670 2671
	if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
		EXT4_ERROR_INODE(inode, "invalid size");
2672 2673
		return 1;
	}
2674 2675 2676 2677
	bh = ext4_read_dirblock(inode, 0, EITHER);
	if (IS_ERR(bh))
		return 1;

2678
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2679
	de1 = ext4_next_entry(de, sb->s_blocksize);
2680 2681
	if (le32_to_cpu(de->inode) != inode->i_ino ||
			!le32_to_cpu(de1->inode) ||
2682 2683
			strcmp(".", de->name) ||
			strcmp("..", de1->name)) {
2684
		ext4_warning(inode->i_sb,
2685 2686 2687
			     "bad directory (dir #%lu) - no `.' or `..'",
			     inode->i_ino);
		brelse(bh);
2688 2689
		return 1;
	}
2690 2691 2692
	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);
2693
	while (offset < inode->i_size) {
D
Dmitry Monakhov 已提交
2694
		if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
2695
			unsigned int lblock;
2696
			err = 0;
2697
			brelse(bh);
2698
			lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
2699 2700 2701
			bh = ext4_read_dirblock(inode, lblock, EITHER);
			if (IS_ERR(bh))
				return 1;
2702
			de = (struct ext4_dir_entry_2 *) bh->b_data;
2703
		}
2704 2705
		if (ext4_check_dir_entry(inode, NULL, de, bh,
					 bh->b_data, bh->b_size, offset)) {
2706
			de = (struct ext4_dir_entry_2 *)(bh->b_data +
2707 2708 2709 2710 2711
							 sb->s_blocksize);
			offset = (offset | (sb->s_blocksize - 1)) + 1;
			continue;
		}
		if (le32_to_cpu(de->inode)) {
2712
			brelse(bh);
2713 2714
			return 0;
		}
2715 2716
		offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
		de = ext4_next_entry(de, sb->s_blocksize);
2717
	}
2718
	brelse(bh);
2719 2720 2721
	return 1;
}

2722 2723
/*
 * ext4_orphan_add() links an unlinked or truncated inode into a list of
2724 2725 2726 2727 2728
 * 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
2729
 * inodes and truncating linked inodes in ext4_orphan_cleanup().
2730 2731 2732
 *
 * Orphan list manipulation functions must be called under i_mutex unless
 * we are just creating the inode or deleting it.
2733
 */
2734
int ext4_orphan_add(handle_t *handle, struct inode *inode)
2735 2736
{
	struct super_block *sb = inode->i_sb;
2737
	struct ext4_sb_info *sbi = EXT4_SB(sb);
2738
	struct ext4_iloc iloc;
2739
	int err = 0, rc;
2740
	bool dirty = false;
2741

2742
	if (!sbi->s_journal || is_bad_inode(inode))
2743 2744
		return 0;

2745 2746 2747 2748 2749 2750
	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.
	 */
2751
	if (!list_empty(&EXT4_I(inode)->i_orphan))
2752
		return 0;
2753

2754 2755 2756 2757 2758
	/*
	 * 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
2759
	 */
2760 2761
	J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		  S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
2762

2763 2764
	BUFFER_TRACE(sbi->s_sbh, "get_write_access");
	err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2765
	if (err)
2766
		goto out;
2767

2768
	err = ext4_reserve_inode_write(handle, inode, &iloc);
2769
	if (err)
2770 2771 2772
		goto out;

	mutex_lock(&sbi->s_orphan_lock);
2773 2774 2775 2776
	/*
	 * Due to previous errors inode may be already a part of on-disk
	 * orphan list. If so skip on-disk list modification.
	 */
2777 2778 2779 2780 2781 2782 2783 2784 2785
	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);
2786

2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802
	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);
		}
	}
2803 2804 2805
	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));
2806
out:
2807
	ext4_std_error(sb, err);
2808 2809 2810 2811
	return err;
}

/*
2812
 * ext4_orphan_del() removes an unlinked or truncated inode from the list
2813 2814
 * of such inodes stored on disk, because it is finally being cleaned up.
 */
2815
int ext4_orphan_del(handle_t *handle, struct inode *inode)
2816 2817
{
	struct list_head *prev;
2818
	struct ext4_inode_info *ei = EXT4_I(inode);
2819
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2820
	__u32 ino_next;
2821
	struct ext4_iloc iloc;
2822 2823
	int err = 0;

2824
	if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
2825 2826
		return 0;

2827 2828 2829
	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. */
2830
	if (list_empty(&ei->i_orphan))
2831
		return 0;
2832

2833 2834 2835 2836
	if (handle) {
		/* Grab inode buffer early before taking global s_orphan_lock */
		err = ext4_reserve_inode_write(handle, inode, &iloc);
	}
2837

2838
	mutex_lock(&sbi->s_orphan_lock);
2839 2840
	jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);

2841
	prev = ei->i_orphan.prev;
2842 2843 2844 2845 2846 2847
	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. */
2848 2849
	if (!handle || err) {
		mutex_unlock(&sbi->s_orphan_lock);
2850
		goto out_err;
2851
	}
2852

2853
	ino_next = NEXT_ORPHAN(inode);
2854
	if (prev == &sbi->s_orphan) {
2855
		jbd_debug(4, "superblock will point to %u\n", ino_next);
2856
		BUFFER_TRACE(sbi->s_sbh, "get_write_access");
2857
		err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2858 2859
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
2860
			goto out_brelse;
2861
		}
2862
		sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
2863
		mutex_unlock(&sbi->s_orphan_lock);
2864
		err = ext4_handle_dirty_super(handle, inode->i_sb);
2865
	} else {
2866
		struct ext4_iloc iloc2;
2867
		struct inode *i_prev =
2868
			&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
2869

2870
		jbd_debug(4, "orphan inode %lu will point to %u\n",
2871
			  i_prev->i_ino, ino_next);
2872
		err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
2873 2874
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
2875
			goto out_brelse;
2876
		}
2877
		NEXT_ORPHAN(i_prev) = ino_next;
2878
		err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
2879
		mutex_unlock(&sbi->s_orphan_lock);
2880 2881 2882 2883
	}
	if (err)
		goto out_brelse;
	NEXT_ORPHAN(inode) = 0;
2884
	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
2885
out_err:
2886
	ext4_std_error(inode->i_sb, err);
2887 2888 2889 2890 2891 2892 2893
	return err;

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

2894
static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
2895 2896
{
	int retval;
2897 2898 2899
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
2900
	handle_t *handle = NULL;
2901 2902 2903

	/* Initialize quotas before so that eventual writes go in
	 * separate transaction */
2904
	dquot_initialize(dir);
2905
	dquot_initialize(d_inode(dentry));
2906

2907
	retval = -ENOENT;
T
Tao Ma 已提交
2908
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
2909 2910
	if (IS_ERR(bh))
		return PTR_ERR(bh);
2911 2912 2913
	if (!bh)
		goto end_rmdir;

2914
	inode = d_inode(dentry);
2915 2916 2917 2918 2919 2920

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

	retval = -ENOTEMPTY;
2921
	if (!ext4_empty_dir(inode))
2922 2923
		goto end_rmdir;

2924
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
2925
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
2926 2927 2928 2929 2930 2931 2932 2933 2934
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rmdir;
	}

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

2935
	retval = ext4_delete_entry(handle, dir, de, bh);
2936 2937
	if (retval)
		goto end_rmdir;
2938
	if (!EXT4_DIR_LINK_EMPTY(inode))
2939
		ext4_warning(inode->i_sb,
2940 2941
			     "empty directory has too many links (%d)",
			     inode->i_nlink);
2942 2943 2944 2945 2946 2947
	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;
2948
	ext4_orphan_add(handle, inode);
K
Kalpak Shah 已提交
2949
	inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode);
2950
	ext4_mark_inode_dirty(handle, inode);
2951
	ext4_dec_count(handle, dir);
2952 2953
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
2954 2955

end_rmdir:
2956
	brelse(bh);
2957 2958
	if (handle)
		ext4_journal_stop(handle);
2959 2960 2961
	return retval;
}

2962
static int ext4_unlink(struct inode *dir, struct dentry *dentry)
2963 2964
{
	int retval;
2965 2966 2967
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
2968
	handle_t *handle = NULL;
2969

2970
	trace_ext4_unlink_enter(dir, dentry);
2971 2972
	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
2973
	dquot_initialize(dir);
2974
	dquot_initialize(d_inode(dentry));
2975

2976
	retval = -ENOENT;
T
Tao Ma 已提交
2977
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
2978 2979
	if (IS_ERR(bh))
		return PTR_ERR(bh);
2980 2981 2982
	if (!bh)
		goto end_unlink;

2983
	inode = d_inode(dentry);
2984 2985 2986 2987 2988

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

2989
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
2990
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
2991 2992 2993 2994 2995 2996 2997 2998 2999
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_unlink;
	}

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

3000
	if (!inode->i_nlink) {
3001
		ext4_warning(inode->i_sb,
3002 3003
			     "Deleting nonexistent file (%lu), %d",
			     inode->i_ino, inode->i_nlink);
M
Miklos Szeredi 已提交
3004
		set_nlink(inode, 1);
3005
	}
3006
	retval = ext4_delete_entry(handle, dir, de, bh);
3007 3008
	if (retval)
		goto end_unlink;
K
Kalpak Shah 已提交
3009
	dir->i_ctime = dir->i_mtime = ext4_current_time(dir);
3010 3011
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
3012
	drop_nlink(inode);
3013
	if (!inode->i_nlink)
3014
		ext4_orphan_add(handle, inode);
K
Kalpak Shah 已提交
3015
	inode->i_ctime = ext4_current_time(inode);
3016
	ext4_mark_inode_dirty(handle, inode);
3017 3018

end_unlink:
3019
	brelse(bh);
3020 3021
	if (handle)
		ext4_journal_stop(handle);
3022
	trace_ext4_unlink_exit(dentry, retval);
3023 3024 3025
	return retval;
}

3026 3027
static int ext4_symlink(struct inode *dir,
			struct dentry *dentry, const char *symname)
3028 3029
{
	handle_t *handle;
3030
	struct inode *inode;
3031
	int err, len = strlen(symname);
3032
	int credits;
3033 3034 3035
	bool encryption_required;
	struct ext4_str disk_link;
	struct ext4_encrypted_symlink_data *sd = NULL;
3036

3037 3038 3039
	disk_link.len = len + 1;
	disk_link.name = (char *) symname;

3040 3041
	encryption_required = (ext4_encrypted_inode(dir) ||
			       DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb)));
3042 3043 3044
	if (encryption_required)
		disk_link.len = encrypted_symlink_data_len(len) + 1;
	if (disk_link.len > dir->i_sb->s_blocksize)
3045 3046
		return -ENAMETOOLONG;

3047
	dquot_initialize(dir);
3048

3049
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3050 3051 3052
		/*
		 * For non-fast symlinks, we just allocate inode and put it on
		 * orphan list in the first transaction => we need bitmap,
3053 3054
		 * group descriptor, sb, inode block, quota blocks, and
		 * possibly selinux xattr blocks.
3055
		 */
3056 3057
		credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
			  EXT4_XATTR_TRANS_BLOCKS;
3058 3059 3060 3061 3062 3063 3064 3065
	} 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) +
3066
			  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3067
	}
3068

3069 3070 3071 3072
	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();
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090
	if (IS_ERR(inode)) {
		if (handle)
			ext4_journal_stop(handle);
		return PTR_ERR(inode);
	}

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

		sd = kzalloc(disk_link.len, GFP_NOFS);
		if (!sd) {
			err = -ENOMEM;
			goto err_drop_inode;
		}
		istr.name = (const unsigned char *) symname;
		istr.len = len;
		ostr.name = sd->encrypted_path;
3091
		ostr.len = disk_link.len;
3092
		err = ext4_fname_usr_to_disk(inode, &istr, &ostr);
3093 3094 3095 3096 3097
		if (err < 0)
			goto err_drop_inode;
		sd->len = cpu_to_le16(ostr.len);
		disk_link.name = (char *) sd;
	}
3098

3099
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3100 3101
		inode->i_op = &ext4_symlink_inode_operations;
		ext4_set_aops(inode);
3102
		/*
3103 3104 3105 3106 3107 3108 3109 3110
		 * 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.
3111
		 */
3112 3113 3114
		drop_nlink(inode);
		err = ext4_orphan_add(handle, inode);
		ext4_journal_stop(handle);
3115
		handle = NULL;
3116 3117
		if (err)
			goto err_drop_inode;
3118
		err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
3119 3120 3121 3122 3123 3124
		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
		 */
3125
		handle = ext4_journal_start(dir, EXT4_HT_DIR,
3126 3127 3128 3129
				EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
				EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
		if (IS_ERR(handle)) {
			err = PTR_ERR(handle);
3130
			handle = NULL;
3131 3132
			goto err_drop_inode;
		}
3133
		set_nlink(inode, 1);
3134
		err = ext4_orphan_del(handle, inode);
3135
		if (err)
3136
			goto err_drop_inode;
3137
	} else {
3138
		/* clear the extent format for fast symlink */
3139
		ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3140 3141 3142 3143 3144 3145
		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;
3146
	}
3147 3148
	EXT4_I(inode)->i_disksize = inode->i_size;
	err = ext4_add_nondir(handle, dentry, inode);
3149 3150 3151 3152 3153
	if (!err && IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

	if (handle)
		ext4_journal_stop(handle);
3154
	kfree(sd);
3155
	return err;
3156
err_drop_inode:
3157 3158 3159 3160
	if (handle)
		ext4_journal_stop(handle);
	kfree(sd);
	clear_nlink(inode);
3161 3162 3163
	unlock_new_inode(inode);
	iput(inode);
	return err;
3164 3165
}

3166 3167
static int ext4_link(struct dentry *old_dentry,
		     struct inode *dir, struct dentry *dentry)
3168 3169
{
	handle_t *handle;
3170
	struct inode *inode = d_inode(old_dentry);
3171 3172
	int err, retries = 0;

3173
	if (inode->i_nlink >= EXT4_LINK_MAX)
3174
		return -EMLINK;
3175 3176 3177
	if (ext4_encrypted_inode(dir) &&
	    !ext4_is_child_context_consistent_with_parent(dir, inode))
		return -EPERM;
3178
	dquot_initialize(dir);
3179

3180
retry:
3181 3182
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
		(EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
A
Al Viro 已提交
3183
		 EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3184 3185 3186 3187
	if (IS_ERR(handle))
		return PTR_ERR(handle);

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

K
Kalpak Shah 已提交
3190
	inode->i_ctime = ext4_current_time(inode);
3191
	ext4_inc_count(handle, inode);
A
Al Viro 已提交
3192
	ihold(inode);
3193

A
Al Viro 已提交
3194 3195 3196
	err = ext4_add_entry(handle, dentry, inode);
	if (!err) {
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
3197 3198 3199 3200 3201
		/* this can happen only for tmpfile being
		 * linked the first time
		 */
		if (inode->i_nlink == 1)
			ext4_orphan_del(handle, inode);
A
Al Viro 已提交
3202 3203 3204 3205 3206
		d_instantiate(dentry, inode);
	} else {
		drop_nlink(inode);
		iput(inode);
	}
3207 3208
	ext4_journal_stop(handle);
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3209 3210 3211 3212
		goto retry;
	return err;
}

T
Tao Ma 已提交
3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227

/*
 * 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)) {
3228 3229 3230
		bh = ext4_read_dirblock(inode, 0, EITHER);
		if (IS_ERR(bh)) {
			*retval = PTR_ERR(bh);
T
Tao Ma 已提交
3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
			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);
}
3242

3243 3244 3245 3246
struct ext4_renament {
	struct inode *dir;
	struct dentry *dentry;
	struct inode *inode;
M
Miklos Szeredi 已提交
3247 3248
	bool is_dir;
	int dir_nlink_delta;
3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260

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

3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342
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);
3343 3344
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3345 3346 3347 3348 3349 3350 3351
	if (bh) {
		retval = ext4_delete_entry(handle, dir, de, bh);
		brelse(bh);
	}
	return retval;
}

3352 3353
static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
			       int force_reread)
3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364
{
	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,
3365 3366
		    ent->de->name_len) ||
	    force_reread) {
3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
		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 已提交
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
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 已提交
3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427
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;
}

3428 3429 3430
/*
 * Anybody can rename anything with this: the permission checks are left to the
 * higher-level routines.
3431 3432 3433 3434
 *
 * 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)
3435
 */
3436
static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
M
Miklos Szeredi 已提交
3437 3438
		       struct inode *new_dir, struct dentry *new_dentry,
		       unsigned int flags)
3439
{
3440
	handle_t *handle = NULL;
3441 3442 3443
	struct ext4_renament old = {
		.dir = old_dir,
		.dentry = old_dentry,
3444
		.inode = d_inode(old_dentry),
3445 3446 3447 3448
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
3449
		.inode = d_inode(new_dentry),
3450
	};
3451
	int force_reread;
3452
	int retval;
M
Miklos Szeredi 已提交
3453 3454 3455
	struct inode *whiteout = NULL;
	int credits;
	u8 old_file_type;
3456

3457 3458
	dquot_initialize(old.dir);
	dquot_initialize(new.dir);
3459 3460 3461

	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
3462 3463
	if (new.inode)
		dquot_initialize(new.inode);
3464

3465
	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
3466 3467
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
3468 3469 3470 3471 3472 3473 3474
	/*
	 *  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;
3475
	if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3476 3477
		goto end_rename;

3478 3479 3480 3481 3482 3483 3484 3485
	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;
	}

3486 3487
	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
				 &new.de, &new.inlined);
3488 3489
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3490
		new.bh = NULL;
3491 3492
		goto end_rename;
	}
3493 3494 3495 3496
	if (new.bh) {
		if (!new.inode) {
			brelse(new.bh);
			new.bh = NULL;
3497 3498
		}
	}
3499 3500
	if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
		ext4_alloc_da_blocks(old.inode);
3501

M
Miklos Szeredi 已提交
3502 3503 3504 3505
	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);
3506 3507 3508 3509 3510
		if (IS_ERR(handle)) {
			retval = PTR_ERR(handle);
			handle = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3511 3512
	} else {
		whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
3513 3514 3515 3516 3517
		if (IS_ERR(whiteout)) {
			retval = PTR_ERR(whiteout);
			whiteout = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3518
	}
3519

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

3523 3524
	if (S_ISDIR(old.inode->i_mode)) {
		if (new.inode) {
3525
			retval = -ENOTEMPTY;
3526
			if (!ext4_empty_dir(new.inode))
3527
				goto end_rename;
3528 3529 3530 3531
		} else {
			retval = -EMLINK;
			if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
				goto end_rename;
3532
		}
3533
		retval = ext4_rename_dir_prepare(handle, &old);
3534 3535
		if (retval)
			goto end_rename;
3536
	}
3537 3538 3539 3540 3541 3542 3543 3544 3545
	/*
	 * 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 已提交
3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558

	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);
	}
3559 3560
	if (!new.bh) {
		retval = ext4_add_entry(handle, new.dentry, old.inode);
3561 3562 3563
		if (retval)
			goto end_rename;
	} else {
3564
		retval = ext4_setent(handle, &new,
M
Miklos Szeredi 已提交
3565
				     old.inode->i_ino, old_file_type);
3566 3567
		if (retval)
			goto end_rename;
3568
	}
3569 3570 3571
	if (force_reread)
		force_reread = !ext4_test_inode_flag(new.dir,
						     EXT4_INODE_INLINE_DATA);
3572 3573 3574 3575 3576

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

M
Miklos Szeredi 已提交
3580 3581 3582 3583 3584 3585
	if (!whiteout) {
		/*
		 * ok, that's it
		 */
		ext4_rename_delete(handle, &old, force_reread);
	}
3586

3587 3588 3589
	if (new.inode) {
		ext4_dec_count(handle, new.inode);
		new.inode->i_ctime = ext4_current_time(new.inode);
3590
	}
3591 3592 3593
	old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir);
	ext4_update_dx_flag(old.dir);
	if (old.dir_bh) {
3594 3595
		retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
		if (retval)
3596
			goto end_rename;
3597

3598 3599
		ext4_dec_count(handle, old.dir);
		if (new.inode) {
3600 3601 3602
			/* checked ext4_empty_dir above, can't have another
			 * parent, ext4_dec_count() won't work for many-linked
			 * dirs */
3603
			clear_nlink(new.inode);
3604
		} else {
3605 3606 3607
			ext4_inc_count(handle, new.dir);
			ext4_update_dx_flag(new.dir);
			ext4_mark_inode_dirty(handle, new.dir);
3608 3609
		}
	}
3610 3611 3612 3613 3614
	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);
3615 3616 3617 3618
	}
	retval = 0;

end_rename:
3619 3620 3621
	brelse(old.dir_bh);
	brelse(old.bh);
	brelse(new.bh);
M
Miklos Szeredi 已提交
3622 3623 3624 3625 3626 3627
	if (whiteout) {
		if (retval)
			drop_nlink(whiteout);
		unlock_new_inode(whiteout);
		iput(whiteout);
	}
3628 3629
	if (handle)
		ext4_journal_stop(handle);
3630 3631 3632
	return retval;
}

M
Miklos Szeredi 已提交
3633 3634 3635 3636 3637 3638 3639
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,
3640
		.inode = d_inode(old_dentry),
M
Miklos Szeredi 已提交
3641 3642 3643 3644
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
3645
		.inode = d_inode(new_dentry),
M
Miklos Szeredi 已提交
3646 3647 3648 3649
	};
	u8 new_file_type;
	int retval;

3650 3651 3652 3653 3654 3655 3656 3657 3658
	if ((ext4_encrypted_inode(old_dir) ||
	     ext4_encrypted_inode(new_dir)) &&
	    (old_dir != new_dir) &&
	    (!ext4_is_child_context_consistent_with_parent(new_dir,
							   old.inode) ||
	     !ext4_is_child_context_consistent_with_parent(old_dir,
							   new.inode)))
		return -EPERM;

M
Miklos Szeredi 已提交
3659 3660 3661 3662 3663
	dquot_initialize(old.dir);
	dquot_initialize(new.dir);

	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
				 &old.de, &old.inlined);
3664 3665
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
M
Miklos Szeredi 已提交
3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677
	/*
	 *  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);
3678 3679
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3680
		new.bh = NULL;
3681 3682
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3683 3684 3685 3686 3687 3688 3689 3690

	/* 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));
3691 3692 3693 3694 3695
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767

	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 已提交
3768 3769 3770 3771
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 已提交
3772
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
M
Miklos Szeredi 已提交
3773 3774
		return -EINVAL;

M
Miklos Szeredi 已提交
3775 3776 3777 3778
	if (flags & RENAME_EXCHANGE) {
		return ext4_cross_rename(old_dir, old_dentry,
					 new_dir, new_dentry);
	}
M
Miklos Szeredi 已提交
3779 3780

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

3783 3784 3785
/*
 * directories can handle most operations...
 */
3786
const struct inode_operations ext4_dir_inode_operations = {
3787 3788 3789 3790 3791 3792 3793 3794
	.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 已提交
3795
	.tmpfile	= ext4_tmpfile,
M
Miklos Szeredi 已提交
3796
	.rename2	= ext4_rename2,
3797
	.setattr	= ext4_setattr,
3798 3799
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3800
	.listxattr	= ext4_listxattr,
3801
	.removexattr	= generic_removexattr,
3802
	.get_acl	= ext4_get_acl,
3803
	.set_acl	= ext4_set_acl,
3804
	.fiemap         = ext4_fiemap,
3805 3806
};

3807
const struct inode_operations ext4_special_inode_operations = {
3808
	.setattr	= ext4_setattr,
3809 3810
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3811
	.listxattr	= ext4_listxattr,
3812
	.removexattr	= generic_removexattr,
3813
	.get_acl	= ext4_get_acl,
3814
	.set_acl	= ext4_set_acl,
3815
};