checkpoint.c (b2efb3f0a1db62aff5e824125785ec6731143b6d) checkpoint.c (a7ffdbe22cecaed59b5d76a5f003d68907d64240)
1/*
2 * fs/f2fs/checkpoint.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as

--- 137 unchanged lines hidden (view full) ---

146out:
147 f2fs_submit_merged_bio(sbi, META, READ);
148 return blkno - start;
149}
150
151static int f2fs_write_meta_page(struct page *page,
152 struct writeback_control *wbc)
153{
1/*
2 * fs/f2fs/checkpoint.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as

--- 137 unchanged lines hidden (view full) ---

146out:
147 f2fs_submit_merged_bio(sbi, META, READ);
148 return blkno - start;
149}
150
151static int f2fs_write_meta_page(struct page *page,
152 struct writeback_control *wbc)
153{
154 struct inode *inode = page->mapping->host;
155 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
154 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
156
157 trace_f2fs_writepage(page, META);
158
159 if (unlikely(sbi->por_doing))
160 goto redirty_out;
161 if (wbc->for_reclaim)
162 goto redirty_out;
163 if (unlikely(f2fs_cp_error(sbi)))

--- 8 unchanged lines hidden (view full) ---

172redirty_out:
173 redirty_page_for_writepage(wbc, page);
174 return AOP_WRITEPAGE_ACTIVATE;
175}
176
177static int f2fs_write_meta_pages(struct address_space *mapping,
178 struct writeback_control *wbc)
179{
155
156 trace_f2fs_writepage(page, META);
157
158 if (unlikely(sbi->por_doing))
159 goto redirty_out;
160 if (wbc->for_reclaim)
161 goto redirty_out;
162 if (unlikely(f2fs_cp_error(sbi)))

--- 8 unchanged lines hidden (view full) ---

171redirty_out:
172 redirty_page_for_writepage(wbc, page);
173 return AOP_WRITEPAGE_ACTIVATE;
174}
175
176static int f2fs_write_meta_pages(struct address_space *mapping,
177 struct writeback_control *wbc)
178{
180 struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
179 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
181 long diff, written;
182
183 trace_f2fs_writepages(mapping->host, wbc, META);
184
185 /* collect a number of dirty meta pages and write together */
186 if (wbc->for_kupdate ||
187 get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META))
188 goto skip_write;

--- 65 unchanged lines hidden (view full) ---

254 if (nwritten)
255 f2fs_submit_merged_bio(sbi, type, WRITE);
256
257 return nwritten;
258}
259
260static int f2fs_set_meta_page_dirty(struct page *page)
261{
180 long diff, written;
181
182 trace_f2fs_writepages(mapping->host, wbc, META);
183
184 /* collect a number of dirty meta pages and write together */
185 if (wbc->for_kupdate ||
186 get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META))
187 goto skip_write;

--- 65 unchanged lines hidden (view full) ---

