dir.c 21.7 KB
Newer Older
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1
/*
2 3 4 5 6 7 8 9 10 11 12 13
 * fs/f2fs/dir.c
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *             http://www.samsung.com/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/fs.h>
#include <linux/f2fs_fs.h>
#include "f2fs.h"
14
#include "node.h"
15
#include "acl.h"
16
#include "xattr.h"
17 18 19 20 21 22 23

static unsigned long dir_blocks(struct inode *inode)
{
	return ((unsigned long long) (i_size_read(inode) + PAGE_CACHE_SIZE - 1))
							>> PAGE_CACHE_SHIFT;
}

24
static unsigned int dir_buckets(unsigned int level, int dir_level)
25
{
26
	if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
27
		return 1 << (level + dir_level);
28
	else
29
		return MAX_DIR_BUCKETS;
30 31 32 33 34 35 36 37 38 39
}

static unsigned int bucket_blocks(unsigned int level)
{
	if (level < MAX_DIR_HASH_DEPTH / 2)
		return 2;
	else
		return 4;
}

40
unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
	[F2FS_FT_UNKNOWN]	= DT_UNKNOWN,
	[F2FS_FT_REG_FILE]	= DT_REG,
	[F2FS_FT_DIR]		= DT_DIR,
	[F2FS_FT_CHRDEV]	= DT_CHR,
	[F2FS_FT_BLKDEV]	= DT_BLK,
	[F2FS_FT_FIFO]		= DT_FIFO,
	[F2FS_FT_SOCK]		= DT_SOCK,
	[F2FS_FT_SYMLINK]	= DT_LNK,
};

#define S_SHIFT 12
static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
	[S_IFREG >> S_SHIFT]	= F2FS_FT_REG_FILE,
	[S_IFDIR >> S_SHIFT]	= F2FS_FT_DIR,
	[S_IFCHR >> S_SHIFT]	= F2FS_FT_CHRDEV,
	[S_IFBLK >> S_SHIFT]	= F2FS_FT_BLKDEV,
	[S_IFIFO >> S_SHIFT]	= F2FS_FT_FIFO,
	[S_IFSOCK >> S_SHIFT]	= F2FS_FT_SOCK,
	[S_IFLNK >> S_SHIFT]	= F2FS_FT_SYMLINK,
};

62
void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
63 64 65 66
{
	de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
}

67 68
static unsigned long dir_block_index(unsigned int level,
				int dir_level, unsigned int idx)
69 70 71 72 73
{
	unsigned long i;
	unsigned long bidx = 0;

	for (i = 0; i < level; i++)
74
		bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
75 76 77 78 79
	bidx += idx * bucket_blocks(level);
	return bidx;
}

static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
80 81 82
				struct f2fs_filename *fname,
				f2fs_hash_t namehash,
				int *max_slots,
83 84 85 86
				struct page **res_page)
{
	struct f2fs_dentry_block *dentry_blk;
	struct f2fs_dir_entry *de;
87
	struct f2fs_dentry_ptr d;
88 89

	dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);
90

91
	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
92
	de = find_target_dentry(fname, namehash, max_slots, &d);
93 94 95 96 97 98 99 100 101
	if (de)
		*res_page = dentry_page;
	else
		kunmap(dentry_page);

	/*
	 * For the most part, it should be a bug when name_len is zero.
	 * We stop here for figuring out where the bugs has occurred.
	 */
102
	f2fs_bug_on(F2FS_P_SB(dentry_page), d.max < 0);
103 104 105
	return de;
}

106 107 108
struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *fname,
			f2fs_hash_t namehash, int *max_slots,
			struct f2fs_dentry_ptr *d)
