namei.c 24.2 KB
Newer Older
J
Jaegeuk Kim 已提交
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15
 * fs/f2fs/namei.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 <linux/pagemap.h>
#include <linux/sched.h>
#include <linux/ctype.h>
C
Chao Yu 已提交
16
#include <linux/dcache.h>
17
#include <linux/namei.h>
18 19

#include "f2fs.h"
20
#include "node.h"
21 22
#include "xattr.h"
#include "acl.h"
23
#include <trace/events/f2fs.h>
24 25 26

static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
{
27
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
28 29 30
	nid_t ino;
	struct inode *inode;
	bool nid_free = false;
31
	int err;
32

33
	inode = new_inode(dir->i_sb);
34 35 36
	if (!inode)
		return ERR_PTR(-ENOMEM);

37
	f2fs_lock_op(sbi);
38
	if (!alloc_nid(sbi, &ino)) {
39
		f2fs_unlock_op(sbi);
40 41 42
		err = -ENOSPC;
		goto fail;
	}
43
	f2fs_unlock_op(sbi);
44

45
	inode_init_owner(inode, dir, mode);
46 47 48 49 50 51 52 53 54 55 56 57

	inode->i_ino = ino;
	inode->i_blocks = 0;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	inode->i_generation = sbi->s_next_generation++;

	err = insert_inode_locked(inode);
	if (err) {
		err = -EINVAL;
		nid_free = true;
		goto out;
	}
C
Chao Yu 已提交
58

59 60 61 62
	/* If the directory encrypted, then we should encrypt the inode. */
	if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))
		f2fs_set_encrypted_inode(inode);

63
	if (f2fs_may_inline_data(inode))
64
		set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
65
	if (f2fs_may_inline_dentry(inode))
C
Chao Yu 已提交
66 67
		set_inode_flag(F2FS_I(inode), FI_INLINE_DENTRY);

J
Jaegeuk Kim 已提交
68 69
	f2fs_init_extent_tree(inode, NULL);

C
Chao Yu 已提交
70
	stat_inc_inline_xattr(inode);
71 72 73
	stat_inc_inline_inode(inode);
	stat_inc_inline_dir(inode);

74
	trace_f2fs_new_inode(inode, 0);
75 76 77 78 79 80 81
	mark_inode_dirty(inode);
	return inode;

out:
	clear_nlink(inode);
	unlock_new_inode(inode);
fail:
82
	trace_f2fs_new_inode(inode, err);
83
	make_bad_inode(inode);
84
	if (nid_free)
85 86
		set_inode_flag(F2FS_I(inode), FI_FREE_NID);
	iput(inode);
87 88 89 90 91
	return ERR_PTR(err);
}

static int is_multimedia_file(const unsigned char *s, const char *sub)
{
92 93
	size_t slen = strlen(s);
	size_t sublen = strlen(sub);
94

C
Chao Yu 已提交
95 96 97 98 99 100 101 102
	/*
	 * filename format of multimedia file should be defined as:
	 * "filename + '.' + extension".
	 */
	if (slen < sublen + 2)
		return 0;

	if (s[slen - sublen - 1] != '.')
103
		return 0;
104

105
	return !strncasecmp(s + slen - sublen, sub, sublen);
106 107
}

J
Jaegeuk Kim 已提交
108
/*
109 110
 * Set multimedia files as cold files for hot/cold data separation
 */
111
static inline void set_cold_files(struct f2fs_sb_info *sbi, struct inode *inode,
112 113 114 115 116 117 118
		const unsigned char *name)
{
	int i;
	__u8 (*extlist)[8] = sbi->raw_super->extension_list;

	int count = le32_to_cpu(sbi->raw_super->extension_count);
	for (i = 0; i < count; i++) {
119
		if (is_multimedia_file(name, extlist[i])) {
120
			file_set_cold(inode);
121 122 123 124 125 126 127 128
			break;
		}
	}
}

static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
						bool excl)
{
129
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
130 131
	struct inode *inode;
	nid_t ino = 0;
132
	int err;
133

134 135
	f2fs_balance_fs(sbi);

136 137 138 139 140
	inode = f2fs_new_inode(dir, mode);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

	if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
141
		set_cold_files(sbi, inode, dentry->d_name.name);
142 143 144 145 146 147

	inode->i_op = &f2fs_file_inode_operations;
	inode->i_fop = &f2fs_file_operations;
	inode->i_mapping->a_ops = &f2fs_dblock_aops;
	ino = inode->i_ino;

148
	f2fs_lock_op(sbi);
149 150 151
	err = f2fs_add_link(dentry, inode);
	if (err)
		goto out;
152
	f2fs_unlock_op(sbi);
153 154 155

	alloc_nid_done(sbi, ino);

156
	d_instantiate(dentry, inode);
157
	unlock_new_inode(inode);
J
Jaegeuk Kim 已提交
158 159 160

	if (IS_DIRSYNC(dir))
		f2fs_sync_fs(sbi->sb, 1);
161 162
	return 0;
out:
163
	handle_failed_inode(inode);
164 165 166 167 168 169
	return err;
}

