file.c 65.9 KB
Newer Older
1
/*
J
Jaegeuk Kim 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15
 * fs/f2fs/file.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/stat.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
16
#include <linux/blkdev.h>
J
Jaegeuk Kim 已提交
17 18
#include <linux/falloc.h>
#include <linux/types.h>
19
#include <linux/compat.h>
J
Jaegeuk Kim 已提交
20 21
#include <linux/uaccess.h>
#include <linux/mount.h>
22
#include <linux/pagevec.h>
23
#include <linux/uio.h>
24
#include <linux/uuid.h>
25
#include <linux/file.h>
J
Jaegeuk Kim 已提交
26 27 28 29 30 31

#include "f2fs.h"
#include "node.h"
#include "segment.h"
#include "xattr.h"
#include "acl.h"
32
#include "gc.h"
33
#include "trace.h"
34
#include <trace/events/f2fs.h>
J
Jaegeuk Kim 已提交
35

36 37 38 39 40 41 42 43 44 45 46 47
static int f2fs_filemap_fault(struct vm_fault *vmf)
{
	struct inode *inode = file_inode(vmf->vma->vm_file);
	int err;

	down_read(&F2FS_I(inode)->i_mmap_sem);
	err = filemap_fault(vmf);
	up_read(&F2FS_I(inode)->i_mmap_sem);

	return err;
}

48
static int f2fs_vm_page_mkwrite(struct vm_fault *vmf)
J
Jaegeuk Kim 已提交
49 50
{
	struct page *page = vmf->page;
51
	struct inode *inode = file_inode(vmf->vma->vm_file);
52
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
J
Jaegeuk Kim 已提交
53
	struct dnode_of_data dn;
54
	int err;
J
Jaegeuk Kim 已提交
55

56 57 58 59 60
	if (unlikely(f2fs_cp_error(sbi))) {
		err = -EIO;
		goto err;
	}

J
Jaegeuk Kim 已提交
61
	sb_start_pagefault(inode->i_sb);
62 63

	f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
64

J
Jaegeuk Kim 已提交
65
	/* block allocation */
66
	f2fs_lock_op(sbi);
67
	set_new_dnode(&dn, inode, NULL, NULL, 0);
68
	err = f2fs_reserve_block(&dn, page->index);
69 70
	if (err) {
		f2fs_unlock_op(sbi);
71
		goto out;
72 73 74
	}
	f2fs_put_dnode(&dn);
	f2fs_unlock_op(sbi);
J
Jaegeuk Kim 已提交
75

76
	f2fs_balance_fs(sbi, dn.node_changed);
77

78
	file_update_time(vmf->vma->vm_file);
79
	down_read(&F2FS_I(inode)->i_mmap_sem);
J
Jaegeuk Kim 已提交
80
	lock_page(page);
81
	if (unlikely(page->mapping != inode->i_mapping ||
82
			page_offset(page) > i_size_read(inode) ||
83
			!PageUptodate(page))) {
J
Jaegeuk Kim 已提交
84 85
		unlock_page(page);
		err = -EFAULT;
86
		goto out_sem;
J
Jaegeuk Kim 已提交
87 88 89 90 91 92
	}

	/*
	 * check to see if the page is mapped already (no holes)
	 */
	if (PageMappedToDisk(page))
93
		goto mapped;
J
Jaegeuk Kim 已提交
94 95

	/* page is wholly or partially inside EOF */
96
	if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
97
						i_size_read(inode)) {
J
Jaegeuk Kim 已提交
98
		unsigned offset;
99 100
		offset = i_size_read(inode) & ~PAGE_MASK;
		zero_user_segment(page, offset, PAGE_SIZE);
J
Jaegeuk Kim 已提交
101 102
	}
	set_page_dirty(page);
103 104
	if (!PageUptodate(page))
		SetPageUptodate(page);
J
Jaegeuk Kim 已提交
105

C
Chao Yu 已提交
106 107
	f2fs_update_iostat(sbi, APP_MAPPED_IO, F2FS_BLKSIZE);

108
	trace_f2fs_vm_page_mkwrite(page, DATA);
109 110
mapped:
	/* fill the page */
111
	f2fs_wait_on_page_writeback(page, DATA, false);
112 113

	/* wait for GCed encrypted page writeback */
114
	if (f2fs_encrypted_file(inode))
115
		f2fs_wait_on_block_writeback(sbi, dn.data_blkaddr);
116

117 118
out_sem:
	up_read(&F2FS_I(inode)->i_mmap_sem);
J
Jaegeuk Kim 已提交
119 120
out:
	sb_end_pagefault(inode->i_sb);
121
	f2fs_update_time(sbi, REQ_TIME);
122
err:
J
Jaegeuk Kim 已提交
123 124 125 126
	return block_page_mkwrite_return(err);
}

static const struct vm_operations_struct f2fs_file_vm_ops = {
127
	.fault		= f2fs_filemap_fault,
128
	.map_pages	= filemap_map_pages,
129
	.page_mkwrite	= f2fs_vm_page_mkwrite,
J
Jaegeuk Kim 已提交
130 131
};

132 133 134 135 136 137 138 139 140 141
static int get_parent_ino(struct inode *inode, nid_t *pino)
{
	struct dentry *dentry;

	inode = igrab(inode);
	dentry = d_find_any_alias(inode);
	iput(inode);
	if (!dentry)
		return 0;

142 143
	*pino = parent_ino(dentry);
	dput(dentry);
144 145 146
	return 1;
}

147
static inline enum cp_reason_type need_do_checkpoint(struct inode *inode)
148
{
149
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
150
	enum cp_reason_type cp_reason = CP_NO_NEEDED;
151

152 153 154 155
	if (!S_ISREG(inode->i_mode))
		cp_reason = CP_NON_REGULAR;
	else if (inode->i_nlink != 1)
		cp_reason = CP_HARDLINK;
156
	else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
157
		cp_reason = CP_SB_NEED_CP;
158
	else if (file_wrong_pino(inode))
159
		cp_reason = CP_WRONG_PINO;
160
	else if (!space_for_roll_forward(sbi))
161
		cp_reason = CP_NO_SPC_ROLL;
162
	else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
163
		cp_reason = CP_NODE_NEED_CP;
164
	else if (test_opt(sbi, FASTBOOT))
165
		cp_reason = CP_FASTBOOT_MODE;
166
	else if (sbi->active_logs == 2)
167
		cp_reason = CP_SPEC_LOG_NUM;
168

169
	return cp_reason;
170 171
}

172 173 174 175 176 177 178 179 180 181 182
static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
{
	struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
	bool ret = false;
	/* But we need to avoid that there are some inode updates */
	if ((i && PageDirty(i)) || need_inode_block_update(sbi, ino))
		ret = true;
	f2fs_put_page(i, 0);
	return ret;
}

183 184 185 186 187 188 189 190
static void try_to_fix_pino(struct inode *inode)
{
	struct f2fs_inode_info *fi = F2FS_I(inode);
	nid_t pino;

	down_write(&fi->i_sem);
	if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
			get_parent_ino(inode, &pino)) {
191
		f2fs_i_pino_write(inode, pino);
192 193
		file_got_pino(inode);
	}
194
	up_write(&fi->i_sem);
195 196
}

197 198
static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
						int datasync, bool atomic)
J
Jaegeuk Kim 已提交
199 200
{
	struct inode *inode = file->f_mapping->host;
201
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
202
	nid_t ino = inode->i_ino;
J
Jaegeuk Kim 已提交
203
	int ret = 0;
204
	enum cp_reason_type cp_reason = 0;
J
Jaegeuk Kim 已提交
205
	struct writeback_control wbc = {
206
		.sync_mode = WB_SYNC_ALL,
J
Jaegeuk Kim 已提交
207 208 209 210
		.nr_to_write = LONG_MAX,
		.for_reclaim = 0,
	};

211
	if (unlikely(f2fs_readonly(inode->i_sb)))
212 213
		return 0;

214
	trace_f2fs_sync_file_enter(inode);
215 216

	/* if fdatasync is triggered, let's do in-place-update */
217
	if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
218
		set_inode_flag(inode, FI_NEED_IPU);
219
	ret = file_write_and_wait_range(file, start, end);
220
	clear_inode_flag(inode, FI_NEED_IPU);
221

222
	if (ret) {
223
		trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
J
Jaegeuk Kim 已提交
224
		return ret;
225
	}
J
Jaegeuk Kim 已提交
226

227
	/* if the inode is dirty, let's recover all the time */
C
Chao Yu 已提交
228
	if (!f2fs_skip_inode_update(inode, datasync)) {
229
		f2fs_write_inode(inode, NULL);
230 231 232
		goto go_write;
	}

233 234 235
	/*
	 * if there is no written data, don't waste time to write recovery info.
	 */
236
	if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
237
			!exist_written_data(sbi, ino, APPEND_INO)) {
238

239 240
		/* it may call write_inode just prior to fsync */
		if (need_inode_page_update(sbi, ino))
241 242
			goto go_write;

243
		if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
244
				exist_written_data(sbi, ino, UPDATE_INO))
245 246 247
			goto flush_out;
		goto out;
	}
248
go_write:
249 250 251 252
	/*
	 * Both of fdatasync() and fsync() are able to be recovered from
	 * sudden-power-off.
	 */
253
	down_read(&F2FS_I(inode)->i_sem);
254
	cp_reason = need_do_checkpoint(inode);
255
	up_read(&F2FS_I(inode)->i_sem);
256

257
	if (cp_reason) {
J
Jaegeuk Kim 已提交
258 259
		/* all the dirty node pages should be flushed for POR */
		ret = f2fs_sync_fs(inode->i_sb, 1);
260

261 262 263 264 265
		/*
		 * We've secured consistency through sync_fs. Following pino
		 * will be used only for fsynced inodes after checkpoint.
		 */
		try_to_fix_pino(inode);
266 267
		clear_inode_flag(inode, FI_APPEND_WRITE);
		clear_inode_flag(inode, FI_UPDATE_WRITE);
268 269
		goto out;
	}
270
sync_nodes:
271
	ret = fsync_node_pages(sbi, inode, &wbc, atomic);
272 273
	if (ret)
		goto out;
274

275
	/* if cp_error was enabled, we should avoid infinite loop */
276 277
	if (unlikely(f2fs_cp_error(sbi))) {
		ret = -EIO;
278
		goto out;
279
	}
280

281
	if (need_inode_block_update(sbi, ino)) {
282
		f2fs_mark_inode_dirty_sync(inode, true);
283 284
		f2fs_write_inode(inode, NULL);
		goto sync_nodes;
J
Jaegeuk Kim 已提交
285
	}
286

287 288 289 290 291 292 293 294 295 296 297 298 299
	/*
	 * If it's atomic_write, it's just fine to keep write ordering. So
	 * here we don't need to wait for node write completion, since we use
	 * node chain which serializes node blocks. If one of node writes are
	 * reordered, we can see simply broken chain, resulting in stopping
	 * roll-forward recovery. It means we'll recover all or none node blocks
	 * given fsync mark.
	 */
	if (!atomic) {
		ret = wait_on_node_pages_writeback(sbi, ino);
		if (ret)
			goto out;
	}
300 301

	/* once recovery info is written, don't need to tack this */
302
	remove_ino_entry(sbi, ino, APPEND_INO);
303
	clear_inode_flag(inode, FI_APPEND_WRITE);
304
flush_out:
305
	if (!atomic)
306
		ret = f2fs_issue_flush(sbi, inode->i_ino);
307 308 309
	if (!ret) {
		remove_ino_entry(sbi, ino, UPDATE_INO);
		clear_inode_flag(inode, FI_UPDATE_WRITE);
310
		remove_ino_entry(sbi, ino, FLUSH_INO);
311
	}
312
	f2fs_update_time(sbi, REQ_TIME);
J
Jaegeuk Kim 已提交
313
out:
314
	trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
315
	f2fs_trace_ios(NULL, 1);
