file.c 47 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 84 85
	}
	set_page_dirty(page);
	SetPageUptodate(page);

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

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

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

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

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

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

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

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

	if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
		need_cp = true;
136 137
	else if (file_enc_name(inode) && need_dentry_mark(sbi, inode->i_ino))
		need_cp = true;
138 139 140 141 142 143 144 145
	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;
146 147
	else if (test_opt(sbi, FASTBOOT))
		need_cp = true;
148 149
	else if (sbi->active_logs == 2)
		need_cp = true;
150 151 152 153

	return need_cp;
}

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

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
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)) {
		fi->i_pino = pino;
		file_got_pino(inode);
		up_write(&fi->i_sem);

		mark_inode_dirty_sync(inode);
		f2fs_write_inode(inode, NULL);
	} else {
		up_write(&fi->i_sem);
	}
}

185 186
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
187 188
{
	struct inode *inode = file->f_mapping->host;
189
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
190
	nid_t ino = inode->i_ino;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
191 192 193
	int ret = 0;
	bool need_cp = false;
	struct writeback_control wbc = {
194
		.sync_mode = WB_SYNC_ALL,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
195 196 197 198
		.nr_to_write = LONG_MAX,
		.for_reclaim = 0,
	};

199
	if (unlikely(f2fs_readonly(inode->i_sb)))
200 201
		return 0;

202
	trace_f2fs_sync_file_enter(inode);
203 204

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

210 211
	if (ret) {
		trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
212
		return ret;
213
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
214

215
	/* if the inode is dirty, let's recover all the time */
216 217
	if (!datasync) {
		f2fs_write_inode(inode, NULL);
218 219 220
		goto go_write;
	}

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

227 228
		/* it may call write_inode just prior to fsync */
		if (need_inode_page_update(sbi, ino))
229 230
			goto go_write;

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

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

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

263
	/* if cp_error was enabled, we should avoid infinite loop */
264 265
	if (unlikely(f2fs_cp_error(sbi))) {
		ret = -EIO;
266
		goto out;
267
	}
268

269 270 271 272
	if (need_inode_block_update(sbi, ino)) {
		mark_inode_dirty_sync(inode);
		f2fs_write_inode(inode, NULL);
		goto sync_nodes;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
273
	}
274 275 276 277 278 279

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

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

293 294 295 296 297
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);
}

298 299 300 301 302 303 304 305 306 307 308
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
309 310
	nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
					PAGECACHE_TAG_DIRTY, 1);
311
	pgofs = nr_pages ? pvec.pages[0]->index : ULONG_MAX;
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
	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;
}

333 334 335 336 337
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;
338 339 340
	pgoff_t pgofs, end_offset, dirty;
	loff_t data_ofs = offset;
	loff_t isize;
341 342
	int err = 0;

Al Viro's avatar
Al Viro committed
343
	inode_lock(inode);
344 345 346 347 348 349

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

	/* handle inline data case */
Chao Yu's avatar
Chao Yu committed
350
	if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
351 352 353 354 355
		if (whence == SEEK_HOLE)
			data_ofs = isize;
		goto found;
	}

356
	pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
357

358 359
	dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);

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

375
		end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
376 377 378 379

		/* find data/hole in dnode block */
		for (; dn.ofs_in_node < end_offset;
				dn.ofs_in_node++, pgofs++,
380
				data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
381 382 383
			block_t blkaddr;
			blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);

384
			if (__found_offset(blkaddr, dirty, pgofs, whence)) {
385 386 387 388 389 390 391 392 393 394
				f2fs_put_dnode(&dn);
				goto found;
			}
		}
		f2fs_put_dnode(&dn);
	}

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

	return -EINVAL;
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
425 426
static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
427
	struct inode *inode = file_inode(file);
428
	int err;
429

430
	if (f2fs_encrypted_inode(inode)) {
431
		err = fscrypt_get_encryption_info(inode);
432 433
		if (err)
			return 0;
434 435
		if (!f2fs_encrypted_inode(inode))
			return -ENOKEY;
436 437
	}

438
	/* we don't need to use inline_data strictly */
439 440 441
	err = f2fs_convert_inline_inode(inode);
	if (err)
		return err;
442