static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
		struct dentry *dentry)
{
170
	struct inode *inode = d_inode(old_dentry);
171
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
172
	int err;
173

174 175 176 177
	if (f2fs_encrypted_inode(dir) &&
		!f2fs_is_child_context_consistent_with_parent(dir, inode))
		return -EPERM;

178 179
	f2fs_balance_fs(sbi);

180
	inode->i_ctime = CURRENT_TIME;
J
Jaegeuk Kim 已提交
181
	ihold(inode);
182 183

	set_inode_flag(F2FS_I(inode), FI_INC_LINK);
184
	f2fs_lock_op(sbi);
185 186 187
	err = f2fs_add_link(dentry, inode);
	if (err)
		goto out;
188
	f2fs_unlock_op(sbi);
189 190

	d_instantiate(dentry, inode);
J
Jaegeuk Kim 已提交
191 192 193

	if (IS_DIRSYNC(dir))
		f2fs_sync_fs(sbi->sb, 1);
194 195 196 197
	return 0;
out:
	clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
	iput(inode);
198
	f2fs_unlock_op(sbi);
199 200 201 202 203 204
	return err;
}

struct dentry *f2fs_get_parent(struct dentry *child)
{
	struct qstr dotdot = QSTR_INIT("..", 2);
205
	unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot);
206 207
	if (!ino)
		return ERR_PTR(-ENOENT);
208
	return d_obtain_alias(f2fs_iget(d_inode(child)->i_sb, ino));
209 210
}

211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
static int __recover_dot_dentries(struct inode *dir, nid_t pino)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
	struct qstr dot = QSTR_INIT(".", 1);
	struct qstr dotdot = QSTR_INIT("..", 2);
	struct f2fs_dir_entry *de;
	struct page *page;
	int err = 0;

	f2fs_lock_op(sbi);

	de = f2fs_find_entry(dir, &dot, &page);
	if (de) {
		f2fs_dentry_kunmap(dir, page);
		f2fs_put_page(page, 0);
	} else {
		err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
		if (err)
			goto out;
	}

	de = f2fs_find_entry(dir, &dotdot, &page);
	if (de) {
		f2fs_dentry_kunmap(dir, page);
		f2fs_put_page(page, 0);
	} else {
		err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
	}
out:
	if (!err) {
		clear_inode_flag(F2FS_I(dir), FI_INLINE_DOTS);
		mark_inode_dirty(dir);
	}

	f2fs_unlock_op(sbi);
	return err;
}

249 250 251 252 253 254
static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
		unsigned int flags)
{
	struct inode *inode = NULL;
	struct f2fs_dir_entry *de;
	struct page *page;
J
Jaegeuk Kim 已提交
255
	nid_t ino;
256
	int err = 0;
257

258
	if (dentry->d_name.len > F2FS_NAME_LEN)
259 260 261
		return ERR_PTR(-ENAMETOOLONG);

	de = f2fs_find_entry(dir, &dentry->d_name, &page);
J
Jaegeuk Kim 已提交
262 263
	if (!de)
		return d_splice_alias(inode, dentry);
264

J
Jaegeuk Kim 已提交
265 266 267
	ino = le32_to_cpu(de->ino);
	f2fs_dentry_kunmap(dir, page);
	f2fs_put_page(page, 0);
268

J
Jaegeuk Kim 已提交
269 270 271
	inode = f2fs_iget(dir->i_sb, ino);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
272

273
	if (f2fs_has_inline_dots(inode)) {
J
Jaegeuk Kim 已提交
274
		err = __recover_dot_dentries(inode, dir->i_ino);
275 276
		if (err)
			goto err_out;
277 278
	}
	return d_splice_alias(inode, dentry);
279 280 281 282

err_out:
	iget_failed(inode);
	return ERR_PTR(err);
283 284 285 286
}

