checkpoint.c 21.3 KB
Newer Older
J
Jaegeuk Kim 已提交
1
/*
J
Jaegeuk Kim 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * fs/f2fs/checkpoint.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/bio.h>
#include <linux/mpage.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>
#include <linux/f2fs_fs.h>
#include <linux/pagevec.h>
#include <linux/swap.h>

#include "f2fs.h"
#include "node.h"
#include "segment.h"
23
#include <trace/events/f2fs.h>
J
Jaegeuk Kim 已提交
24 25 26 27

static struct kmem_cache *orphan_entry_slab;
static struct kmem_cache *inode_entry_slab;

J
Jaegeuk Kim 已提交
28
/*
J
Jaegeuk Kim 已提交
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 * We guarantee no failure on the returned page.
 */
struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
{
	struct address_space *mapping = sbi->meta_inode->i_mapping;
	struct page *page = NULL;
repeat:
	page = grab_cache_page(mapping, index);
	if (!page) {
		cond_resched();
		goto repeat;
	}

	/* We wait writeback only inside grab_meta_page() */
	wait_on_page_writeback(page);
	SetPageUptodate(page);
	return page;
}

J
Jaegeuk Kim 已提交
48
/*
J
Jaegeuk Kim 已提交
49 50 51 52 53 54 55 56 57 58 59 60
 * We guarantee no failure on the returned page.
 */
struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
{
	struct address_space *mapping = sbi->meta_inode->i_mapping;
	struct page *page;
repeat:
	page = grab_cache_page(mapping, index);
	if (!page) {
		cond_resched();
		goto repeat;
	}
61 62 63
	if (PageUptodate(page))
		goto out;

64
	if (f2fs_readpage(sbi, page, index, READ_SYNC | REQ_META | REQ_PRIO))
J
Jaegeuk Kim 已提交
65 66
		goto repeat;

67
	lock_page(page);
68 69 70 71
	if (page->mapping != mapping) {
		f2fs_put_page(page, 1);
		goto repeat;
	}
72 73
out:
	mark_page_accessed(page);
J
Jaegeuk Kim 已提交
74 75 76 77 78 79 80 81 82
	return page;
}

static int f2fs_write_meta_page(struct page *page,
				struct writeback_control *wbc)
{
	struct inode *inode = page->mapping->host;
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

83
	/* Should not write any meta pages, if any IO error was occurred */
84
	if (wbc->for_reclaim || sbi->por_doing ||
85 86
			is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ERROR_FLAG)) {
		dec_page_count(sbi, F2FS_DIRTY_META);
J
Jaegeuk Kim 已提交
87 88
		wbc->pages_skipped++;
		set_page_dirty(page);
89
		return AOP_WRITEPAGE_ACTIVATE;
J
Jaegeuk Kim 已提交
90 91
	}

92
	wait_on_page_writeback(page);
J
Jaegeuk Kim 已提交
93

94 95 96 97
	write_meta_page(sbi, page);
	dec_page_count(sbi, F2FS_DIRTY_META);
	unlock_page(page);
	return 0;
J
Jaegeuk Kim 已提交
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
}

static int f2fs_write_meta_pages(struct address_space *mapping,
				struct writeback_control *wbc)
{
	struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
	struct block_device *bdev = sbi->sb->s_bdev;
	long written;

	if (wbc->for_kupdate)
		return 0;

	if (get_pages(sbi, F2FS_DIRTY_META) == 0)
		return 0;

	/* if mounting is failed, skip writing node pages */
	mutex_lock(&sbi->cp_mutex);
	written = sync_meta_pages(sbi, META, bio_get_nr_vecs(bdev));
	mutex_unlock(&sbi->cp_mutex);
	wbc->nr_to_write -= written;
	return 0;
}