J
Jaegeuk Kim 已提交
316 317 318
	return ret;
}

319 320
int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
{
321 322
	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
		return -EIO;
323 324 325
	return f2fs_do_sync_file(file, start, end, datasync, false);
}

326 327 328
static pgoff_t __get_first_dirty_index(struct address_space *mapping,
						pgoff_t pgofs, int whence)
{
329
	struct page *page;
330 331 332 333 334 335
	int nr_pages;

	if (whence != SEEK_DATA)
		return 0;

	/* find first dirty page index */
336 337 338 339 340 341
	nr_pages = find_get_pages_tag(mapping, &pgofs, PAGECACHE_TAG_DIRTY,
				      1, &page);
	if (!nr_pages)
		return ULONG_MAX;
	pgofs = page->index;
	put_page(page);
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
	return pgofs;
}

static bool __found_offset(block_t blkaddr, pgoff_t dirty, pgoff_t pgofs,
							int whence)
{
	switch (whence) {
	case SEEK_DATA:
		if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
			(blkaddr != NEW_ADDR && blkaddr != NULL_ADDR))
			return true;
		break;
	case SEEK_HOLE:
		if (blkaddr == NULL_ADDR)
			return true;
		break;
	}
	return false;
}

362 363 364 365 366
static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
{
	struct inode *inode = file->f_mapping->host;
	loff_t maxbytes = inode->i_sb->s_maxbytes;
	struct dnode_of_data dn;
367 368 369
	pgoff_t pgofs, end_offset, dirty;
	loff_t data_ofs = offset;
	loff_t isize;
370 371
	int err = 0;

A
Al Viro 已提交
372
	inode_lock(inode);
373 374 375 376 377 378

	isize = i_size_read(inode);
	if (offset >= isize)
		goto fail;

	/* handle inline data case */
379
	if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
380 381 382 383 384
		if (whence == SEEK_HOLE)
			data_ofs = isize;
		goto found;
	}

385
	pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
386

387 388
	dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);

389
	for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
390
		set_new_dnode(&dn, inode, NULL, NULL, 0);
391
		err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
392 393 394
		if (err && err != -ENOENT) {
			goto fail;
		} else if (err == -ENOENT) {
A
arter97 已提交
395
			/* direct node does not exists */
396
			if (whence == SEEK_DATA) {
397
				pgofs = get_next_page_offset(&dn, pgofs);
398 399 400 401 402 403
				continue;
			} else {
				goto found;
			}
		}

404
		end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
405 406 407 408

		/* find data/hole in dnode block */
		for (; dn.ofs_in_node < end_offset;
				dn.ofs_in_node++, pgofs++,
409
				data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
410
			block_t blkaddr;
411 412
			blkaddr = datablock_addr(dn.inode,
					dn.node_page, dn.ofs_in_node);
413

414
			if (__found_offset(blkaddr, dirty, pgofs, whence)) {
415 416 417 418 419 420 421 422 423 424
				f2fs_put_dnode(&dn);
				goto found;
			}
		}
		f2fs_put_dnode(&dn);
	}

	if (whence == SEEK_DATA)
		goto fail;
found:
425 426
	if (whence == SEEK_HOLE && data_ofs > isize)
		data_ofs = isize;
A
Al Viro 已提交
427
	inode_unlock(inode);
428 429
	return vfs_setpos(file, data_ofs, maxbytes);
fail:
A
Al Viro 已提交
430
	inode_unlock(inode);
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
	return -ENXIO;
}

static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
{
	struct inode *inode = file->f_mapping->host;
	loff_t maxbytes = inode->i_sb->s_maxbytes;

	switch (whence) {
	case SEEK_SET:
	case SEEK_CUR:
	case SEEK_END:
		return generic_file_llseek_size(file, offset, whence,
						maxbytes, i_size_read(inode));
	case SEEK_DATA:
	case SEEK_HOLE:
447 448
		if (offset < 0)
			return -ENXIO;
449 450 451 452 453 454
		return f2fs_seek_block(file, offset, whence);
	}

	return -EINVAL;
}

J
Jaegeuk Kim 已提交
455 456
static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
457
	struct inode *inode = file_inode(file);
458
	int err;
459

460 461 462
	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
		return -EIO;

463
	/* we don't need to use inline_data strictly */
464 465 466
	err = f2fs_convert_inline_inode(inode);
	if (err)
		return err;
467

J
Jaegeuk Kim 已提交
468 469 470 471 472
	file_accessed(file);
	vma->vm_ops = &f2fs_file_vm_ops;
	return 0;
}

473 474
static int f2fs_file_open(struct inode *inode, struct file *filp)
{
475
	struct dentry *dir;
476

477 478
	if (f2fs_encrypted_inode(inode)) {
		int ret = fscrypt_get_encryption_info(inode);
479
		if (ret)
480
			return -EACCES;
481
		if (!fscrypt_has_encryption_key(inode))
482
			return -ENOKEY;
483
	}
484 485 486 487
	dir = dget_parent(file_dentry(filp));
	if (f2fs_encrypted_inode(d_inode(dir)) &&
			!fscrypt_has_permitted_context(d_inode(dir), inode)) {
		dput(dir);
488
		return -EPERM;
489 490
	}
	dput(dir);
491
	return dquot_file_open(inode, filp);
492 493
}

494
int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
J
Jaegeuk Kim 已提交
495
{
496
	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
J
Jaegeuk Kim 已提交
497
	struct f2fs_node *raw_node;
498
	int nr_free = 0, ofs = dn->ofs_in_node, len = count;
J
Jaegeuk Kim 已提交
499
	__le32 *addr;
500 501 502 503
	int base = 0;

	if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
		base = get_extra_isize(dn->inode);
J
Jaegeuk Kim 已提交
504

505
	raw_node = F2FS_NODE(dn->node_page);
506
	addr = blkaddr_in_node(raw_node) + base + ofs;
J
Jaegeuk Kim 已提交
507

508
	for (; count > 0; count--, addr++, dn->ofs_in_node++) {
J
Jaegeuk Kim 已提交
509 510 511 512
		block_t blkaddr = le32_to_cpu(*addr);
		if (blkaddr == NULL_ADDR)
			continue;

513
		dn->data_blkaddr = NULL_ADDR;
514
		set_data_blkaddr(dn);
J
Jaegeuk Kim 已提交
515
		invalidate_blocks(sbi, blkaddr);
516
		if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
517
			clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
J
Jaegeuk Kim 已提交
518 519
		nr_free++;
	}
520

J
Jaegeuk Kim 已提交
521
	if (nr_free) {
522 523 524 525 526 527
		pgoff_t fofs;
		/*
		 * once we invalidate valid blkaddr in range [ofs, ofs + count],
		 * we will invalidate all blkaddr in the whole range.
		 */
		fofs = start_bidx_of_node(ofs_of_node(dn->node_page),
528
							dn->inode) + ofs;
529
		f2fs_update_extent_cache_range(dn, fofs, 0, len);
530
		dec_valid_block_count(sbi, dn->inode, nr_free);
J
Jaegeuk Kim 已提交
531 532
	}
	dn->ofs_in_node = ofs;
533

534
	f2fs_update_time(sbi, REQ_TIME);
535 536
	trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
					 dn->ofs_in_node, nr_free);
J
Jaegeuk Kim 已提交
537 538 539 540 541 542 543 544
	return nr_free;
}

void truncate_data_blocks(struct dnode_of_data *dn)
{
	truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
}

545
static int truncate_partial_data_page(struct inode *inode, u64 from,
546
								bool cache_only)
J
Jaegeuk Kim 已提交
547
{
548 549
	unsigned offset = from & (PAGE_SIZE - 1);
	pgoff_t index = from >> PAGE_SHIFT;
550
	struct address_space *mapping = inode->i_mapping;
J
Jaegeuk Kim 已提交
551 552
	struct page *page;

553
	if (!offset && !cache_only)
554
		return 0;
J
Jaegeuk Kim 已提交
555

556
	if (cache_only) {
557
		page = find_lock_page(mapping, index);
558 559 560
		if (page && PageUptodate(page))
			goto truncate_out;
		f2fs_put_page(page, 1);
561
		return 0;
562
	}
J
Jaegeuk Kim 已提交
563

564
	page = get_lock_data_page(inode, index, true);
565
	if (IS_ERR(page))
566
		return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
567
truncate_out:
568
	f2fs_wait_on_page_writeback(page, DATA, true);
569
	zero_user(page, offset, PAGE_SIZE - offset);
570 571 572 573

	/* An encrypted inode should have a key and truncate the last page. */
	f2fs_bug_on(F2FS_I_SB(inode), cache_only && f2fs_encrypted_inode(inode));
	if (!cache_only)
574
		set_page_dirty(page);
J
Jaegeuk Kim 已提交
575
	f2fs_put_page(page, 1);
576
	return 0;
J
Jaegeuk Kim 已提交
577 578
}

579
int truncate_blocks(struct inode *inode, u64 from, bool lock)
J
Jaegeuk Kim 已提交
580
{
581
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
J
Jaegeuk Kim 已提交
582 583 584
	unsigned int blocksize = inode->i_sb->s_blocksize;
	struct dnode_of_data dn;
	pgoff_t free_from;
585
	int count = 0, err = 0;
586
	struct page *ipage;
587
	bool truncate_page = false;
J
Jaegeuk Kim 已提交
588

589 590
	trace_f2fs_truncate_blocks_enter(inode, from);

591
	free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1);
J
Jaegeuk Kim 已提交
592

593 594 595
	if (free_from >= sbi->max_file_blocks)
		goto free_partial;

596 597
	if (lock)
		f2fs_lock_op(sbi);
598

599 600 601 602 603 604 605
	ipage = get_node_page(sbi, inode->i_ino);
	if (IS_ERR(ipage)) {
		err = PTR_ERR(ipage);
		goto out;
	}

	if (f2fs_has_inline_data(inode)) {
606
		truncate_inline_inode(inode, ipage, from);
607
		f2fs_put_page(ipage, 1);
608
		truncate_page = true;
609 610 611 612
		goto out;
	}

	set_new_dnode(&dn, inode, ipage, NULL, 0);
613
	err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
J
Jaegeuk Kim 已提交
614 615 616
	if (err) {
		if (err == -ENOENT)
			goto free_next;
617
		goto out;
618 619
	}

620
	count = ADDRS_PER_PAGE(dn.node_page, inode);
J
Jaegeuk Kim 已提交
621 622

	count -= dn.ofs_in_node;
623
	f2fs_bug_on(sbi, count < 0);
624

J
Jaegeuk Kim 已提交
625 626 627 628 629 630 631 632
	if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
		truncate_data_blocks_range(&dn, count);
		free_from += count;
	}

	f2fs_put_dnode(&dn);
free_next:
	err = truncate_inode_blocks(inode, free_from);
633 634 635
out:
	if (lock)
		f2fs_unlock_op(sbi);
636
free_partial:
637 638
	/* lastly zero out the first data page */
	if (!err)
639
		err = truncate_partial_data_page(inode, from, truncate_page);
J
Jaegeuk Kim 已提交
640

641
	trace_f2fs_truncate_blocks_exit(inode, err);
J
Jaegeuk Kim 已提交
642 643 644
	return err;
}

645
int f2fs_truncate(struct inode *inode)
J
Jaegeuk Kim 已提交
646
{
647 648
	int err;

649 650 651
	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
		return -EIO;

J
Jaegeuk Kim 已提交
652 653
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
				S_ISLNK(inode->i_mode)))
654
		return 0;
J
Jaegeuk Kim 已提交
655

656 657
	trace_f2fs_truncate(inode);

658 659 660 661 662 663
#ifdef CONFIG_F2FS_FAULT_INJECTION
	if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
		f2fs_show_injection_info(FAULT_TRUNCATE);
		return -EIO;
	}
#endif
664
	/* we should check inline_data size */