253 if (nwritten)
254 f2fs_submit_merged_bio(sbi, type, WRITE);
255
256 return nwritten;
257}
258
259static int f2fs_set_meta_page_dirty(struct page *page)
260{
262 struct address_space *mapping = page->mapping;
263 struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
264
265 trace_f2fs_set_page_dirty(page, META);
266
267 SetPageUptodate(page);
268 if (!PageDirty(page)) {
269 __set_page_dirty_nobuffers(page);
261 trace_f2fs_set_page_dirty(page, META);
262
263 SetPageUptodate(page);
264 if (!PageDirty(page)) {
265 __set_page_dirty_nobuffers(page);
270 inc_page_count(sbi, F2FS_DIRTY_META);
266 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);
271 return 1;
272 }
273 return 0;
274}
275
276const struct address_space_operations f2fs_meta_aops = {
277 .writepage = f2fs_write_meta_page,
278 .writepages = f2fs_write_meta_pages,

--- 94 unchanged lines hidden (view full) ---

373 spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
374
375 return err;
376}
377
378void release_orphan_inode(struct f2fs_sb_info *sbi)
379{
380 spin_lock(&sbi->ino_lock[ORPHAN_INO]);
267 return 1;
268 }
269 return 0;
270}
271
272const struct address_space_operations f2fs_meta_aops = {
273 .writepage = f2fs_write_meta_page,
274 .writepages = f2fs_write_meta_pages,

--- 94 unchanged lines hidden (view full) ---

369 spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
370
371 return err;
372}
373
374void release_orphan_inode(struct f2fs_sb_info *sbi)
375{
376 spin_lock(&sbi->ino_lock[ORPHAN_INO]);
381 f2fs_bug_on(sbi->n_orphans == 0);
377 f2fs_bug_on(sbi, sbi->n_orphans == 0);
382 sbi->n_orphans--;
383 spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
384}
385
386void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
387{
388 /* add new orphan ino entry into list */
389 __add_ino_entry(sbi, ino, ORPHAN_INO);
390}
391
392void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
393{
394 /* remove orphan entry from orphan list */
395 __remove_ino_entry(sbi, ino, ORPHAN_INO);
396}
397
398static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
399{
400 struct inode *inode = f2fs_iget(sbi->sb, ino);
378 sbi->n_orphans--;
379 spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
380}
381
382void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
383{
384 /* add new orphan ino entry into list */
385 __add_ino_entry(sbi, ino, ORPHAN_INO);
386}
387
388void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
389{
390 /* remove orphan entry from orphan list */
391 __remove_ino_entry(sbi, ino, ORPHAN_INO);
392}
393
394static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
395{
396 struct inode *inode = f2fs_iget(sbi->sb, ino);
401 f2fs_bug_on(IS_ERR(inode));
397 f2fs_bug_on(sbi, IS_ERR(inode));
402 clear_nlink(inode);
403
404 /* truncate all the data during iput */
405 iput(inode);
406}
407
408void recover_orphan_inodes(struct f2fs_sb_info *sbi)
409{

--- 44 unchanged lines hidden (view full) ---

454 index = 1;
455 spin_lock(&sbi->ino_lock[ORPHAN_INO]);
456 head = &sbi->ino_list[ORPHAN_INO];
457
458 /* loop for each orphan inode entry and write them in Jornal block */
459 list_for_each_entry(orphan, head, list) {
460 if (!page) {
461 page = find_get_page(META_MAPPING(sbi), start_blk++);
398 clear_nlink(inode);
399
400 /* truncate all the data during iput */
401 iput(inode);
402}
403
404void recover_orphan_inodes(struct f2fs_sb_info *sbi)
405{

--- 44 unchanged lines hidden (view full) ---

450 index = 1;
451 spin_lock(&sbi->ino_lock[ORPHAN_INO]);
452 head = &sbi->ino_list[ORPHAN_INO];
453
454 /* loop for each orphan inode entry and write them in Jornal block */
455 list_for_each_entry(orphan, head, list) {
456 if (!page) {
457 page = find_get_page(META_MAPPING(sbi), start_blk++);
462 f2fs_bug_on(!page);
458 f2fs_bug_on(sbi, !page);
463 orphan_blk =
464 (struct f2fs_orphan_block *)page_address(page);
465 memset(orphan_blk, 0, sizeof(*orphan_blk));
466 f2fs_put_page(page, 0);
467 }
468
469 orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino);
470

--- 143 unchanged lines hidden (view full) ---

614
615fail_no_cp:
616 kfree(sbi->ckpt);
617 return -EINVAL;
618}
619
620static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new)
621{
459 orphan_blk =
460 (struct f2fs_orphan_block *)page_address(page);
461 memset(orphan_blk, 0, sizeof(*orphan_blk));
462 f2fs_put_page(page, 0);
463 }
464
465 orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino);
466

--- 143 unchanged lines hidden (view full) ---