static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
{
287
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
288
	struct inode *inode = d_inode(dentry);
289 290 291 292
	struct f2fs_dir_entry *de;
	struct page *page;
	int err = -ENOENT;

293
	trace_f2fs_unlink_enter(dir, dentry);
294 295
	f2fs_balance_fs(sbi);

296 297 298 299
	de = f2fs_find_entry(dir, &dentry->d_name, &page);
	if (!de)
		goto fail;

300
	f2fs_lock_op(sbi);
J
Jaegeuk Kim 已提交
301
	err = acquire_orphan_inode(sbi);
302
	if (err) {
303
		f2fs_unlock_op(sbi);
304
		f2fs_dentry_kunmap(dir, page);
305 306 307
		f2fs_put_page(page, 0);
		goto fail;
	}
308
	f2fs_delete_entry(de, page, dir, inode);
309
	f2fs_unlock_op(sbi);
310

A
arter97 已提交
311
	/* In order to evict this inode, we set it dirty */
312
	mark_inode_dirty(inode);
J
Jaegeuk Kim 已提交
313 314 315

	if (IS_DIRSYNC(dir))
		f2fs_sync_fs(sbi->sb, 1);
316
fail:
317
	trace_f2fs_unlink_exit(inode, err);
318 319 320
	return err;
}

321
static const char *f2fs_follow_link(struct dentry *dentry, void **cookie)
322
{
323
	const char *link = page_follow_link_light(dentry, cookie);
324 325
	if (!IS_ERR(link) && !*link) {
		/* this is broken symlink case */
326
		page_put_link(NULL, *cookie);
327
		link = ERR_PTR(-ENOENT);
328
	}
329
	return link;
330 331
}

332 333 334
static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
					const char *symname)
{
335
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
336
	struct inode *inode;
337 338 339 340 341
	size_t len = strlen(symname);
	size_t p_len;
	char *p_str;
	struct f2fs_str disk_link = FSTR_INIT(NULL, 0);
	struct f2fs_encrypted_symlink_data *sd = NULL;
342
	int err;
343

344 345 346
	if (len > dir->i_sb->s_blocksize)
		return -ENAMETOOLONG;

347 348
	f2fs_balance_fs(sbi);

349 350 351 352
	inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

353 354 355 356
	if (f2fs_encrypted_inode(inode))
		inode->i_op = &f2fs_encrypted_symlink_inode_operations;
	else
		inode->i_op = &f2fs_symlink_inode_operations;
357 358
	inode->i_mapping->a_ops = &f2fs_dblock_aops;

359
	f2fs_lock_op(sbi);
360 361 362
	err = f2fs_add_link(dentry, inode);
	if (err)
		goto out;
363
	f2fs_unlock_op(sbi);
364 365
	alloc_nid_done(sbi, inode->i_ino);

366 367 368
	if (f2fs_encrypted_inode(dir)) {
		struct qstr istr = QSTR_INIT(symname, len);

369
		err = f2fs_get_encryption_info(inode);
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
		if (err)
			goto err_out;

		err = f2fs_fname_crypto_alloc_buffer(inode, len, &disk_link);
		if (err)
			goto err_out;

		err = f2fs_fname_usr_to_disk(inode, &istr, &disk_link);
		if (err < 0)
			goto err_out;

		p_len = encrypted_symlink_data_len(disk_link.len) + 1;

		if (p_len > dir->i_sb->s_blocksize) {
			err = -ENAMETOOLONG;
			goto err_out;
		}

		sd = kzalloc(p_len, GFP_NOFS);
		if (!sd) {
			err = -ENOMEM;
			goto err_out;
		}
		memcpy(sd->encrypted_path, disk_link.name, disk_link.len);
		sd->len = cpu_to_le16(disk_link.len);
		p_str = (char *)sd;
	} else {
		p_len = len + 1;
		p_str = (char *)symname;
	}

	err = page_symlink(inode, p_str, p_len);

err_out:
404 405
	d_instantiate(dentry, inode);
	unlock_new_inode(inode);
J
Jaegeuk Kim 已提交
406

407 408 409 410 411 412 413 414 415
	/*
	 * Let's flush symlink data in order to avoid broken symlink as much as
	 * possible. Nevertheless, fsyncing is the best way, but there is no
	 * way to get a file descriptor in order to flush that.
	 *
	 * Note that, it needs to do dir->fsync to make this recoverable.
	 * If the symlink path is stored into inline_data, there is no
	 * performance regression.
	 */
416 417
	if (!err)
		filemap_write_and_wait_range(inode->i_mapping, 0, p_len - 1);
418

J
Jaegeuk Kim 已提交
419 420
	if (IS_DIRSYNC(dir))
		f2fs_sync_fs(sbi->sb, 1);
421 422 423

	kfree(sd);
	f2fs_fname_crypto_free_buffer(&disk_link);
424 425
	return err;
out:
426
	handle_failed_inode(inode);
427 428 429 430 431
	return err;
}