Jaegeuk Kim's avatar
Jaegeuk Kim committed
443 444 445 446 447
	file_accessed(file);
	vma->vm_ops = &f2fs_file_vm_ops;
	return 0;
}

448 449 450
static int f2fs_file_open(struct inode *inode, struct file *filp)
{
	int ret = generic_file_open(inode, filp);
451
	struct dentry *dir;
452 453

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

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

477
	raw_node = F2FS_NODE(dn->node_page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
478 479
	addr = blkaddr_in_node(raw_node) + ofs;

Chris Fries's avatar
Chris Fries committed
480
	for (; count > 0; count--, addr++, dn->ofs_in_node++) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
481 482 483 484
		block_t blkaddr = le32_to_cpu(*addr);
		if (blkaddr == NULL_ADDR)
			continue;

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

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

507
	f2fs_update_time(sbi, REQ_TIME);
508 509
	trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
					 dn->ofs_in_node, nr_free);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
510 511 512 513 514 515 516 517
	return nr_free;
}

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

518
static int truncate_partial_data_page(struct inode *inode, u64 from,
519
								bool cache_only)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
520
{
521 522
	unsigned offset = from & (PAGE_SIZE - 1);
	pgoff_t index = from >> PAGE_SHIFT;
523
	struct address_space *mapping = inode->i_mapping;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
524 525
	struct page *page;

526
	if (!offset && !cache_only)
527
		return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
528

529
	if (cache_only) {
530
		page = f2fs_grab_cache_page(mapping, index, false);
531 532 533
		if (page && PageUptodate(page))
			goto truncate_out;
		f2fs_put_page(page, 1);
534
		return 0;
535
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
536

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

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

560 561
	trace_f2fs_truncate_blocks_enter(inode, from);

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

564 565 566
	if (free_from >= sbi->max_file_blocks)
		goto free_partial;

567 568
	if (lock)
		f2fs_lock_op(sbi);
569

570 571 572 573 574 575 576
	ipage = get_node_page(sbi, inode->i_ino);
	if (IS_ERR(ipage)) {
		err = PTR_ERR(ipage);
		goto out;
	}

	if (f2fs_has_inline_data(inode)) {
577 578
		if (truncate_inline_inode(ipage, from))
			set_page_dirty(ipage);
579
		f2fs_put_page(ipage, 1);
580
		truncate_page = true;
581 582 583 584
		goto out;
	}

	set_new_dnode(&dn, inode, ipage, NULL, 0);
585
	err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
586 587 588
	if (err) {
		if (err == -ENOENT)
			goto free_next;
589
		goto out;
590 591
	}

592
	count = ADDRS_PER_PAGE(dn.node_page, inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
593 594

	count -= dn.ofs_in_node;
595
	f2fs_bug_on(sbi, count < 0);
596

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

613
	trace_f2fs_truncate_blocks_exit(inode, err);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
614 615 616
	return err;
}

617
int f2fs_truncate(struct inode *inode, bool lock)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
618
{
619 620
	int err;

Jaegeuk Kim's avatar
Jaegeuk Kim committed
621 622
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
				S_ISLNK(inode->i_mode)))
623
		return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
624

625 626
	trace_f2fs_truncate(inode);

627
	/* we should check inline_data size */
628
	if (!f2fs_may_inline_data(inode)) {
629 630 631
		err = f2fs_convert_inline_inode(inode);
		if (err)
			return err;
632 633
	}

634 635 636 637 638 639 640
	err = truncate_blocks(inode, i_size_read(inode), lock);
	if (err)
		return err;

	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	mark_inode_dirty(inode);
	return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
641 642
}

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

int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
{
684
	struct inode *inode = d_inode(dentry);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
685 686 687 688 689 690
	int err;

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

691
	if (attr->ia_valid & ATTR_SIZE) {
692
		if (f2fs_encrypted_inode(inode) &&
693
				fscrypt_get_encryption_info(inode))
694 695
			return -EACCES;

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

			/* should convert inline inode here */
710
			if (!f2fs_may_inline_data(inode)) {
711 712 713 714
				err = f2fs_convert_inline_inode(inode);
				if (err)
					return err;
			}
715
			inode->i_mtime = inode->i_ctime = CURRENT_TIME;
716
		}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
717 718 719 720 721
	}

	__setattr_copy(inode, attr);

	if (attr->ia_valid & ATTR_MODE) {
722
		err = posix_acl_chmod(inode, get_inode_mode(inode));
723 724 725
		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
726 727 728 729 730 731 732 733 734 735 736
		}
	}

	mark_inode_dirty(inode);
	return err;
}

