file.c 46.9 KB
Newer Older
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1
/*
Jaegeuk Kim's avatar
Jaegeuk Kim committed
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>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
17 18
#include <linux/falloc.h>
#include <linux/types.h>
19
#include <linux/compat.h>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
20 21
#include <linux/uaccess.h>
#include <linux/mount.h>
22
#include <linux/pagevec.h>
23
#include <linux/uuid.h>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
24 25 26 27 28 29

#include "f2fs.h"
#include "node.h"
#include "segment.h"
#include "xattr.h"
#include "acl.h"
30
#include "gc.h"
Jaegeuk Kim's avatar
Jaegeuk Kim committed
31
#include "trace.h"
32
#include <trace/events/f2fs.h>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
33 34 35 36 37

static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
						struct vm_fault *vmf)
{
	struct page *page = vmf->page;
38
	struct inode *inode = file_inode(vma->vm_file);
39
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
40
	struct dnode_of_data dn;
41
	int err;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
42 43

	sb_start_pagefault(inode->i_sb);
44 45

	f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
46

Jaegeuk Kim's avatar
Jaegeuk Kim committed
47
	/* block allocation */
48
	f2fs_lock_op(sbi);
49
	set_new_dnode(&dn, inode, NULL, NULL, 0);
50
	err = f2fs_reserve_block(&dn, page->index);
51 52
	if (err) {
		f2fs_unlock_op(sbi);
53
		goto out;
54 55 56
	}
	f2fs_put_dnode(&dn);
	f2fs_unlock_op(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
57

Jaegeuk Kim's avatar
Jaegeuk Kim committed
58
	f2fs_balance_fs(sbi, dn.node_changed);
59

60
	file_update_time(vma->vm_file);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
61
	lock_page(page);
62
	if (unlikely(page->mapping != inode->i_mapping ||
63
			page_offset(page) > i_size_read(inode) ||
64
			!PageUptodate(page))) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
65 66 67 68 69 70 71 72 73
		unlock_page(page);
		err = -EFAULT;
		goto out;
	}

	/*
	 * check to see if the page is mapped already (no holes)
	 */
	if (PageMappedToDisk(page))
74
		goto mapped;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
75 76

	/* page is wholly or partially inside EOF */
77
	if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
78
						i_size_read(inode)) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
79
		unsigned offset;
80 81
		offset = i_size_read(inode) & ~PAGE_MASK;
		zero_user_segment(page, offset, PAGE_SIZE);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
82 83
	}
	set_page_dirty(page);
84 85
	if (!PageUptodate(page))
		SetPageUptodate(page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
86

87
	trace_f2fs_vm_page_mkwrite(page, DATA);
88 89
mapped:
	/* fill the page */
90
	f2fs_wait_on_page_writeback(page, DATA, false);
91 92 93 94 95

	/* wait for GCed encrypted page writeback */
	if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
		f2fs_wait_on_encrypted_page_writeback(sbi, dn.data_blkaddr);

96 97
	/* if gced page is attached, don't write to cold segment */
	clear_cold_data(page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
98 99
out:
	sb_end_pagefault(inode->i_sb);
100
	f2fs_update_time(sbi, REQ_TIME);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
101 102 103 104
	return block_page_mkwrite_return(err);
}

static const struct vm_operations_struct f2fs_file_vm_ops = {
105
	.fault		= filemap_fault,
106
	.map_pages	= filemap_map_pages,
107
	.page_mkwrite	= f2fs_vm_page_mkwrite,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
108 109
};

110 111 112 113 114 115 116 117 118 119
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;

120
	if (update_dent_inode(inode, inode, &dentry->d_name)) {
121 122 123
		dput(dentry);
		return 0;
	}
124

125 126
	*pino = parent_ino(dentry);
	dput(dentry);
127 128 129
	return 1;
}