109 110
{
	struct f2fs_dir_entry *de;
111 112
	unsigned long bit_pos = 0;
	int max_len = 0;
113 114
	struct f2fs_str de_name = FSTR_INIT(NULL, 0);
	struct f2fs_str *name = &fname->disk_name;
115

116 117 118 119
	if (max_slots)
		*max_slots = 0;
	while (bit_pos < d->max) {
		if (!test_bit_le(bit_pos, d->bitmap)) {
120
			bit_pos++;
121
			max_len++;
122 123
			continue;
		}
124

125
		de = &d->dentry[bit_pos];
126 127 128 129 130 131 132 133 134 135 136 137

		/* encrypted case */
		de_name.name = d->filename[bit_pos];
		de_name.len = le16_to_cpu(de->name_len);

		/* show encrypted name */
		if (fname->hash) {
			if (de->hash_code == fname->hash)
				goto found;
		} else if (de_name.len == name->len &&
			de->hash_code == namehash &&
			!memcmp(de_name.name, name->name, name->len))
138 139
			goto found;

140
		if (max_slots && max_len > *max_slots)
141
			*max_slots = max_len;
142
		max_len = 0;
143

144 145
		/* remain bug on condition */
		if (unlikely(!de->name_len))
146
			d->max = -1;
147

148
		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
149 150 151 152
	}

	de = NULL;
found:
153
	if (max_slots && max_len > *max_slots)
154
		*max_slots = max_len;
155 156 157 158
	return de;
}

static struct f2fs_dir_entry *find_in_level(struct inode *dir,
159 160 161
					unsigned int level,
					struct f2fs_filename *fname,
					struct page **res_page)
162
{
163 164
	struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
	int s = GET_DENTRY_SLOTS(name.len);
165 166 167 168 169
	unsigned int nbucket, nblock;
	unsigned int bidx, end_block;
	struct page *dentry_page;
	struct f2fs_dir_entry *de = NULL;
	bool room = false;
170
	int max_slots;
171 172 173
	f2fs_hash_t namehash;

	namehash = f2fs_dentry_hash(&name);
174

175
	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
176 177
	nblock = bucket_blocks(level);

178 179
	bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
					le32_to_cpu(namehash) % nbucket);
180 181 182 183
	end_block = bidx + nblock;

	for (; bidx < end_block; bidx++) {
		/* no need to allocate new dentry pages to all the indices */
184
		dentry_page = find_data_page(dir, bidx);
185 186 187 188 189
		if (IS_ERR(dentry_page)) {
			room = true;
			continue;
		}

190 191
		de = find_in_block(dentry_page, fname, namehash, &max_slots,
								res_page);
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
		if (de)
			break;

		if (max_slots >= s)
			room = true;
		f2fs_put_page(dentry_page, 0);
	}

	if (!de && room && F2FS_I(dir)->chash != namehash) {
		F2FS_I(dir)->chash = namehash;
		F2FS_I(dir)->clevel = level;
	}

	return de;
}

/*
 * Find an entry in the specified directory with the wanted name.
 * It returns the page where the entry was found (as a parameter - res_page),
 * and the entry itself. Page is returned mapped and unlocked.
 * Entry is guaranteed to be valid.
 */
struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
			struct qstr *child, struct page **res_page)
{
	unsigned long npages = dir_blocks(dir);
	struct f2fs_dir_entry *de = NULL;
	unsigned int max_depth;
	unsigned int level;
221 222
	struct f2fs_filename fname;
	int err;
223

224 225
	*res_page = NULL;

226 227 228 229 230 231 232 233
	err = f2fs_fname_setup_filename(dir, child, 1, &fname);
	if (err)
		return NULL;

	if (f2fs_has_inline_dentry(dir)) {
		de = find_in_inline_dir(dir, &fname, res_page);
		goto out;
	}
Chao Yu's avatar
Chao Yu committed
234

235
	if (npages == 0)
236
		goto out;
237 238

	max_depth = F2FS_I(dir)->i_current_depth;
239 240 241 242 243 244 245 246
	if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
		f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING,
				"Corrupted max_depth of %lu: %u",
				dir->i_ino, max_depth);
		max_depth = MAX_DIR_HASH_DEPTH;
		F2FS_I(dir)->i_current_depth = max_depth;
		mark_inode_dirty(dir);
	}
247 248

	for (level = 0; level < max_depth; level++) {
249
		de = find_in_level(dir, level, &fname, res_page);
250 251 252
		if (de)
			break;
	}
253 254
out:
	f2fs_fname_free_filename(&fname);
255 256 257 258 259
	return de;
}

struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
{
260 261 262
	struct page *page;
	struct f2fs_dir_entry *de;
	struct f2fs_dentry_block *dentry_blk;
263

Chao Yu's avatar
Chao Yu committed
264 265 266
	if (f2fs_has_inline_dentry(dir))
		return f2fs_parent_inline_dir(dir, p);

267
	page = get_lock_data_page(dir, 0, false);
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
	if (IS_ERR(page))
		return NULL;

	dentry_blk = kmap(page);
	de = &dentry_blk->dentry[1];
	*p = page;
	unlock_page(page);
	return de;
}

ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr)
{
	ino_t res = 0;
	struct f2fs_dir_entry *de;
	struct page *page;

	de = f2fs_find_entry(dir, qstr, &page);
	if (de) {
		res = le32_to_cpu(de->ino);
287
		f2fs_dentry_kunmap(dir, page);
288 289 290 291 292 293 294 295 296
		f2fs_put_page(page, 0);
	}

	return res;
}