static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
432
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
433
	struct inode *inode;
434
	int err;
435

436 437
	f2fs_balance_fs(sbi);

438 439
	inode = f2fs_new_inode(dir, S_IFDIR | mode);
	if (IS_ERR(inode))
440
		return PTR_ERR(inode);
441 442 443 444

	inode->i_op = &f2fs_dir_inode_operations;
	inode->i_fop = &f2fs_dir_operations;
	inode->i_mapping->a_ops = &f2fs_dblock_aops;
445
	mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO);
446 447

	set_inode_flag(F2FS_I(inode), FI_INC_LINK);
448
	f2fs_lock_op(sbi);
449 450 451
	err = f2fs_add_link(dentry, inode);
	if (err)
		goto out_fail;
452
	f2fs_unlock_op(sbi);
453 454 455 456 457 458

	alloc_nid_done(sbi, inode->i_ino);

	d_instantiate(dentry, inode);
	unlock_new_inode(inode);

J
Jaegeuk Kim 已提交
459 460
	if (IS_DIRSYNC(dir))
		f2fs_sync_fs(sbi->sb, 1);
461 462 463 464
	return 0;

out_fail:
	clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
465
	handle_failed_inode(inode);
466 467 468 469 470
	return err;
}

static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
{
471
	struct inode *inode = d_inode(dentry);
472 473 474 475 476 477 478 479
	if (f2fs_empty_dir(inode))
		return f2fs_unlink(dir, dentry);
	return -ENOTEMPTY;
}

static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
				umode_t mode, dev_t rdev)
{
480
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
481 482 483 484 485 486
	struct inode *inode;
	int err = 0;

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

487 488
	f2fs_balance_fs(sbi);

489 490 491 492 493 494 495
	inode = f2fs_new_inode(dir, mode);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

	init_special_inode(inode, inode->i_mode, rdev);
	inode->i_op = &f2fs_special_inode_operations;

496
	f2fs_lock_op(sbi);
497 498 499
	err = f2fs_add_link(dentry, inode);
	if (err)
		goto out;
500
	f2fs_unlock_op(sbi);
501 502

	alloc_nid_done(sbi, inode->i_ino);
J
Jaegeuk Kim 已提交
503

504 505
	d_instantiate(dentry, inode);
	unlock_new_inode(inode);
J
Jaegeuk Kim 已提交
506 507 508

	if (IS_DIRSYNC(dir))
		f2fs_sync_fs(sbi->sb, 1);
509 510
	return 0;
out:
511
	handle_failed_inode(inode);
512 513 514
	return err;
}

C
Chao Yu 已提交
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
					umode_t mode, struct inode **whiteout)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
	struct inode *inode;
	int err;

	if (!whiteout)
		f2fs_balance_fs(sbi);

	inode = f2fs_new_inode(dir, mode);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

	if (whiteout) {
		init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
		inode->i_op = &f2fs_special_inode_operations;
	} else {
		inode->i_op = &f2fs_file_inode_operations;
		inode->i_fop = &f2fs_file_operations;
		inode->i_mapping->a_ops = &f2fs_dblock_aops;
	}

	f2fs_lock_op(sbi);
	err = acquire_orphan_inode(sbi);
	if (err)
		goto out;

	err = f2fs_do_tmpfile(inode, dir);
	if (err)
		goto release_out;

	/*
	 * add this non-linked tmpfile to orphan list, in this way we could
	 * remove all unused data of tmpfile after abnormal power-off.
	 */
	add_orphan_inode(sbi, inode->i_ino);
	f2fs_unlock_op(sbi);

	alloc_nid_done(sbi, inode->i_ino);

	if (whiteout) {
		inode_dec_link_count(inode);
		*whiteout = inode;
	} else {
		d_tmpfile(dentry, inode);
	}
	unlock_new_inode(inode);
	return 0;

release_out:
	release_orphan_inode(sbi);
out:
	handle_failed_inode(inode);
	return err;
}

static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
{
574 575 576 577 578 579
	if (f2fs_encrypted_inode(dir)) {
		int err = f2fs_get_encryption_info(dir);
		if (err)
			return err;
	}

C
Chao Yu 已提交
580 581 582 583 584 585 586 587
	return __f2fs_tmpfile(dir, dentry, mode, NULL);
}