130 131
static inline bool need_do_checkpoint(struct inode *inode)
{
132
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
133 134 135 136
	bool need_cp = false;

	if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
		need_cp = true;
137 138
	else if (file_enc_name(inode) && need_dentry_mark(sbi, inode->i_ino))
		need_cp = true;
139 140 141 142 143 144 145 146
	else if (file_wrong_pino(inode))
		need_cp = true;
	else if (!space_for_roll_forward(sbi))
		need_cp = true;
	else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
		need_cp = true;
	else if (F2FS_I(inode)->xattr_ver == cur_cp_version(F2FS_CKPT(sbi)))
		need_cp = true;
147 148
	else if (test_opt(sbi, FASTBOOT))
		need_cp = true;
149 150
	else if (sbi->active_logs == 2)
		need_cp = true;
151 152 153 154

	return need_cp;
}

155 156 157 158 159 160 161 162 163 164 165
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;
}

166 167 168 169 170 171 172 173 174
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);
	fi->xattr_ver = 0;
	if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
			get_parent_ino(inode, &pino)) {
175
		f2fs_i_pino_write(inode, pino);
176 177
		file_got_pino(inode);
	}
178
	up_write(&fi->i_sem);
179 180
}

181 182
static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
						int datasync, bool atomic)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
183 184
{
	struct inode *inode = file->f_mapping->host;
185
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
186
	nid_t ino = inode->i_ino;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
187 188 189
	int ret = 0;
	bool need_cp = false;
	struct writeback_control wbc = {
190
		.sync_mode = WB_SYNC_ALL,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
191 192 193 194
		.nr_to_write = LONG_MAX,
		.for_reclaim = 0,
	};

195
	if (unlikely(f2fs_readonly(inode->i_sb)))
196 197
		return 0;

198
	trace_f2fs_sync_file_enter(inode);
199 200

	/* if fdatasync is triggered, let's do in-place-update */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
201
	if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
202
		set_inode_flag(inode, FI_NEED_IPU);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
203
	ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
204
	clear_inode_flag(inode, FI_NEED_IPU);
205

206 207
	if (ret) {
		trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
208
		return ret;
209
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
210

211
	/* if the inode is dirty, let's recover all the time */
212
	if (!datasync && !f2fs_skip_inode_update(inode)) {
213
		f2fs_write_inode(inode, NULL);
214 215 216
		goto go_write;
	}

217 218 219
	/*
	 * if there is no written data, don't waste time to write recovery info.
	 */
220
	if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
221
			!exist_written_data(sbi, ino, APPEND_INO)) {
222

223 224
		/* it may call write_inode just prior to fsync */
		if (need_inode_page_update(sbi, ino))
225 226
			goto go_write;

227
		if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
228
				exist_written_data(sbi, ino, UPDATE_INO))
229 230 231
			goto flush_out;
		goto out;
	}
232
go_write:
233 234 235 236
	/*
	 * Both of fdatasync() and fsync() are able to be recovered from
	 * sudden-power-off.
	 */
237
	down_read(&F2FS_I(inode)->i_sem);
238
	need_cp = need_do_checkpoint(inode);
239
	up_read(&F2FS_I(inode)->i_sem);
240

Jaegeuk Kim's avatar
Jaegeuk Kim committed
241 242 243
	if (need_cp) {
		/* all the dirty node pages should be flushed for POR */
		ret = f2fs_sync_fs(inode->i_sb, 1);
244

245 246 247 248 249
		/*
		 * We've secured consistency through sync_fs. Following pino
		 * will be used only for fsynced inodes after checkpoint.
		 */
		try_to_fix_pino(inode);
250 251
		clear_inode_flag(inode, FI_APPEND_WRITE);
		clear_inode_flag(inode, FI_UPDATE_WRITE);
252 253
		goto out;
	}
254
sync_nodes:
255
	ret = fsync_node_pages(sbi, inode, &wbc, atomic);
256 257
	if (ret)
		goto out;
258

259
	/* if cp_error was enabled, we should avoid infinite loop */
260 261
	if (unlikely(f2fs_cp_error(sbi))) {
		ret = -EIO;
262
		goto out;
263
	}
264

265
	if (need_inode_block_update(sbi, ino)) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
266
		f2fs_mark_inode_dirty_sync(inode);