void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
		struct page *page, struct inode *inode)
{
297
	enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
298
	lock_page(page);
299
	f2fs_wait_on_page_writeback(page, type, true);
300
	de->ino = cpu_to_le32(inode->i_ino);
301
	set_de_type(de, inode->i_mode);
302
	f2fs_dentry_kunmap(dir, page);
303 304 305
	set_page_dirty(page);
	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
	mark_inode_dirty(dir);
306

307 308 309
	f2fs_put_page(page, 1);
}

310
static void init_dent_inode(const struct qstr *name, struct page *ipage)
311
{
312
	struct f2fs_inode *ri;
313

314
	f2fs_wait_on_page_writeback(ipage, NODE, true);
315

316
	/* copy name info. to this inode page */
317 318 319
	ri = F2FS_INODE(ipage);
	ri->i_namelen = cpu_to_le32(name->len);
	memcpy(ri->i_name, name->name, name->len);
320 321 322
	set_page_dirty(ipage);
}

323 324
int update_dent_inode(struct inode *inode, struct inode *to,
					const struct qstr *name)
325 326 327
{
	struct page *page;

328 329 330
	if (file_enc_name(to))
		return 0;

331
	page = get_node_page(F2FS_I_SB(inode), inode->i_ino);
332 333 334 335 336 337 338 339 340
	if (IS_ERR(page))
		return PTR_ERR(page);

	init_dent_inode(name, page);
	f2fs_put_page(page, 1);

	return 0;
}

341 342 343 344 345 346 347 348 349 350
void do_make_empty_dir(struct inode *inode, struct inode *parent,
					struct f2fs_dentry_ptr *d)
{
	struct f2fs_dir_entry *de;

	de = &d->dentry[0];
	de->name_len = cpu_to_le16(1);
	de->hash_code = 0;
	de->ino = cpu_to_le32(inode->i_ino);
	memcpy(d->filename[0], ".", 1);
351
	set_de_type(de, inode->i_mode);
352 353 354 355 356 357

	de = &d->dentry[1];
	de->hash_code = 0;
	de->name_len = cpu_to_le16(2);
	de->ino = cpu_to_le32(parent->i_ino);
	memcpy(d->filename[1], "..", 2);
358
	set_de_type(de, parent->i_mode);
359 360 361 362 363

	test_and_set_bit_le(0, (void *)d->bitmap);
	test_and_set_bit_le(1, (void *)d->bitmap);
}

364 365
static int make_empty_dir(struct inode *inode,
		struct inode *parent, struct page *page)
366 367 368
{
	struct page *dentry_page;
	struct f2fs_dentry_block *dentry_blk;
369
	struct f2fs_dentry_ptr d;
370

Chao Yu's avatar
Chao Yu committed
371 372 373
	if (f2fs_has_inline_dentry(inode))
		return make_empty_inline_dir(inode, parent, page);

374
	dentry_page = get_new_data_page(inode, page, 0, true);
375 376 377
	if (IS_ERR(dentry_page))
		return PTR_ERR(dentry_page);

378
	dentry_blk = kmap_atomic(dentry_page);
379

380
	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
381
	do_make_empty_dir(inode, parent, &d);
382

383
	kunmap_atomic(dentry_blk);
384 385 386 387 388 389

	set_page_dirty(dentry_page);
	f2fs_put_page(dentry_page, 1);
	return 0;
}

390 391
struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
			const struct qstr *name, struct page *dpage)
392
{
393 394 395
	struct page *page;
	int err;

396
	if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
397
		page = new_inode_page(inode);
398 399
		if (IS_ERR(page))
			return page;
400 401

		if (S_ISDIR(inode->i_mode)) {
402 403 404
			err = make_empty_dir(inode, dir, page);
			if (err)
				goto error;
405 406
		}

407
		err = f2fs_init_acl(inode, dir, page, dpage);
408
		if (err)
409
			goto put_error;
410

411 412
		err = f2fs_init_security(inode, dir, name, page);
		if (err)
413
			goto put_error;
414 415 416 417 418 419

		if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {
			err = f2fs_inherit_context(dir, inode, page);
			if (err)
				goto put_error;
		}
420
	} else {
421
		page = get_node_page(F2FS_I_SB(dir), inode->i_ino);
422 423 424 425
		if (IS_ERR(page))
			return page;

		set_cold_node(inode, page);
426
	}