const struct inode_operations f2fs_file_inode_operations = {
	.getattr	= f2fs_getattr,
	.setattr	= f2fs_setattr,
	.get_acl	= f2fs_get_acl,
737
	.set_acl	= f2fs_set_acl,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
738 739 740 741 742 743
#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
744
	.fiemap		= f2fs_fiemap,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
745 746
};

Chao Yu's avatar
Chao Yu committed
747
static int fill_zero(struct inode *inode, pgoff_t index,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
748 749
					loff_t start, loff_t len)
{
750
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
751 752 753
	struct page *page;

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

Jaegeuk Kim's avatar
Jaegeuk Kim committed
756
	f2fs_balance_fs(sbi, true);
757

758
	f2fs_lock_op(sbi);
759
	page = get_new_data_page(inode, NULL, index, false);
760
	f2fs_unlock_op(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
761

Chao Yu's avatar
Chao Yu committed
762 763 764
	if (IS_ERR(page))
		return PTR_ERR(page);

765
	f2fs_wait_on_page_writeback(page, DATA, true);
Chao Yu's avatar
Chao Yu committed
766 767 768 769
	zero_user(page, start, len);
	set_page_dirty(page);
	f2fs_put_page(page, 1);
	return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
770 771 772 773 774 775
}

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

776
	while (pg_start < pg_end) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
777
		struct dnode_of_data dn;
778
		pgoff_t end_offset, count;
779

Jaegeuk Kim's avatar
Jaegeuk Kim committed
780
		set_new_dnode(&dn, inode, NULL, NULL, 0);
781
		err = get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
782
		if (err) {
783 784
			if (err == -ENOENT) {
				pg_start++;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
785
				continue;
786
			}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
787 788 789
			return err;
		}

790
		end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
791 792 793 794 795
		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
796
		f2fs_put_dnode(&dn);
797 798

		pg_start += count;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
799 800 801 802
	}
	return 0;
}

803
static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
804 805 806
{
	pgoff_t pg_start, pg_end;
	loff_t off_start, off_end;
807
	int ret;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
808

809 810 811
	ret = f2fs_convert_inline_inode(inode);
	if (ret)
		return ret;
812

813 814
	pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
	pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
815

816 817
	off_start = offset & (PAGE_SIZE - 1);
	off_end = (offset + len) & (PAGE_SIZE - 1);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
818 819

	if (pg_start == pg_end) {
Chao Yu's avatar
Chao Yu committed
820
		ret = fill_zero(inode, pg_start, off_start,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
821
						off_end - off_start);
Chao Yu's avatar
Chao Yu committed
822 823
		if (ret)
			return ret;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
824
	} else {
Chao Yu's avatar
Chao Yu committed
825 826
		if (off_start) {
			ret = fill_zero(inode, pg_start++, off_start,
827
						PAGE_SIZE - off_start);
Chao Yu's avatar
Chao Yu committed
828 829 830 831 832 833 834 835
			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
836 837 838 839

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

Jaegeuk Kim's avatar
Jaegeuk Kim committed
842
			f2fs_balance_fs(sbi, true);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
843

844 845
			blk_start = (loff_t)pg_start << PAGE_SHIFT;
			blk_end = (loff_t)pg_end << PAGE_SHIFT;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
846 847
			truncate_inode_pages_range(mapping, blk_start,
					blk_end - 1);
848

849
			f2fs_lock_op(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
850
			ret = truncate_hole(inode, pg_start, pg_end);
851
			f2fs_unlock_op(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
852 853 854 855 856 857
		}
	}

	return ret;
}

858 859
static int __exchange_data_block(struct inode *inode, pgoff_t src,
					pgoff_t dst, bool full)
860 861 862
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct dnode_of_data dn;
863 864 865
	block_t new_addr;
	bool do_replace = false;
	int ret;
Chao Yu's avatar