267 268
		f2fs_write_inode(inode, NULL);
		goto sync_nodes;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
269
	}
270 271 272 273 274 275

	ret = wait_on_node_pages_writeback(sbi, ino);
	if (ret)
		goto out;

	/* once recovery info is written, don't need to tack this */
276
	remove_ino_entry(sbi, ino, APPEND_INO);
277
	clear_inode_flag(inode, FI_APPEND_WRITE);
278
flush_out:
279
	remove_ino_entry(sbi, ino, UPDATE_INO);
280
	clear_inode_flag(inode, FI_UPDATE_WRITE);
281
	ret = f2fs_issue_flush(sbi);
282
	f2fs_update_time(sbi, REQ_TIME);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
283
out:
284
	trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
285
	f2fs_trace_ios(NULL, 1);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
286 287 288
	return ret;
}

289 290 291 292 293
int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
{
	return f2fs_do_sync_file(file, start, end, datasync, false);
}

294 295 296 297 298 299 300 301 302 303 304
static pgoff_t __get_first_dirty_index(struct address_space *mapping,
						pgoff_t pgofs, int whence)
{
	struct pagevec pvec;
	int nr_pages;

	if (whence != SEEK_DATA)
		return 0;

	/* find first dirty page index */
	pagevec_init(&pvec, 0);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
305 306
	nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
					PAGECACHE_TAG_DIRTY, 1);
307
	pgofs = nr_pages ? pvec.pages[0]->index : ULONG_MAX;
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	pagevec_release(&pvec);
	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;
}

329 330 331 332 333
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;
334 335 336
	pgoff_t pgofs, end_offset, dirty;
	loff_t data_ofs = offset;
	loff_t isize;
337 338
	int err = 0;

Al Viro's avatar
Al Viro committed
339
	inode_lock(inode);
340 341 342 343 344 345

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

	/* handle inline data case */
Chao Yu's avatar
Chao Yu committed
346
	if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
347 348 349 350 351
		if (whence == SEEK_HOLE)
			data_ofs = isize;
		goto found;
	}

352
	pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
353

354 355
	dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);

356
	for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
357
		set_new_dnode(&dn, inode, NULL, NULL, 0);
358
		err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
359 360 361
		if (err && err != -ENOENT) {
			goto fail;
		} else if (err == -ENOENT) {
arter97's avatar
arter97 committed
362
			/* direct node does not exists */
363
			if (whence == SEEK_DATA) {
364
				pgofs = get_next_page_offset(&dn, pgofs);
365 366 367 368 369 370
				continue;
			} else {
				goto found;
			}
		}

371
		end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
372 373 374 375

		/* find data/hole in dnode block */
		for (; dn.ofs_in_node < end_offset;
				dn.ofs_in_node++, pgofs++,
376
				data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
377 378 379
			block_t blkaddr;
			blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);

380
			if (__found_offset(blkaddr, dirty, pgofs, whence)) {
381 382 383 384 385 386 387 388 389 390
				f2fs_put_dnode(&dn);
				goto found;
			}
		}
		f2fs_put_dnode(&dn);
	}

	if (whence == SEEK_DATA)
		goto fail;
found:
391 392
	if (whence == SEEK_HOLE && data_ofs > isize)
		data_ofs = isize;
Al Viro's avatar
Al Viro committed
393
	inode_unlock(inode);
394 395
	return vfs_setpos(file, data_ofs, maxbytes);
fail:
Al Viro's avatar
Al Viro committed
396
	inode_unlock(inode);
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
	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:
413 414
		if (offset < 0)
			return -ENXIO;
415 416 417 418 419 420
		return f2fs_seek_block(file, offset, whence);
	}

	return -EINVAL;
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
421 422
static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
423
	struct inode *inode = file_inode(file);
424
	int err;
425

426
	if (f2fs_encrypted_inode(inode)) {
427
		err = fscrypt_get_encryption_info(inode);
428 429
		if (err)
			return 0;
430 431
		if (!f2fs_encrypted_inode(inode))
			return -ENOKEY;
432 433
	}