427

428 429
	if (name)
		init_dent_inode(name, page);
430

431 432 433 434
	/*
	 * This file should be checkpointed during fsync.
	 * We lost i_pino from now on.
	 */
435
	if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {
436
		file_lost_pino(inode);
Chao Yu's avatar
Chao Yu committed
437 438 439 440 441
		/*
		 * If link the tmpfile to alias through linkat path,
		 * we should remove this inode from orphan list.
		 */
		if (inode->i_nlink == 0)
442
			remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
443 444
		inc_nlink(inode);
	}
445 446
	return page;

447
put_error:
448
	f2fs_put_page(page, 1);
449
error:
450 451
	/* once the failed inode becomes a bad inode, i_mode is S_IFREG */
	truncate_inode_pages(&inode->i_data, 0);
452
	truncate_blocks(inode, 0, false);
453
	remove_dirty_inode(inode);
454 455
	remove_inode_page(inode);
	return ERR_PTR(err);
456 457
}

458
void update_parent_metadata(struct inode *dir, struct inode *inode,
459 460
						unsigned int current_depth)
{
461
	if (inode && is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
462 463
		if (S_ISDIR(inode->i_mode)) {
			inc_nlink(dir);
464
			set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
465 466 467 468
		}
		clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
	}
	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
469 470
	mark_inode_dirty(dir);

471 472
	if (F2FS_I(dir)->i_current_depth != current_depth) {
		F2FS_I(dir)->i_current_depth = current_depth;
473
		set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
474 475
	}

476
	if (inode && is_inode_flag_set(F2FS_I(inode), FI_INC_LINK))
477 478 479
		clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
}

480
int room_for_filename(const void *bitmap, int slots, int max_slots)
481 482 483 484
{
	int bit_start = 0;
	int zero_start, zero_end;
next:
485 486 487 488 489
	zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
	if (zero_start >= max_slots)
		return max_slots;

	zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
490 491 492 493 494
	if (zero_end - zero_start >= slots)
		return zero_start;

	bit_start = zero_end + 1;

495 496
	if (zero_end + 1 >= max_slots)
		return max_slots;
497 498 499
	goto next;
}

500
void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
501 502 503 504 505 506 507 508 509 510 511
				const struct qstr *name, f2fs_hash_t name_hash,
				unsigned int bit_pos)
{
	struct f2fs_dir_entry *de;
	int slots = GET_DENTRY_SLOTS(name->len);
	int i;

	de = &d->dentry[bit_pos];
	de->hash_code = name_hash;
	de->name_len = cpu_to_le16(name->len);
	memcpy(d->filename[bit_pos], name->name, name->len);
512 513
	de->ino = cpu_to_le32(ino);
	set_de_type(de, mode);
514
	for (i = 0; i < slots; i++) {
515
		test_and_set_bit_le(bit_pos + i, (void *)d->bitmap);
516 517 518 519
		/* avoid wrong garbage data for readdir */
		if (i)
			(de + i)->name_len = 0;
	}
520 521
}

522
/*
Chao Yu's avatar
Chao Yu committed
523 524
 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
 * f2fs_unlock_op().
525
 */
Chris Fries's avatar
Chris Fries committed
526
int __f2fs_add_link(struct inode *dir, const struct qstr *name,
527
				struct inode *inode, nid_t ino, umode_t mode)