665
	if (!f2fs_may_inline_data(inode)) {
666 667 668
		err = f2fs_convert_inline_inode(inode);
		if (err)
			return err;
669 670
	}

671
	err = truncate_blocks(inode, i_size_read(inode), true);
672 673 674
	if (err)
		return err;

675
	inode->i_mtime = inode->i_ctime = current_time(inode);
676
	f2fs_mark_inode_dirty_sync(inode, false);
677
	return 0;
J
Jaegeuk Kim 已提交
678 679
}

680
int f2fs_getattr(const struct path *path, struct kstat *stat,
C
Chao Yu 已提交
681
		 u32 request_mask, unsigned int query_flags)
J
Jaegeuk Kim 已提交
682
{
683
	struct inode *inode = d_inode(path->dentry);
C
Chao Yu 已提交
684 685 686
	struct f2fs_inode_info *fi = F2FS_I(inode);
	unsigned int flags;

687
	flags = fi->i_flags & (FS_FL_USER_VISIBLE | FS_PROJINHERIT_FL);
C
Chao Yu 已提交
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
	if (flags & FS_APPEND_FL)
		stat->attributes |= STATX_ATTR_APPEND;
	if (flags & FS_COMPR_FL)
		stat->attributes |= STATX_ATTR_COMPRESSED;
	if (f2fs_encrypted_inode(inode))
		stat->attributes |= STATX_ATTR_ENCRYPTED;
	if (flags & FS_IMMUTABLE_FL)
		stat->attributes |= STATX_ATTR_IMMUTABLE;
	if (flags & FS_NODUMP_FL)
		stat->attributes |= STATX_ATTR_NODUMP;

	stat->attributes_mask |= (STATX_ATTR_APPEND |
				  STATX_ATTR_COMPRESSED |
				  STATX_ATTR_ENCRYPTED |
				  STATX_ATTR_IMMUTABLE |
				  STATX_ATTR_NODUMP);

J
Jaegeuk Kim 已提交
705
	generic_fillattr(inode, stat);
706 707 708 709 710 711

	/* we need to show initial sectors used for inline_data/dentries */
	if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) ||
					f2fs_has_inline_dentry(inode))
		stat->blocks += (stat->size + 511) >> 9;

J
Jaegeuk Kim 已提交
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
	return 0;
}

#ifdef CONFIG_F2FS_FS_POSIX_ACL
static void __setattr_copy(struct inode *inode, const struct iattr *attr)
{
	unsigned int ia_valid = attr->ia_valid;

	if (ia_valid & ATTR_UID)
		inode->i_uid = attr->ia_uid;
	if (ia_valid & ATTR_GID)
		inode->i_gid = attr->ia_gid;
	if (ia_valid & ATTR_ATIME)
		inode->i_atime = timespec_trunc(attr->ia_atime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_MTIME)
		inode->i_mtime = timespec_trunc(attr->ia_mtime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_CTIME)
		inode->i_ctime = timespec_trunc(attr->ia_ctime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_MODE) {
		umode_t mode = attr->ia_mode;

		if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
			mode &= ~S_ISGID;
738
		set_acl_inode(inode, mode);
J
Jaegeuk Kim 已提交
739 740 741 742 743 744 745 746
	}
}
#else
#define __setattr_copy setattr_copy
#endif

int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
{
747
	struct inode *inode = d_inode(dentry);
J
Jaegeuk Kim 已提交
748
	int err;
749
	bool size_changed = false;
J
Jaegeuk Kim 已提交
750

751 752 753
	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
		return -EIO;

754
	err = setattr_prepare(dentry, attr);
J
Jaegeuk Kim 已提交
755 756 757
	if (err)
		return err;

758 759 760 761 762 763 764 765 766 767 768 769 770 771
	if (is_quota_modification(inode, attr)) {
		err = dquot_initialize(inode);
		if (err)
			return err;
	}
	if ((attr->ia_valid & ATTR_UID &&
		!uid_eq(attr->ia_uid, inode->i_uid)) ||
		(attr->ia_valid & ATTR_GID &&
		!gid_eq(attr->ia_gid, inode->i_gid))) {
		err = dquot_transfer(inode, attr);
		if (err)
			return err;
	}

772
	if (attr->ia_valid & ATTR_SIZE) {
773 774 775 776 777 778 779
		if (f2fs_encrypted_inode(inode)) {
			err = fscrypt_get_encryption_info(inode);
			if (err)
				return err;
			if (!fscrypt_has_encryption_key(inode))
				return -ENOKEY;
		}
780

781
		if (attr->ia_size <= i_size_read(inode)) {
782
			down_write(&F2FS_I(inode)->i_mmap_sem);
783
			truncate_setsize(inode, attr->ia_size);
784
			err = f2fs_truncate(inode);
785
			up_write(&F2FS_I(inode)->i_mmap_sem);
786 787
			if (err)
				return err;
788 789
		} else {
			/*
790 791
			 * do not trim all blocks after i_size if target size is
			 * larger than i_size.
792
			 */
793
			down_write(&F2FS_I(inode)->i_mmap_sem);
794
			truncate_setsize(inode, attr->ia_size);
795
			up_write(&F2FS_I(inode)->i_mmap_sem);
796 797

			/* should convert inline inode here */
798
			if (!f2fs_may_inline_data(inode)) {
799 800 801 802
				err = f2fs_convert_inline_inode(inode);
				if (err)
					return err;
			}
803
			inode->i_mtime = inode->i_ctime = current_time(inode);
804
		}
805

806 807 808 809
		down_write(&F2FS_I(inode)->i_sem);
		F2FS_I(inode)->last_disk_size = i_size_read(inode);
		up_write(&F2FS_I(inode)->i_sem);

810
		size_changed = true;
J
Jaegeuk Kim 已提交
811 812 813 814 815
	}

	__setattr_copy(inode, attr);

	if (attr->ia_valid & ATTR_MODE) {
816
		err = posix_acl_chmod(inode, get_inode_mode(inode));
817 818 819
		if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
			inode->i_mode = F2FS_I(inode)->i_acl_mode;
			clear_inode_flag(inode, FI_ACL_MODE);
J
Jaegeuk Kim 已提交
820 821 822
		}
	}

823 824
	/* file size may changed here */
	f2fs_mark_inode_dirty_sync(inode, size_changed);
825 826 827 828

	/* inode change will produce dirty node pages flushed by checkpoint */
	f2fs_balance_fs(F2FS_I_SB(inode), true);

J
Jaegeuk Kim 已提交
829 830 831 832 833 834 835
	return err;
}

const struct inode_operations f2fs_file_inode_operations = {
	.getattr	= f2fs_getattr,
	.setattr	= f2fs_setattr,
	.get_acl	= f2fs_get_acl,
836
	.set_acl	= f2fs_set_acl,
J
Jaegeuk Kim 已提交
837 838 839
#ifdef CONFIG_F2FS_FS_XATTR
	.listxattr	= f2fs_listxattr,
#endif
J
Jaegeuk Kim 已提交
840
	.fiemap		= f2fs_fiemap,
J
Jaegeuk Kim 已提交
841 842
};

843
static int fill_zero(struct inode *inode, pgoff_t index,
J
Jaegeuk Kim 已提交
844 845
					loff_t start, loff_t len)
{
846
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
J
Jaegeuk Kim 已提交
847 848 849
	struct page *page;

	if (!len)
850
		return 0;
J
Jaegeuk Kim 已提交
851

852
	f2fs_balance_fs(sbi, true);
853

854
	f2fs_lock_op(sbi);
855
	page = get_new_data_page(inode, NULL, index, false);
856
	f2fs_unlock_op(sbi);
J
Jaegeuk Kim 已提交
857

858 859 860
	if (IS_ERR(page))
		return PTR_ERR(page);

861
	f2fs_wait_on_page_writeback(page, DATA, true);
862 863 864 865
	zero_user(page, start, len);
	set_page_dirty(page);
	f2fs_put_page(page, 1);
	return 0;
J
Jaegeuk Kim 已提交
866 867 868 869 870 871
}

int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
{
	int err;

872
	while (pg_start < pg_end) {
J
Jaegeuk Kim 已提交
873
		struct dnode_of_data dn;
874
		pgoff_t end_offset, count;
875

J
Jaegeuk Kim 已提交
876
		set_new_dnode(&dn, inode, NULL, NULL, 0);
877
		err = get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
J
Jaegeuk Kim 已提交
878
		if (err) {
879
			if (err == -ENOENT) {
880
				pg_start = get_next_page_offset(&dn, pg_start);
J
Jaegeuk Kim 已提交
881
				continue;
882
			}
J
Jaegeuk Kim 已提交
883 884 885
			return err;
		}

886
		end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
887 888 889 890 891
		count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);

		f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);

		truncate_data_blocks_range(&dn, count);
J
Jaegeuk Kim 已提交
892
		f2fs_put_dnode(&dn);
893 894

		pg_start += count;
J
Jaegeuk Kim 已提交
895 896 897 898
	}
	return 0;
}

899
static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
J
Jaegeuk Kim 已提交
900 901 902
{
	pgoff_t pg_start, pg_end;
	loff_t off_start, off_end;
903
	int ret;
J
Jaegeuk Kim 已提交
904

905 906 907
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
		return ret;
908

909 910
	pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
	pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
J
Jaegeuk Kim 已提交
911

912 913
	off_start = offset & (PAGE_SIZE - 1);
	off_end = (offset + len) & (PAGE_SIZE - 1);
J
Jaegeuk Kim 已提交
914 915

	if (pg_start == pg_end) {
916
		ret = fill_zero(inode, pg_start, off_start,
J
Jaegeuk Kim 已提交
917
						off_end - off_start);
918 919
		if (ret)
			return ret;
J
Jaegeuk Kim 已提交
920
	} else {
921 922
		if (off_start) {
			ret = fill_zero(inode, pg_start++, off_start,
923
						PAGE_SIZE - off_start);
924 925 926 927 928 929 930 931
			if (ret)
				return ret;
		}
		if (off_end) {
			ret = fill_zero(inode, pg_end, 0, off_end);
			if (ret)
				return ret;
		}
J
Jaegeuk Kim 已提交
932 933 934 935

		if (pg_start < pg_end) {
			struct address_space *mapping = inode->i_mapping;
			loff_t blk_start, blk_end;
936
			struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
937

938
			f2fs_balance_fs(sbi, true);
J
Jaegeuk Kim 已提交
939

940 941
			blk_start = (loff_t)pg_start << PAGE_SHIFT;
			blk_end = (loff_t)pg_end << PAGE_SHIFT;
942
			down_write(&F2FS_I(inode)->i_mmap_sem);
J
Jaegeuk Kim 已提交
943 944
			truncate_inode_pages_range(mapping, blk_start,
					blk_end - 1);
945

946
			f2fs_lock_op(sbi);
J
Jaegeuk Kim 已提交
947
			ret = truncate_hole(inode, pg_start, pg_end);
948
			f2fs_unlock_op(sbi);
949
			up_write(&F2FS_I(inode)->i_mmap_sem);
J
Jaegeuk Kim 已提交
950 951 952 953 954 955
		}
	}

	return ret;
}

956 957
static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
				int *do_replace, pgoff_t off, pgoff_t len)
958 959 960
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct dnode_of_data dn;
961
	int ret, done, i;
962

963
next_dnode:
964
	set_new_dnode(&dn, inode, NULL, NULL, 0);
965
	ret = get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
966 967 968
	if (ret && ret != -ENOENT) {
		return ret;
	} else if (ret == -ENOENT) {
969 970 971 972 973 974 975 976 977 978 979
		if (dn.max_level == 0)
			return -ENOENT;
		done = min((pgoff_t)ADDRS_PER_BLOCK - dn.ofs_in_node, len);
		blkaddr += done;
		do_replace += done;
		goto next;
	}

	done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
							dn.ofs_in_node, len);
	for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
980 981
		*blkaddr = datablock_addr(dn.inode,
					dn.node_page, dn.ofs_in_node);
