namei.c 100.4 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
static int ext4_dx_csum_verify(struct inode *inode,
			       struct ext4_dir_entry *dirent);

typedef enum {
	EITHER, INDEX, DIRENT
} dirblock_type_t;

#define ext4_read_dirblock(inode, block, type) \
87
	__ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
88 89

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

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

		return bh;
	}
	if (!bh) {
110 111
		ext4_error_inode(inode, func, line, block,
				 "Directory hole found");
112
		return ERR_PTR(-EIO);
113 114 115 116 117 118 119 120 121 122 123 124
	}
	dirent = (struct ext4_dir_entry *) bh->b_data;
	/* Determine whether or not we have an index block */
	if (is_dx(inode)) {
		if (block == 0)
			is_dx_block = 1;
		else if (ext4_rec_len_from_disk(dirent->rec_len,
						inode->i_sb->s_blocksize) ==
			 inode->i_sb->s_blocksize)
			is_dx_block = 1;
	}
	if (!is_dx_block && type == INDEX) {
125
		ext4_error_inode(inode, func, line, block,
126 127 128
		       "directory leaf block found instead of index block");
		return ERR_PTR(-EIO);
	}
129
	if (!ext4_has_metadata_csum(inode->i_sb) ||
130 131 132 133 134 135 136 137 138 139 140 141
	    buffer_verified(bh))
		return bh;

	/*
	 * An empty leaf block can get mistaken for a index block; for
	 * this reason, we can only check the index checksum when the
	 * caller is sure it should be an index block.
	 */
	if (is_dx_block && type == INDEX) {
		if (ext4_dx_csum_verify(inode, dirent))
			set_buffer_verified(bh);
		else {
142 143
			ext4_error_inode(inode, func, line, block,
					 "Directory index failed checksum");
144
			brelse(bh);
145
			return ERR_PTR(-EIO);
146
		}
147
	}
148 149 150 151
	if (!is_dx_block) {
		if (ext4_dirent_csum_verify(inode, dirent))
			set_buffer_verified(bh);
		else {
152 153
			ext4_error_inode(inode, func, line, block,
					 "Directory block failed checksum");
154 155 156
			brelse(bh);
			return ERR_PTR(-EIO);
		}
C
Carlos Maiolino 已提交
157
	}
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	return bh;
}

#ifndef assert
#define assert(test) J_ASSERT(test)
#endif

#ifdef DX_DEBUG
#define dxtrace(command) command
#else
#define dxtrace(command)
#endif

struct fake_dirent
{
	__le32 inode;
	__le16 rec_len;
	u8 name_len;
	u8 file_type;
};

struct dx_countlimit
{
	__le16 limit;
	__le16 count;
};

struct dx_entry
{
	__le32 hash;
	__le32 block;
};

/*
 * dx_root_info is laid out so that if it should somehow get overlaid by a
 * dirent the two low bits of the hash version will be zero.  Therefore, the
 * hash version mod 4 should never be 0.  Sincerely, the paranoia department.
 */

struct dx_root
{
	struct fake_dirent dot;
	char dot_name[4];
	struct fake_dirent dotdot;
	char dotdot_name[4];
	struct dx_root_info
	{
		__le32 reserved_zero;
		u8 hash_version;
		u8 info_length; /* 8 */
		u8 indirect_levels;
		u8 unused_flags;
	}
	info;
	struct dx_entry	entries[0];
};

struct dx_node
{
	struct fake_dirent fake;
	struct dx_entry	entries[0];
};


struct dx_frame
{
	struct buffer_head *bh;
	struct dx_entry *entries;
	struct dx_entry *at;
};

struct dx_map_entry
{
	u32 hash;
232 233
	u16 offs;
	u16 size;
234 235
};

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

A
Aneesh Kumar K.V 已提交
244 245
static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
246 247 248 249 250 251 252 253
static inline unsigned dx_get_hash(struct dx_entry *entry);
static void dx_set_hash(struct dx_entry *entry, unsigned value);
static unsigned dx_get_count(struct dx_entry *entries);
static unsigned dx_get_limit(struct dx_entry *entries);
static void dx_set_count(struct dx_entry *entries, unsigned value);
static void dx_set_limit(struct dx_entry *entries, unsigned value);
static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
static unsigned dx_node_limit(struct inode *dir);
254
static struct dx_frame *dx_probe(struct ext4_filename *fname,
255 256
				 struct inode *dir,
				 struct dx_hash_info *hinfo,
257
				 struct dx_frame *frame);
258
static void dx_release(struct dx_frame *frames);
259 260 261
static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
		       unsigned blocksize, struct dx_hash_info *hinfo,
		       struct dx_map_entry map[]);
262
static void dx_sort_map(struct dx_map_entry *map, unsigned count);
263
static struct ext4_dir_entry_2 *dx_move_dirents(char *from, char *to,
264
		struct dx_map_entry *offsets, int count, unsigned blocksize);
265
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize);
A
Aneesh Kumar K.V 已提交
266 267
static void dx_insert_block(struct dx_frame *frame,
					u32 hash, ext4_lblk_t block);
268
static int ext4_htree_next_block(struct inode *dir, __u32 hash,
269 270 271
				 struct dx_frame *frame,
				 struct dx_frame *frames,
				 __u32 *start_hash);
272
static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
273
		struct ext4_filename *fname,
274
		struct ext4_dir_entry_2 **res_dir);
275 276
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
			     struct dentry *dentry, struct inode *inode);
277

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

/* Walk through a dirent block to find a checksum "dirent" at the tail */
static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
						   struct ext4_dir_entry *de)
{
	struct ext4_dir_entry_tail *t;

#ifdef PARANOID
	struct ext4_dir_entry *d, *top;

	d = de;
	top = (struct ext4_dir_entry *)(((void *)de) +
		(EXT4_BLOCK_SIZE(inode->i_sb) -
		sizeof(struct ext4_dir_entry_tail)));
	while (d < top && d->rec_len)
		d = (struct ext4_dir_entry *)(((void *)d) +
		    le16_to_cpu(d->rec_len));

	if (d != top)
		return NULL;

	t = (struct ext4_dir_entry_tail *)d;
#else
	t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode->i_sb));
#endif

	if (t->det_reserved_zero1 ||
	    le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
	    t->det_reserved_zero2 ||
	    t->det_reserved_ft != EXT4_FT_DIR_CSUM)
		return NULL;

	return t;
}

static __le32 ext4_dirent_csum(struct inode *inode,
			       struct ext4_dir_entry *dirent, int size)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	struct ext4_inode_info *ei = EXT4_I(inode);
	__u32 csum;

	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
	return cpu_to_le32(csum);
}

333 334 335 336 337
#define warn_no_space_for_csum(inode)					\
	__warn_no_space_for_csum((inode), __func__, __LINE__)

static void __warn_no_space_for_csum(struct inode *inode, const char *func,
				     unsigned int line)
338
{
339 340
	__ext4_warning_inode(inode, func, line,
		"No space for directory leaf checksum. Please run e2fsck -D.");
341 342
}

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

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

	t = get_dirent_tail(inode, dirent);
	if (!t) {
352
		warn_no_space_for_csum(inode);
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
		return 0;
	}

	if (t->det_checksum != ext4_dirent_csum(inode, dirent,
						(void *)t - (void *)dirent))
		return 0;

	return 1;
}

static void ext4_dirent_csum_set(struct inode *inode,
				 struct ext4_dir_entry *dirent)
{
	struct ext4_dir_entry_tail *t;

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

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

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

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

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
					       struct ext4_dir_entry *dirent,
					       int *offset)
{
	struct ext4_dir_entry *dp;
	struct dx_root_info *root;
	int count_offset;

	if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
		count_offset = 8;
	else if (le16_to_cpu(dirent->rec_len) == 12) {
		dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
		if (le16_to_cpu(dp->rec_len) !=
		    EXT4_BLOCK_SIZE(inode->i_sb) - 12)
			return NULL;
		root = (struct dx_root_info *)(((void *)dp + 12));
		if (root->reserved_zero ||
		    root->info_length != sizeof(struct dx_root_info))
			return NULL;
		count_offset = 32;
	} else
		return NULL;

	if (offset)
		*offset = count_offset;
	return (struct dx_countlimit *)(((void *)dirent) + count_offset);
}