528 529 530 531 532 533 534 535 536
{
	unsigned int bit_pos;
	unsigned int level;
	unsigned int current_depth;
	unsigned long bidx, block;
	f2fs_hash_t dentry_hash;
	unsigned int nbucket, nblock;
	struct page *dentry_page = NULL;
	struct f2fs_dentry_block *dentry_blk = NULL;
537
	struct f2fs_dentry_ptr d;
538
	struct page *page = NULL;
539 540 541 542 543 544 545 546 547 548
	struct f2fs_filename fname;
	struct qstr new_name;
	int slots, err;

	err = f2fs_fname_setup_filename(dir, name, 0, &fname);
	if (err)
		return err;

	new_name.name = fname_name(&fname);
	new_name.len = fname_len(&fname);
549

Chao Yu's avatar
Chao Yu committed
550
	if (f2fs_has_inline_dentry(dir)) {
551
		err = f2fs_add_inline_entry(dir, &new_name, inode, ino, mode);
Chao Yu's avatar
Chao Yu committed
552
		if (!err || err != -EAGAIN)
553
			goto out;
Chao Yu's avatar
Chao Yu committed
554 555 556 557
		else
			err = 0;
	}

558
	level = 0;
559 560 561
	slots = GET_DENTRY_SLOTS(new_name.len);
	dentry_hash = f2fs_dentry_hash(&new_name);

562 563 564 565 566 567 568
	current_depth = F2FS_I(dir)->i_current_depth;
	if (F2FS_I(dir)->chash == dentry_hash) {
		level = F2FS_I(dir)->clevel;
		F2FS_I(dir)->chash = 0;
	}

start:
569 570 571 572
	if (unlikely(current_depth == MAX_DIR_HASH_DEPTH)) {
		err = -ENOSPC;
		goto out;
	}
573 574 575 576 577

	/* Increase the depth, if required */
	if (level == current_depth)
		++current_depth;

578
	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
579 580
	nblock = bucket_blocks(level);

581 582
	bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
				(le32_to_cpu(dentry_hash) % nbucket));
583 584

	for (block = bidx; block <= (bidx + nblock - 1); block++) {
585
		dentry_page = get_new_data_page(dir, NULL, block, true);
586 587 588 589
		if (IS_ERR(dentry_page)) {
			err = PTR_ERR(dentry_page);
			goto out;
		}
590 591

		dentry_blk = kmap(dentry_page);
592 593
		bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
						slots, NR_DENTRY_IN_BLOCK);
594 595 596 597 598 599 600 601 602 603 604
		if (bit_pos < NR_DENTRY_IN_BLOCK)
			goto add_dentry;

		kunmap(dentry_page);
		f2fs_put_page(dentry_page, 1);
	}

	/* Move to next level to find the empty slot for new dentry */
	++level;
	goto start;
add_dentry:
605
	f2fs_wait_on_page_writeback(dentry_page, DATA, true);
606

607 608
	if (inode) {
		down_write(&F2FS_I(inode)->i_sem);
609
		page = init_inode_metadata(inode, dir, &new_name, NULL);
610 611 612 613
		if (IS_ERR(page)) {
			err = PTR_ERR(page);
			goto fail;
		}
614 615
		if (f2fs_encrypted_inode(dir))
			file_set_enc_name(inode);
616
	}
617

618
	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
619
	f2fs_update_dentry(ino, mode, &d, &new_name, dentry_hash, bit_pos);
620

621
	set_page_dirty(dentry_page);
622

623 624 625 626 627 628
	if (inode) {
		/* we don't need to mark_inode_dirty now */
		F2FS_I(inode)->i_pino = dir->i_ino;
		update_inode(inode, page);
		f2fs_put_page(page, 1);
	}
629 630

	update_parent_metadata(dir, inode, current_depth);
631
fail:
632 633
	if (inode)
		up_write(&F2FS_I(inode)->i_sem);
634

635 636 637 638
	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
		update_inode_page(dir);
		clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
	}
639 640
	kunmap(dentry_page);
	f2fs_put_page(dentry_page, 1);
641 642
out:
	f2fs_fname_free_filename(&fname);
643
	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
644 645 646
	return err;
}

647 648 649 650 651 652
int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
{
	struct page *page;
	int err = 0;

	down_write(&F2FS_I(inode)->i_sem);
653
	page = init_inode_metadata(inode, dir, NULL, NULL);
654 655 656 657 658 659 660 661 662 663 664
	if (IS_ERR(page)) {
		err = PTR_ERR(page);
		goto fail;
	}
	/* we don't need to mark_inode_dirty now */
	update_inode(inode, page);
	f2fs_put_page(page, 1);

	clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
fail:
	up_write(&F2FS_I(inode)->i_sem);
665
	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
666 667 668
	return err;
}

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
void f2fs_drop_nlink(struct inode *dir, struct inode *inode, struct page *page)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);

	down_write(&F2FS_I(inode)->i_sem);

	if (S_ISDIR(inode->i_mode)) {
		drop_nlink(dir);
		if (page)
			update_inode(dir, page);
		else
			update_inode_page(dir);
	}
	inode->i_ctime = CURRENT_TIME;

	drop_nlink(inode);
	if (S_ISDIR(inode->i_mode)) {
		drop_nlink(inode);
		i_size_write(inode, 0);
	}
	up_write(&F2FS_I(inode)->i_sem);
	update_inode_page(inode);

	if (inode->i_nlink == 0)
		add_orphan_inode(sbi, inode->i_ino);
	else
		release_orphan_inode(sbi);
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
698
/*
arter97's avatar
arter97 committed
699
 * It only removes the dentry from the dentry page, corresponding name
700 701 702
 * entry in name page does not need to be touched during deletion.
 */