610
611fail_no_cp:
612 kfree(sbi->ckpt);
613 return -EINVAL;
614}
615
616static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new)
617{
622 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
618 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
623
624 if (is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR))
625 return -EEXIST;
626
627 set_inode_flag(F2FS_I(inode), FI_DIRTY_DIR);
628 F2FS_I(inode)->dirty_dir = new;
629 list_add_tail(&new->list, &sbi->dir_inode_list);
630 stat_inc_dirty_dir(sbi);
631 return 0;
632}
633
619
620 if (is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR))
621 return -EEXIST;
622
623 set_inode_flag(F2FS_I(inode), FI_DIRTY_DIR);
624 F2FS_I(inode)->dirty_dir = new;
625 list_add_tail(&new->list, &sbi->dir_inode_list);
626 stat_inc_dirty_dir(sbi);
627 return 0;
628}
629
634void set_dirty_dir_page(struct inode *inode, struct page *page)
630void update_dirty_page(struct inode *inode, struct page *page)
635{
631{
636 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
632 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
637 struct dir_inode_entry *new;
638 int ret = 0;
639
633 struct dir_inode_entry *new;
634 int ret = 0;
635
640 if (!S_ISDIR(inode->i_mode))
636 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
641 return;
642
637 return;
638
639 if (!S_ISDIR(inode->i_mode)) {
640 inode_inc_dirty_pages(inode);
641 goto out;
642 }
643
643 new = f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
644 new->inode = inode;
645 INIT_LIST_HEAD(&new->list);
646
647 spin_lock(&sbi->dir_inode_lock);
648 ret = __add_dirty_inode(inode, new);
644 new = f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
645 new->inode = inode;
646 INIT_LIST_HEAD(&new->list);
647
648 spin_lock(&sbi->dir_inode_lock);
649 ret = __add_dirty_inode(inode, new);
649 inode_inc_dirty_dents(inode);
650 SetPagePrivate(page);
650 inode_inc_dirty_pages(inode);
651 spin_unlock(&sbi->dir_inode_lock);
652
653 if (ret)
654 kmem_cache_free(inode_entry_slab, new);
651 spin_unlock(&sbi->dir_inode_lock);
652
653 if (ret)
654 kmem_cache_free(inode_entry_slab, new);
655out:
656 SetPagePrivate(page);
655}
656
657void add_dirty_dir_inode(struct inode *inode)
658{
657}
658
659void add_dirty_dir_inode(struct inode *inode)
660{
659 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
661 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
660 struct dir_inode_entry *new =
661 f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
662 int ret = 0;
663
664 new->inode = inode;
665 INIT_LIST_HEAD(&new->list);
666
667 spin_lock(&sbi->dir_inode_lock);
668 ret = __add_dirty_inode(inode, new);
669 spin_unlock(&sbi->dir_inode_lock);
670
671 if (ret)
672 kmem_cache_free(inode_entry_slab, new);
673}
674
675void remove_dirty_dir_inode(struct inode *inode)
676{
662 struct dir_inode_entry *new =
663 f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
664 int ret = 0;
665
666 new->inode = inode;
667 INIT_LIST_HEAD(&new->list);
668
669 spin_lock(&sbi->dir_inode_lock);
670 ret = __add_dirty_inode(inode, new);
671 spin_unlock(&sbi->dir_inode_lock);
672
673 if (ret)
674 kmem_cache_free(inode_entry_slab, new);
675}
676
677void remove_dirty_dir_inode(struct inode *inode)
678{
677 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
679 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
678 struct dir_inode_entry *entry;
679
680 if (!S_ISDIR(inode->i_mode))
681 return;
682
683 spin_lock(&sbi->dir_inode_lock);
680 struct dir_inode_entry *entry;
681
682 if (!S_ISDIR(inode->i_mode))
683 return;
684
685 spin_lock(&sbi->dir_inode_lock);
684 if (get_dirty_dents(inode) ||
686 if (get_dirty_pages(inode) ||
685 !is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR)) {
686 spin_unlock(&sbi->dir_inode_lock);
687 return;
688 }
689
690 entry = F2FS_I(inode)->dirty_dir;
691 list_del(&entry->list);
692 F2FS_I(inode)->dirty_dir = NULL;

--- 188 unchanged lines hidden (view full) ---

881 orphan_blocks);
882 }
883
884 if (sbi->n_orphans)
885 set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
886 else
887 clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
888
687 !is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR)) {
688 spin_unlock(&sbi->dir_inode_lock);
689 return;
690 }
691
692 entry = F2FS_I(inode)->dirty_dir;
693 list_del(&entry->list);
694 F2FS_I(inode)->dirty_dir = NULL;

--- 188 unchanged lines hidden (view full) ---

883 orphan_blocks);
884 }
885
886 if (sbi->n_orphans)
887 set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
888 else
889 clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
890
891 if (sbi->need_fsck)
892 set_ckpt_flags(ckpt, CP_FSCK_FLAG);
893
889 /* update SIT/NAT bitmap */
890 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
891 get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
892
893 crc32 = f2fs_crc32(ckpt, le32_to_cpu(ckpt->checksum_offset));
894 *((__le32 *)((unsigned char *)ckpt +
895 le32_to_cpu(ckpt->checksum_offset)))
896 = cpu_to_le32(crc32);

--- 151 unchanged lines hidden --- 		894 /* update SIT/NAT bitmap */
895 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
896 get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
897
898 crc32 = f2fs_crc32(ckpt, le32_to_cpu(ckpt->checksum_offset));
899 *((__le32 *)((unsigned char *)ckpt +
900 le32_to_cpu(ckpt->checksum_offset)))
901 = cpu_to_le32(crc32);

--- 151 unchanged lines hidden ---