434
	/* we don't need to use inline_data strictly */
435 436 437
	err = f2fs_convert_inline_inode(inode);
	if (err)
		return err;
438

Jaegeuk Kim's avatar
Jaegeuk Kim committed
439 440 441 442 443
	file_accessed(file);
	vma->vm_ops = &f2fs_file_vm_ops;
	return 0;
}

444 445 446
static int f2fs_file_open(struct inode *inode, struct file *filp)
{
	int ret = generic_file_open(inode, filp);
447
	struct dentry *dir;
448 449

	if (!ret && f2fs_encrypted_inode(inode)) {
450
		ret = fscrypt_get_encryption_info(inode);
451
		if (ret)
452
			return -EACCES;
453
		if (!fscrypt_has_encryption_key(inode))
454
			return -ENOKEY;
455
	}
456 457 458 459
	dir = dget_parent(file_dentry(filp));
	if (f2fs_encrypted_inode(d_inode(dir)) &&
			!fscrypt_has_permitted_context(d_inode(dir), inode)) {
		dput(dir);
460
		return -EPERM;
461 462
	}
	dput(dir);
463 464 465
	return ret;
}

466
int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
467
{
468
	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
469
	struct f2fs_node *raw_node;
Chao Yu's avatar
Chao Yu committed
470
	int nr_free = 0, ofs = dn->ofs_in_node, len = count;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
471 472
	__le32 *addr;

473
	raw_node = F2FS_NODE(dn->node_page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
474 475
	addr = blkaddr_in_node(raw_node) + ofs;

Chris Fries's avatar
Chris Fries committed
476
	for (; count > 0; count--, addr++, dn->ofs_in_node++) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
477 478 479 480
		block_t blkaddr = le32_to_cpu(*addr);
		if (blkaddr == NULL_ADDR)
			continue;

481
		dn->data_blkaddr = NULL_ADDR;
482
		set_data_blkaddr(dn);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
483
		invalidate_blocks(sbi, blkaddr);
484
		if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
485
			clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
486 487
		nr_free++;
	}
Chao Yu's avatar
Chao Yu committed
488

Jaegeuk Kim's avatar
Jaegeuk Kim committed
489
	if (nr_free) {
Chao Yu's avatar
Chao Yu committed
490 491 492 493 494 495
		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),
496
							dn->inode) + ofs;
Chao Yu's avatar
Chao Yu committed
497
		f2fs_update_extent_cache_range(dn, fofs, 0, len);
498
		dec_valid_block_count(sbi, dn->inode, nr_free);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
499 500
	}
	dn->ofs_in_node = ofs;
501

502
	f2fs_update_time(sbi, REQ_TIME);
503 504
	trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
					 dn->ofs_in_node, nr_free);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
505 506 507 508 509 510 511 512
	return nr_free;
}

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

513
static int truncate_partial_data_page(struct inode *inode, u64 from,
514
								bool cache_only)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