static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
			   int count_offset, int count, struct dx_tail *t)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	struct ext4_inode_info *ei = EXT4_I(inode);
422 423
	__u32 csum;
	__le32 save_csum;
424 425 426
	int size;

	size = count_offset + (count * sizeof(struct dx_entry));
427
	save_csum = t->dt_checksum;
428 429 430
	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));
431
	t->dt_checksum = save_csum;
432 433 434 435 436 437 438 439 440 441 442

	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;

443
	if (!ext4_has_metadata_csum(inode->i_sb))
444 445 446 447 448 449 450 451 452 453 454
		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)) {
455
		warn_no_space_for_csum(inode);
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
		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;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

596 597 598 599
static struct stats dx_show_leaf(struct inode *dir,
				struct dx_hash_info *hinfo,
				struct ext4_dir_entry_2 *de,
				int size, int show_names)
600 601 602 603 604 605 606 607 608 609 610 611
{
	unsigned names = 0, space = 0;
	char *base = (char *) de;
	struct dx_hash_info h = *hinfo;

	printk("names: ");
	while ((char *) de < base + size)
	{
		if (de->inode)
		{
			if (show_names)
			{
612 613 614 615 616
#ifdef CONFIG_EXT4_FS_ENCRYPTION
				int len;
				char *name;
				struct ext4_str fname_crypto_str
					= {.name = NULL, .len = 0};
617
				int res = 0;
618 619 620

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

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

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

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

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

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

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

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

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

838 839 840 841
		if (dx_get_limit(entries) != dx_node_limit(dir)) {
			ext4_warning_inode(dir,
				"dx entry: limit %u != node limit %u",
				dx_get_limit(entries), dx_node_limit(dir));
842
			goto fail;
843
		}
844
	}
845
fail:
846 847 848 849
	while (frame >= frame_in) {
		brelse(frame->bh);
		frame--;
	}
850

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

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

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

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

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

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

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

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

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

1155 1156 1157 1158
/*
 * Directory block splitting, compacting
 */

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

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

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

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

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

1240 1241
	if (!de->inode)
		return 0;
1242 1243

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

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

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

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

	res = 0;
return_result:
	return res;
1315 1316
}

1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
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;
}
1332 1333

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

	*res_dir = NULL;
	sb = dir->i_sb;
1365
	namelen = d_name->len;
1366
	if (namelen > EXT4_NAME_LEN)
1367
		return NULL;
1368

1369 1370 1371 1372
	retval = ext4_fname_setup_filename(dir, d_name, 1, &fname);
	if (retval)
		return ERR_PTR(retval);

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

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

cleanup_and_exit:
	/* Clean up the read-ahead blocks */
	for (; ra_ptr < ra_max; ra_ptr++)
1496
		brelse(bh_use[ra_ptr]);
1497
	ext4_fname_free_filename(&fname);
1498 1499 1500
	return ret;
}

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

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

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

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

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

A
Al Viro 已提交
1555
static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1556
{
1557 1558 1559
	struct inode *inode;
	struct ext4_dir_entry_2 *de;
	struct buffer_head *bh;
1560

1561
	if (dentry->d_name.len > EXT4_NAME_LEN)
1562 1563
		return ERR_PTR(-ENAMETOOLONG);

T
Tao Ma 已提交
1564
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
1565 1566
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1567 1568
	inode = NULL;
	if (bh) {
1569
		__u32 ino = le32_to_cpu(de->inode);
1570
		brelse(bh);
1571
		if (!ext4_valid_inum(dir->i_sb, ino)) {
1572
			EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1573
			return ERR_PTR(-EIO);
1574
		}
1575
		if (unlikely(ino == dir->i_ino)) {
D
David Howells 已提交
1576 1577
			EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
					 dentry);
1578 1579
			return ERR_PTR(-EIO);
		}
1580
		inode = ext4_iget_normal(dir->i_sb, ino);
1581 1582 1583 1584 1585
		if (inode == ERR_PTR(-ESTALE)) {
			EXT4_ERROR_INODE(dir,
					 "deleted inode referenced: %u",
					 ino);
			return ERR_PTR(-EIO);
1586
		}
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
		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);
		}
1599 1600 1601 1602 1603
	}
	return d_splice_alias(inode, dentry);
}


1604
struct dentry *ext4_get_parent(struct dentry *child)
1605
{
1606
	__u32 ino;
1607
	static const struct qstr dotdot = QSTR_INIT("..", 2);
1608
	struct ext4_dir_entry_2 * de;
1609 1610
	struct buffer_head *bh;

1611
	bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
1612 1613
	if (IS_ERR(bh))
		return (struct dentry *) bh;
1614 1615 1616 1617 1618
	if (!bh)
		return ERR_PTR(-ENOENT);
	ino = le32_to_cpu(de->inode);
	brelse(bh);

1619 1620
	if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
		EXT4_ERROR_INODE(d_inode(child),
1621
				 "bad parent inode number: %u", ino);
1622
		return ERR_PTR(-EIO);
1623 1624
	}

1625
	return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
1626 1627
}

1628 1629 1630 1631
/*
 * Move count entries from end of map between two memory locations.
 * Returns pointer to last entry moved.
 */
1632
static struct ext4_dir_entry_2 *
1633 1634
dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
		unsigned blocksize)
1635 1636 1637 1638
{
	unsigned rec_len = 0;

	while (count--) {
1639
		struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1640
						(from + (map->offs<<2));
1641
		rec_len = EXT4_DIR_REC_LEN(de->name_len);
1642
		memcpy (to, de, rec_len);
1643
		((struct ext4_dir_entry_2 *) to)->rec_len =
1644
				ext4_rec_len_to_disk(rec_len, blocksize);
1645 1646 1647 1648
		de->inode = 0;
		map++;
		to += rec_len;
	}
1649
	return (struct ext4_dir_entry_2 *) (to - rec_len);
1650 1651
}

1652 1653 1654 1655
/*
 * Compact each dir entry in the range to the minimal rec_len.
 * Returns pointer to last entry in range.
 */
1656
static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
1657
{
1658
	struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1659 1660 1661
	unsigned rec_len = 0;

	prev = to = de;
1662
	while ((char*)de < base + blocksize) {
1663
		next = ext4_next_entry(de, blocksize);
1664
		if (de->inode && de->name_len) {
1665
			rec_len = EXT4_DIR_REC_LEN(de->name_len);
1666 1667
			if (de > to)
				memmove(to, de, rec_len);
1668
			to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1669
			prev = to;
1670
			to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1671 1672 1673 1674 1675 1676
		}
		de = next;
	}
	return prev;
}

1677 1678 1679 1680 1681
/*
 * 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.
 */
1682
static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1683
			struct buffer_head **bh,struct dx_frame *frame,
1684
			struct dx_hash_info *hinfo)