long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
						long nr_to_write)
{
	struct address_space *mapping = sbi->meta_inode->i_mapping;
	pgoff_t index = 0, end = LONG_MAX;
	struct pagevec pvec;
	long nwritten = 0;
	struct writeback_control wbc = {
		.for_reclaim = 0,
	};

	pagevec_init(&pvec, 0);

	while (index <= end) {
		int i, nr_pages;
		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
				PAGECACHE_TAG_DIRTY,
				min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
		if (nr_pages == 0)
			break;

		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
			lock_page(page);
145 146
			f2fs_bug_on(page->mapping != mapping);
			f2fs_bug_on(!PageDirty(page));
J
Jaegeuk Kim 已提交
147
			clear_page_dirty_for_io(page);
148 149 150 151
			if (f2fs_write_meta_page(page, &wbc)) {
				unlock_page(page);
				break;
			}
J
Jaegeuk Kim 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
			if (nwritten++ >= nr_to_write)
				break;
		}
		pagevec_release(&pvec);
		cond_resched();
	}

	if (nwritten)
		f2fs_submit_bio(sbi, type, nr_to_write == LONG_MAX);

	return nwritten;
}

static int f2fs_set_meta_page_dirty(struct page *page)
{
	struct address_space *mapping = page->mapping;
	struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);

170 171
	trace_f2fs_set_page_dirty(page, META);

J
Jaegeuk Kim 已提交
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
	SetPageUptodate(page);
	if (!PageDirty(page)) {
		__set_page_dirty_nobuffers(page);
		inc_page_count(sbi, F2FS_DIRTY_META);
		return 1;
	}
	return 0;
}

const struct address_space_operations f2fs_meta_aops = {
	.writepage	= f2fs_write_meta_page,
	.writepages	= f2fs_write_meta_pages,
	.set_page_dirty	= f2fs_set_meta_page_dirty,
};

J
Jaegeuk Kim 已提交
187
int acquire_orphan_inode(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
188 189 190 191 192 193 194 195 196 197 198 199 200 201
{
	unsigned int max_orphans;
	int err = 0;

	/*
	 * considering 512 blocks in a segment 5 blocks are needed for cp
	 * and log segment summaries. Remaining blocks are used to keep
	 * orphan entries with the limitation one reserved segment
	 * for cp pack we can have max 1020*507 orphan entries
	 */
	max_orphans = (sbi->blocks_per_seg - 5) * F2FS_ORPHANS_PER_BLOCK;
	mutex_lock(&sbi->orphan_inode_mutex);
	if (sbi->n_orphans >= max_orphans)
		err = -ENOSPC;
J
Jaegeuk Kim 已提交
202 203
	else
		sbi->n_orphans++;
J
Jaegeuk Kim 已提交
204 205 206 207
	mutex_unlock(&sbi->orphan_inode_mutex);
	return err;
}

J
Jaegeuk Kim 已提交
208 209 210
void release_orphan_inode(struct f2fs_sb_info *sbi)
{
	mutex_lock(&sbi->orphan_inode_mutex);
211
	f2fs_bug_on(sbi->n_orphans == 0);
J
Jaegeuk Kim 已提交
212 213 214 215
	sbi->n_orphans--;
	mutex_unlock(&sbi->orphan_inode_mutex);
}

J
Jaegeuk Kim 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
{
	struct list_head *head, *this;
	struct orphan_inode_entry *new = NULL, *orphan = NULL;

	mutex_lock(&sbi->orphan_inode_mutex);
	head = &sbi->orphan_inode_list;
	list_for_each(this, head) {
		orphan = list_entry(this, struct orphan_inode_entry, list);
		if (orphan->ino == ino)
			goto out;
		if (orphan->ino > ino)
			break;
		orphan = NULL;
	}
231 232

	new = f2fs_kmem_cache_alloc(orphan_entry_slab, GFP_ATOMIC);
J
Jaegeuk Kim 已提交
233 234 235
	new->ino = ino;

	/* add new_oentry into list which is sorted by inode number */
236 237 238
	if (orphan)
		list_add(&new->list, this->prev);
	else
J
Jaegeuk Kim 已提交
239 240 241 242 243 244 245
		list_add_tail(&new->list, head);
out:
	mutex_unlock(&sbi->orphan_inode_mutex);
}

void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
{
246
	struct list_head *head;
J
Jaegeuk Kim 已提交
247 248 249 250
	struct orphan_inode_entry *orphan;

	mutex_lock(&sbi->orphan_inode_mutex);
	head = &sbi->orphan_inode_list;
251
	list_for_each_entry(orphan, head, list) {
J
Jaegeuk Kim 已提交
252 253 254
		if (orphan->ino == ino) {
			list_del(&orphan->list);
			kmem_cache_free(orphan_entry_slab, orphan);
255
			f2fs_bug_on(sbi->n_orphans == 0);
J
Jaegeuk Kim 已提交
256 257 258 259 260 261 262 263 264 265
			sbi->n_orphans--;
			break;
		}
	}
	mutex_unlock(&sbi->orphan_inode_mutex);
}

static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
{
	struct inode *inode = f2fs_iget(sbi->sb, ino);
266
	f2fs_bug_on(IS_ERR(inode));
J
Jaegeuk Kim 已提交
267 268 269 270 271 272 273 274 275 276
	clear_nlink(inode);

	/* truncate all the data during iput */
	iput(inode);
}

int recover_orphan_inodes(struct f2fs_sb_info *sbi)
{
	block_t start_blk, orphan_blkaddr, i, j;

277
	if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))