void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
703
					struct inode *dir, struct inode *inode)
704 705 706
{
	struct	f2fs_dentry_block *dentry_blk;
	unsigned int bit_pos;
707
	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
708 709
	int i;

710 711
	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);

Chao Yu's avatar
Chao Yu committed
712 713 714
	if (f2fs_has_inline_dentry(dir))
		return f2fs_delete_inline_entry(dentry, page, dir, inode);

715
	lock_page(page);
716
	f2fs_wait_on_page_writeback(page, DATA, true);
717

718 719
	dentry_blk = page_address(page);
	bit_pos = dentry - dentry_blk->dentry;
720
	for (i = 0; i < slots; i++)
721
		clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
722 723 724 725 726 727 728 729 730 731

	/* Let's check and deallocate this dentry page */
	bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
			NR_DENTRY_IN_BLOCK,
			0);
	kunmap(page); /* kunmap - pair of f2fs_find_entry */
	set_page_dirty(page);

	dir->i_ctime = dir->i_mtime = CURRENT_TIME;

732 733
	if (inode)
		f2fs_drop_nlink(dir, inode, NULL);
734

Chao Yu's avatar
Chao Yu committed
735 736
	if (bit_pos == NR_DENTRY_IN_BLOCK &&
			!truncate_hole(dir, page->index, page->index + 1)) {
737
		clear_page_dirty_for_io(page);
738
		ClearPagePrivate(page);
739
		ClearPageUptodate(page);
740
		inode_dec_dirty_pages(dir);
741
	}
742
	f2fs_put_page(page, 1);
743 744 745 746 747 748 749
}

bool f2fs_empty_dir(struct inode *dir)
{
	unsigned long bidx;
	struct page *dentry_page;
	unsigned int bit_pos;
750
	struct f2fs_dentry_block *dentry_blk;
751 752
	unsigned long nblock = dir_blocks(dir);

Chao Yu's avatar
Chao Yu committed
753 754 755
	if (f2fs_has_inline_dentry(dir))
		return f2fs_empty_inline_dir(dir);

756
	for (bidx = 0; bidx < nblock; bidx++) {
757
		dentry_page = get_lock_data_page(dir, bidx, false);
758 759 760 761 762 763 764
		if (IS_ERR(dentry_page)) {
			if (PTR_ERR(dentry_page) == -ENOENT)
				continue;
			else
				return false;
		}

765
		dentry_blk = kmap_atomic(dentry_page);
766 767 768 769 770 771 772
		if (bidx == 0)
			bit_pos = 2;
		else
			bit_pos = 0;
		bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
						NR_DENTRY_IN_BLOCK,
						bit_pos);
773
		kunmap_atomic(dentry_blk);
774 775 776 777 778 779 780 781 782

		f2fs_put_page(dentry_page, 1);

		if (bit_pos < NR_DENTRY_IN_BLOCK)
			return false;
	}
	return true;
}

783
bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
784
				unsigned int start_pos, struct f2fs_str *fstr)