515
{
516 517
	unsigned offset = from & (PAGE_SIZE - 1);
	pgoff_t index = from >> PAGE_SHIFT;
518
	struct address_space *mapping = inode->i_mapping;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
519 520
	struct page *page;

521
	if (!offset && !cache_only)
522
		return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
523

524
	if (cache_only) {
525
		page = f2fs_grab_cache_page(mapping, index, false);
526 527 528
		if (page && PageUptodate(page))
			goto truncate_out;
		f2fs_put_page(page, 1);
529
		return 0;
530
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
531

532
	page = get_lock_data_page(inode, index, true);
533 534 535
	if (IS_ERR(page))
		return 0;
truncate_out:
536
	f2fs_wait_on_page_writeback(page, DATA, true);
537
	zero_user(page, offset, PAGE_SIZE - offset);
538 539
	if (!cache_only || !f2fs_encrypted_inode(inode) ||
					!S_ISREG(inode->i_mode))
540
		set_page_dirty(page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
541
	f2fs_put_page(page, 1);
542
	return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
543 544
}

545
int truncate_blocks(struct inode *inode, u64 from, bool lock)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
546
{
547
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
548 549 550
	unsigned int blocksize = inode->i_sb->s_blocksize;
	struct dnode_of_data dn;
	pgoff_t free_from;
551
	int count = 0, err = 0;
552
	struct page *ipage;
553
	bool truncate_page = false;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
554

555 556
	trace_f2fs_truncate_blocks_enter(inode, from);

557
	free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
558

559 560 561
	if (free_from >= sbi->max_file_blocks)
		goto free_partial;

562 563
	if (lock)
		f2fs_lock_op(sbi);
564

565 566 567 568 569 570 571
	ipage = get_node_page(sbi, inode->i_ino);
	if (IS_ERR(ipage)) {
		err = PTR_ERR(ipage);
		goto out;
	}

	if (f2fs_has_inline_data(inode)) {
572 573
		if (truncate_inline_inode(ipage, from))
			set_page_dirty(ipage);
574
		f2fs_put_page(ipage, 1);
575
		truncate_page = true;
576 577 578 579
		goto out;
	}

	set_new_dnode(&dn, inode, ipage, NULL, 0);
580
	err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
581 582 583
	if (err) {
		if (err == -ENOENT)
			goto free_next;
584
		goto out;
585 586
	}

587
	count = ADDRS_PER_PAGE(dn.node_page, inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
588 589

	count -= dn.ofs_in_node;
590
	f2fs_bug_on(sbi, count < 0);
591

Jaegeuk Kim's avatar
Jaegeuk Kim committed
592 593 594 595 596 597 598 599
	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);
600 601 602
out:
	if (lock)
		f2fs_unlock_op(sbi);
603
free_partial:
604 605
	/* lastly zero out the first data page */
	if (!err)
606
		err = truncate_partial_data_page(inode, from, truncate_page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
607

608
	trace_f2fs_truncate_blocks_exit(inode, err);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
609 610 611
	return err;
}

612
int f2fs_truncate(struct inode *inode)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
613
{
614 615
	int err;

Jaegeuk Kim's avatar
Jaegeuk Kim committed
616 617
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
				S_ISLNK(inode->i_mode)))
618
		return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
619

620 621
	trace_f2fs_truncate(inode);

622
	/* we should check inline_data size */
623
	if (!f2fs_may_inline_data(inode)) {
624 625 626
		err = f2fs_convert_inline_inode(inode);
		if (err)
			return err;
627 628
	}

629
	err = truncate_blocks(inode, i_size_read(inode), true);
630 631 632 633
	if (err)
		return err;

	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
634
	f2fs_mark_inode_dirty_sync(inode);
635
	return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
636 637
}

638
int f2fs_getattr(struct vfsmount *mnt,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
639 640
			 struct dentry *dentry, struct kstat *stat)
{
641
	struct inode *inode = d_inode(dentry);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
	generic_fillattr(inode, stat);
	stat->blocks <<= 3;
	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;
670
		set_acl_inode(inode, mode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
671 672 673 674 675 676 677 678
	}
}
#else
#define __setattr_copy setattr_copy
#endif

int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
{
679
	struct inode *inode = d_inode(dentry);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
680 681 682 683 684 685
	int err;

	err = inode_change_ok(inode, attr);
	if (err)
		return err;

686
	if (attr->ia_valid & ATTR_SIZE) {
687
		if (f2fs_encrypted_inode(inode) &&
688
				fscrypt_get_encryption_info(inode))
689 690
			return -EACCES;

691
		if (attr->ia_size <= i_size_read(inode)) {
692
			truncate_setsize(inode, attr->ia_size);
693
			err = f2fs_truncate(inode);
694 695
			if (err)
				return err;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
696
			f2fs_balance_fs(F2FS_I_SB(inode), true);
697 698
		} else {
			/*
699 700
			 * do not trim all blocks after i_size if target size is
			 * larger than i_size.
701
			 */
702
			truncate_setsize(inode, attr->ia_size);
703 704

			/* should convert inline inode here */
705
			if (!f2fs_may_inline_data(inode)) {
706 707 708 709
				err = f2fs_convert_inline_inode(inode);
				if (err)
					return err;
			}
710
			inode->i_mtime = inode->i_ctime = CURRENT_TIME;
711
		}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
712 713 714 715 716
	}

	__setattr_copy(inode, attr);

	if (attr->ia_valid & ATTR_MODE) {
717
		err = posix_acl_chmod(inode, get_inode_mode(inode));
718 719 720
		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);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
721 722 723
		}
	}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