J
Jaegeuk Kim 已提交
278 279
		return 0;

H
Haicheng Li 已提交
280
	sbi->por_doing = true;
J
Jaegeuk Kim 已提交
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
	start_blk = __start_cp_addr(sbi) + 1;
	orphan_blkaddr = __start_sum_addr(sbi) - 1;

	for (i = 0; i < orphan_blkaddr; i++) {
		struct page *page = get_meta_page(sbi, start_blk + i);
		struct f2fs_orphan_block *orphan_blk;

		orphan_blk = (struct f2fs_orphan_block *)page_address(page);
		for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
			nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
			recover_orphan_inode(sbi, ino);
		}
		f2fs_put_page(page, 1);
	}
	/* clear Orphan Flag */
296
	clear_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG);
H
Haicheng Li 已提交
297
	sbi->por_doing = false;
J
Jaegeuk Kim 已提交
298 299 300 301 302
	return 0;
}

static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk)
{
303
	struct list_head *head;
J
Jaegeuk Kim 已提交
304 305 306 307 308
	struct f2fs_orphan_block *orphan_blk = NULL;
	struct page *page = NULL;
	unsigned int nentries = 0;
	unsigned short index = 1;
	unsigned short orphan_blocks;
309
	struct orphan_inode_entry *orphan = NULL;
J
Jaegeuk Kim 已提交
310 311 312 313 314 315 316 317

	orphan_blocks = (unsigned short)((sbi->n_orphans +
		(F2FS_ORPHANS_PER_BLOCK - 1)) / F2FS_ORPHANS_PER_BLOCK);

	mutex_lock(&sbi->orphan_inode_mutex);
	head = &sbi->orphan_inode_list;

	/* loop for each orphan inode entry and write them in Jornal block */
318 319 320 321 322 323 324
	list_for_each_entry(orphan, head, list) {
		if (!page) {
			page = grab_meta_page(sbi, start_blk);
			orphan_blk =
				(struct f2fs_orphan_block *)page_address(page);
			memset(orphan_blk, 0, sizeof(*orphan_blk));
		}
J
Jaegeuk Kim 已提交
325

326
		orphan_blk->ino[nentries] = cpu_to_le32(orphan->ino);
J
Jaegeuk Kim 已提交
327

328
		if (nentries++ == F2FS_ORPHANS_PER_BLOCK) {
J
Jaegeuk Kim 已提交
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
			/*
			 * an orphan block is full of 1020 entries,
			 * then we need to flush current orphan blocks
			 * and bring another one in memory
			 */
			orphan_blk->blk_addr = cpu_to_le16(index);
			orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
			orphan_blk->entry_count = cpu_to_le32(nentries);
			set_page_dirty(page);
			f2fs_put_page(page, 1);
			index++;
			start_blk++;
			nentries = 0;
			page = NULL;
		}
344
	}
J
Jaegeuk Kim 已提交
345

346 347 348 349 350 351
	if (page) {
		orphan_blk->blk_addr = cpu_to_le16(index);
		orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
		orphan_blk->entry_count = cpu_to_le32(nentries);
		set_page_dirty(page);
		f2fs_put_page(page, 1);
J
Jaegeuk Kim 已提交
352
	}
353

J
Jaegeuk Kim 已提交
354 355 356 357 358 359 360 361 362 363 364
	mutex_unlock(&sbi->orphan_inode_mutex);
}