1685 1686 1687 1688
{
	unsigned blocksize = dir->i_sb->s_blocksize;
	unsigned count, continued;
	struct buffer_head *bh2;
A
Aneesh Kumar K.V 已提交
1689
	ext4_lblk_t newblock;
1690 1691 1692
	u32 hash2;
	struct dx_map_entry *map;
	char *data1 = (*bh)->b_data, *data2;
1693
	unsigned split, move, size;
1694
	struct ext4_dir_entry_2 *de = NULL, *de2;
1695 1696
	struct ext4_dir_entry_tail *t;
	int	csum_size = 0;
1697
	int	err = 0, i;
1698

1699
	if (ext4_has_metadata_csum(dir->i_sb))
1700 1701
		csum_size = sizeof(struct ext4_dir_entry_tail);

1702 1703
	bh2 = ext4_append(handle, dir, &newblock);
	if (IS_ERR(bh2)) {
1704 1705
		brelse(*bh);
		*bh = NULL;
1706
		return (struct ext4_dir_entry_2 *) bh2;
1707 1708 1709
	}

	BUFFER_TRACE(*bh, "get_write_access");
1710
	err = ext4_journal_get_write_access(handle, *bh);
1711 1712 1713
	if (err)
		goto journal_error;

1714
	BUFFER_TRACE(frame->bh, "get_write_access");
1715
	err = ext4_journal_get_write_access(handle, frame->bh);
1716 1717 1718 1719 1720 1721 1722
	if (err)
		goto journal_error;

	data2 = bh2->b_data;

	/* create map in the end of data2 block */
	map = (struct dx_map_entry *) (data2 + blocksize);
1723
	count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
1724 1725
			     blocksize, hinfo, map);
	map -= count;
1726
	dx_sort_map(map, count);
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
	/* 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;
1739 1740
	hash2 = map[split].hash;
	continued = hash2 == map[split - 1].hash;
A
Aneesh Kumar K.V 已提交
1741 1742 1743
	dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
			(unsigned long)dx_get_block(frame->at),
					hash2, split, count-split));
1744 1745

	/* Fancy dance to stay within two buffers */
1746 1747
	de2 = dx_move_dirents(data1, data2, map + split, count - split,
			      blocksize);
1748
	de = dx_pack_dirents(data1, blocksize);
1749 1750
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
1751
					   blocksize);
1752 1753
	de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
					    (char *) de2,
1754
					    blocksize);
1755 1756 1757 1758 1759 1760 1761 1762
	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);
	}

1763 1764 1765 1766
	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));
1767 1768

	/* Which block gets the new entry? */
1769
	if (hinfo->hash >= hash2) {
1770 1771 1772
		swap(*bh, bh2);
		de = de2;
	}
1773
	dx_insert_block(frame, hash2 + continued, newblock);
1774
	err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
1775 1776
	if (err)
		goto journal_error;
1777
	err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
1778 1779
	if (err)
		goto journal_error;
1780 1781
	brelse(bh2);
	dxtrace(dx_show_index("frame", frame->entries));
1782
	return de;
1783 1784 1785 1786 1787 1788

journal_error:
	brelse(*bh);
	brelse(bh2);
	*bh = NULL;
	ext4_std_error(dir->i_sb, err);
1789
	return ERR_PTR(err);
1790 1791
}

1792 1793 1794
int ext4_find_dest_de(struct inode *dir, struct inode *inode,
		      struct buffer_head *bh,
		      void *buf, int buf_size,
1795
		      struct ext4_filename *fname,
1796 1797 1798
		      struct ext4_dir_entry_2 **dest_de)
{
	struct ext4_dir_entry_2 *de;
1799
	unsigned short reclen = EXT4_DIR_REC_LEN(fname_len(fname));
1800 1801 1802
	int nlen, rlen;
	unsigned int offset = 0;
	char *top;
1803 1804
	int res;

1805 1806 1807 1808
	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,
1809 1810 1811 1812 1813
					 buf, buf_size, offset)) {
			res = -EIO;
			goto return_result;
		}
		/* Provide crypto context and crypto buffer to ext4 match */
1814
		res = ext4_match(fname, de);
1815 1816 1817 1818 1819 1820
		if (res < 0)
			goto return_result;
		if (res > 0) {
			res = -EEXIST;
			goto return_result;
		}
1821 1822 1823 1824 1825 1826 1827 1828
		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;
	}

1829 1830 1831 1832 1833 1834 1835 1836
	if ((char *) de > top)
		res = -ENOSPC;
	else {
		*dest_de = de;
		res = 0;
	}
return_result:
	return res;
1837 1838
}

1839 1840 1841 1842
int ext4_insert_dentry(struct inode *dir,
		       struct inode *inode,
		       struct ext4_dir_entry_2 *de,
		       int buf_size,
1843
		       struct ext4_filename *fname)
1844 1845 1846 1847 1848 1849 1850 1851
{

	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 =
1852
			(struct ext4_dir_entry_2 *)((char *)de + nlen);
1853 1854 1855 1856 1857 1858 1859
		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);
1860 1861
	de->name_len = fname_len(fname);
	memcpy(de->name, fname_name(fname), fname_len(fname));
1862
	return 0;
1863
}
1864

1865 1866 1867 1868 1869 1870 1871 1872
/*
 * 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.
 */
1873 1874
static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
			     struct inode *dir,
1875
			     struct inode *inode, struct ext4_dir_entry_2 *de,
1876
			     struct buffer_head *bh)
1877
{
1878
	unsigned int	blocksize = dir->i_sb->s_blocksize;
1879
	int		csum_size = 0;
1880
	int		err;
1881

1882
	if (ext4_has_metadata_csum(inode->i_sb))
1883
		csum_size = sizeof(struct ext4_dir_entry_tail);
1884 1885

	if (!de) {
1886 1887
		err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
					blocksize - csum_size, fname, &de);
1888 1889
		if (err)
			return err;
1890 1891
	}
	BUFFER_TRACE(bh, "get_write_access");
1892
	err = ext4_journal_get_write_access(handle, bh);
1893
	if (err) {
1894
		ext4_std_error(dir->i_sb, err);
1895 1896 1897
		return err;
	}

1898 1899
	/* By now the buffer is marked for journaling. Due to crypto operations,
	 * the following function call may fail */
1900
	err = ext4_insert_dentry(dir, inode, de, blocksize, fname);
1901 1902
	if (err < 0)
		return err;
1903

1904 1905 1906 1907 1908 1909
	/*
	 * 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
1910
	 * ext4_new_inode() setting the times, but error
1911 1912 1913 1914
	 * 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 已提交
1915
	dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
1916
	ext4_update_dx_flag(dir);
1917
	dir->i_version++;
1918
	ext4_mark_inode_dirty(handle, dir);
1919
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1920
	err = ext4_handle_dirty_dirent_node(handle, dir, bh);
1921
	if (err)
1922
		ext4_std_error(dir->i_sb, err);
1923 1924 1925 1926 1927 1928 1929
	return 0;
}

/*
 * This converts a one block unindexed directory to a 3 block indexed
 * directory, and adds the dentry to the indexed directory.
 */
1930 1931
static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
			    struct dentry *dentry,
1932 1933
			    struct inode *inode, struct buffer_head *bh)
{
1934
	struct inode	*dir = d_inode(dentry->d_parent);
1935 1936 1937 1938
	struct buffer_head *bh2;
	struct dx_root	*root;
	struct dx_frame	frames[2], *frame;
	struct dx_entry *entries;
1939
	struct ext4_dir_entry_2	*de, *de2;
1940
	struct ext4_dir_entry_tail *t;
1941 1942 1943 1944
	char		*data1, *top;
	unsigned	len;
	int		retval;
	unsigned	blocksize;
A
Aneesh Kumar K.V 已提交
1945
	ext4_lblk_t  block;
1946
	struct fake_dirent *fde;
1947 1948
	int csum_size = 0;

1949
	if (ext4_has_metadata_csum(inode->i_sb))
1950
		csum_size = sizeof(struct ext4_dir_entry_tail);
1951 1952

	blocksize =  dir->i_sb->s_blocksize;
1953
	dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
1954
	BUFFER_TRACE(bh, "get_write_access");
1955
	retval = ext4_journal_get_write_access(handle, bh);
1956
	if (retval) {
1957
		ext4_std_error(dir->i_sb, retval);
1958 1959 1960 1961 1962
		brelse(bh);
		return retval;
	}
	root = (struct dx_root *) bh->b_data;

1963 1964 1965
	/* The 0th block becomes the root, move the dirents out */
	fde = &root->dotdot;
	de = (struct ext4_dir_entry_2 *)((char *)fde +
1966
		ext4_rec_len_from_disk(fde->rec_len, blocksize));
1967
	if ((char *) de >= (((char *) root) + blocksize)) {
1968
		EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
1969 1970 1971
		brelse(bh);
		return -EIO;
	}
1972
	len = ((char *) root) + (blocksize - csum_size) - (char *) de;
1973 1974