982 983 984 985 986 987 988
		if (!is_checkpointed_data(sbi, *blkaddr)) {

			if (test_opt(sbi, LFS)) {
				f2fs_put_dnode(&dn);
				return -ENOTSUPP;
			}

989
			/* do not invalidate this block address */
990
			f2fs_update_data_blkaddr(&dn, NULL_ADDR);
991
			*do_replace = 1;
992
		}
993
	}
994 995 996 997 998 999 1000 1001
	f2fs_put_dnode(&dn);
next:
	len -= done;
	off += done;
	if (len)
		goto next_dnode;
	return 0;
}
1002

1003 1004 1005 1006 1007 1008
static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
				int *do_replace, pgoff_t off, int len)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct dnode_of_data dn;
	int ret, i;
1009

1010 1011 1012
	for (i = 0; i < len; i++, do_replace++, blkaddr++) {
		if (*do_replace == 0)
			continue;
1013

1014 1015 1016 1017 1018 1019 1020
		set_new_dnode(&dn, inode, NULL, NULL, 0);
		ret = get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
		if (ret) {
			dec_valid_block_count(sbi, inode, 1);
			invalidate_blocks(sbi, *blkaddr);
		} else {
			f2fs_update_data_blkaddr(&dn, *blkaddr);
1021
		}
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
		f2fs_put_dnode(&dn);
	}
	return 0;
}

static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
			block_t *blkaddr, int *do_replace,
			pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
	pgoff_t i = 0;
	int ret;
1034

1035 1036 1037 1038
	while (i < len) {
		if (blkaddr[i] == NULL_ADDR && !full) {
			i++;
			continue;
1039
		}
1040

1041 1042 1043 1044 1045
		if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
			struct dnode_of_data dn;
			struct node_info ni;
			size_t new_size;
			pgoff_t ilen;
1046

1047 1048 1049 1050
			set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
			ret = get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
			if (ret)
				return ret;
1051

1052 1053 1054 1055 1056
			get_node_info(sbi, dn.nid, &ni);
			ilen = min((pgoff_t)
				ADDRS_PER_PAGE(dn.node_page, dst_inode) -
						dn.ofs_in_node, len - i);
			do {
1057 1058
				dn.data_blkaddr = datablock_addr(dn.inode,
						dn.node_page, dn.ofs_in_node);
1059 1060 1061 1062
				truncate_data_blocks_range(&dn, 1);

				if (do_replace[i]) {
					f2fs_i_blocks_write(src_inode,
1063
							1, false, false);
1064
					f2fs_i_blocks_write(dst_inode,
1065
							1, true, false);
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
					f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
					blkaddr[i], ni.version, true, false);

					do_replace[i] = 0;
				}
				dn.ofs_in_node++;
				i++;
				new_size = (dst + i) << PAGE_SHIFT;
				if (dst_inode->i_size < new_size)
					f2fs_i_size_write(dst_inode, new_size);
1076
			} while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));
1077

1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
			f2fs_put_dnode(&dn);
		} else {
			struct page *psrc, *pdst;

			psrc = get_lock_data_page(src_inode, src + i, true);
			if (IS_ERR(psrc))
				return PTR_ERR(psrc);
			pdst = get_new_data_page(dst_inode, NULL, dst + i,
								true);
			if (IS_ERR(pdst)) {
				f2fs_put_page(psrc, 1);
				return PTR_ERR(pdst);
			}
			f2fs_copy_page(psrc, pdst);
			set_page_dirty(pdst);
			f2fs_put_page(pdst, 1);
1094
			f2fs_put_page(psrc, 1);
1095

1096 1097 1098 1099 1100
			ret = truncate_hole(src_inode, src + i, src + i + 1);
			if (ret)
				return ret;
			i++;
		}
1101 1102
	}
	return 0;
1103
}
1104

1105 1106
static int __exchange_data_block(struct inode *src_inode,
			struct inode *dst_inode, pgoff_t src, pgoff_t dst,
1107
			pgoff_t len, bool full)
1108 1109 1110
{
	block_t *src_blkaddr;
	int *do_replace;
1111
	pgoff_t olen;
1112 1113
	int ret;

1114 1115
	while (len) {
		olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len);
1116

1117
		src_blkaddr = kvzalloc(sizeof(block_t) * olen, GFP_KERNEL);
1118 1119
		if (!src_blkaddr)
			return -ENOMEM;
1120

1121
		do_replace = kvzalloc(sizeof(int) * olen, GFP_KERNEL);
1122 1123 1124 1125
		if (!do_replace) {
			kvfree(src_blkaddr);
			return -ENOMEM;
		}
1126

1127 1128 1129 1130
		ret = __read_out_blkaddrs(src_inode, src_blkaddr,
					do_replace, src, olen);
		if (ret)
			goto roll_back;
1131

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
		ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
					do_replace, src, dst, olen, full);
		if (ret)
			goto roll_back;

		src += olen;
		dst += olen;
		len -= olen;

		kvfree(src_blkaddr);
		kvfree(do_replace);
	}
1144 1145 1146 1147 1148 1149
	return 0;

roll_back:
	__roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, len);
	kvfree(src_blkaddr);
	kvfree(do_replace);
1150 1151
	return ret;
}
1152

1153 1154 1155 1156
static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
1157
	int ret;
1158

1159 1160
	f2fs_balance_fs(sbi, true);
	f2fs_lock_op(sbi);
1161 1162 1163

	f2fs_drop_extent_tree(inode);

1164 1165
	ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
	f2fs_unlock_op(sbi);
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
	return ret;
}

static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
{
	pgoff_t pg_start, pg_end;
	loff_t new_size;
	int ret;

	if (offset + len >= i_size_read(inode))
		return -EINVAL;

	/* collapse range should be aligned to block size of f2fs. */
	if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
		return -EINVAL;

1182 1183 1184
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
		return ret;
1185

1186 1187
	pg_start = offset >> PAGE_SHIFT;
	pg_end = (offset + len) >> PAGE_SHIFT;
1188

1189
	down_write(&F2FS_I(inode)->i_mmap_sem);
1190 1191 1192
	/* write out all dirty pages from offset */
	ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
	if (ret)
1193
		goto out;
1194

1195 1196 1197
	/* avoid gc operation during block exchange */
	down_write(&F2FS_I(inode)->dio_rwsem[WRITE]);

1198 1199 1200 1201
	truncate_pagecache(inode, offset);

	ret = f2fs_do_collapse(inode, pg_start, pg_end);
	if (ret)
1202
		goto out_unlock;
1203

1204 1205 1206 1207
	/* write out all moved pages, if possible */
	filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
	truncate_pagecache(inode, offset);

1208
	new_size = i_size_read(inode) - len;
1209
	truncate_pagecache(inode, new_size);
1210 1211 1212

	ret = truncate_blocks(inode, new_size, true);
	if (!ret)
1213
		f2fs_i_size_write(inode, new_size);
1214 1215
out_unlock:
	up_write(&F2FS_I(inode)->dio_rwsem[WRITE]);
1216 1217
out:
	up_write(&F2FS_I(inode)->i_mmap_sem);
1218 1219 1220
	return ret;
}

1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
								pgoff_t end)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
	pgoff_t index = start;
	unsigned int ofs_in_node = dn->ofs_in_node;
	blkcnt_t count = 0;
	int ret;

	for (; index < end; index++, dn->ofs_in_node++) {
1231 1232
		if (datablock_addr(dn->inode, dn->node_page,
					dn->ofs_in_node) == NULL_ADDR)
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
			count++;
	}

	dn->ofs_in_node = ofs_in_node;
	ret = reserve_new_blocks(dn, count);
	if (ret)
		return ret;

	dn->ofs_in_node = ofs_in_node;
	for (index = start; index < end; index++, dn->ofs_in_node++) {
1243 1244
		dn->data_blkaddr = datablock_addr(dn->inode,
					dn->node_page, dn->ofs_in_node);
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
		/*
		 * reserve_new_blocks will not guarantee entire block
		 * allocation.
		 */
		if (dn->data_blkaddr == NULL_ADDR) {
			ret = -ENOSPC;
			break;
		}
		if (dn->data_blkaddr != NEW_ADDR) {
			invalidate_blocks(sbi, dn->data_blkaddr);
			dn->data_blkaddr = NEW_ADDR;
			set_data_blkaddr(dn);
		}
	}

	f2fs_update_extent_cache_range(dn, start, 0, index - start);

	return ret;
}

1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
								int mode)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct address_space *mapping = inode->i_mapping;
	pgoff_t index, pg_start, pg_end;
	loff_t new_size = i_size_read(inode);
	loff_t off_start, off_end;
	int ret = 0;

	ret = inode_newsize_ok(inode, (len + offset));
	if (ret)
		return ret;

1279 1280 1281
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
		return ret;
1282

1283
	down_write(&F2FS_I(inode)->i_mmap_sem);
1284 1285
	ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
	if (ret)
1286
		goto out_sem;
1287 1288 1289

	truncate_pagecache_range(inode, offset, offset + len - 1);

1290 1291
	pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
	pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1292

1293 1294
	off_start = offset & (PAGE_SIZE - 1);
	off_end = (offset + len) & (PAGE_SIZE - 1);
1295 1296

	if (pg_start == pg_end) {
1297 1298 1299
		ret = fill_zero(inode, pg_start, off_start,
						off_end - off_start);
		if (ret)
1300
			goto out_sem;
1301

1302 1303 1304
		new_size = max_t(loff_t, new_size, offset + len);
	} else {
		if (off_start) {
1305
			ret = fill_zero(inode, pg_start++, off_start,
1306
						PAGE_SIZE - off_start);
1307
			if (ret)
1308
				goto out_sem;
1309

1310
			new_size = max_t(loff_t, new_size,
1311
					(loff_t)pg_start << PAGE_SHIFT);
1312 1313
		}

1314
		for (index = pg_start; index < pg_end;) {
1315
			struct dnode_of_data dn;
1316 1317
			unsigned int end_offset;
			pgoff_t end;
1318 1319 1320

			f2fs_lock_op(sbi);

1321 1322
			set_new_dnode(&dn, inode, NULL, NULL, 0);
			ret = get_dnode_of_data(&dn, index, ALLOC_NODE);
1323 1324 1325 1326 1327
			if (ret) {
				f2fs_unlock_op(sbi);
				goto out;
			}

1328 1329 1330 1331
			end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
			end = min(pg_end, end_offset - dn.ofs_in_node + index);

			ret = f2fs_do_zero_range(&dn, index, end);
1332 1333
			f2fs_put_dnode(&dn);
			f2fs_unlock_op(sbi);
1334 1335 1336

			f2fs_balance_fs(sbi, dn.node_changed);

1337 1338
			if (ret)
				goto out;
1339

1340
			index = end;
1341
			new_size = max_t(loff_t, new_size,
1342
					(loff_t)index << PAGE_SHIFT);
1343 1344 1345
		}

		if (off_end) {
1346 1347 1348 1349
			ret = fill_zero(inode, pg_end, 0, off_end);
			if (ret)
				goto out;

1350 1351 1352 1353 1354
			new_size = max_t(loff_t, new_size, offset + len);
		}
	}

out:
1355
	if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
1356
		f2fs_i_size_write(inode, new_size);
1357 1358
out_sem:
	up_write(&F2FS_I(inode)->i_mmap_sem);
1359 1360 1361 1362

	return ret;
}

1363 1364 1365
static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1366
	pgoff_t nr, pg_start, pg_end, delta, idx;
1367
	loff_t new_size;
1368
	int ret = 0;
1369 1370

	new_size = i_size_read(inode) + len;
1371 1372 1373
	ret = inode_newsize_ok(inode, new_size);
	if (ret)
		return ret;
1374 1375 1376 1377 1378 1379 1380 1381

	if (offset >= i_size_read(inode))
		return -EINVAL;

	/* insert range should be aligned to block size of f2fs. */
	if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
		return -EINVAL;