static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
				block_t cp_addr, unsigned long long *version)
{
	struct page *cp_page_1, *cp_page_2 = NULL;
	unsigned long blk_size = sbi->blocksize;
	struct f2fs_checkpoint *cp_block;
	unsigned long long cur_version = 0, pre_version = 0;
	size_t crc_offset;
J
Jaegeuk Kim 已提交
365
	__u32 crc = 0;
J
Jaegeuk Kim 已提交
366 367 368 369 370 371 372 373 374 375

	/* Read the 1st cp block in this CP pack */
	cp_page_1 = get_meta_page(sbi, cp_addr);

	/* get the version number */
	cp_block = (struct f2fs_checkpoint *)page_address(cp_page_1);
	crc_offset = le32_to_cpu(cp_block->checksum_offset);
	if (crc_offset >= blk_size)
		goto invalid_cp1;

J
Jaegeuk Kim 已提交
376
	crc = le32_to_cpu(*((__u32 *)((unsigned char *)cp_block + crc_offset)));
J
Jaegeuk Kim 已提交
377 378 379
	if (!f2fs_crc_valid(crc, cp_block, crc_offset))
		goto invalid_cp1;

380
	pre_version = cur_cp_version(cp_block);
J
Jaegeuk Kim 已提交
381 382

	/* Read the 2nd cp block in this CP pack */
383
	cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
J
Jaegeuk Kim 已提交
384 385 386 387 388 389 390
	cp_page_2 = get_meta_page(sbi, cp_addr);

	cp_block = (struct f2fs_checkpoint *)page_address(cp_page_2);
	crc_offset = le32_to_cpu(cp_block->checksum_offset);
	if (crc_offset >= blk_size)
		goto invalid_cp2;

J
Jaegeuk Kim 已提交
391
	crc = le32_to_cpu(*((__u32 *)((unsigned char *)cp_block + crc_offset)));
J
Jaegeuk Kim 已提交
392 393 394
	if (!f2fs_crc_valid(crc, cp_block, crc_offset))
		goto invalid_cp2;

395
	cur_version = cur_cp_version(cp_block);
J
Jaegeuk Kim 已提交
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456

	if (cur_version == pre_version) {
		*version = cur_version;
		f2fs_put_page(cp_page_2, 1);
		return cp_page_1;
	}
invalid_cp2:
	f2fs_put_page(cp_page_2, 1);
invalid_cp1:
	f2fs_put_page(cp_page_1, 1);
	return NULL;
}