	/* Allocate new block for the 0th block's dirents */
1975 1976
	bh2 = ext4_append(handle, dir, &block);
	if (IS_ERR(bh2)) {
1977
		brelse(bh);
1978
		return PTR_ERR(bh2);
1979
	}
1980
	ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
1981 1982 1983
	data1 = bh2->b_data;

	memcpy (data1, de, len);
1984
	de = (struct ext4_dir_entry_2 *) data1;
1985
	top = data1 + len;
1986
	while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
1987
		de = de2;
1988 1989
	de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
					   (char *) de,
1990
					   blocksize);
1991 1992 1993 1994 1995 1996

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

1997
	/* Initialize the root; the dot dirents already exist */
1998
	de = (struct ext4_dir_entry_2 *) (&root->dotdot);
1999 2000
	de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
					   blocksize);
2001 2002
	memset (&root->info, 0, sizeof(root->info));
	root->info.info_length = sizeof(root->info);
2003
	root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
2004
	entries = root->entries;
2005 2006 2007
	dx_set_block(entries, 1);
	dx_set_count(entries, 1);
	dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2008 2009

	/* Initialize as for dx_probe */
2010 2011 2012 2013 2014 2015
	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);

2016
	memset(frames, 0, sizeof(frames));
2017 2018 2019 2020 2021
	frame = frames;
	frame->entries = entries;
	frame->at = entries;
	frame->bh = bh;
	bh = bh2;
2022

2023 2024 2025 2026 2027 2028
	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;	
2029

2030
	de = do_split(handle,dir, &bh, frame, &fname->hinfo);
2031
	if (IS_ERR(de)) {
2032 2033
		retval = PTR_ERR(de);
		goto out_frames;
2034 2035
	}
	dx_release(frames);
2036

2037
	retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2038 2039
	brelse(bh);
	return retval;
2040 2041 2042 2043 2044 2045 2046 2047 2048
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;
2049 2050 2051
}

/*
2052
 *	ext4_add_entry()
2053 2054
 *
 * adds a file entry to the specified directory, using the same
2055
 * semantics as ext4_find_entry(). It returns NULL if it failed.
2056 2057 2058 2059 2060
 *
 * 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.
 */
2061 2062
static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
			  struct inode *inode)
2063
{
2064
	struct inode *dir = d_inode(dentry->d_parent);
2065
	struct buffer_head *bh = NULL;
2066
	struct ext4_dir_entry_2 *de;
2067
	struct ext4_dir_entry_tail *t;
2068
	struct super_block *sb;
2069
	struct ext4_filename fname;
2070 2071 2072
	int	retval;
	int	dx_fallback=0;
	unsigned blocksize;
A
Aneesh Kumar K.V 已提交
2073
	ext4_lblk_t block, blocks;
2074 2075
	int	csum_size = 0;

2076
	if (ext4_has_metadata_csum(inode->i_sb))
2077
		csum_size = sizeof(struct ext4_dir_entry_tail);
2078 2079 2080 2081 2082

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

2084 2085 2086 2087
	retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
	if (retval)
		return retval;

2088
	if (ext4_has_inline_data(dir)) {
2089 2090
		retval = ext4_try_add_inline_entry(handle, &fname,
						   dentry, inode);
2091
		if (retval < 0)
2092
			goto out;
2093 2094
		if (retval == 1) {
			retval = 0;
2095
			goto out;
2096 2097 2098
		}
	}

2099
	if (is_dx(dir)) {
2100
		retval = ext4_dx_add_entry(handle, &fname, dentry, inode);
2101
		if (!retval || (retval != ERR_BAD_DX_DIR))
2102
			goto out;
2103
		ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2104
		dx_fallback++;
2105
		ext4_mark_inode_dirty(handle, dir);
2106 2107
	}
	blocks = dir->i_size >> sb->s_blocksize_bits;
2108
	for (block = 0; block < blocks; block++) {
2109
		bh = ext4_read_dirblock(dir, block, DIRENT);
2110 2111 2112 2113 2114 2115 2116
		if (IS_ERR(bh)) {
			retval = PTR_ERR(bh);
			bh = NULL;
			goto out;
		}
		retval = add_dirent_to_buf(handle, &fname, dir, inode,
					   NULL, bh);
2117 2118
		if (retval != -ENOSPC)
			goto out;
2119 2120

		if (blocks == 1 && !dx_fallback &&
2121
		    EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) {
2122 2123
			retval = make_indexed_dir(handle, &fname, dentry,
						  inode, bh);
2124 2125 2126
			bh = NULL; /* make_indexed_dir releases bh */
			goto out;
		}
2127 2128
		brelse(bh);
	}
2129
	bh = ext4_append(handle, dir, &block);
2130 2131 2132 2133 2134
	if (IS_ERR(bh)) {
		retval = PTR_ERR(bh);
		bh = NULL;
		goto out;
	}
2135
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2136
	de->inode = 0;
2137 2138 2139 2140 2141 2142 2143
	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);
	}

2144
	retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2145
out:
2146
	ext4_fname_free_filename(&fname);
2147
	brelse(bh);
2148 2149
	if (retval == 0)
		ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
2150
	return retval;
2151 2152 2153 2154 2155
}

/*
 * Returns 0 for success, or a negative error value
 */
2156 2157
static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
			     struct dentry *dentry, struct inode *inode)
2158 2159 2160
{
	struct dx_frame frames[2], *frame;
	struct dx_entry *entries, *at;
2161
	struct buffer_head *bh;
2162
	struct inode *dir = d_inode(dentry->d_parent);
2163
	struct super_block *sb = dir->i_sb;
2164
	struct ext4_dir_entry_2 *de;
2165 2166
	int err;

2167
	frame = dx_probe(fname, dir, NULL, frames);
2168 2169
	if (IS_ERR(frame))
		return PTR_ERR(frame);
2170 2171
	entries = frame->entries;
	at = frame->at;
2172 2173 2174 2175
	bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
	if (IS_ERR(bh)) {
		err = PTR_ERR(bh);
		bh = NULL;
2176
		goto cleanup;
C
Carlos Maiolino 已提交
2177
	}
2178 2179

	BUFFER_TRACE(bh, "get_write_access");
2180
	err = ext4_journal_get_write_access(handle, bh);
2181 2182 2183
	if (err)
		goto journal_error;

2184
	err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2185
	if (err != -ENOSPC)
2186 2187 2188
		goto cleanup;

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

			BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2227
			err = ext4_journal_get_write_access(handle,
2228 2229 2230 2231
							     frames[0].bh);
			if (err)
				goto journal_error;

2232 2233 2234 2235 2236
			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));
2237 2238 2239 2240 2241 2242 2243

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

journal_error:
2289
	ext4_std_error(dir->i_sb, err);
2290
cleanup:
2291
	brelse(bh);
2292 2293 2294 2295 2296
	dx_release(frames);
	return err;
}

/*
T
Tao Ma 已提交
2297 2298
 * ext4_generic_delete_entry deletes a directory entry by merging it
 * with the previous entry
2299
 */
T
Tao Ma 已提交
2300 2301 2302 2303 2304 2305 2306
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)
2307
{
2308
	struct ext4_dir_entry_2 *de, *pde;
2309
	unsigned int blocksize = dir->i_sb->s_blocksize;
T
Tao Ma 已提交
2310
	int i;
2311

2312 2313
	i = 0;
	pde = NULL;
T
Tao Ma 已提交
2314 2315
	de = (struct ext4_dir_entry_2 *)entry_buf;
	while (i < buf_size - csum_size) {
2316 2317
		if (ext4_check_dir_entry(dir, NULL, de, bh,
					 bh->b_data, bh->b_size, i))
2318 2319 2320
			return -EIO;
		if (de == de_del)  {
			if (pde)
2321
				pde->rec_len = ext4_rec_len_to_disk(
2322 2323 2324 2325 2326
					ext4_rec_len_from_disk(pde->rec_len,
							       blocksize) +
					ext4_rec_len_from_disk(de->rec_len,
							       blocksize),
					blocksize);
2327 2328 2329 2330 2331
			else
				de->inode = 0;
			dir->i_version++;
			return 0;
		}
2332
		i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2333
		pde = de;
2334
		de = ext4_next_entry(de, blocksize);
2335 2336 2337 2338
	}
	return -ENOENT;
}