1382 1383 1384
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
		return ret;
1385

1386
	f2fs_balance_fs(sbi, true);
1387

1388
	down_write(&F2FS_I(inode)->i_mmap_sem);
1389 1390
	ret = truncate_blocks(inode, i_size_read(inode), true);
	if (ret)
1391
		goto out;
1392 1393 1394 1395

	/* write out all dirty pages from offset */
	ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
	if (ret)
1396
		goto out;
1397

1398 1399 1400
	/* avoid gc operation during block exchange */
	down_write(&F2FS_I(inode)->dio_rwsem[WRITE]);

1401 1402
	truncate_pagecache(inode, offset);

1403 1404
	pg_start = offset >> PAGE_SHIFT;
	pg_end = (offset + len) >> PAGE_SHIFT;
1405
	delta = pg_end - pg_start;
1406 1407 1408 1409 1410 1411 1412
	idx = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;

	while (!ret && idx > pg_start) {
		nr = idx - pg_start;
		if (nr > delta)
			nr = delta;
		idx -= nr;
1413 1414

		f2fs_lock_op(sbi);
1415 1416
		f2fs_drop_extent_tree(inode);

1417 1418
		ret = __exchange_data_block(inode, inode, idx,
					idx + delta, nr, false);
1419 1420 1421
		f2fs_unlock_op(sbi);
	}

1422 1423 1424 1425 1426
	/* write out all moved pages, if possible */
	filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
	truncate_pagecache(inode, offset);

	if (!ret)
1427
		f2fs_i_size_write(inode, new_size);
1428 1429

	up_write(&F2FS_I(inode)->dio_rwsem[WRITE]);
1430 1431
out:
	up_write(&F2FS_I(inode)->i_mmap_sem);
1432 1433 1434
	return ret;
}

J
Jaegeuk Kim 已提交
1435 1436 1437
static int expand_inode_data(struct inode *inode, loff_t offset,
					loff_t len, int mode)
{
1438
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1439 1440
	struct f2fs_map_blocks map = { .m_next_pgofs = NULL };
	pgoff_t pg_end;
J
Jaegeuk Kim 已提交
1441
	loff_t new_size = i_size_read(inode);
1442
	loff_t off_end;
1443
	int err;
J
Jaegeuk Kim 已提交
1444

1445 1446 1447
	err = inode_newsize_ok(inode, (len + offset));
	if (err)
		return err;
J
Jaegeuk Kim 已提交
1448

1449 1450 1451
	err = f2fs_convert_inline_inode(inode);
	if (err)
		return err;
1452

1453
	f2fs_balance_fs(sbi, true);
1454

1455
	pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
1456
	off_end = (offset + len) & (PAGE_SIZE - 1);
J
Jaegeuk Kim 已提交
1457

1458 1459 1460 1461
	map.m_lblk = ((unsigned long long)offset) >> PAGE_SHIFT;
	map.m_len = pg_end - map.m_lblk;
	if (off_end)
		map.m_len++;
1462

1463 1464
	err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
	if (err) {
1465
		pgoff_t last_off;
J
Jaegeuk Kim 已提交
1466

1467
		if (!map.m_len)
1468
			return err;
1469

1470 1471 1472 1473 1474 1475 1476
		last_off = map.m_lblk + map.m_len - 1;

		/* update new size to the failed position */
		new_size = (last_off == pg_end) ? offset + len:
					(loff_t)(last_off + 1) << PAGE_SHIFT;
	} else {
		new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
J
Jaegeuk Kim 已提交
1477 1478
	}

1479 1480 1481 1482 1483 1484
	if (new_size > i_size_read(inode)) {
		if (mode & FALLOC_FL_KEEP_SIZE)
			file_set_keep_isize(inode);
		else
			f2fs_i_size_write(inode, new_size);
	}
J
Jaegeuk Kim 已提交
1485

1486
	return err;
J
Jaegeuk Kim 已提交
1487 1488 1489 1490 1491
}

static long f2fs_fallocate(struct file *file, int mode,
				loff_t offset, loff_t len)
{
1492
	struct inode *inode = file_inode(file);
1493
	long ret = 0;
J
Jaegeuk Kim 已提交
1494

1495 1496 1497
	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
		return -EIO;

1498 1499 1500 1501
	/* f2fs only support ->fallocate for regular file */
	if (!S_ISREG(inode->i_mode))
		return -EINVAL;

1502 1503
	if (f2fs_encrypted_inode(inode) &&
		(mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
1504 1505
		return -EOPNOTSUPP;

1506
	if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1507 1508
			FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
			FALLOC_FL_INSERT_RANGE))
J
Jaegeuk Kim 已提交
1509 1510
		return -EOPNOTSUPP;

A
Al Viro 已提交
1511
	inode_lock(inode);
1512

1513 1514 1515 1516
	if (mode & FALLOC_FL_PUNCH_HOLE) {
		if (offset >= inode->i_size)
			goto out;

1517
		ret = punch_hole(inode, offset, len);
1518 1519
	} else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
		ret = f2fs_collapse_range(inode, offset, len);
1520 1521
	} else if (mode & FALLOC_FL_ZERO_RANGE) {
		ret = f2fs_zero_range(inode, offset, len, mode);
1522 1523
	} else if (mode & FALLOC_FL_INSERT_RANGE) {
		ret = f2fs_insert_range(inode, offset, len);
1524
	} else {
J
Jaegeuk Kim 已提交
1525
		ret = expand_inode_data(inode, offset, len, mode);
1526
	}
J
Jaegeuk Kim 已提交
1527

1528
	if (!ret) {
1529
		inode->i_mtime = inode->i_ctime = current_time(inode);
1530
		f2fs_mark_inode_dirty_sync(inode, false);
1531
		f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1532
	}
1533

1534
out:
A
Al Viro 已提交
1535
	inode_unlock(inode);
1536

1537
	trace_f2fs_fallocate(inode, mode, offset, len, ret);
J
Jaegeuk Kim 已提交
1538 1539 1540
	return ret;
}

1541 1542
static int f2fs_release_file(struct inode *inode, struct file *filp)
{
1543 1544 1545 1546 1547 1548 1549 1550
	/*
	 * f2fs_relase_file is called at every close calls. So we should
	 * not drop any inmemory pages by close called by other process.
	 */
	if (!(filp->f_mode & FMODE_WRITE) ||
			atomic_read(&inode->i_writecount) != 1)
		return 0;

1551 1552
	/* some remained atomic pages should discarded */
	if (f2fs_is_atomic_file(inode))
1553
		drop_inmem_pages(inode);
1554
	if (f2fs_is_volatile_file(inode)) {
1555
		clear_inode_flag(inode, FI_VOLATILE_FILE);
1556
		stat_dec_volatile_write(inode);
1557
		set_inode_flag(inode, FI_DROP_CACHE);
1558
		filemap_fdatawrite(inode->i_mapping);
1559
		clear_inode_flag(inode, FI_DROP_CACHE);
1560 1561 1562 1563
	}
	return 0;
}

1564
static int f2fs_file_flush(struct file *file, fl_owner_t id)
J
Jaegeuk Kim 已提交
1565
{
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
	struct inode *inode = file_inode(file);

	/*
	 * If the process doing a transaction is crashed, we should do
	 * roll-back. Otherwise, other reader/write can see corrupted database
	 * until all the writers close its file. Since this should be done
	 * before dropping file lock, it needs to do in ->flush.
	 */
	if (f2fs_is_atomic_file(inode) &&
			F2FS_I(inode)->inmem_task == current)
		drop_inmem_pages(inode);
	return 0;
J
Jaegeuk Kim 已提交
1578 1579
}

1580
static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
J
Jaegeuk Kim 已提交
1581
{
1582
	struct inode *inode = file_inode(filp);
J
Jaegeuk Kim 已提交
1583
	struct f2fs_inode_info *fi = F2FS_I(inode);
1584 1585
	unsigned int flags = fi->i_flags &
			(FS_FL_USER_VISIBLE | FS_PROJINHERIT_FL);
1586 1587
	return put_user(flags, (int __user *)arg);
}
J
Jaegeuk Kim 已提交
1588

1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
static int __f2fs_ioc_setflags(struct inode *inode, unsigned int flags)
{
	struct f2fs_inode_info *fi = F2FS_I(inode);
	unsigned int oldflags;

	/* Is it quota file? Do not allow user to mess with it */
	if (IS_NOQUOTA(inode))
		return -EPERM;

	flags = f2fs_mask_flags(inode->i_mode, flags);

	oldflags = fi->i_flags;

	if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL))
		if (!capable(CAP_LINUX_IMMUTABLE))
			return -EPERM;

	flags = flags & (FS_FL_USER_MODIFIABLE | FS_PROJINHERIT_FL);
	flags |= oldflags & ~(FS_FL_USER_MODIFIABLE | FS_PROJINHERIT_FL);
	fi->i_flags = flags;

	if (fi->i_flags & FS_PROJINHERIT_FL)
		set_inode_flag(inode, FI_PROJ_INHERIT);
	else
		clear_inode_flag(inode, FI_PROJ_INHERIT);

	inode->i_ctime = current_time(inode);
	f2fs_set_inode_flags(inode);
	f2fs_mark_inode_dirty_sync(inode, false);
	return 0;
}

1621 1622 1623
static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
1624
	unsigned int flags;
1625
	int ret;
J
Jaegeuk Kim 已提交
1626

1627 1628 1629 1630 1631 1632
	if (!inode_owner_or_capable(inode))
		return -EACCES;

	if (get_user(flags, (int __user *)arg))
		return -EFAULT;

1633 1634 1635
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;
J
Jaegeuk Kim 已提交
1636

A
Al Viro 已提交
1637
	inode_lock(inode);
J
Jaegeuk Kim 已提交
1638

1639
	ret = __f2fs_ioc_setflags(inode, flags);
J
Jaegeuk Kim 已提交
1640

1641
	inode_unlock(inode);
1642 1643 1644
	mnt_drop_write_file(filp);
	return ret;
}
1645

1646 1647 1648 1649 1650 1651 1652
static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);

	return put_user(inode->i_generation, (int __user *)arg);
}

J
Jaegeuk Kim 已提交
1653 1654 1655
static int f2fs_ioc_start_atomic_write(struct file *filp)
{
	struct inode *inode = file_inode(filp);
1656
	int ret;
J
Jaegeuk Kim 已提交
1657 1658 1659 1660

	if (!inode_owner_or_capable(inode))
		return -EACCES;

1661 1662 1663
	if (!S_ISREG(inode->i_mode))
		return -EINVAL;

1664 1665 1666 1667
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

1668 1669
	inode_lock(inode);

1670
	if (f2fs_is_atomic_file(inode))
1671
		goto out;
J
Jaegeuk Kim 已提交
1672

1673 1674
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
1675
		goto out;
J
Jaegeuk Kim 已提交
1676

1677
	set_inode_flag(inode, FI_ATOMIC_FILE);
1678
	set_inode_flag(inode, FI_HOT_DATA);
1679 1680
	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);

1681
	if (!get_dirty_pages(inode))
1682
		goto inc_stat;
1683 1684

	f2fs_msg(F2FS_I_SB(inode)->sb, KERN_WARNING,
1685
		"Unexpected flush for atomic writes: ino=%lu, npages=%u",
1686 1687
					inode->i_ino, get_dirty_pages(inode));
	ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
1688
	if (ret) {
1689
		clear_inode_flag(inode, FI_ATOMIC_FILE);
1690
		clear_inode_flag(inode, FI_HOT_DATA);
1691 1692 1693 1694
		goto out;
	}

inc_stat:
1695
	F2FS_I(inode)->inmem_task = current;
1696 1697
	stat_inc_atomic_write(inode);
	stat_update_max_atomic_write(inode);
1698
out:
1699
	inode_unlock(inode);
1700
	mnt_drop_write_file(filp);
1701
	return ret;
J
Jaegeuk Kim 已提交
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
}