int get_valid_checkpoint(struct f2fs_sb_info *sbi)
{
	struct f2fs_checkpoint *cp_block;
	struct f2fs_super_block *fsb = sbi->raw_super;
	struct page *cp1, *cp2, *cur_page;
	unsigned long blk_size = sbi->blocksize;
	unsigned long long cp1_version = 0, cp2_version = 0;
	unsigned long long cp_start_blk_no;

	sbi->ckpt = kzalloc(blk_size, GFP_KERNEL);
	if (!sbi->ckpt)
		return -ENOMEM;
	/*
	 * Finding out valid cp block involves read both
	 * sets( cp pack1 and cp pack 2)
	 */
	cp_start_blk_no = le32_to_cpu(fsb->cp_blkaddr);
	cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);

	/* The second checkpoint pack should start at the next segment */
	cp_start_blk_no += 1 << le32_to_cpu(fsb->log_blocks_per_seg);
	cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);

	if (cp1 && cp2) {
		if (ver_after(cp2_version, cp1_version))
			cur_page = cp2;
		else
			cur_page = cp1;
	} else if (cp1) {
		cur_page = cp1;
	} else if (cp2) {
		cur_page = cp2;
	} else {
		goto fail_no_cp;
	}

	cp_block = (struct f2fs_checkpoint *)page_address(cur_page);
	memcpy(sbi->ckpt, cp_block, blk_size);

	f2fs_put_page(cp1, 1);
	f2fs_put_page(cp2, 1);
	return 0;

fail_no_cp:
	kfree(sbi->ckpt);
	return -EINVAL;
}

457
static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new)
J
Jaegeuk Kim 已提交
458 459 460 461 462
{
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
	struct list_head *head = &sbi->dir_inode_list;
	struct list_head *this;

463 464 465 466 467 468 469
	list_for_each(this, head) {
		struct dir_inode_entry *entry;
		entry = list_entry(this, struct dir_inode_entry, list);
		if (entry->inode == inode)
			return -EEXIST;
	}
	list_add_tail(&new->list, head);
470
	stat_inc_dirty_dir(sbi);
471 472 473 474 475 476 477 478
	return 0;
}

void set_dirty_dir_page(struct inode *inode, struct page *page)
{
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
	struct dir_inode_entry *new;

J
Jaegeuk Kim 已提交
479 480
	if (!S_ISDIR(inode->i_mode))
		return;
481 482

	new = f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
J
Jaegeuk Kim 已提交
483 484 485 486
	new->inode = inode;
	INIT_LIST_HEAD(&new->list);

	spin_lock(&sbi->dir_inode_lock);
487 488
	if (__add_dirty_inode(inode, new))
		kmem_cache_free(inode_entry_slab, new);
J
Jaegeuk Kim 已提交
489 490 491 492

	inc_page_count(sbi, F2FS_DIRTY_DENTS);
	inode_inc_dirty_dents(inode);
	SetPagePrivate(page);
493 494 495 496 497 498
	spin_unlock(&sbi->dir_inode_lock);
}

void add_dirty_dir_inode(struct inode *inode)
{
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
499 500 501
	struct dir_inode_entry *new =
			f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);

502 503
	new->inode = inode;
	INIT_LIST_HEAD(&new->list);
J
Jaegeuk Kim 已提交
504

505 506 507
	spin_lock(&sbi->dir_inode_lock);
	if (__add_dirty_inode(inode, new))
		kmem_cache_free(inode_entry_slab, new);
J
Jaegeuk Kim 已提交
508 509 510 511 512 513
	spin_unlock(&sbi->dir_inode_lock);
}

void remove_dirty_dir_inode(struct inode *inode)
{
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
514 515

	struct list_head *this, *head;
J
Jaegeuk Kim 已提交
516 517 518 519 520

	if (!S_ISDIR(inode->i_mode))
		return;

	spin_lock(&sbi->dir_inode_lock);
521 522 523 524
	if (atomic_read(&F2FS_I(inode)->dirty_dents)) {
		spin_unlock(&sbi->dir_inode_lock);
		return;
	}
J
Jaegeuk Kim 已提交
525

526
	head = &sbi->dir_inode_list;
J
Jaegeuk Kim 已提交
527 528 529 530 531 532
	list_for_each(this, head) {
		struct dir_inode_entry *entry;
		entry = list_entry(this, struct dir_inode_entry, list);
		if (entry->inode == inode) {
			list_del(&entry->list);
			kmem_cache_free(inode_entry_slab, entry);
533
			stat_dec_dirty_dir(sbi);
J
Jaegeuk Kim 已提交
534 535 536 537
			break;
		}
	}
	spin_unlock(&sbi->dir_inode_lock);
538 539

	/* Only from the recovery routine */
540 541
	if (is_inode_flag_set(F2FS_I(inode), FI_DELAY_IPUT)) {
		clear_inode_flag(F2FS_I(inode), FI_DELAY_IPUT);
542
		iput(inode);
543
	}
544 545 546 547
}