T
Tao Ma 已提交
2339 2340 2341 2342 2343 2344 2345
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;

2346 2347 2348 2349 2350 2351 2352 2353
	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;
	}

2354
	if (ext4_has_metadata_csum(dir->i_sb))
T
Tao Ma 已提交
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
		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;
}

2380 2381 2382 2383 2384 2385 2386 2387 2388 2389
/*
 * 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 已提交
2390
			set_nlink(inode, 1);
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
			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)
{
2403 2404
	if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
		drop_nlink(inode);
2405 2406 2407
}


2408
static int ext4_add_nondir(handle_t *handle,
2409 2410
		struct dentry *dentry, struct inode *inode)
{
2411
	int err = ext4_add_entry(handle, dentry, inode);
2412
	if (!err) {
2413
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
2414
		unlock_new_inode(inode);
2415
		d_instantiate(dentry, inode);
2416 2417
		return 0;
	}
2418
	drop_nlink(inode);
A
Al Viro 已提交
2419
	unlock_new_inode(inode);
2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431
	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 已提交
2432
static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
A
Al Viro 已提交
2433
		       bool excl)
2434 2435
{
	handle_t *handle;
2436
	struct inode *inode;
2437
	int err, credits, retries = 0;
2438

2439
	dquot_initialize(dir);
2440

2441
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2442
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2443
retry:
2444 2445 2446
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2447 2448
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
2449
		inode->i_op = &ext4_file_inode_operations;
2450
		inode->i_fop = &ext4_file_operations;
2451
		ext4_set_aops(inode);
2452
		err = ext4_add_nondir(handle, dentry, inode);
2453 2454
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2455
	}
2456 2457
	if (handle)
		ext4_journal_stop(handle);
2458
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2459 2460 2461 2462
		goto retry;
	return err;
}

2463
static int ext4_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
2464
		      umode_t mode, dev_t rdev)
2465 2466 2467
{
	handle_t *handle;
	struct inode *inode;
2468
	int err, credits, retries = 0;
2469 2470 2471 2472

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

2473
	dquot_initialize(dir);
2474

2475
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2476
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2477
retry:
2478 2479 2480
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2481 2482 2483
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
		init_special_inode(inode, inode->i_mode, rdev);
2484 2485
		inode->i_op = &ext4_special_inode_operations;
		err = ext4_add_nondir(handle, dentry, inode);
2486 2487
		if (!err && IS_DIRSYNC(dir))
			ext4_handle_sync(handle);
2488
	}
2489 2490
	if (handle)
		ext4_journal_stop(handle);
2491
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2492 2493 2494 2495
		goto retry;
	return err;
}

A
Al Viro 已提交
2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
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;
2514
		inode->i_fop = &ext4_file_operations;
A
Al Viro 已提交
2515
		ext4_set_aops(inode);
2516
		d_tmpfile(dentry, inode);
A
Al Viro 已提交
2517 2518
		err = ext4_orphan_add(handle, inode);
		if (err)
2519
			goto err_unlock_inode;
A
Al Viro 已提交
2520 2521 2522 2523 2524 2525 2526 2527
		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;
2528
err_unlock_inode:
A
Al Viro 已提交
2529 2530 2531 2532 2533
	ext4_journal_stop(handle);
	unlock_new_inode(inode);
	return err;
}

2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
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)
2564
{
2565
	struct buffer_head *dir_block = NULL;
2566
	struct ext4_dir_entry_2 *de;
2567
	struct ext4_dir_entry_tail *t;
2568
	ext4_lblk_t block = 0;
2569
	unsigned int blocksize = dir->i_sb->s_blocksize;
2570
	int csum_size = 0;
2571
	int err;
2572

2573
	if (ext4_has_metadata_csum(dir->i_sb))
2574 2575
		csum_size = sizeof(struct ext4_dir_entry_tail);

2576 2577 2578 2579 2580 2581 2582 2583
	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;
	}

2584
	inode->i_size = 0;
2585 2586 2587
	dir_block = ext4_append(handle, inode, &block);
	if (IS_ERR(dir_block))
		return PTR_ERR(dir_block);
2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
	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;
2610
	int err, credits, retries = 0;
2611

2612
	if (EXT4_DIR_LINK_MAX(dir))
2613 2614
		return -EMLINK;

2615
	dquot_initialize(dir);
2616

2617
	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2618
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2619
retry:
2620 2621 2622 2623
	inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
					    &dentry->d_name,
					    0, NULL, EXT4_HT_DIR, credits);
	handle = ext4_journal_current_handle();
2624 2625 2626 2627
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_stop;

2628 2629
	inode->i_op = &ext4_dir_inode_operations;
	inode->i_fop = &ext4_dir_operations;
2630
	err = ext4_init_new_dir(handle, dir, inode);
2631 2632 2633 2634 2635
	if (err)
		goto out_clear_inode;
	err = ext4_mark_inode_dirty(handle, inode);
	if (!err)
		err = ext4_add_entry(handle, dentry, inode);
2636
	if (err) {
2637 2638
out_clear_inode:
		clear_nlink(inode);
A
Al Viro 已提交
2639
		unlock_new_inode(inode);
2640
		ext4_mark_inode_dirty(handle, inode);
2641
		iput(inode);
2642 2643
		goto out_stop;
	}
2644
	ext4_inc_count(handle, dir);
2645
	ext4_update_dx_flag(dir);
2646 2647 2648
	err = ext4_mark_inode_dirty(handle, dir);
	if (err)
		goto out_clear_inode;
A
Al Viro 已提交
2649
	unlock_new_inode(inode);
2650
	d_instantiate(dentry, inode);
2651 2652 2653
	if (IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

2654
out_stop:
2655 2656
	if (handle)
		ext4_journal_stop(handle);
2657
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2658 2659 2660 2661 2662 2663 2664
		goto retry;
	return err;
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
2665
int ext4_empty_dir(struct inode *inode)
2666
{
2667
	unsigned int offset;
2668 2669 2670
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de, *de1;
	struct super_block *sb;
2671 2672
	int err = 0;

T
Tao Ma 已提交
2673 2674 2675 2676 2677 2678 2679 2680
	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;
	}

2681
	sb = inode->i_sb;
2682 2683
	if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
		EXT4_ERROR_INODE(inode, "invalid size");
2684 2685
		return 1;
	}
2686 2687 2688 2689
	bh = ext4_read_dirblock(inode, 0, EITHER);
	if (IS_ERR(bh))
		return 1;

2690
	de = (struct ext4_dir_entry_2 *) bh->b_data;
2691
	de1 = ext4_next_entry(de, sb->s_blocksize);
2692
	if (le32_to_cpu(de->inode) != inode->i_ino ||
2693 2694 2695
			le32_to_cpu(de1->inode) == 0 ||
			strcmp(".", de->name) || strcmp("..", de1->name)) {
		ext4_warning_inode(inode, "directory missing '.' and/or '..'");
2696
		brelse(bh);
2697 2698
		return 1;
	}
2699 2700 2701
	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);
2702
	while (offset < inode->i_size) {
D
Dmitry Monakhov 已提交
2703
		if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
2704
			unsigned int lblock;
2705
			err = 0;
2706
			brelse(bh);
2707
			lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
2708 2709 2710
			bh = ext4_read_dirblock(inode, lblock, EITHER);
			if (IS_ERR(bh))
				return 1;
2711
			de = (struct ext4_dir_entry_2 *) bh->b_data;
2712
		}
2713 2714
		if (ext4_check_dir_entry(inode, NULL, de, bh,
					 bh->b_data, bh->b_size, offset)) {
2715
			de = (struct ext4_dir_entry_2 *)(bh->b_data +
2716 2717 2718 2719 2720
							 sb->s_blocksize);
			offset = (offset | (sb->s_blocksize - 1)) + 1;
			continue;
		}
		if (le32_to_cpu(de->inode)) {
2721
			brelse(bh);
2722 2723
			return 0;
		}
2724 2725
		offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
		de = ext4_next_entry(de, sb->s_blocksize);
2726
	}
2727
	brelse(bh);
2728 2729 2730
	return 1;
}

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

2751
	if (!sbi->s_journal || is_bad_inode(inode))
2752 2753
		return 0;

2754 2755 2756 2757 2758 2759
	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.
	 */