static int f2fs_ioc_commit_atomic_write(struct file *filp)
{
	struct inode *inode = file_inode(filp);
	int ret;

	if (!inode_owner_or_capable(inode))
		return -EACCES;

	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

1716 1717
	inode_lock(inode);

1718 1719 1720
	if (f2fs_is_volatile_file(inode))
		goto err_out;

1721
	if (f2fs_is_atomic_file(inode)) {
1722
		ret = commit_inmem_pages(inode);
1723
		if (ret)
1724
			goto err_out;
1725

1726
		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1727 1728
		if (!ret) {
			clear_inode_flag(inode, FI_ATOMIC_FILE);
1729
			clear_inode_flag(inode, FI_HOT_DATA);
1730
			stat_dec_atomic_write(inode);
1731
		}
1732
	} else {
1733
		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
1734
	}
1735
err_out:
1736
	inode_unlock(inode);
J
Jaegeuk Kim 已提交
1737 1738 1739 1740
	mnt_drop_write_file(filp);
	return ret;
}

1741 1742 1743
static int f2fs_ioc_start_volatile_write(struct file *filp)
{
	struct inode *inode = file_inode(filp);
1744
	int ret;
1745 1746 1747 1748

	if (!inode_owner_or_capable(inode))
		return -EACCES;

1749 1750 1751
	if (!S_ISREG(inode->i_mode))
		return -EINVAL;

1752 1753 1754 1755
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

1756 1757
	inode_lock(inode);

1758
	if (f2fs_is_volatile_file(inode))
1759
		goto out;
1760

1761 1762
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
1763
		goto out;
1764

1765 1766 1767
	stat_inc_volatile_write(inode);
	stat_update_max_volatile_write(inode);

1768
	set_inode_flag(inode, FI_VOLATILE_FILE);
1769
	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1770
out:
1771
	inode_unlock(inode);
1772 1773
	mnt_drop_write_file(filp);
	return ret;
1774 1775
}

1776 1777 1778
static int f2fs_ioc_release_volatile_write(struct file *filp)
{
	struct inode *inode = file_inode(filp);
1779
	int ret;
1780 1781 1782 1783

	if (!inode_owner_or_capable(inode))
		return -EACCES;

1784 1785 1786 1787
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

1788 1789
	inode_lock(inode);

1790
	if (!f2fs_is_volatile_file(inode))
1791
		goto out;
1792

1793 1794 1795 1796
	if (!f2fs_is_first_block_written(inode)) {
		ret = truncate_partial_data_page(inode, 0, true);
		goto out;
	}
1797

1798 1799
	ret = punch_hole(inode, 0, F2FS_BLKSIZE);
out:
1800
	inode_unlock(inode);
1801 1802
	mnt_drop_write_file(filp);
	return ret;
1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
}

static int f2fs_ioc_abort_volatile_write(struct file *filp)
{
	struct inode *inode = file_inode(filp);
	int ret;

	if (!inode_owner_or_capable(inode))
		return -EACCES;

	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

1817 1818
	inode_lock(inode);

1819
	if (f2fs_is_atomic_file(inode))
1820
		drop_inmem_pages(inode);
1821
	if (f2fs_is_volatile_file(inode)) {
1822
		clear_inode_flag(inode, FI_VOLATILE_FILE);
1823
		stat_dec_volatile_write(inode);
1824
		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1825
	}
1826

1827 1828
	inode_unlock(inode);

1829
	mnt_drop_write_file(filp);
1830
	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1831 1832 1833
	return ret;
}

J
Jaegeuk Kim 已提交
1834 1835 1836 1837 1838 1839
static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct super_block *sb = sbi->sb;
	__u32 in;
1840
	int ret;
J
Jaegeuk Kim 已提交
1841 1842 1843 1844 1845 1846 1847

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (get_user(in, (__u32 __user *)arg))
		return -EFAULT;

1848 1849 1850 1851
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

J
Jaegeuk Kim 已提交
1852 1853 1854 1855
	switch (in) {
	case F2FS_GOING_DOWN_FULLSYNC:
		sb = freeze_bdev(sb->s_bdev);
		if (sb && !IS_ERR(sb)) {
1856
			f2fs_stop_checkpoint(sbi, false);
J
Jaegeuk Kim 已提交
1857 1858 1859 1860 1861 1862
			thaw_bdev(sb->s_bdev, sb);
		}
		break;
	case F2FS_GOING_DOWN_METASYNC:
		/* do checkpoint only */
		f2fs_sync_fs(sb, 1);
1863
		f2fs_stop_checkpoint(sbi, false);
J
Jaegeuk Kim 已提交
1864 1865
		break;
	case F2FS_GOING_DOWN_NOSYNC:
1866
		f2fs_stop_checkpoint(sbi, false);
J
Jaegeuk Kim 已提交
1867
		break;
1868
	case F2FS_GOING_DOWN_METAFLUSH:
C
Chao Yu 已提交
1869
		sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO);
1870
		f2fs_stop_checkpoint(sbi, false);
1871
		break;
J
Jaegeuk Kim 已提交
1872
	default:
1873 1874
		ret = -EINVAL;
		goto out;
J
Jaegeuk Kim 已提交
1875
	}
1876
	f2fs_update_time(sbi, REQ_TIME);
1877 1878 1879
out:
	mnt_drop_write_file(filp);
	return ret;
J
Jaegeuk Kim 已提交
1880 1881
}

1882 1883 1884 1885 1886 1887 1888
static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct super_block *sb = inode->i_sb;
	struct request_queue *q = bdev_get_queue(sb->s_bdev);
	struct fstrim_range range;
	int ret;
1889

1890 1891
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
1892

1893 1894
	if (!blk_queue_discard(q))
		return -EOPNOTSUPP;
1895

1896 1897 1898
	if (copy_from_user(&range, (struct fstrim_range __user *)arg,
				sizeof(range)))
		return -EFAULT;
1899

1900 1901 1902 1903
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

1904 1905 1906
	range.minlen = max((unsigned int)range.minlen,
				q->limits.discard_granularity);
	ret = f2fs_trim_fs(F2FS_SB(sb), &range);
1907
	mnt_drop_write_file(filp);
1908 1909
	if (ret < 0)
		return ret;
1910

1911 1912 1913
	if (copy_to_user((struct fstrim_range __user *)arg, &range,
				sizeof(range)))
		return -EFAULT;
1914
	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1915 1916 1917
	return 0;
}

1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931
static bool uuid_is_nonzero(__u8 u[16])
{
	int i;

	for (i = 0; i < 16; i++)
		if (u[i])
			return true;
	return false;
}

static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);

1932 1933 1934
	if (!f2fs_sb_has_crypto(inode->i_sb))
		return -EOPNOTSUPP;

1935
	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1936

1937
	return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
1938 1939 1940 1941
}

static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
{
1942 1943
	if (!f2fs_sb_has_crypto(file_inode(filp)->i_sb))
		return -EOPNOTSUPP;
1944
	return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
}

static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	int err;

	if (!f2fs_sb_has_crypto(inode->i_sb))
		return -EOPNOTSUPP;

	if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
		goto got_it;

	err = mnt_want_write_file(filp);
	if (err)
		return err;

	/* update superblock with uuid */
	generate_random_uuid(sbi->raw_super->encrypt_pw_salt);

1966
	err = f2fs_commit_super(sbi, false);
1967 1968 1969
	if (err) {
		/* undo new data */
		memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
1970
		mnt_drop_write_file(filp);
1971 1972
		return err;
	}
1973
	mnt_drop_write_file(filp);
1974 1975 1976 1977 1978 1979 1980
got_it:
	if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
									16))
		return -EFAULT;
	return 0;
}

1981 1982 1983 1984
static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1985
	__u32 sync;
1986
	int ret;
1987 1988 1989 1990

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

1991
	if (get_user(sync, (__u32 __user *)arg))
1992 1993
		return -EFAULT;

1994 1995
	if (f2fs_readonly(sbi->sb))
		return -EROFS;
1996

1997 1998 1999 2000
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

2001
	if (!sync) {
2002 2003 2004 2005
		if (!mutex_trylock(&sbi->gc_mutex)) {
			ret = -EBUSY;
			goto out;
		}
2006 2007
	} else {
		mutex_lock(&sbi->gc_mutex);
2008 2009
	}

2010
	ret = f2fs_gc(sbi, sync, true, NULL_SEGNO);
2011 2012 2013
out:
	mnt_drop_write_file(filp);
	return ret;
2014 2015
}

2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct f2fs_gc_range range;
	u64 end;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg,
							sizeof(range)))
		return -EFAULT;

	if (f2fs_readonly(sbi->sb))
		return -EROFS;

	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

	end = range.start + range.len;
	if (range.start < MAIN_BLKADDR(sbi) || end >= MAX_BLKADDR(sbi))
		return -EINVAL;
do_more:
	if (!range.sync) {
		if (!mutex_trylock(&sbi->gc_mutex)) {
			ret = -EBUSY;
			goto out;
		}
	} else {
		mutex_lock(&sbi->gc_mutex);
	}

	ret = f2fs_gc(sbi, range.sync, true, GET_SEGNO(sbi, range.start));
	range.start += sbi->blocks_per_seg;
	if (range.start <= end)
		goto do_more;
out:
	mnt_drop_write_file(filp);
	return ret;
}

2060 2061 2062 2063
static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2064
	int ret;
2065 2066 2067 2068 2069 2070 2071

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (f2fs_readonly(sbi->sb))
		return -EROFS;

2072 2073 2074 2075 2076 2077 2078 2079
	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

	ret = f2fs_sync_fs(sbi->sb, 1);

	mnt_drop_write_file(filp);
	return ret;
2080 2081
}

C
Chao Yu 已提交
2082 2083 2084 2085 2086
static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
					struct file *filp,
					struct f2fs_defragment *range)
{
	struct inode *inode = file_inode(filp);
2087
	struct f2fs_map_blocks map = { .m_next_pgofs = NULL };
2088
	struct extent_info ei = {0,0,0};
C
Chao Yu 已提交
2089
	pgoff_t pg_start, pg_end;
2090
	unsigned int blk_per_seg = sbi->blocks_per_seg;
C
Chao Yu 已提交
2091 2092 2093 2094 2095 2096
	unsigned int total = 0, sec_num;
	block_t blk_end = 0;
	bool fragmented = false;
	int err;

	/* if in-place-update policy is enabled, don't waste time here */
2097
	if (need_inplace_update_policy(inode, NULL))
C
Chao Yu 已提交
2098 2099
		return -EINVAL;

2100 2101
	pg_start = range->start >> PAGE_SHIFT;
	pg_end = (range->start + range->len) >> PAGE_SHIFT;
C
Chao Yu 已提交
2102

2103
	f2fs_balance_fs(sbi, true);
C
Chao Yu 已提交
2104

A
Al Viro 已提交
2105
	inode_lock(inode);
C
Chao Yu 已提交
2106 2107 2108

	/* writeback all dirty pages in the range */
	err = filemap_write_and_wait_range(inode->i_mapping, range->start,
2109
						range->start + range->len - 1);
C
Chao Yu 已提交
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
	if (err)
		goto out;

	/*
	 * lookup mapping info in extent cache, skip defragmenting if physical
	 * block addresses are continuous.
	 */
	if (f2fs_lookup_extent_cache(inode, pg_start, &ei)) {
		if (ei.fofs + ei.len >= pg_end)
			goto out;
	}

	map.m_lblk = pg_start;

	/*
	 * lookup mapping info in dnode page cache, skip defragmenting if all
	 * physical block addresses are continuous even if there are hole(s)
	 * in logical blocks.
	 */
	while (map.m_lblk < pg_end) {
2130
		map.m_len = pg_end - map.m_lblk;
2131
		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
C
Chao Yu 已提交
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
		if (err)
			goto out;

		if (!(map.m_flags & F2FS_MAP_FLAGS)) {
			map.m_lblk++;
			continue;
		}

		if (blk_end && blk_end != map.m_pblk) {
			fragmented = true;
			break;
		}
		blk_end = map.m_pblk + map.m_len;

		map.m_lblk += map.m_len;
	}