struct inode *check_dirty_dir_inode(struct f2fs_sb_info *sbi, nid_t ino)
{
548 549

	struct list_head *this, *head;
550 551 552
	struct inode *inode = NULL;

	spin_lock(&sbi->dir_inode_lock);
553 554

	head = &sbi->dir_inode_list;
555 556 557 558 559 560 561 562 563 564
	list_for_each(this, head) {
		struct dir_inode_entry *entry;
		entry = list_entry(this, struct dir_inode_entry, list);
		if (entry->inode->i_ino == ino) {
			inode = entry->inode;
			break;
		}
	}
	spin_unlock(&sbi->dir_inode_lock);
	return inode;
J
Jaegeuk Kim 已提交
565 566 567 568
}

void sync_dirty_dir_inodes(struct f2fs_sb_info *sbi)
{
569
	struct list_head *head;
J
Jaegeuk Kim 已提交
570 571 572 573
	struct dir_inode_entry *entry;
	struct inode *inode;
retry:
	spin_lock(&sbi->dir_inode_lock);
574 575

	head = &sbi->dir_inode_list;
J
Jaegeuk Kim 已提交
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
	if (list_empty(head)) {
		spin_unlock(&sbi->dir_inode_lock);
		return;
	}
	entry = list_entry(head->next, struct dir_inode_entry, list);
	inode = igrab(entry->inode);
	spin_unlock(&sbi->dir_inode_lock);
	if (inode) {
		filemap_flush(inode->i_mapping);
		iput(inode);
	} else {
		/*
		 * We should submit bio, since it exists several
		 * wribacking dentry pages in the freeing inode.
		 */
		f2fs_submit_bio(sbi, DATA, true);
	}
	goto retry;
}

J
Jaegeuk Kim 已提交
596
/*
J
Jaegeuk Kim 已提交
597 598
 * Freeze all the FS-operations for checkpoint.
 */
599
static void block_operations(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
600 601 602 603 604 605
{
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = LONG_MAX,
		.for_reclaim = 0,
	};
606 607 608 609
	struct blk_plug plug;

	blk_start_plug(&plug);

610
retry_flush_dents:
611
	f2fs_lock_all(sbi);
J
Jaegeuk Kim 已提交
612 613
	/* write all the dirty dentry pages */
	if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
614
		f2fs_unlock_all(sbi);
615 616
		sync_dirty_dir_inodes(sbi);
		goto retry_flush_dents;
J
Jaegeuk Kim 已提交
617 618 619 620 621 622
	}

	/*
	 * POR: we should ensure that there is no dirty node pages
	 * until finishing nat/sit flush.
	 */
623 624
retry_flush_nodes:
	mutex_lock(&sbi->node_write);
J
Jaegeuk Kim 已提交
625 626

	if (get_pages(sbi, F2FS_DIRTY_NODES)) {
627 628 629
		mutex_unlock(&sbi->node_write);
		sync_node_pages(sbi, 0, &wbc);
		goto retry_flush_nodes;
J
Jaegeuk Kim 已提交
630
	}
631
	blk_finish_plug(&plug);
J
Jaegeuk Kim 已提交
632 633 634 635
}

static void unblock_operations(struct f2fs_sb_info *sbi)
{
636
	mutex_unlock(&sbi->node_write);
637
	f2fs_unlock_all(sbi);
J
Jaegeuk Kim 已提交
638 639
}

640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi)
{
	DEFINE_WAIT(wait);

	for (;;) {
		prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);

		if (!get_pages(sbi, F2FS_WRITEBACK))
			break;

		io_schedule();
	}
	finish_wait(&sbi->cp_wait, &wait);
}