static int f2fs_create_whiteout(struct inode *dir, struct inode **whiteout)
{
	return __f2fs_tmpfile(dir, NULL, S_IFCHR | WHITEOUT_MODE, whiteout);
}

588
static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
C
Chao Yu 已提交
589 590
			struct inode *new_dir, struct dentry *new_dentry,
			unsigned int flags)
591
{
592
	struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
593 594
	struct inode *old_inode = d_inode(old_dentry);
	struct inode *new_inode = d_inode(new_dentry);
C
Chao Yu 已提交
595
	struct inode *whiteout = NULL;
596
	struct page *old_dir_page;
C
Chao Yu 已提交
597
	struct page *old_page, *new_page = NULL;
598 599 600
	struct f2fs_dir_entry *old_dir_entry = NULL;
	struct f2fs_dir_entry *old_entry;
	struct f2fs_dir_entry *new_entry;
601
	int err = -ENOENT;
602

603 604 605 606 607 608 609
	if ((old_dir != new_dir) && f2fs_encrypted_inode(new_dir) &&
		!f2fs_is_child_context_consistent_with_parent(new_dir,
							old_inode)) {
		err = -EPERM;
		goto out;
	}

610 611
	f2fs_balance_fs(sbi);

612 613 614 615 616 617 618 619 620 621 622
	old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
	if (!old_entry)
		goto out;

	if (S_ISDIR(old_inode->i_mode)) {
		err = -EIO;
		old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
		if (!old_dir_entry)
			goto out_old;
	}

C
Chao Yu 已提交
623 624 625 626 627 628
	if (flags & RENAME_WHITEOUT) {
		err = f2fs_create_whiteout(old_dir, &whiteout);
		if (err)
			goto out_dir;
	}

629 630 631 632
	if (new_inode) {

		err = -ENOTEMPTY;
		if (old_dir_entry && !f2fs_empty_dir(new_inode))
C
Chao Yu 已提交
633
			goto out_whiteout;
634 635 636 637 638

		err = -ENOENT;
		new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
						&new_page);
		if (!new_entry)
C
Chao Yu 已提交
639
			goto out_whiteout;
640

641 642
		f2fs_lock_op(sbi);

J
Jaegeuk Kim 已提交
643 644 645 646
		err = acquire_orphan_inode(sbi);
		if (err)
			goto put_out_dir;

647 648
		if (update_dent_inode(old_inode, new_inode,
						&new_dentry->d_name)) {
J
Jaegeuk Kim 已提交
649 650
			release_orphan_inode(sbi);
			goto put_out_dir;
651 652
		}

653 654 655
		f2fs_set_link(new_dir, new_entry, new_page, old_inode);

		new_inode->i_ctime = CURRENT_TIME;
656
		down_write(&F2FS_I(new_inode)->i_sem);
657 658 659
		if (old_dir_entry)
			drop_nlink(new_inode);
		drop_nlink(new_inode);
660 661
		up_write(&F2FS_I(new_inode)->i_sem);

662
		mark_inode_dirty(new_inode);
J
Jaegeuk Kim 已提交
663

664 665
		if (!new_inode->i_nlink)
			add_orphan_inode(sbi, new_inode->i_ino);
J
Jaegeuk Kim 已提交
666 667 668
		else
			release_orphan_inode(sbi);

669
		update_inode_page(old_inode);
670
		update_inode_page(new_inode);
671
	} else {
672 673
		f2fs_lock_op(sbi);

674
		err = f2fs_add_link(new_dentry, old_inode);
675 676
		if (err) {
			f2fs_unlock_op(sbi);
C
Chao Yu 已提交
677
			goto out_whiteout;
678
		}
679 680 681

		if (old_dir_entry) {
			inc_nlink(new_dir);
682
			update_inode_page(new_dir);
683 684 685
		}
	}

686 687
	down_write(&F2FS_I(old_inode)->i_sem);
	file_lost_pino(old_inode);
688 689
	if (new_inode && file_enc_name(new_inode))
		file_set_enc_name(old_inode);
690 691
	up_write(&F2FS_I(old_inode)->i_sem);

692 693 694
	old_inode->i_ctime = CURRENT_TIME;
	mark_inode_dirty(old_inode);

695
	f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
696