785 786 787 788
{
	unsigned char d_type = DT_UNKNOWN;
	unsigned int bit_pos;
	struct f2fs_dir_entry *de = NULL;
789
	struct f2fs_str de_name = FSTR_INIT(NULL, 0);
790

791
	bit_pos = ((unsigned long)ctx->pos % d->max);
792

793 794 795
	while (bit_pos < d->max) {
		bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
		if (bit_pos >= d->max)
796 797
			break;

798
		de = &d->dentry[bit_pos];
799 800 801 802 803 804
		if (de->name_len == 0) {
			bit_pos++;
			ctx->pos = start_pos + bit_pos;
			continue;
		}

805 806 807 808
		if (de->file_type < F2FS_FT_MAX)
			d_type = f2fs_filetype_table[de->file_type];
		else
			d_type = DT_UNKNOWN;
809 810 811 812 813 814 815 816

		de_name.name = d->filename[bit_pos];
		de_name.len = le16_to_cpu(de->name_len);

		if (f2fs_encrypted_inode(d->inode)) {
			int save_len = fstr->len;
			int ret;

817 818 819 820 821 822
			de_name.name = kmalloc(de_name.len, GFP_NOFS);
			if (!de_name.name)
				return false;

			memcpy(de_name.name, d->filename[bit_pos], de_name.len);

823 824
			ret = f2fs_fname_disk_to_usr(d->inode, &de->hash_code,
							&de_name, fstr);
825
			kfree(de_name.name);
826 827
			if (ret < 0)
				return true;
828 829 830

			de_name = *fstr;
			fstr->len = save_len;
831 832 833
		}

		if (!dir_emit(ctx, de_name.name, de_name.len,
834 835 836 837 838 839 840 841 842
					le32_to_cpu(de->ino), d_type))
			return true;

		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
		ctx->pos = start_pos + bit_pos;
	}
	return false;
}

Al Viro's avatar
Al Viro committed
843
static int f2fs_readdir(struct file *file, struct dir_context *ctx)
844
{
Al Viro's avatar
Al Viro committed
845
	struct inode *inode = file_inode(file);
846 847 848
	unsigned long npages = dir_blocks(inode);
	struct f2fs_dentry_block *dentry_blk = NULL;
	struct page *dentry_page = NULL;
849
	struct file_ra_state *ra = &file->f_ra;
Al Viro's avatar
Al Viro committed
850
	unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
851
	struct f2fs_dentry_ptr d;
852 853
	struct f2fs_str fstr = FSTR_INIT(NULL, 0);
	int err = 0;
854

855
	if (f2fs_encrypted_inode(inode)) {
856 857 858 859
		err = f2fs_get_encryption_info(inode);
		if (err)
			return err;

860 861 862 863 864 865 866 867 868 869
		err = f2fs_fname_crypto_alloc_buffer(inode, F2FS_NAME_LEN,
								&fstr);
		if (err < 0)
			return err;
	}

	if (f2fs_has_inline_dentry(inode)) {
		err = f2fs_read_inline_dir(file, ctx, &fstr);
		goto out;
	}
Chao Yu's avatar
Chao Yu committed
870

871 872 873 874 875
	/* readahead for multi pages of dir */
	if (npages - n > 1 && !ra_has_index(ra, n))
		page_cache_sync_readahead(inode->i_mapping, ra, file, n,
				min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));

Chris Fries's avatar
Chris Fries committed
876
	for (; n < npages; n++) {
877
		dentry_page = get_lock_data_page(inode, n, false);
878 879 880 881 882 883 884
		if (IS_ERR(dentry_page)) {
			err = PTR_ERR(dentry_page);
			if (err == -ENOENT)
				continue;
			else
				goto out;
		}
885 886

		dentry_blk = kmap(dentry_page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
887

888
		make_dentry_ptr(inode, &d, (void *)dentry_blk, 1);
889

890 891 892 893 894
		if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK, &fstr)) {
			kunmap(dentry_page);
			f2fs_put_page(dentry_page, 1);
			break;
		}
895

Al Viro's avatar
Al Viro committed
896
		ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;
897 898 899
		kunmap(dentry_page);
		f2fs_put_page(dentry_page, 1);
	}
900 901 902
out:
	f2fs_fname_crypto_free_buffer(&fstr);
	return err;
903 904
}

905 906 907 908 909 910 911
static int f2fs_dir_open(struct inode *inode, struct file *filp)
{
	if (f2fs_encrypted_inode(inode))
		return f2fs_get_encryption_info(inode) ? -EACCES : 0;
	return 0;
}

912 913 914
const struct file_operations f2fs_dir_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
Al Viro's avatar
Al Viro committed
915
	.iterate	= f2fs_readdir,
916
	.fsync		= f2fs_sync_file,
917
	.open		= f2fs_dir_open,
918
	.unlocked_ioctl	= f2fs_ioctl,
919 920 921
#ifdef CONFIG_COMPAT
	.compat_ioctl   = f2fs_compat_ioctl,
#endif
922
};