724
	f2fs_mark_inode_dirty_sync(inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
725 726 727 728 729 730 731
	return err;
}

const struct inode_operations f2fs_file_inode_operations = {
	.getattr	= f2fs_getattr,
	.setattr	= f2fs_setattr,
	.get_acl	= f2fs_get_acl,
732
	.set_acl	= f2fs_set_acl,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
733 734 735 736 737 738
#ifdef CONFIG_F2FS_FS_XATTR
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= f2fs_listxattr,
	.removexattr	= generic_removexattr,
#endif
Jaegeuk Kim's avatar
Jaegeuk Kim committed
739
	.fiemap		= f2fs_fiemap,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
740 741
};

Chao Yu's avatar
Chao Yu committed
742
static int fill_zero(struct inode *inode, pgoff_t index,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
743 744
					loff_t start, loff_t len)
{
745
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
746 747 748
	struct page *page;

	if (!len)
Chao Yu's avatar
Chao Yu committed
749
		return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
750

Jaegeuk Kim's avatar
Jaegeuk Kim committed
751
	f2fs_balance_fs(sbi, true);
752

753
	f2fs_lock_op(sbi);
754
	page = get_new_data_page(inode, NULL, index, false);
755
	f2fs_unlock_op(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
756

Chao Yu's avatar
Chao Yu committed
757 758 759
	if (IS_ERR(page))
		return PTR_ERR(page);

760
	f2fs_wait_on_page_writeback(page, DATA, true);
Chao Yu's avatar
Chao Yu committed
761 762 763 764
	zero_user(page, start, len);
	set_page_dirty(page);
	f2fs_put_page(page, 1);
	return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
765 766 767 768 769 770
}

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

771
	while (pg_start < pg_end) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
772
		struct dnode_of_data dn;
773
		pgoff_t end_offset, count;
774

Jaegeuk Kim's avatar
Jaegeuk Kim committed
775
		set_new_dnode(&dn, inode, NULL, NULL, 0);
776
		err = get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
777
		if (err) {
778 779
			if (err == -ENOENT) {
				pg_start++;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
780
				continue;
781
			}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
782 783 784
			return err;
		}

785
		end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
786 787 788 789 790
		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);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
791
		f2fs_put_dnode(&dn);
792 793

		pg_start += count;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
794 795 796 797
	}
	return 0;
}

798
static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
799 800 801
{
	pgoff_t pg_start, pg_end;
	loff_t off_start, off_end;
802
	int ret;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
803

804 805 806
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
		return ret;
807

808 809
	pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
	pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
810

811 812
	off_start = offset & (PAGE_SIZE - 1);
	off_end = (offset + len) & (PAGE_SIZE - 1);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
813 814

	if (pg_start == pg_end) {
Chao Yu's avatar
Chao Yu committed
815
		ret = fill_zero(inode, pg_start, off_start,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
816
						off_end - off_start);
Chao Yu's avatar
Chao Yu committed
817 818
		if (ret)
			return ret;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
819
	} else {
Chao Yu's avatar
Chao Yu committed
820 821
		if (off_start) {
			ret = fill_zero(inode, pg_start++, off_start,
822
						PAGE_SIZE - off_start);
Chao Yu's avatar
Chao Yu committed
823 824 825 826 827 828 829 830
			if (ret)
				return ret;
		}
		if (off_end) {
			ret = fill_zero(inode, pg_end, 0, off_end);
			if (ret)
				return ret;
		}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
831 832 833 834

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

Jaegeuk Kim's avatar
Jaegeuk Kim committed
837
			f2fs_balance_fs(sbi, true);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
838

839