C
Chao Yu 已提交
697 698 699 700 701 702 703 704 705 706
	if (whiteout) {
		whiteout->i_state |= I_LINKABLE;
		set_inode_flag(F2FS_I(whiteout), FI_INC_LINK);
		err = f2fs_add_link(old_dentry, whiteout);
		if (err)
			goto put_out_dir;
		whiteout->i_state &= ~I_LINKABLE;
		iput(whiteout);
	}

707
	if (old_dir_entry) {
C
Chao Yu 已提交
708
		if (old_dir != new_dir && !whiteout) {
709 710
			f2fs_set_link(old_inode, old_dir_entry,
						old_dir_page, new_dir);
711
			update_inode_page(old_inode);
712
		} else {
713
			f2fs_dentry_kunmap(old_inode, old_dir_page);
714 715 716
			f2fs_put_page(old_dir_page, 0);
		}
		drop_nlink(old_dir);
717
		mark_inode_dirty(old_dir);
718
		update_inode_page(old_dir);
719 720
	}

721
	f2fs_unlock_op(sbi);
J
Jaegeuk Kim 已提交
722 723 724

	if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
		f2fs_sync_fs(sbi->sb, 1);
725 726
	return 0;

J
Jaegeuk Kim 已提交
727
put_out_dir:
728
	f2fs_unlock_op(sbi);
C
Chao Yu 已提交
729 730 731 732 733 734 735
	if (new_page) {
		f2fs_dentry_kunmap(new_dir, new_page);
		f2fs_put_page(new_page, 0);
	}
out_whiteout:
	if (whiteout)
		iput(whiteout);
736 737
out_dir:
	if (old_dir_entry) {
738
		f2fs_dentry_kunmap(old_inode, old_dir_page);
739 740 741
		f2fs_put_page(old_dir_page, 0);
	}
out_old:
742
	f2fs_dentry_kunmap(old_dir, old_page);
743 744 745 746 747
	f2fs_put_page(old_page, 0);
out:
	return err;
}

C
Chao Yu 已提交
748 749 750
static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
			     struct inode *new_dir, struct dentry *new_dentry)
{
751
	struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
752 753
	struct inode *old_inode = d_inode(old_dentry);
	struct inode *new_inode = d_inode(new_dentry);
C
Chao Yu 已提交
754 755 756 757 758 759 760
	struct page *old_dir_page, *new_dir_page;
	struct page *old_page, *new_page;
	struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
	struct f2fs_dir_entry *old_entry, *new_entry;
	int old_nlink = 0, new_nlink = 0;
	int err = -ENOENT;

761 762 763 764 765 766 767 768
	if ((f2fs_encrypted_inode(old_dir) || f2fs_encrypted_inode(new_dir)) &&
		(old_dir != new_dir) &&
		(!f2fs_is_child_context_consistent_with_parent(new_dir,
								old_inode) ||
		!f2fs_is_child_context_consistent_with_parent(old_dir,
								new_inode)))
		return -EPERM;

C
Chao Yu 已提交
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
	f2fs_balance_fs(sbi);

	old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
	if (!old_entry)
		goto out;

	new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);
	if (!new_entry)
		goto out_old;

	/* prepare for updating ".." directory entry info later */
	if (old_dir != new_dir) {
		if (S_ISDIR(old_inode->i_mode)) {
			err = -EIO;
			old_dir_entry = f2fs_parent_dir(old_inode,
							&old_dir_page);
			if (!old_dir_entry)
				goto out_new;
		}

		if (S_ISDIR(new_inode->i_mode)) {
			err = -EIO;
			new_dir_entry = f2fs_parent_dir(new_inode,
							&new_dir_page);
			if (!new_dir_entry)
				goto out_old_dir;
		}
	}

	/*
	 * If cross rename between file and directory those are not
	 * in the same directory, we will inc nlink of file's parent
	 * later, so we should check upper boundary of its nlink.
	 */
	if ((!old_dir_entry || !new_dir_entry) &&
				old_dir_entry != new_dir_entry) {
		old_nlink = old_dir_entry ? -1 : 1;
		new_nlink = -old_nlink;
		err = -EMLINK;
		if ((old_nlink > 0 && old_inode->i_nlink >= F2FS_LINK_MAX) ||
			(new_nlink > 0 && new_inode->i_nlink >= F2FS_LINK_MAX))
			goto out_new_dir;
	}

	f2fs_lock_op(sbi);

815
	err = update_dent_inode(old_inode, new_inode, &new_dentry->d_name);
C
Chao Yu 已提交
816 817
	if (err)
		goto out_unlock;
818 819
	if (file_enc_name(new_inode))
		file_set_enc_name(old_inode);
C
Chao Yu 已提交
820