2760
	if (!list_empty(&EXT4_I(inode)->i_orphan))
2761
		return 0;
2762

2763 2764 2765 2766 2767
	/*
	 * 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
2768
	 */
2769 2770
	J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		  S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
2771

2772 2773
	BUFFER_TRACE(sbi->s_sbh, "get_write_access");
	err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2774
	if (err)
2775
		goto out;
2776

2777
	err = ext4_reserve_inode_write(handle, inode, &iloc);
2778
	if (err)
2779 2780 2781
		goto out;

	mutex_lock(&sbi->s_orphan_lock);
2782 2783 2784 2785
	/*
	 * Due to previous errors inode may be already a part of on-disk
	 * orphan list. If so skip on-disk list modification.
	 */
2786 2787 2788 2789 2790 2791 2792 2793 2794
	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);
2795

2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
	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);
		}
	}
2812 2813 2814
	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));
2815
out:
2816
	ext4_std_error(sb, err);
2817 2818 2819 2820
	return err;
}

/*
2821
 * ext4_orphan_del() removes an unlinked or truncated inode from the list
2822 2823
 * of such inodes stored on disk, because it is finally being cleaned up.
 */
2824
int ext4_orphan_del(handle_t *handle, struct inode *inode)
2825 2826
{
	struct list_head *prev;
2827
	struct ext4_inode_info *ei = EXT4_I(inode);
2828
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2829
	__u32 ino_next;
2830
	struct ext4_iloc iloc;
2831 2832
	int err = 0;

2833
	if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
2834 2835
		return 0;

2836 2837 2838
	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. */
2839
	if (list_empty(&ei->i_orphan))
2840
		return 0;
2841

2842 2843 2844 2845
	if (handle) {
		/* Grab inode buffer early before taking global s_orphan_lock */
		err = ext4_reserve_inode_write(handle, inode, &iloc);
	}
2846

2847
	mutex_lock(&sbi->s_orphan_lock);
2848 2849
	jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);

2850
	prev = ei->i_orphan.prev;
2851 2852 2853 2854 2855 2856
	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. */
2857 2858
	if (!handle || err) {
		mutex_unlock(&sbi->s_orphan_lock);
2859
		goto out_err;
2860
	}
2861

2862
	ino_next = NEXT_ORPHAN(inode);
2863
	if (prev == &sbi->s_orphan) {
2864
		jbd_debug(4, "superblock will point to %u\n", ino_next);
2865
		BUFFER_TRACE(sbi->s_sbh, "get_write_access");
2866
		err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2867 2868
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
2869
			goto out_brelse;
2870
		}
2871
		sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
2872
		mutex_unlock(&sbi->s_orphan_lock);
2873
		err = ext4_handle_dirty_super(handle, inode->i_sb);
2874
	} else {
2875
		struct ext4_iloc iloc2;
2876
		struct inode *i_prev =
2877
			&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
2878

2879
		jbd_debug(4, "orphan inode %lu will point to %u\n",
2880
			  i_prev->i_ino, ino_next);
2881
		err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
2882 2883
		if (err) {
			mutex_unlock(&sbi->s_orphan_lock);
2884
			goto out_brelse;
2885
		}
2886
		NEXT_ORPHAN(i_prev) = ino_next;
2887
		err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
2888
		mutex_unlock(&sbi->s_orphan_lock);
2889 2890 2891 2892
	}
	if (err)
		goto out_brelse;
	NEXT_ORPHAN(inode) = 0;
2893
	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
2894
out_err:
2895
	ext4_std_error(inode->i_sb, err);
2896 2897 2898 2899 2900 2901 2902
	return err;

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

2903
static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
2904 2905
{
	int retval;
2906 2907 2908
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
2909
	handle_t *handle = NULL;
2910 2911 2912

	/* Initialize quotas before so that eventual writes go in
	 * separate transaction */
2913
	dquot_initialize(dir);
2914
	dquot_initialize(d_inode(dentry));
2915

2916
	retval = -ENOENT;
T
Tao Ma 已提交
2917
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
2918 2919
	if (IS_ERR(bh))
		return PTR_ERR(bh);
2920 2921 2922
	if (!bh)
		goto end_rmdir;

2923
	inode = d_inode(dentry);
2924 2925 2926 2927 2928 2929

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

	retval = -ENOTEMPTY;
2930
	if (!ext4_empty_dir(inode))
2931 2932
		goto end_rmdir;

2933
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
2934
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
2935 2936 2937 2938 2939 2940 2941 2942 2943
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rmdir;
	}

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

2944
	retval = ext4_delete_entry(handle, dir, de, bh);
2945 2946
	if (retval)
		goto end_rmdir;
2947
	if (!EXT4_DIR_LINK_EMPTY(inode))
2948 2949 2950
		ext4_warning_inode(inode,
			     "empty directory '%.*s' has too many links (%u)",
			     dentry->d_name.len, dentry->d_name.name,
2951
			     inode->i_nlink);
2952 2953 2954 2955 2956 2957
	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;
2958
	ext4_orphan_add(handle, inode);
K
Kalpak Shah 已提交
2959
	inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode);
2960
	ext4_mark_inode_dirty(handle, inode);
2961
	ext4_dec_count(handle, dir);
2962 2963
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
2964 2965

end_rmdir:
2966
	brelse(bh);
2967 2968
	if (handle)
		ext4_journal_stop(handle);
2969 2970 2971
	return retval;
}

2972
static int ext4_unlink(struct inode *dir, struct dentry *dentry)
2973 2974
{
	int retval;
2975 2976 2977
	struct inode *inode;
	struct buffer_head *bh;
	struct ext4_dir_entry_2 *de;
2978
	handle_t *handle = NULL;
2979

2980
	trace_ext4_unlink_enter(dir, dentry);
2981 2982
	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
2983
	dquot_initialize(dir);
2984
	dquot_initialize(d_inode(dentry));
2985

2986
	retval = -ENOENT;
T
Tao Ma 已提交
2987
	bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
2988 2989
	if (IS_ERR(bh))
		return PTR_ERR(bh);
2990 2991 2992
	if (!bh)
		goto end_unlink;

2993
	inode = d_inode(dentry);
2994 2995 2996 2997 2998

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

2999
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
3000
				    EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3001 3002 3003 3004 3005 3006 3007 3008 3009
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_unlink;
	}

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

3010 3011 3012
	if (inode->i_nlink == 0) {
		ext4_warning_inode(inode, "Deleting file '%.*s' with no links",
				   dentry->d_name.len, dentry->d_name.name);
M
Miklos Szeredi 已提交
3013
		set_nlink(inode, 1);
3014
	}
3015
	retval = ext4_delete_entry(handle, dir, de, bh);
3016 3017
	if (retval)
		goto end_unlink;
K
Kalpak Shah 已提交
3018
	dir->i_ctime = dir->i_mtime = ext4_current_time(dir);
3019 3020
	ext4_update_dx_flag(dir);
	ext4_mark_inode_dirty(handle, dir);
3021
	drop_nlink(inode);
3022
	if (!inode->i_nlink)
3023
		ext4_orphan_add(handle, inode);