J
Jaegeuk Kim 已提交
655 656 657 658 659 660 661
static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
{
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
	nid_t last_nid = 0;
	block_t start_blk;
	struct page *cp_page;
	unsigned int data_sum_blocks, orphan_blocks;
J
Jaegeuk Kim 已提交
662
	__u32 crc32 = 0;
J
Jaegeuk Kim 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	void *kaddr;
	int i;

	/* Flush all the NAT/SIT pages */
	while (get_pages(sbi, F2FS_DIRTY_META))
		sync_meta_pages(sbi, META, LONG_MAX);

	next_free_nid(sbi, &last_nid);

	/*
	 * modify checkpoint
	 * version number is already updated
	 */
	ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi));
	ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi));
	ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));
	for (i = 0; i < 3; i++) {
		ckpt->cur_node_segno[i] =
			cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE));
		ckpt->cur_node_blkoff[i] =
			cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_NODE));
		ckpt->alloc_type[i + CURSEG_HOT_NODE] =
				curseg_alloc_type(sbi, i + CURSEG_HOT_NODE);
	}
	for (i = 0; i < 3; i++) {
		ckpt->cur_data_segno[i] =
			cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA));
		ckpt->cur_data_blkoff[i] =
			cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_DATA));
		ckpt->alloc_type[i + CURSEG_HOT_DATA] =
				curseg_alloc_type(sbi, i + CURSEG_HOT_DATA);
	}

	ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi));
	ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi));
	ckpt->next_free_nid = cpu_to_le32(last_nid);

	/* 2 cp  + n data seg summary + orphan inode blocks */
	data_sum_blocks = npages_for_summary_flush(sbi);
	if (data_sum_blocks < 3)
703
		set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
J
Jaegeuk Kim 已提交
704
	else
705
		clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
J
Jaegeuk Kim 已提交
706 707 708

	orphan_blocks = (sbi->n_orphans + F2FS_ORPHANS_PER_BLOCK - 1)
					/ F2FS_ORPHANS_PER_BLOCK;
709
	ckpt->cp_pack_start_sum = cpu_to_le32(1 + orphan_blocks);
J
Jaegeuk Kim 已提交
710 711

	if (is_umount) {
712 713 714
		set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
		ckpt->cp_pack_total_block_count = cpu_to_le32(2 +
			data_sum_blocks + orphan_blocks + NR_CURSEG_NODE_TYPE);
J
Jaegeuk Kim 已提交
715
	} else {
716 717 718
		clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
		ckpt->cp_pack_total_block_count = cpu_to_le32(2 +
			data_sum_blocks + orphan_blocks);
J
Jaegeuk Kim 已提交
719 720 721
	}

	if (sbi->n_orphans)
722
		set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
J
Jaegeuk Kim 已提交
723
	else
724
		clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
J
Jaegeuk Kim 已提交
725 726 727 728 729 730

	/* update SIT/NAT bitmap */
	get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
	get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));

	crc32 = f2fs_crc32(ckpt, le32_to_cpu(ckpt->checksum_offset));
J
Jaegeuk Kim 已提交
731 732
	*((__le32 *)((unsigned char *)ckpt +
				le32_to_cpu(ckpt->checksum_offset)))
J
Jaegeuk Kim 已提交
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
				= cpu_to_le32(crc32);

	start_blk = __start_cp_addr(sbi);

	/* write out checkpoint buffer at block 0 */
	cp_page = grab_meta_page(sbi, start_blk++);
	kaddr = page_address(cp_page);
	memcpy(kaddr, ckpt, (1 << sbi->log_blocksize));
	set_page_dirty(cp_page);
	f2fs_put_page(cp_page, 1);

	if (sbi->n_orphans) {
		write_orphan_inodes(sbi, start_blk);
		start_blk += orphan_blocks;
	}

	write_data_summaries(sbi, start_blk);
	start_blk += data_sum_blocks;
	if (is_umount) {
		write_node_summaries(sbi, start_blk);
		start_blk += NR_CURSEG_NODE_TYPE;
	}

	/* writeout checkpoint block */
	cp_page = grab_meta_page(sbi, start_blk);
	kaddr = page_address(cp_page);
	memcpy(kaddr, ckpt, (1 << sbi->log_blocksize));
	set_page_dirty(cp_page);
	f2fs_put_page(cp_page, 1);

	/* wait for previous submitted node/meta pages writeback */