	if (!fragmented)
		goto out;

	map.m_lblk = pg_start;
	map.m_len = pg_end - pg_start;

2155
	sec_num = (map.m_len + BLKS_PER_SEC(sbi) - 1) / BLKS_PER_SEC(sbi);
C
Chao Yu 已提交
2156 2157 2158 2159 2160 2161

	/*
	 * make sure there are enough free section for LFS allocation, this can
	 * avoid defragment running in SSR mode when free section are allocated
	 * intensively
	 */
2162
	if (has_not_enough_free_secs(sbi, 0, sec_num)) {
C
Chao Yu 已提交
2163 2164 2165 2166 2167 2168 2169 2170 2171
		err = -EAGAIN;
		goto out;
	}

	while (map.m_lblk < pg_end) {
		pgoff_t idx;
		int cnt = 0;

do_map:
2172
		map.m_len = pg_end - map.m_lblk;
2173
		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
C
Chao Yu 已提交
2174 2175 2176 2177 2178 2179 2180 2181
		if (err)
			goto clear_out;

		if (!(map.m_flags & F2FS_MAP_FLAGS)) {
			map.m_lblk++;
			continue;
		}

2182
		set_inode_flag(inode, FI_DO_DEFRAG);
C
Chao Yu 已提交
2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206

		idx = map.m_lblk;
		while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
			struct page *page;

			page = get_lock_data_page(inode, idx, true);
			if (IS_ERR(page)) {
				err = PTR_ERR(page);
				goto clear_out;
			}

			set_page_dirty(page);
			f2fs_put_page(page, 1);

			idx++;
			cnt++;
			total++;
		}

		map.m_lblk = idx;

		if (idx < pg_end && cnt < blk_per_seg)
			goto do_map;

2207
		clear_inode_flag(inode, FI_DO_DEFRAG);
C
Chao Yu 已提交
2208 2209 2210 2211 2212 2213

		err = filemap_fdatawrite(inode->i_mapping);
		if (err)
			goto out;
	}
clear_out:
2214
	clear_inode_flag(inode, FI_DO_DEFRAG);
C
Chao Yu 已提交
2215
out:
A
Al Viro 已提交
2216
	inode_unlock(inode);
C
Chao Yu 已提交
2217
	if (!err)
2218
		range->len = (u64)total << PAGE_SHIFT;
C
Chao Yu 已提交
2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
	return err;
}

static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct f2fs_defragment range;
	int err;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

2232
	if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode))
C
Chao Yu 已提交
2233 2234
		return -EINVAL;

2235 2236
	if (f2fs_readonly(sbi->sb))
		return -EROFS;
C
Chao Yu 已提交
2237 2238

	if (copy_from_user(&range, (struct f2fs_defragment __user *)arg,
2239 2240
							sizeof(range)))
		return -EFAULT;
C
Chao Yu 已提交
2241 2242

	/* verify alignment of offset & size */
2243 2244
	if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
		return -EINVAL;
C
Chao Yu 已提交
2245

2246
	if (unlikely((range.start + range.len) >> PAGE_SHIFT >
2247 2248 2249 2250 2251 2252
					sbi->max_file_blocks))
		return -EINVAL;

	err = mnt_want_write_file(filp);
	if (err)
		return err;
2253

C
Chao Yu 已提交
2254
	err = f2fs_defragment_range(sbi, filp, &range);
2255 2256
	mnt_drop_write_file(filp);

2257
	f2fs_update_time(sbi, REQ_TIME);
C
Chao Yu 已提交
2258
	if (err < 0)
2259
		return err;
C
Chao Yu 已提交
2260 2261 2262

	if (copy_to_user((struct f2fs_defragment __user *)arg, &range,
							sizeof(range)))
2263 2264 2265
		return -EFAULT;

	return 0;
C
Chao Yu 已提交
2266 2267
}

2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284
static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
			struct file *file_out, loff_t pos_out, size_t len)
{
	struct inode *src = file_inode(file_in);
	struct inode *dst = file_inode(file_out);
	struct f2fs_sb_info *sbi = F2FS_I_SB(src);
	size_t olen = len, dst_max_i_size = 0;
	size_t dst_osize;
	int ret;

	if (file_in->f_path.mnt != file_out->f_path.mnt ||
				src->i_sb != dst->i_sb)
		return -EXDEV;

	if (unlikely(f2fs_readonly(src->i_sb)))
		return -EROFS;

2285 2286
	if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))
		return -EINVAL;
2287 2288 2289 2290

	if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst))
		return -EOPNOTSUPP;

2291 2292 2293 2294 2295 2296 2297
	if (src == dst) {
		if (pos_in == pos_out)
			return 0;
		if (pos_out > pos_in && pos_out < pos_in + len)
			return -EINVAL;
	}

2298
	inode_lock(src);
2299
	down_write(&F2FS_I(src)->dio_rwsem[WRITE]);
2300
	if (src != dst) {
2301 2302 2303 2304 2305
		ret = -EBUSY;
		if (!inode_trylock(dst))
			goto out;
		if (!down_write_trylock(&F2FS_I(dst)->dio_rwsem[WRITE])) {
			inode_unlock(dst);
2306 2307 2308
			goto out;
		}
	}
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352

	ret = -EINVAL;
	if (pos_in + len > src->i_size || pos_in + len < pos_in)
		goto out_unlock;
	if (len == 0)
		olen = len = src->i_size - pos_in;
	if (pos_in + len == src->i_size)
		len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
	if (len == 0) {
		ret = 0;
		goto out_unlock;
	}

	dst_osize = dst->i_size;
	if (pos_out + olen > dst->i_size)
		dst_max_i_size = pos_out + olen;

	/* verify the end result is block aligned */
	if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
			!IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
			!IS_ALIGNED(pos_out, F2FS_BLKSIZE))
		goto out_unlock;

	ret = f2fs_convert_inline_inode(src);
	if (ret)
		goto out_unlock;

	ret = f2fs_convert_inline_inode(dst);
	if (ret)
		goto out_unlock;

	/* write out all dirty pages from offset */
	ret = filemap_write_and_wait_range(src->i_mapping,
					pos_in, pos_in + len);
	if (ret)
		goto out_unlock;

	ret = filemap_write_and_wait_range(dst->i_mapping,
					pos_out, pos_out + len);
	if (ret)
		goto out_unlock;

	f2fs_balance_fs(sbi, true);
	f2fs_lock_op(sbi);
2353 2354 2355
	ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
				pos_out >> F2FS_BLKSIZE_BITS,
				len >> F2FS_BLKSIZE_BITS, false);
2356 2357 2358 2359 2360 2361 2362 2363 2364

	if (!ret) {
		if (dst_max_i_size)
			f2fs_i_size_write(dst, dst_max_i_size);
		else if (dst_osize != dst->i_size)
			f2fs_i_size_write(dst, dst_osize);
	}
	f2fs_unlock_op(sbi);
out_unlock:
2365 2366
	if (src != dst) {
		up_write(&F2FS_I(dst)->dio_rwsem[WRITE]);
2367
		inode_unlock(dst);
2368
	}
2369
out:
2370
	up_write(&F2FS_I(src)->dio_rwsem[WRITE]);
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
	inode_unlock(src);
	return ret;
}

static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
{
	struct f2fs_move_range range;
	struct fd dst;
	int err;

	if (!(filp->f_mode & FMODE_READ) ||
			!(filp->f_mode & FMODE_WRITE))
		return -EBADF;

	if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
							sizeof(range)))
		return -EFAULT;

	dst = fdget(range.dst_fd);
	if (!dst.file)
		return -EBADF;

	if (!(dst.file->f_mode & FMODE_WRITE)) {
		err = -EBADF;
		goto err_out;
	}

	err = mnt_want_write_file(filp);
	if (err)
		goto err_out;

	err = f2fs_move_file_range(filp, range.pos_in, dst.file,
					range.pos_out, range.len);

	mnt_drop_write_file(filp);
2406 2407
	if (err)
		goto err_out;
2408 2409 2410 2411 2412 2413 2414 2415 2416

	if (copy_to_user((struct f2fs_move_range __user *)arg,
						&range, sizeof(range)))
		err = -EFAULT;
err_out:
	fdput(dst);
	return err;
}

2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478
static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct sit_info *sm = SIT_I(sbi);
	unsigned int start_segno = 0, end_segno = 0;
	unsigned int dev_start_segno = 0, dev_end_segno = 0;
	struct f2fs_flush_device range;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (f2fs_readonly(sbi->sb))
		return -EROFS;

	if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
							sizeof(range)))
		return -EFAULT;

	if (sbi->s_ndevs <= 1 || sbi->s_ndevs - 1 <= range.dev_num ||
			sbi->segs_per_sec != 1) {
		f2fs_msg(sbi->sb, KERN_WARNING,
			"Can't flush %u in %d for segs_per_sec %u != 1\n",
				range.dev_num, sbi->s_ndevs,
				sbi->segs_per_sec);
		return -EINVAL;
	}

	ret = mnt_want_write_file(filp);
	if (ret)
		return ret;

	if (range.dev_num != 0)
		dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk);
	dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);

	start_segno = sm->last_victim[FLUSH_DEVICE];
	if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
		start_segno = dev_start_segno;
	end_segno = min(start_segno + range.segments, dev_end_segno);

	while (start_segno < end_segno) {
		if (!mutex_trylock(&sbi->gc_mutex)) {
			ret = -EBUSY;
			goto out;
		}
		sm->last_victim[GC_CB] = end_segno + 1;
		sm->last_victim[GC_GREEDY] = end_segno + 1;
		sm->last_victim[ALLOC_NEXT] = end_segno + 1;
		ret = f2fs_gc(sbi, true, true, start_segno);
		if (ret == -EAGAIN)
			ret = 0;
		else if (ret < 0)
			break;
		start_segno++;
	}
out:
	mnt_drop_write_file(filp);
	return ret;
}

2479 2480 2481 2482 2483 2484 2485 2486 2487 2488
static int f2fs_ioc_get_features(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature);

	/* Must validate to set it with SQLite behavior in Android. */
	sb_feature |= F2FS_FEATURE_ATOMIC_WRITE;

	return put_user(sb_feature, (u32 __user *)arg);
}
2489

2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682
#ifdef CONFIG_QUOTA
static int f2fs_ioc_setproject(struct file *filp, __u32 projid)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct super_block *sb = sbi->sb;
	struct dquot *transfer_to[MAXQUOTAS] = {};
	struct page *ipage;
	kprojid_t kprojid;
	int err;

	if (!f2fs_sb_has_project_quota(sb)) {
		if (projid != F2FS_DEF_PROJID)
			return -EOPNOTSUPP;
		else
			return 0;
	}

	if (!f2fs_has_extra_attr(inode))
		return -EOPNOTSUPP;

	kprojid = make_kprojid(&init_user_ns, (projid_t)projid);

	if (projid_eq(kprojid, F2FS_I(inode)->i_projid))
		return 0;

	err = mnt_want_write_file(filp);
	if (err)
		return err;

	err = -EPERM;
	inode_lock(inode);

	/* Is it quota file? Do not allow user to mess with it */
	if (IS_NOQUOTA(inode))
		goto out_unlock;

	ipage = get_node_page(sbi, inode->i_ino);
	if (IS_ERR(ipage)) {
		err = PTR_ERR(ipage);
		goto out_unlock;
	}

	if (!F2FS_FITS_IN_INODE(F2FS_INODE(ipage), fi->i_extra_isize,
								i_projid)) {
		err = -EOVERFLOW;
		f2fs_put_page(ipage, 1);
		goto out_unlock;
	}
	f2fs_put_page(ipage, 1);

	dquot_initialize(inode);

	transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
	if (!IS_ERR(transfer_to[PRJQUOTA])) {
		err = __dquot_transfer(inode, transfer_to);
		dqput(transfer_to[PRJQUOTA]);
		if (err)
			goto out_dirty;
	}

	F2FS_I(inode)->i_projid = kprojid;
	inode->i_ctime = current_time(inode);