K
Kalpak Shah 已提交
3024
	inode->i_ctime = ext4_current_time(inode);
3025
	ext4_mark_inode_dirty(handle, inode);
3026 3027

end_unlink:
3028
	brelse(bh);
3029 3030
	if (handle)
		ext4_journal_stop(handle);
3031
	trace_ext4_unlink_exit(dentry, retval);
3032 3033 3034
	return retval;
}

3035 3036
static int ext4_symlink(struct inode *dir,
			struct dentry *dentry, const char *symname)
3037 3038
{
	handle_t *handle;
3039
	struct inode *inode;
3040
	int err, len = strlen(symname);
3041
	int credits;
3042 3043 3044
	bool encryption_required;
	struct ext4_str disk_link;
	struct ext4_encrypted_symlink_data *sd = NULL;
3045

3046 3047 3048
	disk_link.len = len + 1;
	disk_link.name = (char *) symname;

3049 3050
	encryption_required = (ext4_encrypted_inode(dir) ||
			       DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb)));
3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067
	if (encryption_required) {
		err = ext4_get_encryption_info(dir);
		if (err)
			return err;
		if (ext4_encryption_info(dir) == NULL)
			return -EPERM;
		disk_link.len = (ext4_fname_encrypted_size(dir, len) +
				 sizeof(struct ext4_encrypted_symlink_data));
		sd = kzalloc(disk_link.len, GFP_KERNEL);
		if (!sd)
			return -ENOMEM;
	}

	if (disk_link.len > dir->i_sb->s_blocksize) {
		err = -ENAMETOOLONG;
		goto err_free_sd;
	}
3068

3069
	dquot_initialize(dir);
3070

3071
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3072 3073 3074
		/*
		 * For non-fast symlinks, we just allocate inode and put it on
		 * orphan list in the first transaction => we need bitmap,
3075 3076
		 * group descriptor, sb, inode block, quota blocks, and
		 * possibly selinux xattr blocks.
3077
		 */
3078 3079
		credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
			  EXT4_XATTR_TRANS_BLOCKS;
3080 3081 3082 3083 3084 3085 3086 3087
	} 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) +
3088
			  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3089
	}
3090

3091 3092 3093 3094
	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();
3095 3096 3097
	if (IS_ERR(inode)) {
		if (handle)
			ext4_journal_stop(handle);
3098 3099
		err = PTR_ERR(inode);
		goto err_free_sd;
3100 3101 3102 3103 3104 3105 3106 3107 3108
	}

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

		istr.name = (const unsigned char *) symname;
		istr.len = len;
		ostr.name = sd->encrypted_path;
3109
		ostr.len = disk_link.len;
3110
		err = ext4_fname_usr_to_disk(inode, &istr, &ostr);
3111 3112 3113 3114 3115
		if (err < 0)
			goto err_drop_inode;
		sd->len = cpu_to_le16(ostr.len);
		disk_link.name = (char *) sd;
	}
3116

3117
	if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3118 3119
		inode->i_op = &ext4_symlink_inode_operations;
		ext4_set_aops(inode);
3120
		/*
3121 3122 3123 3124 3125 3126 3127 3128
		 * 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.
3129
		 */
3130 3131 3132
		drop_nlink(inode);
		err = ext4_orphan_add(handle, inode);
		ext4_journal_stop(handle);
3133
		handle = NULL;
3134 3135
		if (err)
			goto err_drop_inode;
3136
		err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
3137 3138 3139 3140 3141 3142
		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
		 */
3143
		handle = ext4_journal_start(dir, EXT4_HT_DIR,
3144 3145 3146 3147
				EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
				EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
		if (IS_ERR(handle)) {
			err = PTR_ERR(handle);
3148
			handle = NULL;
3149 3150
			goto err_drop_inode;
		}
3151
		set_nlink(inode, 1);
3152
		err = ext4_orphan_del(handle, inode);
3153
		if (err)
3154
			goto err_drop_inode;
3155
	} else {
3156
		/* clear the extent format for fast symlink */
3157
		ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3158 3159 3160 3161 3162 3163
		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;
3164
	}
3165 3166
	EXT4_I(inode)->i_disksize = inode->i_size;
	err = ext4_add_nondir(handle, dentry, inode);
3167 3168 3169 3170 3171
	if (!err && IS_DIRSYNC(dir))
		ext4_handle_sync(handle);

	if (handle)
		ext4_journal_stop(handle);
3172
	kfree(sd);
3173
	return err;
3174
err_drop_inode:
3175 3176 3177
	if (handle)
		ext4_journal_stop(handle);
	clear_nlink(inode);
3178 3179
	unlock_new_inode(inode);
	iput(inode);
3180 3181
err_free_sd:
	kfree(sd);
3182
	return err;
3183 3184
}

3185 3186
static int ext4_link(struct dentry *old_dentry,
		     struct inode *dir, struct dentry *dentry)