821
	err = update_dent_inode(new_inode, old_inode, &old_dentry->d_name);
C
Chao Yu 已提交
822 823
	if (err)
		goto out_undo;
824 825
	if (file_enc_name(old_inode))
		file_set_enc_name(new_inode);
C
Chao Yu 已提交
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877

	/* update ".." directory entry info of old dentry */
	if (old_dir_entry)
		f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);

	/* update ".." directory entry info of new dentry */
	if (new_dir_entry)
		f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);

	/* update directory entry info of old dir inode */
	f2fs_set_link(old_dir, old_entry, old_page, new_inode);

	down_write(&F2FS_I(old_inode)->i_sem);
	file_lost_pino(old_inode);
	up_write(&F2FS_I(old_inode)->i_sem);

	update_inode_page(old_inode);

	old_dir->i_ctime = CURRENT_TIME;
	if (old_nlink) {
		down_write(&F2FS_I(old_dir)->i_sem);
		if (old_nlink < 0)
			drop_nlink(old_dir);
		else
			inc_nlink(old_dir);
		up_write(&F2FS_I(old_dir)->i_sem);
	}
	mark_inode_dirty(old_dir);
	update_inode_page(old_dir);

	/* update directory entry info of new dir inode */
	f2fs_set_link(new_dir, new_entry, new_page, old_inode);

	down_write(&F2FS_I(new_inode)->i_sem);
	file_lost_pino(new_inode);
	up_write(&F2FS_I(new_inode)->i_sem);

	update_inode_page(new_inode);

	new_dir->i_ctime = CURRENT_TIME;
	if (new_nlink) {
		down_write(&F2FS_I(new_dir)->i_sem);
		if (new_nlink < 0)
			drop_nlink(new_dir);
		else
			inc_nlink(new_dir);
		up_write(&F2FS_I(new_dir)->i_sem);
	}
	mark_inode_dirty(new_dir);
	update_inode_page(new_dir);

	f2fs_unlock_op(sbi);
J
Jaegeuk Kim 已提交
878 879 880

	if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
		f2fs_sync_fs(sbi->sb, 1);
C
Chao Yu 已提交
881 882
	return 0;
out_undo:
883 884 885 886 887
	/*
	 * Still we may fail to recover name info of f2fs_inode here
	 * Drop it, once its name is set as encrypted
	 */
	update_dent_inode(old_inode, old_inode, &old_dentry->d_name);
C
Chao Yu 已提交
888 889 890 891
out_unlock:
	f2fs_unlock_op(sbi);
out_new_dir:
	if (new_dir_entry) {
892
		f2fs_dentry_kunmap(new_inode, new_dir_page);
C
Chao Yu 已提交
893 894 895 896
		f2fs_put_page(new_dir_page, 0);
	}
out_old_dir:
	if (old_dir_entry) {
897
		f2fs_dentry_kunmap(old_inode, old_dir_page);
C
Chao Yu 已提交
898 899 900
		f2fs_put_page(old_dir_page, 0);
	}
out_new:
901
	f2fs_dentry_kunmap(new_dir, new_page);
C
Chao Yu 已提交
902 903
	f2fs_put_page(new_page, 0);
out_old:
904
	f2fs_dentry_kunmap(old_dir, old_page);
C
Chao Yu 已提交
905 906 907 908 909 910 911 912 913
	f2fs_put_page(old_page, 0);
out:
	return err;
}

static int f2fs_rename2(struct inode *old_dir, struct dentry *old_dentry,
			struct inode *new_dir, struct dentry *new_dentry,
			unsigned int flags)
{
C
Chao Yu 已提交
914
	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
C
Chao Yu 已提交
915 916 917 918 919 920 921 922 923 924
		return -EINVAL;

	if (flags & RENAME_EXCHANGE) {
		return f2fs_cross_rename(old_dir, old_dentry,
					 new_dir, new_dentry);
	}
	/*
	 * VFS has already handled the new dentry existence case,
	 * here, we just deal with "RENAME_NOREPLACE" as regular rename.
	 */
C
Chao Yu 已提交
925
	return f2fs_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
C
Chao Yu 已提交
926 927
}