out_dirty:
	f2fs_mark_inode_dirty_sync(inode, true);
out_unlock:
	inode_unlock(inode);
	mnt_drop_write_file(filp);
	return err;
}
#else
static int f2fs_ioc_setproject(struct file *filp, __u32 projid)
{
	if (projid != F2FS_DEF_PROJID)
		return -EOPNOTSUPP;
	return 0;
}
#endif

/* Transfer internal flags to xflags */
static inline __u32 f2fs_iflags_to_xflags(unsigned long iflags)
{
	__u32 xflags = 0;

	if (iflags & FS_SYNC_FL)
		xflags |= FS_XFLAG_SYNC;
	if (iflags & FS_IMMUTABLE_FL)
		xflags |= FS_XFLAG_IMMUTABLE;
	if (iflags & FS_APPEND_FL)
		xflags |= FS_XFLAG_APPEND;
	if (iflags & FS_NODUMP_FL)
		xflags |= FS_XFLAG_NODUMP;
	if (iflags & FS_NOATIME_FL)
		xflags |= FS_XFLAG_NOATIME;
	if (iflags & FS_PROJINHERIT_FL)
		xflags |= FS_XFLAG_PROJINHERIT;
	return xflags;
}

#define F2FS_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \
				  FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \
				  FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT)

/* Flags we can manipulate with through EXT4_IOC_FSSETXATTR */
#define F2FS_FL_XFLAG_VISIBLE		(FS_SYNC_FL | \
					 FS_IMMUTABLE_FL | \
					 FS_APPEND_FL | \
					 FS_NODUMP_FL | \
					 FS_NOATIME_FL | \
					 FS_PROJINHERIT_FL)

/* Transfer xflags flags to internal */
static inline unsigned long f2fs_xflags_to_iflags(__u32 xflags)
{
	unsigned long iflags = 0;

	if (xflags & FS_XFLAG_SYNC)
		iflags |= FS_SYNC_FL;
	if (xflags & FS_XFLAG_IMMUTABLE)
		iflags |= FS_IMMUTABLE_FL;
	if (xflags & FS_XFLAG_APPEND)
		iflags |= FS_APPEND_FL;
	if (xflags & FS_XFLAG_NODUMP)
		iflags |= FS_NODUMP_FL;
	if (xflags & FS_XFLAG_NOATIME)
		iflags |= FS_NOATIME_FL;
	if (xflags & FS_XFLAG_PROJINHERIT)
		iflags |= FS_PROJINHERIT_FL;

	return iflags;
}

static int f2fs_ioc_fsgetxattr(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct fsxattr fa;

	memset(&fa, 0, sizeof(struct fsxattr));
	fa.fsx_xflags = f2fs_iflags_to_xflags(fi->i_flags &
				(FS_FL_USER_VISIBLE | FS_PROJINHERIT_FL));

	if (f2fs_sb_has_project_quota(inode->i_sb))
		fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,
							fi->i_projid);

	if (copy_to_user((struct fsxattr __user *)arg, &fa, sizeof(fa)))
		return -EFAULT;
	return 0;
}

static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg)
{
	struct inode *inode = file_inode(filp);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct fsxattr fa;
	unsigned int flags;
	int err;

	if (copy_from_user(&fa, (struct fsxattr __user *)arg, sizeof(fa)))
		return -EFAULT;

	/* Make sure caller has proper permission */
	if (!inode_owner_or_capable(inode))
		return -EACCES;

	if (fa.fsx_xflags & ~F2FS_SUPPORTED_FS_XFLAGS)
		return -EOPNOTSUPP;

	flags = f2fs_xflags_to_iflags(fa.fsx_xflags);
	if (f2fs_mask_flags(inode->i_mode, flags) != flags)
		return -EOPNOTSUPP;

	err = mnt_want_write_file(filp);
	if (err)
		return err;

	inode_lock(inode);
	flags = (fi->i_flags & ~F2FS_FL_XFLAG_VISIBLE) |
				(flags & F2FS_FL_XFLAG_VISIBLE);
	err = __f2fs_ioc_setflags(inode, flags);
	inode_unlock(inode);
	mnt_drop_write_file(filp);
	if (err)
		return err;

	err = f2fs_ioc_setproject(filp, fa.fsx_projid);
	if (err)
		return err;

	return 0;
}
2683

2684 2685
long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
2686 2687 2688
	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
		return -EIO;

2689 2690 2691 2692 2693
	switch (cmd) {
	case F2FS_IOC_GETFLAGS:
		return f2fs_ioc_getflags(filp, arg);
	case F2FS_IOC_SETFLAGS:
		return f2fs_ioc_setflags(filp, arg);
2694 2695
	case F2FS_IOC_GETVERSION:
		return f2fs_ioc_getversion(filp, arg);
J
Jaegeuk Kim 已提交
2696 2697 2698 2699
	case F2FS_IOC_START_ATOMIC_WRITE:
		return f2fs_ioc_start_atomic_write(filp);
	case F2FS_IOC_COMMIT_ATOMIC_WRITE:
		return f2fs_ioc_commit_atomic_write(filp);
2700 2701
	case F2FS_IOC_START_VOLATILE_WRITE:
		return f2fs_ioc_start_volatile_write(filp);
2702 2703 2704 2705
	case F2FS_IOC_RELEASE_VOLATILE_WRITE:
		return f2fs_ioc_release_volatile_write(filp);
	case F2FS_IOC_ABORT_VOLATILE_WRITE:
		return f2fs_ioc_abort_volatile_write(filp);
J
Jaegeuk Kim 已提交
2706 2707
	case F2FS_IOC_SHUTDOWN:
		return f2fs_ioc_shutdown(filp, arg);
2708 2709
	case FITRIM:
		return f2fs_ioc_fitrim(filp, arg);
2710 2711 2712 2713 2714 2715
	case F2FS_IOC_SET_ENCRYPTION_POLICY:
		return f2fs_ioc_set_encryption_policy(filp, arg);
	case F2FS_IOC_GET_ENCRYPTION_POLICY:
		return f2fs_ioc_get_encryption_policy(filp, arg);
	case F2FS_IOC_GET_ENCRYPTION_PWSALT:
		return f2fs_ioc_get_encryption_pwsalt(filp, arg);
2716 2717
	case F2FS_IOC_GARBAGE_COLLECT:
		return f2fs_ioc_gc(filp, arg);
2718 2719
	case F2FS_IOC_GARBAGE_COLLECT_RANGE:
		return f2fs_ioc_gc_range(filp, arg);
2720 2721
	case F2FS_IOC_WRITE_CHECKPOINT:
		return f2fs_ioc_write_checkpoint(filp, arg);
C
Chao Yu 已提交
2722 2723
	case F2FS_IOC_DEFRAGMENT:
		return f2fs_ioc_defragment(filp, arg);
2724 2725
	case F2FS_IOC_MOVE_RANGE:
		return f2fs_ioc_move_range(filp, arg);
2726 2727
	case F2FS_IOC_FLUSH_DEVICE:
		return f2fs_ioc_flush_device(filp, arg);
2728 2729
	case F2FS_IOC_GET_FEATURES:
		return f2fs_ioc_get_features(filp, arg);
2730 2731 2732 2733
	case F2FS_IOC_FSGETXATTR:
		return f2fs_ioc_fsgetxattr(filp, arg);
	case F2FS_IOC_FSSETXATTR:
		return f2fs_ioc_fssetxattr(filp, arg);
J
Jaegeuk Kim 已提交
2734 2735 2736 2737 2738
	default:
		return -ENOTTY;
	}
}

2739 2740
static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
2741 2742
	struct file *file = iocb->ki_filp;
	struct inode *inode = file_inode(file);
2743
	struct blk_plug plug;
2744
	ssize_t ret;
2745

2746 2747 2748
	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
		return -EIO;

2749 2750 2751
	inode_lock(inode);
	ret = generic_write_checks(iocb, from);
	if (ret > 0) {
2752
		int err;
2753

2754 2755
		if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
			set_inode_flag(inode, FI_NO_PREALLOC);
2756

2757
		err = f2fs_preallocate_blocks(iocb, from);
2758
		if (err) {
2759
			clear_inode_flag(inode, FI_NO_PREALLOC);
2760 2761
			inode_unlock(inode);
			return err;
2762
		}
2763 2764 2765
		blk_start_plug(&plug);
		ret = __generic_file_write_iter(iocb, from);
		blk_finish_plug(&plug);
2766
		clear_inode_flag(inode, FI_NO_PREALLOC);
C
Chao Yu 已提交
2767 2768 2769

		if (ret > 0)
			f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret);
2770 2771 2772
	}
	inode_unlock(inode);

2773 2774
	if (ret > 0)
		ret = generic_write_sync(iocb, ret);
2775
	return ret;
2776 2777
}

2778 2779 2780 2781 2782 2783 2784 2785 2786 2787
#ifdef CONFIG_COMPAT
long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case F2FS_IOC32_GETFLAGS:
		cmd = F2FS_IOC_GETFLAGS;
		break;
	case F2FS_IOC32_SETFLAGS:
		cmd = F2FS_IOC_SETFLAGS;
		break;
2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
	case F2FS_IOC32_GETVERSION:
		cmd = F2FS_IOC_GETVERSION;
		break;
	case F2FS_IOC_START_ATOMIC_WRITE:
	case F2FS_IOC_COMMIT_ATOMIC_WRITE:
	case F2FS_IOC_START_VOLATILE_WRITE:
	case F2FS_IOC_RELEASE_VOLATILE_WRITE:
	case F2FS_IOC_ABORT_VOLATILE_WRITE:
	case F2FS_IOC_SHUTDOWN:
	case F2FS_IOC_SET_ENCRYPTION_POLICY:
	case F2FS_IOC_GET_ENCRYPTION_PWSALT:
	case F2FS_IOC_GET_ENCRYPTION_POLICY:
	case F2FS_IOC_GARBAGE_COLLECT:
2801
	case F2FS_IOC_GARBAGE_COLLECT_RANGE:
2802 2803
	case F2FS_IOC_WRITE_CHECKPOINT:
	case F2FS_IOC_DEFRAGMENT:
2804
	case F2FS_IOC_MOVE_RANGE:
2805
	case F2FS_IOC_FLUSH_DEVICE:
2806
	case F2FS_IOC_GET_FEATURES:
2807 2808
	case F2FS_IOC_FSGETXATTR:
	case F2FS_IOC_FSSETXATTR:
2809
		break;
2810 2811 2812 2813 2814 2815 2816
	default:
		return -ENOIOCTLCMD;
	}
	return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
}
#endif

J
Jaegeuk Kim 已提交
2817
const struct file_operations f2fs_file_operations = {
2818
	.llseek		= f2fs_llseek,
2819
	.read_iter	= generic_file_read_iter,
2820 2821
	.write_iter	= f2fs_file_write_iter,
	.open		= f2fs_file_open,
2822
	.release	= f2fs_release_file,
J
Jaegeuk Kim 已提交
2823
	.mmap		= f2fs_file_mmap,
2824
	.flush		= f2fs_file_flush,
J
Jaegeuk Kim 已提交
2825 2826 2827
	.fsync		= f2fs_sync_file,
	.fallocate	= f2fs_fallocate,
	.unlocked_ioctl	= f2fs_ioctl,
2828 2829 2830
#ifdef CONFIG_COMPAT
	.compat_ioctl	= f2fs_compat_ioctl,
#endif
J
Jaegeuk Kim 已提交
2831
	.splice_read	= generic_file_splice_read,
2832
	.splice_write	= iter_file_splice_write,
J
Jaegeuk Kim 已提交
2833
};