764
	wait_on_all_pages_writeback(sbi);
J
Jaegeuk Kim 已提交
765 766 767 768 769 770 771 772 773

	filemap_fdatawait_range(sbi->node_inode->i_mapping, 0, LONG_MAX);
	filemap_fdatawait_range(sbi->meta_inode->i_mapping, 0, LONG_MAX);

	/* update user_block_counts */
	sbi->last_valid_block_count = sbi->total_valid_block_count;
	sbi->alloc_valid_block_count = 0;

	/* Here, we only have one bio having CP pack */
774
	sync_meta_pages(sbi, META_FLUSH, LONG_MAX);
J
Jaegeuk Kim 已提交
775

776 777 778 779
	if (!is_set_ckpt_flags(ckpt, CP_ERROR_FLAG)) {
		clear_prefree_segments(sbi);
		F2FS_RESET_SB_DIRT(sbi);
	}
J
Jaegeuk Kim 已提交
780 781
}

J
Jaegeuk Kim 已提交
782
/*
J
Jaegeuk Kim 已提交
783 784
 * We guarantee that this checkpoint procedure should not fail.
 */
785
void write_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
J
Jaegeuk Kim 已提交
786 787 788 789
{
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
	unsigned long long ckpt_ver;

790 791
	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "start block_ops");

792 793
	mutex_lock(&sbi->cp_mutex);
	block_operations(sbi);
J
Jaegeuk Kim 已提交
794

795 796
	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish block_ops");

J
Jaegeuk Kim 已提交
797 798 799 800 801 802 803 804 805
	f2fs_submit_bio(sbi, DATA, true);
	f2fs_submit_bio(sbi, NODE, true);
	f2fs_submit_bio(sbi, META, true);

	/*
	 * update checkpoint pack index
	 * Increase the version number so that
	 * SIT entries and seg summaries are written at correct place
	 */
806
	ckpt_ver = cur_cp_version(ckpt);
J
Jaegeuk Kim 已提交
807 808 809 810 811 812 813 814 815 816 817
	ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);

	/* write cached NAT/SIT entries to NAT/SIT area */
	flush_nat_entries(sbi);
	flush_sit_entries(sbi);

	/* unlock all the fs_lock[] in do_checkpoint() */
	do_checkpoint(sbi, is_umount);

	unblock_operations(sbi);
	mutex_unlock(&sbi->cp_mutex);
818 819

	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish checkpoint");
J
Jaegeuk Kim 已提交
820 821 822 823 824 825 826 827 828
}

void init_orphan_info(struct f2fs_sb_info *sbi)
{
	mutex_init(&sbi->orphan_inode_mutex);
	INIT_LIST_HEAD(&sbi->orphan_inode_list);
	sbi->n_orphans = 0;
}

829
int __init create_checkpoint_caches(void)
J
Jaegeuk Kim 已提交
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
{
	orphan_entry_slab = f2fs_kmem_cache_create("f2fs_orphan_entry",
			sizeof(struct orphan_inode_entry), NULL);
	if (unlikely(!orphan_entry_slab))
		return -ENOMEM;
	inode_entry_slab = f2fs_kmem_cache_create("f2fs_dirty_dir_entry",
			sizeof(struct dir_inode_entry), NULL);
	if (unlikely(!inode_entry_slab)) {
		kmem_cache_destroy(orphan_entry_slab);
		return -ENOMEM;
	}
	return 0;
}

void destroy_checkpoint_caches(void)
{
	kmem_cache_destroy(orphan_entry_slab);
	kmem_cache_destroy(inode_entry_slab);
}