3187 3188
{
	handle_t *handle;
3189
	struct inode *inode = d_inode(old_dentry);
3190 3191
	int err, retries = 0;

3192
	if (inode->i_nlink >= EXT4_LINK_MAX)
3193
		return -EMLINK;
3194 3195 3196
	if (ext4_encrypted_inode(dir) &&
	    !ext4_is_child_context_consistent_with_parent(dir, inode))
		return -EPERM;
3197
	dquot_initialize(dir);
3198

3199
retry:
3200 3201
	handle = ext4_journal_start(dir, EXT4_HT_DIR,
		(EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
A
Al Viro 已提交
3202
		 EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3203 3204 3205 3206
	if (IS_ERR(handle))
		return PTR_ERR(handle);

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

K
Kalpak Shah 已提交
3209
	inode->i_ctime = ext4_current_time(inode);
3210
	ext4_inc_count(handle, inode);
A
Al Viro 已提交
3211
	ihold(inode);
3212

A
Al Viro 已提交
3213 3214 3215
	err = ext4_add_entry(handle, dentry, inode);
	if (!err) {
		ext4_mark_inode_dirty(handle, inode);
A
Al Viro 已提交
3216 3217 3218 3219 3220
		/* this can happen only for tmpfile being
		 * linked the first time
		 */
		if (inode->i_nlink == 1)
			ext4_orphan_del(handle, inode);
A
Al Viro 已提交
3221 3222 3223 3224 3225
		d_instantiate(dentry, inode);
	} else {
		drop_nlink(inode);
		iput(inode);
	}
3226 3227
	ext4_journal_stop(handle);
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3228 3229 3230 3231
		goto retry;
	return err;
}

T
Tao Ma 已提交
3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246

/*
 * 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)) {
3247 3248 3249
		bh = ext4_read_dirblock(inode, 0, EITHER);
		if (IS_ERR(bh)) {
			*retval = PTR_ERR(bh);
T
Tao Ma 已提交
3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
			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);
}
3261

3262 3263 3264 3265
struct ext4_renament {
	struct inode *dir;
	struct dentry *dentry;
	struct inode *inode;
M
Miklos Szeredi 已提交
3266 3267
	bool is_dir;
	int dir_nlink_delta;
3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279

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

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 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361
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);
3362 3363
	if (IS_ERR(bh))
		return PTR_ERR(bh);
3364 3365 3366 3367 3368 3369 3370
	if (bh) {
		retval = ext4_delete_entry(handle, dir, de, bh);
		brelse(bh);
	}
	return retval;
}

3371 3372
static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
			       int force_reread)
3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
{
	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,
3384 3385
		    ent->de->name_len) ||
	    force_reread) {
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396
		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) {
3397 3398 3399
		ext4_warning_inode(ent->dir,
				   "Deleting old file: nlink %d, error=%d",
				   ent->dir->i_nlink, retval);
3400 3401 3402
	}
}

M
Miklos Szeredi 已提交
3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413
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 已提交
3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
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;
}

3447 3448 3449
/*
 * Anybody can rename anything with this: the permission checks are left to the
 * higher-level routines.
3450 3451 3452 3453
 *
 * 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)
3454
 */
3455
static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
M
Miklos Szeredi 已提交
3456 3457
		       struct inode *new_dir, struct dentry *new_dentry,
		       unsigned int flags)
3458
{
3459
	handle_t *handle = NULL;
3460 3461 3462
	struct ext4_renament old = {
		.dir = old_dir,
		.dentry = old_dentry,
3463
		.inode = d_inode(old_dentry),
3464 3465 3466 3467
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
3468
		.inode = d_inode(new_dentry),
3469
	};
3470
	int force_reread;
3471
	int retval;
M
Miklos Szeredi 已提交
3472 3473 3474
	struct inode *whiteout = NULL;
	int credits;
	u8 old_file_type;
3475

3476 3477
	dquot_initialize(old.dir);
	dquot_initialize(new.dir);
3478 3479 3480

	/* Initialize quotas before so that eventual writes go
	 * in separate transaction */
3481 3482
	if (new.inode)
		dquot_initialize(new.inode);
3483

3484
	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
3485 3486
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
3487 3488 3489 3490 3491 3492 3493
	/*
	 *  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;
3494
	if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3495 3496
		goto end_rename;

3497 3498 3499 3500 3501 3502 3503 3504
	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;
	}

3505 3506
	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
				 &new.de, &new.inlined);
3507 3508
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3509
		new.bh = NULL;
3510 3511
		goto end_rename;
	}
3512 3513 3514 3515
	if (new.bh) {
		if (!new.inode) {
			brelse(new.bh);
			new.bh = NULL;
3516 3517
		}
	}
3518 3519
	if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
		ext4_alloc_da_blocks(old.inode);
3520

M
Miklos Szeredi 已提交
3521 3522 3523 3524
	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);
3525 3526 3527 3528 3529
		if (IS_ERR(handle)) {
			retval = PTR_ERR(handle);
			handle = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3530 3531
	} else {
		whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
3532 3533 3534 3535 3536
		if (IS_ERR(whiteout)) {
			retval = PTR_ERR(whiteout);
			whiteout = NULL;
			goto end_rename;
		}
M
Miklos Szeredi 已提交
3537
	}
3538

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

3542 3543
	if (S_ISDIR(old.inode->i_mode)) {
		if (new.inode) {
3544
			retval = -ENOTEMPTY;
3545
			if (!ext4_empty_dir(new.inode))
3546
				goto end_rename;
3547 3548 3549 3550
		} else {
			retval = -EMLINK;
			if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
				goto end_rename;
3551
		}
3552
		retval = ext4_rename_dir_prepare(handle, &old);
3553 3554
		if (retval)
			goto end_rename;
3555
	}
3556 3557 3558 3559 3560 3561 3562 3563 3564
	/*
	 * 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 已提交
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577

	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);
	}
3578 3579
	if (!new.bh) {
		retval = ext4_add_entry(handle, new.dentry, old.inode);
3580 3581 3582
		if (retval)
			goto end_rename;
	} else {
3583
		retval = ext4_setent(handle, &new,
M
Miklos Szeredi 已提交
3584
				     old.inode->i_ino, old_file_type);
3585 3586
		if (retval)
			goto end_rename;
3587
	}
3588 3589 3590
	if (force_reread)
		force_reread = !ext4_test_inode_flag(new.dir,
						     EXT4_INODE_INLINE_DATA);
3591 3592 3593 3594 3595

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

M
Miklos Szeredi 已提交
3599 3600 3601 3602 3603 3604
	if (!whiteout) {
		/*
		 * ok, that's it
		 */
		ext4_rename_delete(handle, &old, force_reread);
	}
3605

3606 3607 3608
	if (new.inode) {
		ext4_dec_count(handle, new.inode);
		new.inode->i_ctime = ext4_current_time(new.inode);
3609
	}
3610 3611 3612
	old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir);
	ext4_update_dx_flag(old.dir);
	if (old.dir_bh) {
3613 3614
		retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
		if (retval)
3615
			goto end_rename;
3616

3617 3618
		ext4_dec_count(handle, old.dir);
		if (new.inode) {
3619 3620 3621
			/* checked ext4_empty_dir above, can't have another
			 * parent, ext4_dec_count() won't work for many-linked
			 * dirs */
3622
			clear_nlink(new.inode);
3623
		} else {
3624 3625 3626
			ext4_inc_count(handle, new.dir);
			ext4_update_dx_flag(new.dir);
			ext4_mark_inode_dirty(handle, new.dir);
3627 3628
		}
	}
3629 3630 3631 3632 3633
	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);
3634 3635 3636 3637
	}
	retval = 0;

end_rename:
3638 3639 3640
	brelse(old.dir_bh);
	brelse(old.bh);
	brelse(new.bh);
M
Miklos Szeredi 已提交
3641 3642 3643 3644 3645 3646
	if (whiteout) {
		if (retval)
			drop_nlink(whiteout);
		unlock_new_inode(whiteout);
		iput(whiteout);
	}
3647 3648
	if (handle)
		ext4_journal_stop(handle);
3649 3650 3651
	return retval;
}

M
Miklos Szeredi 已提交
3652 3653 3654 3655 3656 3657 3658
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,
3659
		.inode = d_inode(old_dentry),
M
Miklos Szeredi 已提交
3660 3661 3662 3663
	};
	struct ext4_renament new = {
		.dir = new_dir,
		.dentry = new_dentry,
3664
		.inode = d_inode(new_dentry),
M
Miklos Szeredi 已提交
3665 3666 3667 3668
	};
	u8 new_file_type;
	int retval;

3669 3670 3671 3672 3673 3674 3675 3676 3677
	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 已提交
3678 3679 3680 3681 3682
	dquot_initialize(old.dir);
	dquot_initialize(new.dir);

	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
				 &old.de, &old.inlined);
3683 3684
	if (IS_ERR(old.bh))
		return PTR_ERR(old.bh);
M
Miklos Szeredi 已提交
3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696
	/*
	 *  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);
3697 3698
	if (IS_ERR(new.bh)) {
		retval = PTR_ERR(new.bh);
3699
		new.bh = NULL;
3700 3701
		goto end_rename;
	}
M
Miklos Szeredi 已提交
3702 3703 3704 3705 3706 3707 3708 3709

	/* 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));
3710 3711 3712 3713 3714
	if (IS_ERR(handle)) {
		retval = PTR_ERR(handle);
		handle = NULL;
		goto end_rename;
	}
M
Miklos Szeredi 已提交
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 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786

	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 已提交
3787 3788 3789 3790
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 已提交
3791
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
M
Miklos Szeredi 已提交
3792 3793
		return -EINVAL;

M
Miklos Szeredi 已提交
3794 3795 3796 3797
	if (flags & RENAME_EXCHANGE) {
		return ext4_cross_rename(old_dir, old_dentry,
					 new_dir, new_dentry);
	}
M
Miklos Szeredi 已提交
3798 3799

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

3802 3803 3804
/*
 * directories can handle most operations...
 */
3805
const struct inode_operations ext4_dir_inode_operations = {
3806 3807 3808 3809 3810 3811 3812 3813
	.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 已提交
3814
	.tmpfile	= ext4_tmpfile,
M
Miklos Szeredi 已提交
3815
	.rename2	= ext4_rename2,
3816
	.setattr	= ext4_setattr,
3817 3818
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3819
	.listxattr	= ext4_listxattr,
3820
	.removexattr	= generic_removexattr,
3821
	.get_acl	= ext4_get_acl,
3822
	.set_acl	= ext4_set_acl,
3823
	.fiemap         = ext4_fiemap,
3824 3825
};

3826
const struct inode_operations ext4_special_inode_operations = {
3827
	.setattr	= ext4_setattr,
3828 3829
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
3830
	.listxattr	= ext4_listxattr,
3831
	.removexattr	= generic_removexattr,
3832
	.get_acl	= ext4_get_acl,
3833
	.set_acl	= ext4_set_acl,
3834
};