928
#ifdef CONFIG_F2FS_FS_ENCRYPTION
929
static const char *f2fs_encrypted_follow_link(struct dentry *dentry, void **cookie)
C
Chao Yu 已提交
930
{
931 932 933 934 935 936 937 938 939 940
	struct page *cpage = NULL;
	char *caddr, *paddr = NULL;
	struct f2fs_str cstr;
	struct f2fs_str pstr = FSTR_INIT(NULL, 0);
	struct inode *inode = d_inode(dentry);
	struct f2fs_encrypted_symlink_data *sd;
	loff_t size = min_t(loff_t, i_size_read(inode), PAGE_SIZE - 1);
	u32 max_size = inode->i_sb->s_blocksize;
	int res;

941
	res = f2fs_get_encryption_info(inode);
942 943 944 945 946
	if (res)
		return ERR_PTR(res);

	cpage = read_mapping_page(inode->i_mapping, 0, NULL);
	if (IS_ERR(cpage))
947
		return ERR_CAST(cpage);
948 949 950 951 952 953 954 955 956 957 958 959 960
	caddr = kmap(cpage);
	caddr[size] = 0;

	/* Symlink is encrypted */
	sd = (struct f2fs_encrypted_symlink_data *)caddr;
	cstr.name = sd->encrypted_path;
	cstr.len = le16_to_cpu(sd->len);

	/* this is broken symlink case */
	if (cstr.name[0] == 0 && cstr.len == 0) {
		res = -ENOENT;
		goto errout;
	}
961

962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
	if ((cstr.len + sizeof(struct f2fs_encrypted_symlink_data) - 1) >
								max_size) {
		/* Symlink data on the disk is corrupted */
		res = -EIO;
		goto errout;
	}
	res = f2fs_fname_crypto_alloc_buffer(inode, cstr.len, &pstr);
	if (res)
		goto errout;

	res = f2fs_fname_disk_to_usr(inode, NULL, &cstr, &pstr);
	if (res < 0)
		goto errout;

	paddr = pstr.name;

	/* Null-terminate the name */
	paddr[res] = '\0';

	kunmap(cpage);
	page_cache_release(cpage);
983
	return *cookie = paddr;
984 985 986 987 988
errout:
	f2fs_fname_crypto_free_buffer(&pstr);
	kunmap(cpage);
	page_cache_release(cpage);
	return ERR_PTR(res);
C
Chao Yu 已提交
989 990
}

991 992 993 994 995 996 997 998 999 1000 1001 1002 1003
const struct inode_operations f2fs_encrypted_symlink_inode_operations = {
	.readlink       = generic_readlink,
	.follow_link    = f2fs_encrypted_follow_link,
	.put_link       = kfree_put_link,
	.getattr	= f2fs_getattr,
	.setattr	= f2fs_setattr,
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= f2fs_listxattr,
	.removexattr	= generic_removexattr,
};
#endif

1004 1005 1006 1007 1008 1009 1010 1011 1012
const struct inode_operations f2fs_dir_inode_operations = {
	.create		= f2fs_create,
	.lookup		= f2fs_lookup,
	.link		= f2fs_link,
	.unlink		= f2fs_unlink,
	.symlink	= f2fs_symlink,
	.mkdir		= f2fs_mkdir,
	.rmdir		= f2fs_rmdir,
	.mknod		= f2fs_mknod,
C
Chao Yu 已提交
1013
	.rename2	= f2fs_rename2,
C
Chao Yu 已提交
1014
	.tmpfile	= f2fs_tmpfile,
1015
	.getattr	= f2fs_getattr,
1016 1017
	.setattr	= f2fs_setattr,
	.get_acl	= f2fs_get_acl,
1018
	.set_acl	= f2fs_set_acl,
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
#ifdef CONFIG_F2FS_FS_XATTR
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= f2fs_listxattr,
	.removexattr	= generic_removexattr,
#endif
};

const struct inode_operations f2fs_symlink_inode_operations = {
	.readlink       = generic_readlink,
1029
	.follow_link    = f2fs_follow_link,
1030
	.put_link       = page_put_link,
1031
	.getattr	= f2fs_getattr,
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
	.setattr	= f2fs_setattr,
#ifdef CONFIG_F2FS_FS_XATTR
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= f2fs_listxattr,
	.removexattr	= generic_removexattr,
#endif
};

const struct inode_operations f2fs_special_inode_operations = {
1042
	.getattr	= f2fs_getattr,
1043 1044
	.setattr        = f2fs_setattr,
	.get_acl	= f2fs_get_acl,
1045
	.set_acl	= f2fs_set_acl,
1046 1047 1048 1049 1050 1051 1052
#ifdef CONFIG_F2FS_FS_XATTR
	.setxattr       = generic_setxattr,
	.getxattr       = generic_getxattr,
	.listxattr	= f2fs_listxattr,
	.removexattr    = generic_removexattr,
#endif
};