blob: 502d7afd71a2da26c15a1e300ae81d9ee8b81744 [file] [log] [blame]
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +09002 * 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
9 * published by the Free Software Foundation.
10 */
11#include <linux/fs.h>
12#include <linux/bio.h>
13#include <linux/mpage.h>
14#include <linux/writeback.h>
15#include <linux/blkdev.h>
16#include <linux/f2fs_fs.h>
17#include <linux/pagevec.h>
18#include <linux/swap.h>
19
20#include "f2fs.h"
21#include "node.h"
22#include "segment.h"
Jaegeuk Kim9e4ded32014-12-17 19:58:58 -080023#include "trace.h"
Namjae Jeon2af4bd62013-04-23 18:26:54 +090024#include <trace/events/f2fs.h>
Jaegeuk Kim127e6702012-11-02 17:08:18 +090025
Jaegeuk Kim6451e042014-07-25 15:47:17 -070026static struct kmem_cache *ino_entry_slab;
Chao Yu4d57b862018-05-30 00:20:41 +080027struct kmem_cache *f2fs_inode_entry_slab;
Jaegeuk Kim127e6702012-11-02 17:08:18 +090028
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -070029void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)
30{
Jaegeuk Kim83a3bfd2018-06-21 13:46:23 -070031 f2fs_build_fault_attr(sbi, 0);
Chao Yuaaec2b12016-09-20 11:04:18 +080032 set_ckpt_flags(sbi, CP_ERROR_FLAG);
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -070033 if (!end_io)
Jaegeuk Kimb9109b02017-05-10 11:28:38 -070034 f2fs_flush_merged_writes(sbi);
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -070035}
36
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +090037/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +090038 * We guarantee no failure on the returned page.
39 */
Chao Yu4d57b862018-05-30 00:20:41 +080040struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
Jaegeuk Kim127e6702012-11-02 17:08:18 +090041{
Gu Zheng9df27d92014-01-20 18:37:04 +080042 struct address_space *mapping = META_MAPPING(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090043 struct page *page = NULL;
44repeat:
Jaegeuk Kim300e1292016-04-29 16:11:53 -070045 page = f2fs_grab_cache_page(mapping, index, false);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090046 if (!page) {
47 cond_resched();
48 goto repeat;
49 }
Jaegeuk Kimfec1d652016-01-20 23:43:51 +080050 f2fs_wait_on_page_writeback(page, META, true);
Jaegeuk Kim237c0792016-06-30 18:49:15 -070051 if (!PageUptodate(page))
52 SetPageUptodate(page);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090053 return page;
54}
55
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +090056/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +090057 * We guarantee no failure on the returned page.
58 */
Chao Yu2b947002015-10-12 17:04:21 +080059static struct page *__get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index,
60 bool is_meta)
Jaegeuk Kim127e6702012-11-02 17:08:18 +090061{
Gu Zheng9df27d92014-01-20 18:37:04 +080062 struct address_space *mapping = META_MAPPING(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090063 struct page *page;
Jaegeuk Kimcf04e8e2014-12-17 19:33:13 -080064 struct f2fs_io_info fio = {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -070065 .sbi = sbi,
Jaegeuk Kimcf04e8e2014-12-17 19:33:13 -080066 .type = META,
Mike Christie04d328d2016-06-05 14:31:55 -050067 .op = REQ_OP_READ,
Christoph Hellwig70fd7612016-11-01 07:40:10 -060068 .op_flags = REQ_META | REQ_PRIO,
Chao Yu7a9d7542016-02-22 18:36:38 +080069 .old_blkaddr = index,
70 .new_blkaddr = index,
Jaegeuk Kim4375a332015-04-23 12:04:33 -070071 .encrypted_page = NULL,
Yunlei He08337212018-03-08 16:29:13 +080072 .is_meta = is_meta,
Jaegeuk Kimcf04e8e2014-12-17 19:33:13 -080073 };
Chao Yu2b947002015-10-12 17:04:21 +080074
75 if (unlikely(!is_meta))
Mike Christie04d328d2016-06-05 14:31:55 -050076 fio.op_flags &= ~REQ_META;
Jaegeuk Kim127e6702012-11-02 17:08:18 +090077repeat:
Jaegeuk Kim300e1292016-04-29 16:11:53 -070078 page = f2fs_grab_cache_page(mapping, index, false);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090079 if (!page) {
80 cond_resched();
81 goto repeat;
82 }
Jaegeuk Kim393ff912013-03-08 21:29:23 +090083 if (PageUptodate(page))
84 goto out;
Jaegeuk Kim127e6702012-11-02 17:08:18 +090085
Jaegeuk Kim05ca3632015-04-23 14:38:15 -070086 fio.page = page;
87
Jaegeuk Kim86531d62015-07-15 13:08:21 -070088 if (f2fs_submit_page_bio(&fio)) {
89 f2fs_put_page(page, 1);
Jaegeuk Kim393ff912013-03-08 21:29:23 +090090 goto repeat;
Jaegeuk Kim86531d62015-07-15 13:08:21 -070091 }
Jaegeuk Kim393ff912013-03-08 21:29:23 +090092
93 lock_page(page);
Jaegeuk Kim6bacf522013-12-06 15:00:58 +090094 if (unlikely(page->mapping != mapping)) {
Jaegeuk Kimafcb7ca02013-04-26 11:55:17 +090095 f2fs_put_page(page, 1);
96 goto repeat;
97 }
Chao Yuf3f338c2015-07-29 17:33:13 +080098
99 /*
100 * if there is any IO error when accessing device, make our filesystem
101 * readonly and make sure do not write checkpoint with non-uptodate
102 * meta page.
103 */
Chao Yu81114ba2018-04-09 20:25:06 +0800104 if (unlikely(!PageUptodate(page))) {
105 memset(page_address(page), 0, PAGE_SIZE);
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -0700106 f2fs_stop_checkpoint(sbi, false);
Chao Yu81114ba2018-04-09 20:25:06 +0800107 }
Jaegeuk Kim393ff912013-03-08 21:29:23 +0900108out:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900109 return page;
110}
111
Chao Yu4d57b862018-05-30 00:20:41 +0800112struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu2b947002015-10-12 17:04:21 +0800113{
114 return __get_meta_page(sbi, index, true);
115}
116
117/* for POR only */
Chao Yu4d57b862018-05-30 00:20:41 +0800118struct page *f2fs_get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu2b947002015-10-12 17:04:21 +0800119{
120 return __get_meta_page(sbi, index, false);
121}
122
Chao Yu4d57b862018-05-30 00:20:41 +0800123bool f2fs_is_valid_meta_blkaddr(struct f2fs_sb_info *sbi,
124 block_t blkaddr, int type)
Chao Yu662befd2014-02-07 16:11:53 +0800125{
126 switch (type) {
127 case META_NAT:
Chao Yu66b00c182014-12-08 14:59:17 +0800128 break;
Chao Yu662befd2014-02-07 16:11:53 +0800129 case META_SIT:
Chao Yu66b00c182014-12-08 14:59:17 +0800130 if (unlikely(blkaddr >= SIT_BLK_CNT(sbi)))
131 return false;
132 break;
Chao Yu81c1a0f12014-02-27 19:12:24 +0800133 case META_SSA:
Chao Yu66b00c182014-12-08 14:59:17 +0800134 if (unlikely(blkaddr >= MAIN_BLKADDR(sbi) ||
135 blkaddr < SM_I(sbi)->ssa_blkaddr))
136 return false;
137 break;
Chao Yu662befd2014-02-07 16:11:53 +0800138 case META_CP:
Chao Yu66b00c182014-12-08 14:59:17 +0800139 if (unlikely(blkaddr >= SIT_I(sbi)->sit_base_addr ||
140 blkaddr < __start_cp_addr(sbi)))
141 return false;
142 break;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700143 case META_POR:
Chao Yu66b00c182014-12-08 14:59:17 +0800144 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
145 blkaddr < MAIN_BLKADDR(sbi)))
146 return false;
147 break;
Chao Yu662befd2014-02-07 16:11:53 +0800148 default:
149 BUG();
150 }
Chao Yu66b00c182014-12-08 14:59:17 +0800151
152 return true;
Chao Yu662befd2014-02-07 16:11:53 +0800153}
154
155/*
Chao Yu81c1a0f12014-02-27 19:12:24 +0800156 * Readahead CP/NAT/SIT/SSA pages
Chao Yu662befd2014-02-07 16:11:53 +0800157 */
Chao Yu4d57b862018-05-30 00:20:41 +0800158int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
Chao Yu26879fb2015-10-12 17:05:59 +0800159 int type, bool sync)
Chao Yu662befd2014-02-07 16:11:53 +0800160{
Chao Yu662befd2014-02-07 16:11:53 +0800161 struct page *page;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700162 block_t blkno = start;
Chao Yu662befd2014-02-07 16:11:53 +0800163 struct f2fs_io_info fio = {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700164 .sbi = sbi,
Chao Yu662befd2014-02-07 16:11:53 +0800165 .type = META,
Mike Christie04d328d2016-06-05 14:31:55 -0500166 .op = REQ_OP_READ,
Christoph Hellwig70fd7612016-11-01 07:40:10 -0600167 .op_flags = sync ? (REQ_META | REQ_PRIO) : REQ_RAHEAD,
Jaegeuk Kim4375a332015-04-23 12:04:33 -0700168 .encrypted_page = NULL,
Chao Yufb830fc2017-05-19 23:37:01 +0800169 .in_list = false,
Yunlei He08337212018-03-08 16:29:13 +0800170 .is_meta = (type != META_POR),
Chao Yu662befd2014-02-07 16:11:53 +0800171 };
Chao Yue9f5b8b2016-02-14 18:54:33 +0800172 struct blk_plug plug;
Chao Yu662befd2014-02-07 16:11:53 +0800173
Chao Yu2b947002015-10-12 17:04:21 +0800174 if (unlikely(type == META_POR))
Mike Christie04d328d2016-06-05 14:31:55 -0500175 fio.op_flags &= ~REQ_META;
Chao Yu2b947002015-10-12 17:04:21 +0800176
Chao Yue9f5b8b2016-02-14 18:54:33 +0800177 blk_start_plug(&plug);
Chao Yu662befd2014-02-07 16:11:53 +0800178 for (; nrpages-- > 0; blkno++) {
Chao Yu662befd2014-02-07 16:11:53 +0800179
Chao Yu4d57b862018-05-30 00:20:41 +0800180 if (!f2fs_is_valid_meta_blkaddr(sbi, blkno, type))
Chao Yu66b00c182014-12-08 14:59:17 +0800181 goto out;
182
Chao Yu662befd2014-02-07 16:11:53 +0800183 switch (type) {
184 case META_NAT:
Chao Yu66b00c182014-12-08 14:59:17 +0800185 if (unlikely(blkno >=
186 NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid)))
Chao Yu662befd2014-02-07 16:11:53 +0800187 blkno = 0;
Chao Yu66b00c182014-12-08 14:59:17 +0800188 /* get nat block addr */
Chao Yu7a9d7542016-02-22 18:36:38 +0800189 fio.new_blkaddr = current_nat_addr(sbi,
Chao Yu662befd2014-02-07 16:11:53 +0800190 blkno * NAT_ENTRY_PER_BLOCK);
191 break;
192 case META_SIT:
193 /* get sit block addr */
Chao Yu7a9d7542016-02-22 18:36:38 +0800194 fio.new_blkaddr = current_sit_addr(sbi,
Chao Yu662befd2014-02-07 16:11:53 +0800195 blkno * SIT_ENTRY_PER_BLOCK);
Chao Yu662befd2014-02-07 16:11:53 +0800196 break;
Chao Yu81c1a0f12014-02-27 19:12:24 +0800197 case META_SSA:
Chao Yu662befd2014-02-07 16:11:53 +0800198 case META_CP:
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700199 case META_POR:
Chao Yu7a9d7542016-02-22 18:36:38 +0800200 fio.new_blkaddr = blkno;
Chao Yu662befd2014-02-07 16:11:53 +0800201 break;
202 default:
203 BUG();
204 }
205
Jaegeuk Kim300e1292016-04-29 16:11:53 -0700206 page = f2fs_grab_cache_page(META_MAPPING(sbi),
207 fio.new_blkaddr, false);
Chao Yu662befd2014-02-07 16:11:53 +0800208 if (!page)
209 continue;
210 if (PageUptodate(page)) {
Chao Yu662befd2014-02-07 16:11:53 +0800211 f2fs_put_page(page, 1);
212 continue;
213 }
214
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700215 fio.page = page;
Jaegeuk Kim1919ffc2017-05-10 11:23:36 -0700216 f2fs_submit_page_bio(&fio);
Chao Yu662befd2014-02-07 16:11:53 +0800217 f2fs_put_page(page, 0);
218 }
219out:
Chao Yue9f5b8b2016-02-14 18:54:33 +0800220 blk_finish_plug(&plug);
Chao Yu662befd2014-02-07 16:11:53 +0800221 return blkno - start;
222}
223
Chao Yu4d57b862018-05-30 00:20:41 +0800224void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu635aee12014-12-08 15:02:52 +0800225{
226 struct page *page;
227 bool readahead = false;
228
229 page = find_get_page(META_MAPPING(sbi), index);
Jaegeuk Kim4da7bf52016-04-06 11:27:03 -0700230 if (!page || !PageUptodate(page))
Chao Yu635aee12014-12-08 15:02:52 +0800231 readahead = true;
232 f2fs_put_page(page, 0);
233
234 if (readahead)
Chao Yu4d57b862018-05-30 00:20:41 +0800235 f2fs_ra_meta_pages(sbi, index, BIO_MAX_PAGES, META_POR, true);
Chao Yu635aee12014-12-08 15:02:52 +0800236}
237
Chao Yub0af6d42017-08-02 23:21:48 +0800238static int __f2fs_write_meta_page(struct page *page,
239 struct writeback_control *wbc,
240 enum iostat_type io_type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900241{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700242 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900243
Chao Yuecda0de2014-05-06 16:48:26 +0800244 trace_f2fs_writepage(page, META);
245
Jaegeuk Kimaf697c02018-07-11 18:30:42 -0700246 if (unlikely(f2fs_cp_error(sbi)))
247 goto redirty_out;
Chao Yucaf00472015-01-28 17:48:42 +0800248 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
Chao Yucfb271d2013-12-05 17:15:22 +0800249 goto redirty_out;
Jaegeuk Kim857dc4e2014-11-19 11:03:34 -0800250 if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0))
Chao Yucfb271d2013-12-05 17:15:22 +0800251 goto redirty_out;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900252
Chao Yu4d57b862018-05-30 00:20:41 +0800253 f2fs_do_write_meta_page(sbi, page, io_type);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900254 dec_page_count(sbi, F2FS_DIRTY_META);
Chao Yu0c3a5792016-01-18 18:28:11 +0800255
256 if (wbc->for_reclaim)
Jaegeuk Kimb9109b02017-05-10 11:28:38 -0700257 f2fs_submit_merged_write_cond(sbi, page->mapping->host,
258 0, page->index, META);
Chao Yu0c3a5792016-01-18 18:28:11 +0800259
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900260 unlock_page(page);
Jaegeuk Kim857dc4e2014-11-19 11:03:34 -0800261
Chao Yu0c3a5792016-01-18 18:28:11 +0800262 if (unlikely(f2fs_cp_error(sbi)))
Jaegeuk Kimb9109b02017-05-10 11:28:38 -0700263 f2fs_submit_merged_write(sbi, META);
Chao Yu0c3a5792016-01-18 18:28:11 +0800264
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900265 return 0;
Chao Yucfb271d2013-12-05 17:15:22 +0800266
267redirty_out:
Jaegeuk Kim76f60262014-04-15 16:04:15 +0900268 redirty_page_for_writepage(wbc, page);
Chao Yucfb271d2013-12-05 17:15:22 +0800269 return AOP_WRITEPAGE_ACTIVATE;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900270}
271
Chao Yub0af6d42017-08-02 23:21:48 +0800272static int f2fs_write_meta_page(struct page *page,
273 struct writeback_control *wbc)
274{
275 return __f2fs_write_meta_page(page, wbc, FS_META_IO);
276}
277
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900278static int f2fs_write_meta_pages(struct address_space *mapping,
279 struct writeback_control *wbc)
280{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700281 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900282 long diff, written;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900283
Chao Yu0771fcc2017-06-29 23:20:45 +0800284 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
285 goto skip_write;
286
Jaegeuk Kim5459aa92013-12-17 17:28:41 +0900287 /* collect a number of dirty meta pages and write together */
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900288 if (wbc->for_kupdate ||
289 get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META))
Jaegeuk Kimd3baf952014-03-18 13:43:05 +0900290 goto skip_write;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900291
Yunlei Hea29d0e02017-03-01 18:07:10 +0800292 /* if locked failed, cp will flush dirty pages instead */
293 if (!mutex_trylock(&sbi->cp_mutex))
294 goto skip_write;
Yunlei Hed31c7c32016-02-04 16:14:00 +0800295
Yunlei Hea29d0e02017-03-01 18:07:10 +0800296 trace_f2fs_writepages(mapping->host, wbc, META);
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900297 diff = nr_pages_to_write(sbi, META, wbc);
Chao Yu4d57b862018-05-30 00:20:41 +0800298 written = f2fs_sync_meta_pages(sbi, META, wbc->nr_to_write, FS_META_IO);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900299 mutex_unlock(&sbi->cp_mutex);
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900300 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900301 return 0;
Jaegeuk Kimd3baf952014-03-18 13:43:05 +0900302
303skip_write:
304 wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_META);
Yunlei Hed31c7c32016-02-04 16:14:00 +0800305 trace_f2fs_writepages(mapping->host, wbc, META);
Jaegeuk Kimd3baf952014-03-18 13:43:05 +0900306 return 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900307}
308
Chao Yu4d57b862018-05-30 00:20:41 +0800309long f2fs_sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
Chao Yub0af6d42017-08-02 23:21:48 +0800310 long nr_to_write, enum iostat_type io_type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900311{
Gu Zheng9df27d92014-01-20 18:37:04 +0800312 struct address_space *mapping = META_MAPPING(sbi);
Jan Kara028a63a2017-11-15 17:34:51 -0800313 pgoff_t index = 0, prev = ULONG_MAX;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900314 struct pagevec pvec;
315 long nwritten = 0;
Jan Kara028a63a2017-11-15 17:34:51 -0800316 int nr_pages;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900317 struct writeback_control wbc = {
318 .for_reclaim = 0,
319 };
Chao Yue9f5b8b2016-02-14 18:54:33 +0800320 struct blk_plug plug;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900321
Mel Gorman86679822017-11-15 17:37:52 -0800322 pagevec_init(&pvec);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900323
Chao Yue9f5b8b2016-02-14 18:54:33 +0800324 blk_start_plug(&plug);
325
Jan Kara028a63a2017-11-15 17:34:51 -0800326 while ((nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
Jan Kara67fd7072017-11-15 17:35:19 -0800327 PAGECACHE_TAG_DIRTY))) {
Jan Kara028a63a2017-11-15 17:34:51 -0800328 int i;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900329
330 for (i = 0; i < nr_pages; i++) {
331 struct page *page = pvec.pages[i];
Jaegeuk Kim203681f2014-02-05 13:03:57 +0900332
Chao Yu80dd9c02016-02-24 17:20:44 +0800333 if (prev == ULONG_MAX)
Jaegeuk Kim6066d8c2015-10-01 16:42:55 -0700334 prev = page->index - 1;
335 if (nr_to_write != LONG_MAX && page->index != prev + 1) {
336 pagevec_release(&pvec);
337 goto stop;
338 }
339
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900340 lock_page(page);
Jaegeuk Kim203681f2014-02-05 13:03:57 +0900341
342 if (unlikely(page->mapping != mapping)) {
343continue_unlock:
344 unlock_page(page);
345 continue;
346 }
347 if (!PageDirty(page)) {
348 /* someone wrote it for us */
349 goto continue_unlock;
350 }
351
Jaegeuk Kimfa3d2bd2016-01-28 11:48:52 -0800352 f2fs_wait_on_page_writeback(page, META, true);
353
354 BUG_ON(PageWriteback(page));
Jaegeuk Kim203681f2014-02-05 13:03:57 +0900355 if (!clear_page_dirty_for_io(page))
356 goto continue_unlock;
357
Chao Yub0af6d42017-08-02 23:21:48 +0800358 if (__f2fs_write_meta_page(page, &wbc, io_type)) {
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900359 unlock_page(page);
360 break;
361 }
Chao Yucfb271d2013-12-05 17:15:22 +0800362 nwritten++;
Jaegeuk Kim6066d8c2015-10-01 16:42:55 -0700363 prev = page->index;
Chao Yucfb271d2013-12-05 17:15:22 +0800364 if (unlikely(nwritten >= nr_to_write))
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900365 break;
366 }
367 pagevec_release(&pvec);
368 cond_resched();
369 }
Jaegeuk Kim6066d8c2015-10-01 16:42:55 -0700370stop:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900371 if (nwritten)
Jaegeuk Kimb9109b02017-05-10 11:28:38 -0700372 f2fs_submit_merged_write(sbi, type);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900373
Chao Yue9f5b8b2016-02-14 18:54:33 +0800374 blk_finish_plug(&plug);
375
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900376 return nwritten;
377}
378
379static int f2fs_set_meta_page_dirty(struct page *page)
380{
Jaegeuk Kim26c6b882013-10-24 17:53:29 +0900381 trace_f2fs_set_page_dirty(page, META);
382
Jaegeuk Kim237c0792016-06-30 18:49:15 -0700383 if (!PageUptodate(page))
384 SetPageUptodate(page);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900385 if (!PageDirty(page)) {
Jaegeuk Kimb87078a2018-04-20 19:29:52 -0700386 __set_page_dirty_nobuffers(page);
Jaegeuk Kim40813632014-09-02 15:31:18 -0700387 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);
Chao Yu16018392015-01-19 20:24:37 +0800388 SetPagePrivate(page);
Jaegeuk Kim9e4ded32014-12-17 19:58:58 -0800389 f2fs_trace_pid(page);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900390 return 1;
391 }
392 return 0;
393}
394
395const struct address_space_operations f2fs_meta_aops = {
396 .writepage = f2fs_write_meta_page,
397 .writepages = f2fs_write_meta_pages,
398 .set_page_dirty = f2fs_set_meta_page_dirty,
Chao Yu487261f2015-02-05 17:44:29 +0800399 .invalidatepage = f2fs_invalidate_page,
400 .releasepage = f2fs_release_page,
Weichao Guo5b7a4872016-09-20 05:03:27 +0800401#ifdef CONFIG_MIGRATION
402 .migratepage = f2fs_migrate_page,
403#endif
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900404};
405
Chao Yu39d787b2017-09-29 13:59:38 +0800406static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino,
407 unsigned int devidx, int type)
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700408{
Chao Yu67298802014-11-18 11:18:36 +0800409 struct inode_management *im = &sbi->im[type];
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700410 struct ino_entry *e, *tmp;
411
412 tmp = f2fs_kmem_cache_alloc(ino_entry_slab, GFP_NOFS);
Chao Yu19526d72017-11-10 09:30:42 +0800413
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700414 radix_tree_preload(GFP_NOFS | __GFP_NOFAIL);
Jaegeuk Kim769ec6e2014-12-03 20:47:26 -0800415
Chao Yu67298802014-11-18 11:18:36 +0800416 spin_lock(&im->ino_lock);
Chao Yu67298802014-11-18 11:18:36 +0800417 e = radix_tree_lookup(&im->ino_root, ino);
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700418 if (!e) {
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700419 e = tmp;
Chao Yu19526d72017-11-10 09:30:42 +0800420 if (unlikely(radix_tree_insert(&im->ino_root, ino, e)))
421 f2fs_bug_on(sbi, 1);
422
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700423 memset(e, 0, sizeof(struct ino_entry));
424 e->ino = ino;
425
Chao Yu67298802014-11-18 11:18:36 +0800426 list_add_tail(&e->list, &im->ino_list);
Jaegeuk Kim8c402942014-11-06 15:16:04 -0800427 if (type != ORPHAN_INO)
Chao Yu67298802014-11-18 11:18:36 +0800428 im->ino_num++;
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700429 }
Chao Yu39d787b2017-09-29 13:59:38 +0800430
431 if (type == FLUSH_INO)
432 f2fs_set_bit(devidx, (char *)&e->dirty_device);
433
Chao Yu67298802014-11-18 11:18:36 +0800434 spin_unlock(&im->ino_lock);
Jaegeuk Kim769ec6e2014-12-03 20:47:26 -0800435 radix_tree_preload_end();
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700436
437 if (e != tmp)
438 kmem_cache_free(ino_entry_slab, tmp);
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700439}
440
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700441static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700442{
Chao Yu67298802014-11-18 11:18:36 +0800443 struct inode_management *im = &sbi->im[type];
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700444 struct ino_entry *e;
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700445
Chao Yu67298802014-11-18 11:18:36 +0800446 spin_lock(&im->ino_lock);
447 e = radix_tree_lookup(&im->ino_root, ino);
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700448 if (e) {
449 list_del(&e->list);
Chao Yu67298802014-11-18 11:18:36 +0800450 radix_tree_delete(&im->ino_root, ino);
451 im->ino_num--;
452 spin_unlock(&im->ino_lock);
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700453 kmem_cache_free(ino_entry_slab, e);
454 return;
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700455 }
Chao Yu67298802014-11-18 11:18:36 +0800456 spin_unlock(&im->ino_lock);
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700457}
458
Chao Yu4d57b862018-05-30 00:20:41 +0800459void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700460{
461 /* add new dirty ino entry into list */
Chao Yu39d787b2017-09-29 13:59:38 +0800462 __add_ino_entry(sbi, ino, 0, type);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700463}
464
Chao Yu4d57b862018-05-30 00:20:41 +0800465void f2fs_remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700466{
467 /* remove dirty ino entry from list */
468 __remove_ino_entry(sbi, ino, type);
469}
470
471/* mode should be APPEND_INO or UPDATE_INO */
Chao Yu4d57b862018-05-30 00:20:41 +0800472bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700473{
Chao Yu67298802014-11-18 11:18:36 +0800474 struct inode_management *im = &sbi->im[mode];
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700475 struct ino_entry *e;
Chao Yu67298802014-11-18 11:18:36 +0800476
477 spin_lock(&im->ino_lock);
478 e = radix_tree_lookup(&im->ino_root, ino);
479 spin_unlock(&im->ino_lock);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700480 return e ? true : false;
481}
482
Chao Yu4d57b862018-05-30 00:20:41 +0800483void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700484{
485 struct ino_entry *e, *tmp;
486 int i;
487
Chao Yu39d787b2017-09-29 13:59:38 +0800488 for (i = all ? ORPHAN_INO : APPEND_INO; i < MAX_INO_ENTRY; i++) {
Chao Yu67298802014-11-18 11:18:36 +0800489 struct inode_management *im = &sbi->im[i];
490
491 spin_lock(&im->ino_lock);
492 list_for_each_entry_safe(e, tmp, &im->ino_list, list) {
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700493 list_del(&e->list);
Chao Yu67298802014-11-18 11:18:36 +0800494 radix_tree_delete(&im->ino_root, e->ino);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700495 kmem_cache_free(ino_entry_slab, e);
Chao Yu67298802014-11-18 11:18:36 +0800496 im->ino_num--;
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700497 }
Chao Yu67298802014-11-18 11:18:36 +0800498 spin_unlock(&im->ino_lock);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700499 }
500}
501
Chao Yu4d57b862018-05-30 00:20:41 +0800502void f2fs_set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
Chao Yu39d787b2017-09-29 13:59:38 +0800503 unsigned int devidx, int type)
504{
505 __add_ino_entry(sbi, ino, devidx, type);
506}
507
Chao Yu4d57b862018-05-30 00:20:41 +0800508bool f2fs_is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
Chao Yu39d787b2017-09-29 13:59:38 +0800509 unsigned int devidx, int type)
510{
511 struct inode_management *im = &sbi->im[type];
512 struct ino_entry *e;
513 bool is_dirty = false;
514
515 spin_lock(&im->ino_lock);
516 e = radix_tree_lookup(&im->ino_root, ino);
517 if (e && f2fs_test_bit(devidx, (char *)&e->dirty_device))
518 is_dirty = true;
519 spin_unlock(&im->ino_lock);
520 return is_dirty;
521}
522
Chao Yu4d57b862018-05-30 00:20:41 +0800523int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900524{
Chao Yu67298802014-11-18 11:18:36 +0800525 struct inode_management *im = &sbi->im[ORPHAN_INO];
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900526 int err = 0;
527
Chao Yu67298802014-11-18 11:18:36 +0800528 spin_lock(&im->ino_lock);
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700529
530#ifdef CONFIG_F2FS_FAULT_INJECTION
Chao Yu1ecc0c52016-09-23 21:30:09 +0800531 if (time_to_inject(sbi, FAULT_ORPHAN)) {
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700532 spin_unlock(&im->ino_lock);
Chao Yu55523512017-02-25 11:08:28 +0800533 f2fs_show_injection_info(FAULT_ORPHAN);
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700534 return -ENOSPC;
535 }
536#endif
Chao Yu67298802014-11-18 11:18:36 +0800537 if (unlikely(im->ino_num >= sbi->max_orphans))
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900538 err = -ENOSPC;
Jaegeuk Kimcbd56e72013-07-30 11:36:53 +0900539 else
Chao Yu67298802014-11-18 11:18:36 +0800540 im->ino_num++;
541 spin_unlock(&im->ino_lock);
Gu Zheng0d47c1a2013-12-26 18:24:19 +0800542
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900543 return err;
544}
545
Chao Yu4d57b862018-05-30 00:20:41 +0800546void f2fs_release_orphan_inode(struct f2fs_sb_info *sbi)
Jaegeuk Kimcbd56e72013-07-30 11:36:53 +0900547{
Chao Yu67298802014-11-18 11:18:36 +0800548 struct inode_management *im = &sbi->im[ORPHAN_INO];
549
550 spin_lock(&im->ino_lock);
551 f2fs_bug_on(sbi, im->ino_num == 0);
552 im->ino_num--;
553 spin_unlock(&im->ino_lock);
Jaegeuk Kimcbd56e72013-07-30 11:36:53 +0900554}
555
Chao Yu4d57b862018-05-30 00:20:41 +0800556void f2fs_add_orphan_inode(struct inode *inode)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900557{
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700558 /* add new orphan ino entry into list */
Chao Yu39d787b2017-09-29 13:59:38 +0800559 __add_ino_entry(F2FS_I_SB(inode), inode->i_ino, 0, ORPHAN_INO);
Chao Yu4d57b862018-05-30 00:20:41 +0800560 f2fs_update_inode_page(inode);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900561}
562
Chao Yu4d57b862018-05-30 00:20:41 +0800563void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900564{
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700565 /* remove orphan entry from orphan list */
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700566 __remove_ino_entry(sbi, ino, ORPHAN_INO);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900567}
568
Chao Yu8c14bfa2015-08-07 17:58:43 +0800569static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900570{
Chao Yu8c14bfa2015-08-07 17:58:43 +0800571 struct inode *inode;
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700572 struct node_info ni;
Chao Yu76a45e32018-06-06 23:55:01 +0800573 int err;
Chao Yu8c14bfa2015-08-07 17:58:43 +0800574
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700575 inode = f2fs_iget_retry(sbi->sb, ino);
Chao Yu8c14bfa2015-08-07 17:58:43 +0800576 if (IS_ERR(inode)) {
577 /*
578 * there should be a bug that we can't find the entry
579 * to orphan inode.
580 */
581 f2fs_bug_on(sbi, PTR_ERR(inode) == -ENOENT);
582 return PTR_ERR(inode);
583 }
584
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800585 err = dquot_initialize(inode);
Sheng Yonga515d122018-04-21 14:12:50 +0800586 if (err) {
587 iput(inode);
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800588 goto err_out;
Sheng Yonga515d122018-04-21 14:12:50 +0800589 }
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800590
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900591 clear_nlink(inode);
592
593 /* truncate all the data during iput */
594 iput(inode);
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700595
Chao Yu4d57b862018-05-30 00:20:41 +0800596 f2fs_get_node_info(sbi, ino, &ni);
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700597
598 /* ENOMEM was fully retried in f2fs_evict_inode. */
599 if (ni.blk_addr != NULL_ADDR) {
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800600 err = -EIO;
601 goto err_out;
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700602 }
Chao Yu8c14bfa2015-08-07 17:58:43 +0800603 return 0;
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800604
605err_out:
606 set_sbi_flag(sbi, SBI_NEED_FSCK);
607 f2fs_msg(sbi->sb, KERN_WARNING,
608 "%s: orphan failed (ino=%x), run fsck to fix.",
609 __func__, ino);
610 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900611}
612
Chao Yu4d57b862018-05-30 00:20:41 +0800613int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900614{
Wanpeng Li3c642982015-02-26 07:57:21 +0800615 block_t start_blk, orphan_blocks, i, j;
Chao Yu4b2414d2017-08-08 10:54:31 +0800616 unsigned int s_flags = sbi->sb->s_flags;
617 int err = 0;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700618#ifdef CONFIG_QUOTA
619 int quota_enabled;
620#endif
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900621
Chao Yuaaec2b12016-09-20 11:04:18 +0800622 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
Chao Yu8c14bfa2015-08-07 17:58:43 +0800623 return 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900624
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800625 if (s_flags & SB_RDONLY) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800626 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800627 sbi->sb->s_flags &= ~SB_RDONLY;
Chao Yu4b2414d2017-08-08 10:54:31 +0800628 }
629
630#ifdef CONFIG_QUOTA
631 /* Needed for iput() to work correctly and not trash data */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800632 sbi->sb->s_flags |= SB_ACTIVE;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700633
Chao Yu4b2414d2017-08-08 10:54:31 +0800634 /* Turn on quotas so that they are updated correctly */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800635 quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
Chao Yu4b2414d2017-08-08 10:54:31 +0800636#endif
637
Wanpeng Li55141482015-02-26 07:57:20 +0800638 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
Wanpeng Li3c642982015-02-26 07:57:21 +0800639 orphan_blocks = __start_sum_addr(sbi) - 1 - __cp_payload(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900640
Chao Yu4d57b862018-05-30 00:20:41 +0800641 f2fs_ra_meta_pages(sbi, start_blk, orphan_blocks, META_CP, true);
Chao Yu662befd2014-02-07 16:11:53 +0800642
Wanpeng Li3c642982015-02-26 07:57:21 +0800643 for (i = 0; i < orphan_blocks; i++) {
Chao Yu4d57b862018-05-30 00:20:41 +0800644 struct page *page = f2fs_get_meta_page(sbi, start_blk + i);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900645 struct f2fs_orphan_block *orphan_blk;
646
647 orphan_blk = (struct f2fs_orphan_block *)page_address(page);
648 for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
649 nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
Chao Yu8c14bfa2015-08-07 17:58:43 +0800650 err = recover_orphan_inode(sbi, ino);
651 if (err) {
652 f2fs_put_page(page, 1);
Chao Yu4b2414d2017-08-08 10:54:31 +0800653 goto out;
Chao Yu8c14bfa2015-08-07 17:58:43 +0800654 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900655 }
656 f2fs_put_page(page, 1);
657 }
658 /* clear Orphan Flag */
Chao Yuaaec2b12016-09-20 11:04:18 +0800659 clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG);
Chao Yu4b2414d2017-08-08 10:54:31 +0800660out:
661#ifdef CONFIG_QUOTA
662 /* Turn quotas off */
Jaegeuk Kimea676732017-10-06 09:14:28 -0700663 if (quota_enabled)
664 f2fs_quota_off_umount(sbi->sb);
Chao Yu4b2414d2017-08-08 10:54:31 +0800665#endif
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800666 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
Chao Yu4b2414d2017-08-08 10:54:31 +0800667
668 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900669}
670
671static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk)
672{
Gu Zheng502c6e02013-11-19 18:03:58 +0800673 struct list_head *head;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900674 struct f2fs_orphan_block *orphan_blk = NULL;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900675 unsigned int nentries = 0;
Chao Yubd936f82015-07-13 17:44:25 +0800676 unsigned short index = 1;
Jaegeuk Kim8c402942014-11-06 15:16:04 -0800677 unsigned short orphan_blocks;
Gu Zheng45319292014-01-10 18:09:02 +0800678 struct page *page = NULL;
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700679 struct ino_entry *orphan = NULL;
Chao Yu67298802014-11-18 11:18:36 +0800680 struct inode_management *im = &sbi->im[ORPHAN_INO];
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900681
Chao Yu67298802014-11-18 11:18:36 +0800682 orphan_blocks = GET_ORPHAN_BLOCKS(im->ino_num);
Jaegeuk Kim8c402942014-11-06 15:16:04 -0800683
Jaegeuk Kimd6c67a42015-05-01 11:08:59 -0700684 /*
685 * we don't need to do spin_lock(&im->ino_lock) here, since all the
686 * orphan inode operations are covered under f2fs_lock_op().
687 * And, spin_lock should be avoided due to page operations below.
688 */
Chao Yu67298802014-11-18 11:18:36 +0800689 head = &im->ino_list;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900690
691 /* loop for each orphan inode entry and write them in Jornal block */
Gu Zheng502c6e02013-11-19 18:03:58 +0800692 list_for_each_entry(orphan, head, list) {
693 if (!page) {
Chao Yu4d57b862018-05-30 00:20:41 +0800694 page = f2fs_grab_meta_page(sbi, start_blk++);
Gu Zheng502c6e02013-11-19 18:03:58 +0800695 orphan_blk =
696 (struct f2fs_orphan_block *)page_address(page);
697 memset(orphan_blk, 0, sizeof(*orphan_blk));
698 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900699
Gu Zheng36795562013-11-26 16:44:16 +0800700 orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900701
Gu Zheng36795562013-11-26 16:44:16 +0800702 if (nentries == F2FS_ORPHANS_PER_BLOCK) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900703 /*
704 * an orphan block is full of 1020 entries,
705 * then we need to flush current orphan blocks
706 * and bring another one in memory
707 */
708 orphan_blk->blk_addr = cpu_to_le16(index);
709 orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
710 orphan_blk->entry_count = cpu_to_le32(nentries);
711 set_page_dirty(page);
712 f2fs_put_page(page, 1);
713 index++;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900714 nentries = 0;
715 page = NULL;
716 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900717 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900718
Gu Zheng502c6e02013-11-19 18:03:58 +0800719 if (page) {
720 orphan_blk->blk_addr = cpu_to_le16(index);
721 orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
722 orphan_blk->entry_count = cpu_to_le32(nentries);
723 set_page_dirty(page);
724 f2fs_put_page(page, 1);
725 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900726}
727
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800728static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr,
729 struct f2fs_checkpoint **cp_block, struct page **cp_page,
730 unsigned long long *version)
731{
732 unsigned long blk_size = sbi->blocksize;
733 size_t crc_offset = 0;
734 __u32 crc = 0;
735
Chao Yu4d57b862018-05-30 00:20:41 +0800736 *cp_page = f2fs_get_meta_page(sbi, cp_addr);
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800737 *cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);
738
739 crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
Kinglong Meec6f89df2017-03-15 21:12:50 +0800740 if (crc_offset > (blk_size - sizeof(__le32))) {
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800741 f2fs_msg(sbi->sb, KERN_WARNING,
742 "invalid crc_offset: %zu", crc_offset);
743 return -EINVAL;
744 }
745
Kinglong Meeced2c7e2017-02-25 19:53:39 +0800746 crc = cur_cp_crc(*cp_block);
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800747 if (!f2fs_crc_valid(sbi, crc, *cp_block, crc_offset)) {
748 f2fs_msg(sbi->sb, KERN_WARNING, "invalid crc value");
749 return -EINVAL;
750 }
751
752 *version = cur_cp_version(*cp_block);
753 return 0;
754}
755
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900756static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
757 block_t cp_addr, unsigned long long *version)
758{
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800759 struct page *cp_page_1 = NULL, *cp_page_2 = NULL;
760 struct f2fs_checkpoint *cp_block = NULL;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900761 unsigned long long cur_version = 0, pre_version = 0;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800762 int err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900763
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800764 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
765 &cp_page_1, version);
766 if (err)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900767 goto invalid_cp1;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800768 pre_version = *version;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900769
Jaegeuk Kim25ca9232012-11-28 16:12:41 +0900770 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800771 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
772 &cp_page_2, version);
773 if (err)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900774 goto invalid_cp2;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800775 cur_version = *version;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900776
777 if (cur_version == pre_version) {
778 *version = cur_version;
779 f2fs_put_page(cp_page_2, 1);
780 return cp_page_1;
781 }
782invalid_cp2:
783 f2fs_put_page(cp_page_2, 1);
784invalid_cp1:
785 f2fs_put_page(cp_page_1, 1);
786 return NULL;
787}
788
Chao Yu4d57b862018-05-30 00:20:41 +0800789int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900790{
791 struct f2fs_checkpoint *cp_block;
792 struct f2fs_super_block *fsb = sbi->raw_super;
793 struct page *cp1, *cp2, *cur_page;
794 unsigned long blk_size = sbi->blocksize;
795 unsigned long long cp1_version = 0, cp2_version = 0;
796 unsigned long long cp_start_blk_no;
Wanpeng Li55141482015-02-26 07:57:20 +0800797 unsigned int cp_blks = 1 + __cp_payload(sbi);
Changman Lee1dbe4152014-05-12 12:27:43 +0900798 block_t cp_blk_no;
799 int i;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900800
Kees Cook026f0502018-06-12 14:28:23 -0700801 sbi->ckpt = f2fs_kzalloc(sbi, array_size(blk_size, cp_blks),
802 GFP_KERNEL);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900803 if (!sbi->ckpt)
804 return -ENOMEM;
805 /*
806 * Finding out valid cp block involves read both
807 * sets( cp pack1 and cp pack 2)
808 */
809 cp_start_blk_no = le32_to_cpu(fsb->cp_blkaddr);
810 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
811
812 /* The second checkpoint pack should start at the next segment */
Jaegeuk Kimf9a4e6d2013-11-28 12:44:05 +0900813 cp_start_blk_no += ((unsigned long long)1) <<
814 le32_to_cpu(fsb->log_blocks_per_seg);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900815 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
816
817 if (cp1 && cp2) {
818 if (ver_after(cp2_version, cp1_version))
819 cur_page = cp2;
820 else
821 cur_page = cp1;
822 } else if (cp1) {
823 cur_page = cp1;
824 } else if (cp2) {
825 cur_page = cp2;
826 } else {
827 goto fail_no_cp;
828 }
829
830 cp_block = (struct f2fs_checkpoint *)page_address(cur_page);
831 memcpy(sbi->ckpt, cp_block, blk_size);
832
Shawn Lin984ec632016-02-17 11:26:32 +0800833 /* Sanity checking of checkpoint */
Chao Yu4d57b862018-05-30 00:20:41 +0800834 if (f2fs_sanity_check_ckpt(sbi))
Jaegeuk Kima2125ff2016-12-05 17:25:32 -0800835 goto free_fail_no_cp;
Shawn Lin984ec632016-02-17 11:26:32 +0800836
Jaegeuk Kim8508e442016-11-24 12:45:15 -0800837 if (cur_page == cp1)
838 sbi->cur_cp_pack = 1;
839 else
840 sbi->cur_cp_pack = 2;
Changman Lee1dbe4152014-05-12 12:27:43 +0900841
842 if (cp_blks <= 1)
843 goto done;
844
845 cp_blk_no = le32_to_cpu(fsb->cp_blkaddr);
846 if (cur_page == cp2)
847 cp_blk_no += 1 << le32_to_cpu(fsb->log_blocks_per_seg);
848
849 for (i = 1; i < cp_blks; i++) {
850 void *sit_bitmap_ptr;
851 unsigned char *ckpt = (unsigned char *)sbi->ckpt;
852
Chao Yu4d57b862018-05-30 00:20:41 +0800853 cur_page = f2fs_get_meta_page(sbi, cp_blk_no + i);
Changman Lee1dbe4152014-05-12 12:27:43 +0900854 sit_bitmap_ptr = page_address(cur_page);
855 memcpy(ckpt + i * blk_size, sit_bitmap_ptr, blk_size);
856 f2fs_put_page(cur_page, 1);
857 }
858done:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900859 f2fs_put_page(cp1, 1);
860 f2fs_put_page(cp2, 1);
861 return 0;
862
Jaegeuk Kima2125ff2016-12-05 17:25:32 -0800863free_fail_no_cp:
864 f2fs_put_page(cp1, 1);
865 f2fs_put_page(cp2, 1);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900866fail_no_cp:
867 kfree(sbi->ckpt);
868 return -EINVAL;
869}
870
Chao Yuc227f912015-12-16 13:09:20 +0800871static void __add_dirty_inode(struct inode *inode, enum inode_type type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900872{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700873 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yuc227f912015-12-16 13:09:20 +0800874 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900875
Jaegeuk Kim91942322016-05-20 10:13:22 -0700876 if (is_inode_flag_set(inode, flag))
Chao Yu2710fd72015-12-15 13:30:45 +0800877 return;
Chao Yu2d7b8222014-03-29 11:33:17 +0800878
Jaegeuk Kim91942322016-05-20 10:13:22 -0700879 set_inode_flag(inode, flag);
Chao Yu99f4b912017-03-22 17:23:46 +0800880 if (!f2fs_is_volatile_file(inode))
881 list_add_tail(&F2FS_I(inode)->dirty_list,
882 &sbi->inode_list[type]);
Chao Yu33fbd512015-12-17 17:14:44 +0800883 stat_inc_dirty_inode(sbi, type);
Jaegeuk Kim5deb8262013-06-05 17:42:45 +0900884}
885
Chao Yuc227f912015-12-16 13:09:20 +0800886static void __remove_dirty_inode(struct inode *inode, enum inode_type type)
Chao Yu6ad76092015-12-15 13:31:40 +0800887{
Chao Yuc227f912015-12-16 13:09:20 +0800888 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE;
Chao Yu6ad76092015-12-15 13:31:40 +0800889
Jaegeuk Kim91942322016-05-20 10:13:22 -0700890 if (get_dirty_pages(inode) || !is_inode_flag_set(inode, flag))
Chao Yu6ad76092015-12-15 13:31:40 +0800891 return;
892
Jaegeuk Kim91942322016-05-20 10:13:22 -0700893 list_del_init(&F2FS_I(inode)->dirty_list);
894 clear_inode_flag(inode, flag);
Chao Yu33fbd512015-12-17 17:14:44 +0800895 stat_dec_dirty_inode(F2FS_I_SB(inode), type);
Chao Yu6ad76092015-12-15 13:31:40 +0800896}
897
Chao Yu4d57b862018-05-30 00:20:41 +0800898void f2fs_update_dirty_page(struct inode *inode, struct page *page)
Jaegeuk Kim5deb8262013-06-05 17:42:45 +0900899{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700900 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yuc227f912015-12-16 13:09:20 +0800901 enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
Jaegeuk Kim5deb8262013-06-05 17:42:45 +0900902
Chao Yu5ac9f362015-06-29 18:14:10 +0800903 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
904 !S_ISLNK(inode->i_mode))
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900905 return;
Gu Zheng7bd59382013-10-22 14:52:26 +0800906
Jaegeuk Kim1c4bf762016-06-01 20:55:51 -0700907 spin_lock(&sbi->inode_lock[type]);
908 if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH))
Jaegeuk Kim10aa97c32016-05-16 10:33:40 -0700909 __add_dirty_inode(inode, type);
Yunlei Heb951a4e2016-05-13 14:57:43 +0800910 inode_inc_dirty_pages(inode);
Jaegeuk Kim1c4bf762016-06-01 20:55:51 -0700911 spin_unlock(&sbi->inode_lock[type]);
912
Jaegeuk Kima7ffdbe2014-09-12 15:53:45 -0700913 SetPagePrivate(page);
Jaegeuk Kim9e4ded32014-12-17 19:58:58 -0800914 f2fs_trace_pid(page);
Jaegeuk Kim5deb8262013-06-05 17:42:45 +0900915}
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900916
Chao Yu4d57b862018-05-30 00:20:41 +0800917void f2fs_remove_dirty_inode(struct inode *inode)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900918{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700919 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yuc227f912015-12-16 13:09:20 +0800920 enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900921
Chao Yuc227f912015-12-16 13:09:20 +0800922 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
923 !S_ISLNK(inode->i_mode))
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900924 return;
925
Jaegeuk Kim10aa97c32016-05-16 10:33:40 -0700926 if (type == FILE_INODE && !test_opt(sbi, DATA_FLUSH))
927 return;
928
Chao Yuc227f912015-12-16 13:09:20 +0800929 spin_lock(&sbi->inode_lock[type]);
930 __remove_dirty_inode(inode, type);
931 spin_unlock(&sbi->inode_lock[type]);
Jaegeuk Kim74d0b912013-05-15 16:40:02 +0900932}
933
Chao Yu4d57b862018-05-30 00:20:41 +0800934int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900935{
Gu Zhengce3b7d82013-11-19 18:03:47 +0800936 struct list_head *head;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900937 struct inode *inode;
Chao Yu2710fd72015-12-15 13:30:45 +0800938 struct f2fs_inode_info *fi;
Chao Yu4cf18532015-12-17 17:17:16 +0800939 bool is_dir = (type == DIR_INODE);
Jaegeuk Kim4db08d02017-07-14 11:45:21 -0700940 unsigned long ino = 0;
Chao Yu4cf18532015-12-17 17:17:16 +0800941
942 trace_f2fs_sync_dirty_inodes_enter(sbi->sb, is_dir,
943 get_pages(sbi, is_dir ?
944 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA));
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900945retry:
Jaegeuk Kimaf41d3e2014-10-17 14:14:16 -0700946 if (unlikely(f2fs_cp_error(sbi)))
Chao Yu6d5a1492015-12-24 18:04:56 +0800947 return -EIO;
Jaegeuk Kimaf41d3e2014-10-17 14:14:16 -0700948
Chao Yuc227f912015-12-16 13:09:20 +0800949 spin_lock(&sbi->inode_lock[type]);
Gu Zhengce3b7d82013-11-19 18:03:47 +0800950
Chao Yuc227f912015-12-16 13:09:20 +0800951 head = &sbi->inode_list[type];
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900952 if (list_empty(head)) {
Chao Yuc227f912015-12-16 13:09:20 +0800953 spin_unlock(&sbi->inode_lock[type]);
Chao Yu4cf18532015-12-17 17:17:16 +0800954 trace_f2fs_sync_dirty_inodes_exit(sbi->sb, is_dir,
955 get_pages(sbi, is_dir ?
956 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA));
Chao Yu6d5a1492015-12-24 18:04:56 +0800957 return 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900958 }
Chao Yu939afa92017-01-07 18:49:42 +0800959 fi = list_first_entry(head, struct f2fs_inode_info, dirty_list);
Chao Yu2710fd72015-12-15 13:30:45 +0800960 inode = igrab(&fi->vfs_inode);
Chao Yuc227f912015-12-16 13:09:20 +0800961 spin_unlock(&sbi->inode_lock[type]);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900962 if (inode) {
Jaegeuk Kim4db08d02017-07-14 11:45:21 -0700963 unsigned long cur_ino = inode->i_ino;
964
Chao Yub0af6d42017-08-02 23:21:48 +0800965 if (is_dir)
966 F2FS_I(inode)->cp_task = current;
967
Jaegeuk Kim87d6f892014-03-18 12:40:49 +0900968 filemap_fdatawrite(inode->i_mapping);
Chao Yub0af6d42017-08-02 23:21:48 +0800969
970 if (is_dir)
971 F2FS_I(inode)->cp_task = NULL;
972
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900973 iput(inode);
Jaegeuk Kim4db08d02017-07-14 11:45:21 -0700974 /* We need to give cpu to another writers. */
975 if (ino == cur_ino) {
976 congestion_wait(BLK_RW_ASYNC, HZ/50);
977 cond_resched();
978 } else {
979 ino = cur_ino;
980 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900981 } else {
982 /*
983 * We should submit bio, since it exists several
984 * wribacking dentry pages in the freeing inode.
985 */
Jaegeuk Kimb9109b02017-05-10 11:28:38 -0700986 f2fs_submit_merged_write(sbi, DATA);
Sebastian Andrzej Siewior7ecebe52015-02-27 13:13:14 +0100987 cond_resched();
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900988 }
989 goto retry;
990}
991
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700992int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi)
993{
994 struct list_head *head = &sbi->inode_list[DIRTY_META];
995 struct inode *inode;
996 struct f2fs_inode_info *fi;
997 s64 total = get_pages(sbi, F2FS_DIRTY_IMETA);
998
999 while (total--) {
1000 if (unlikely(f2fs_cp_error(sbi)))
1001 return -EIO;
1002
1003 spin_lock(&sbi->inode_lock[DIRTY_META]);
1004 if (list_empty(head)) {
1005 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1006 return 0;
1007 }
Chao Yu939afa92017-01-07 18:49:42 +08001008 fi = list_first_entry(head, struct f2fs_inode_info,
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001009 gdirty_list);
1010 inode = igrab(&fi->vfs_inode);
1011 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1012 if (inode) {
Jaegeuk Kim18340ed2016-10-19 18:27:56 -07001013 sync_inode_metadata(inode, 0);
1014
1015 /* it's on eviction */
1016 if (is_inode_flag_set(inode, FI_DIRTY_INODE))
Chao Yu4d57b862018-05-30 00:20:41 +08001017 f2fs_update_inode_page(inode);
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001018 iput(inode);
1019 }
Chao Yudee668c2017-11-02 20:41:01 +08001020 }
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001021 return 0;
1022}
1023
Yunlei He59c90812017-03-13 20:22:18 +08001024static void __prepare_cp_block(struct f2fs_sb_info *sbi)
1025{
1026 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1027 struct f2fs_nm_info *nm_i = NM_I(sbi);
1028 nid_t last_nid = nm_i->next_scan_nid;
1029
1030 next_free_nid(sbi, &last_nid);
1031 ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi));
1032 ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi));
1033 ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi));
1034 ckpt->next_free_nid = cpu_to_le32(last_nid);
1035}
1036
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001037/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001038 * Freeze all the FS-operations for checkpoint.
1039 */
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001040static int block_operations(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001041{
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001042 struct writeback_control wbc = {
1043 .sync_mode = WB_SYNC_ALL,
1044 .nr_to_write = LONG_MAX,
1045 .for_reclaim = 0,
1046 };
Jaegeuk Kimc718379b2013-04-24 13:19:56 +09001047 struct blk_plug plug;
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001048 int err = 0;
Jaegeuk Kimc718379b2013-04-24 13:19:56 +09001049
1050 blk_start_plug(&plug);
1051
Jaegeuk Kim39936832012-11-22 16:21:29 +09001052retry_flush_dents:
Gu Zhenge4795562013-09-27 18:08:30 +08001053 f2fs_lock_all(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001054 /* write all the dirty dentry pages */
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001055 if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
Gu Zhenge4795562013-09-27 18:08:30 +08001056 f2fs_unlock_all(sbi);
Chao Yu4d57b862018-05-30 00:20:41 +08001057 err = f2fs_sync_dirty_inodes(sbi, DIR_INODE);
Chao Yu6d5a1492015-12-24 18:04:56 +08001058 if (err)
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001059 goto out;
Jaegeuk Kim30973882017-04-11 19:15:33 -07001060 cond_resched();
Jaegeuk Kim39936832012-11-22 16:21:29 +09001061 goto retry_flush_dents;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001062 }
1063
Yunlei He59c90812017-03-13 20:22:18 +08001064 /*
1065 * POR: we should ensure that there are no dirty node pages
1066 * until finishing nat/sit flush. inode->i_blocks can be updated.
1067 */
1068 down_write(&sbi->node_change);
1069
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001070 if (get_pages(sbi, F2FS_DIRTY_IMETA)) {
Yunlei He59c90812017-03-13 20:22:18 +08001071 up_write(&sbi->node_change);
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001072 f2fs_unlock_all(sbi);
1073 err = f2fs_sync_inode_meta(sbi);
1074 if (err)
1075 goto out;
Jaegeuk Kim30973882017-04-11 19:15:33 -07001076 cond_resched();
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001077 goto retry_flush_dents;
1078 }
1079
Jaegeuk Kim39936832012-11-22 16:21:29 +09001080retry_flush_nodes:
Chao Yub3582c62014-07-03 18:58:39 +08001081 down_write(&sbi->node_write);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001082
1083 if (get_pages(sbi, F2FS_DIRTY_NODES)) {
Chao Yub3582c62014-07-03 18:58:39 +08001084 up_write(&sbi->node_write);
Chao Yuc29fd0c2018-06-04 23:20:36 +08001085 atomic_inc(&sbi->wb_sync_req[NODE]);
Chao Yu4d57b862018-05-30 00:20:41 +08001086 err = f2fs_sync_node_pages(sbi, &wbc, false, FS_CP_NODE_IO);
Chao Yuc29fd0c2018-06-04 23:20:36 +08001087 atomic_dec(&sbi->wb_sync_req[NODE]);
Chao Yu6d5a1492015-12-24 18:04:56 +08001088 if (err) {
Yunlei He59c90812017-03-13 20:22:18 +08001089 up_write(&sbi->node_change);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001090 f2fs_unlock_all(sbi);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001091 goto out;
1092 }
Jaegeuk Kim30973882017-04-11 19:15:33 -07001093 cond_resched();
Jaegeuk Kim39936832012-11-22 16:21:29 +09001094 goto retry_flush_nodes;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001095 }
Yunlei He59c90812017-03-13 20:22:18 +08001096
1097 /*
1098 * sbi->node_change is used only for AIO write_begin path which produces
1099 * dirty node blocks and some checkpoint values by block allocation.
1100 */
1101 __prepare_cp_block(sbi);
1102 up_write(&sbi->node_change);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001103out:
Jaegeuk Kimc718379b2013-04-24 13:19:56 +09001104 blk_finish_plug(&plug);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001105 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001106}
1107
1108static void unblock_operations(struct f2fs_sb_info *sbi)
1109{
Chao Yub3582c62014-07-03 18:58:39 +08001110 up_write(&sbi->node_write);
Gu Zhenge4795562013-09-27 18:08:30 +08001111 f2fs_unlock_all(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001112}
1113
Changman Leefb51b5e2013-11-07 12:48:25 +09001114static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi)
1115{
1116 DEFINE_WAIT(wait);
1117
1118 for (;;) {
1119 prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);
1120
Chao Yu36951b32016-11-16 10:41:20 +08001121 if (!get_pages(sbi, F2FS_WB_CP_DATA))
Changman Leefb51b5e2013-11-07 12:48:25 +09001122 break;
1123
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001124 if (unlikely(f2fs_cp_error(sbi)))
1125 break;
1126
Yunlei He0ff21642016-02-23 12:07:56 +08001127 io_schedule_timeout(5*HZ);
Changman Leefb51b5e2013-11-07 12:48:25 +09001128 }
1129 finish_wait(&sbi->cp_wait, &wait);
1130}
1131
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001132static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1133{
1134 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;
1135 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Chao Yud1aa2452017-07-07 14:10:15 +08001136 unsigned long flags;
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001137
Chao Yud1aa2452017-07-07 14:10:15 +08001138 spin_lock_irqsave(&sbi->cp_lock, flags);
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001139
Chao Yuc473f1a2017-04-27 20:40:39 +08001140 if ((cpc->reason & CP_UMOUNT) &&
Kinglong Mee10047f52017-03-11 21:18:01 +08001141 le32_to_cpu(ckpt->cp_pack_total_block_count) >
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001142 sbi->blocks_per_seg - NM_I(sbi)->nat_bits_blocks)
1143 disable_nat_bits(sbi, false);
1144
Chao Yu1f43e2a2017-04-28 13:56:08 +08001145 if (cpc->reason & CP_TRIMMED)
1146 __set_ckpt_flags(ckpt, CP_TRIMMED_FLAG);
Chao Yucd36d7a2018-01-31 09:30:34 +08001147 else
1148 __clear_ckpt_flags(ckpt, CP_TRIMMED_FLAG);
Chao Yu1f43e2a2017-04-28 13:56:08 +08001149
Chao Yuc473f1a2017-04-27 20:40:39 +08001150 if (cpc->reason & CP_UMOUNT)
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001151 __set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1152 else
1153 __clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1154
Chao Yuc473f1a2017-04-27 20:40:39 +08001155 if (cpc->reason & CP_FASTBOOT)
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001156 __set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1157 else
1158 __clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1159
1160 if (orphan_num)
1161 __set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1162 else
1163 __clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1164
1165 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))
1166 __set_ckpt_flags(ckpt, CP_FSCK_FLAG);
1167
1168 /* set this flag to activate crc|cp_ver for recovery */
1169 __set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);
Jaegeuk Kimf2367922018-01-19 13:42:33 -08001170 __clear_ckpt_flags(ckpt, CP_NOCRC_RECOVERY_FLAG);
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001171
Chao Yud1aa2452017-07-07 14:10:15 +08001172 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001173}
1174
Gao Xiang46706d52018-02-10 12:12:51 +08001175static void commit_checkpoint(struct f2fs_sb_info *sbi,
1176 void *src, block_t blk_addr)
1177{
1178 struct writeback_control wbc = {
1179 .for_reclaim = 0,
1180 };
1181
1182 /*
1183 * pagevec_lookup_tag and lock_page again will take
Chao Yu4d57b862018-05-30 00:20:41 +08001184 * some extra time. Therefore, f2fs_update_meta_pages and
1185 * f2fs_sync_meta_pages are combined in this function.
Gao Xiang46706d52018-02-10 12:12:51 +08001186 */
Chao Yu4d57b862018-05-30 00:20:41 +08001187 struct page *page = f2fs_grab_meta_page(sbi, blk_addr);
Gao Xiang46706d52018-02-10 12:12:51 +08001188 int err;
1189
1190 memcpy(page_address(page), src, PAGE_SIZE);
1191 set_page_dirty(page);
1192
1193 f2fs_wait_on_page_writeback(page, META, true);
1194 f2fs_bug_on(sbi, PageWriteback(page));
1195 if (unlikely(!clear_page_dirty_for_io(page)))
1196 f2fs_bug_on(sbi, 1);
1197
1198 /* writeout cp pack 2 page */
1199 err = __f2fs_write_meta_page(page, &wbc, FS_CP_META_IO);
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001200 if (unlikely(err && f2fs_cp_error(sbi))) {
1201 f2fs_put_page(page, 1);
1202 return;
1203 }
Gao Xiang46706d52018-02-10 12:12:51 +08001204
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001205 f2fs_bug_on(sbi, err);
Gao Xiang46706d52018-02-10 12:12:51 +08001206 f2fs_put_page(page, 0);
1207
1208 /* submit checkpoint (with barrier if NOBARRIER is not set) */
1209 f2fs_submit_merged_write(sbi, META_FLUSH);
1210}
1211
Chao Yuc34f42e2015-12-23 17:50:30 +08001212static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001213{
1214 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Huang Ying77041822014-09-12 20:19:48 +08001215 struct f2fs_nm_info *nm_i = NM_I(sbi);
Chao Yud1aa2452017-07-07 14:10:15 +08001216 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num, flags;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001217 block_t start_blk;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001218 unsigned int data_sum_blocks, orphan_blocks;
Jaegeuk Kim7e586fa2013-06-19 20:47:19 +09001219 __u32 crc32 = 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001220 int i;
Wanpeng Li55141482015-02-26 07:57:20 +08001221 int cp_payload_blks = __cp_payload(sbi);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001222 struct super_block *sb = sbi->sb;
1223 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
1224 u64 kbytes_written;
Chao Yu1228b482017-09-29 13:59:39 +08001225 int err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001226
1227 /* Flush all the NAT/SIT pages */
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001228 while (get_pages(sbi, F2FS_DIRTY_META)) {
Chao Yu4d57b862018-05-30 00:20:41 +08001229 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001230 if (unlikely(f2fs_cp_error(sbi)))
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001231 break;
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001232 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001233
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001234 /*
1235 * modify checkpoint
1236 * version number is already updated
1237 */
Chao Yua1f72ac22018-06-04 23:20:17 +08001238 ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi, true));
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001239 ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));
Chao Yub5b82202014-08-22 16:17:38 +08001240 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001241 ckpt->cur_node_segno[i] =
1242 cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE));
1243 ckpt->cur_node_blkoff[i] =
1244 cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_NODE));
1245 ckpt->alloc_type[i + CURSEG_HOT_NODE] =
1246 curseg_alloc_type(sbi, i + CURSEG_HOT_NODE);
1247 }
Chao Yub5b82202014-08-22 16:17:38 +08001248 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001249 ckpt->cur_data_segno[i] =
1250 cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA));
1251 ckpt->cur_data_blkoff[i] =
1252 cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_DATA));
1253 ckpt->alloc_type[i + CURSEG_HOT_DATA] =
1254 curseg_alloc_type(sbi, i + CURSEG_HOT_DATA);
1255 }
1256
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001257 /* 2 cp + n data seg summary + orphan inode blocks */
Chao Yu4d57b862018-05-30 00:20:41 +08001258 data_sum_blocks = f2fs_npages_for_summary_flush(sbi, false);
Chao Yud1aa2452017-07-07 14:10:15 +08001259 spin_lock_irqsave(&sbi->cp_lock, flags);
Chao Yub5b82202014-08-22 16:17:38 +08001260 if (data_sum_blocks < NR_CURSEG_DATA_TYPE)
Chao Yuaaec2b12016-09-20 11:04:18 +08001261 __set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001262 else
Chao Yuaaec2b12016-09-20 11:04:18 +08001263 __clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
Chao Yud1aa2452017-07-07 14:10:15 +08001264 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001265
Chao Yu67298802014-11-18 11:18:36 +08001266 orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num);
Changman Lee1dbe4152014-05-12 12:27:43 +09001267 ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
1268 orphan_blocks);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001269
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001270 if (__remain_node_summaries(cpc->reason))
Chao Yub5b82202014-08-22 16:17:38 +08001271 ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+
Changman Lee1dbe4152014-05-12 12:27:43 +09001272 cp_payload_blks + data_sum_blocks +
1273 orphan_blocks + NR_CURSEG_NODE_TYPE);
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001274 else
Chao Yub5b82202014-08-22 16:17:38 +08001275 ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS +
Changman Lee1dbe4152014-05-12 12:27:43 +09001276 cp_payload_blks + data_sum_blocks +
1277 orphan_blocks);
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001278
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001279 /* update ckpt flag for checkpoint */
1280 update_ckpt_flags(sbi, cpc);
Jaegeuk Kima468f0e2016-09-19 17:55:10 -07001281
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001282 /* update SIT/NAT bitmap */
1283 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
1284 get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
1285
Keith Mok43b65732016-03-02 12:04:24 -08001286 crc32 = f2fs_crc32(sbi, ckpt, le32_to_cpu(ckpt->checksum_offset));
Jaegeuk Kim7e586fa2013-06-19 20:47:19 +09001287 *((__le32 *)((unsigned char *)ckpt +
1288 le32_to_cpu(ckpt->checksum_offset)))
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001289 = cpu_to_le32(crc32);
1290
Jaegeuk Kim8508e442016-11-24 12:45:15 -08001291 start_blk = __start_cp_next_addr(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001292
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001293 /* write nat bits */
1294 if (enabled_nat_bits(sbi, cpc)) {
1295 __u64 cp_ver = cur_cp_version(ckpt);
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001296 block_t blk;
1297
1298 cp_ver |= ((__u64)crc32 << 32);
1299 *(__le64 *)nm_i->nat_bits = cpu_to_le64(cp_ver);
1300
1301 blk = start_blk + sbi->blocks_per_seg - nm_i->nat_bits_blocks;
1302 for (i = 0; i < nm_i->nat_bits_blocks; i++)
Chao Yu4d57b862018-05-30 00:20:41 +08001303 f2fs_update_meta_page(sbi, nm_i->nat_bits +
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001304 (i << F2FS_BLKSIZE_BITS), blk + i);
1305
1306 /* Flush all the NAT BITS pages */
1307 while (get_pages(sbi, F2FS_DIRTY_META)) {
Chao Yu4d57b862018-05-30 00:20:41 +08001308 f2fs_sync_meta_pages(sbi, META, LONG_MAX,
1309 FS_CP_META_IO);
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001310 if (unlikely(f2fs_cp_error(sbi)))
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001311 break;
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001312 }
1313 }
1314
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001315 /* write out checkpoint buffer at block 0 */
Chao Yu4d57b862018-05-30 00:20:41 +08001316 f2fs_update_meta_page(sbi, ckpt, start_blk++);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001317
Chao Yu381722d2015-05-19 17:40:04 +08001318 for (i = 1; i < 1 + cp_payload_blks; i++)
Chao Yu4d57b862018-05-30 00:20:41 +08001319 f2fs_update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE,
Chao Yu381722d2015-05-19 17:40:04 +08001320 start_blk++);
Changman Lee1dbe4152014-05-12 12:27:43 +09001321
Chao Yu67298802014-11-18 11:18:36 +08001322 if (orphan_num) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001323 write_orphan_inodes(sbi, start_blk);
1324 start_blk += orphan_blocks;
1325 }
1326
Chao Yu4d57b862018-05-30 00:20:41 +08001327 f2fs_write_data_summaries(sbi, start_blk);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001328 start_blk += data_sum_blocks;
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001329
1330 /* Record write statistics in the hot node summary */
1331 kbytes_written = sbi->kbytes_written;
1332 if (sb->s_bdev->bd_part)
1333 kbytes_written += BD_PART_WRITTEN(sbi);
1334
Chao Yub7ad7512016-02-19 18:08:46 +08001335 seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001336
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001337 if (__remain_node_summaries(cpc->reason)) {
Chao Yu4d57b862018-05-30 00:20:41 +08001338 f2fs_write_node_summaries(sbi, start_blk);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001339 start_blk += NR_CURSEG_NODE_TYPE;
1340 }
1341
Gao Xiang46706d52018-02-10 12:12:51 +08001342 /* update user_block_counts */
1343 sbi->last_valid_block_count = sbi->total_valid_block_count;
1344 percpu_counter_set(&sbi->alloc_valid_block_count, 0);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001345
Gao Xiang46706d52018-02-10 12:12:51 +08001346 /* Here, we have one bio having CP pack except cp pack 2 page */
Chao Yu4d57b862018-05-30 00:20:41 +08001347 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
Gao Xiang46706d52018-02-10 12:12:51 +08001348
1349 /* wait for previous submitted meta pages writeback */
Changman Leefb51b5e2013-11-07 12:48:25 +09001350 wait_on_all_pages_writeback(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001351
Gao Xiang46706d52018-02-10 12:12:51 +08001352 /* flush all device cache */
1353 err = f2fs_flush_device_cache(sbi);
1354 if (err)
1355 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001356
Gao Xiang46706d52018-02-10 12:12:51 +08001357 /* barrier and flush checkpoint cp pack 2 page if it can */
1358 commit_checkpoint(sbi, ckpt, start_blk);
Jaegeuk Kim6a8f8ca2014-10-29 14:37:22 -07001359 wait_on_all_pages_writeback(sbi);
1360
Chao Yu4d57b862018-05-30 00:20:41 +08001361 f2fs_release_ino_entry(sbi, false);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001362
Chao Yucaf00472015-01-28 17:48:42 +08001363 clear_sbi_flag(sbi, SBI_IS_DIRTY);
Jaegeuk Kimbbf156f2016-08-29 18:23:45 -07001364 clear_sbi_flag(sbi, SBI_NEED_CP);
Jaegeuk Kim8508e442016-11-24 12:45:15 -08001365 __set_cp_next_pack(sbi);
Chao Yuc34f42e2015-12-23 17:50:30 +08001366
Chao Yuc2a080a2016-08-31 10:43:19 +08001367 /*
1368 * redirty superblock if metadata like node page or inode cache is
1369 * updated during writing checkpoint.
1370 */
1371 if (get_pages(sbi, F2FS_DIRTY_NODES) ||
1372 get_pages(sbi, F2FS_DIRTY_IMETA))
1373 set_sbi_flag(sbi, SBI_IS_DIRTY);
1374
1375 f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS));
1376
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001377 return unlikely(f2fs_cp_error(sbi)) ? -EIO : 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001378}
1379
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001380/*
arter97e1c42042014-08-06 23:22:50 +09001381 * We guarantee that this checkpoint procedure will not fail.
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001382 */
Chao Yu4d57b862018-05-30 00:20:41 +08001383int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001384{
1385 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1386 unsigned long long ckpt_ver;
Chao Yuc34f42e2015-12-23 17:50:30 +08001387 int err = 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001388
Jaegeuk Kim43727522013-02-04 15:11:17 +09001389 mutex_lock(&sbi->cp_mutex);
Jaegeuk Kim85010172014-08-11 18:37:46 -07001390
Chao Yucaf00472015-01-28 17:48:42 +08001391 if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
Chao Yuc473f1a2017-04-27 20:40:39 +08001392 ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
1393 ((cpc->reason & CP_DISCARD) && !sbi->discard_blks)))
Jaegeuk Kim85010172014-08-11 18:37:46 -07001394 goto out;
Chao Yuc34f42e2015-12-23 17:50:30 +08001395 if (unlikely(f2fs_cp_error(sbi))) {
1396 err = -EIO;
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001397 goto out;
Chao Yuc34f42e2015-12-23 17:50:30 +08001398 }
1399 if (f2fs_readonly(sbi->sb)) {
1400 err = -EROFS;
Jaegeuk Kim11504a82015-01-23 18:43:45 -08001401 goto out;
Chao Yuc34f42e2015-12-23 17:50:30 +08001402 }
Wanpeng Li2bda5422015-02-27 15:56:16 +08001403
1404 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
1405
Chao Yuc34f42e2015-12-23 17:50:30 +08001406 err = block_operations(sbi);
1407 if (err)
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001408 goto out;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001409
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -07001410 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
Namjae Jeon2af4bd62013-04-23 18:26:54 +09001411
Jaegeuk Kimb9109b02017-05-10 11:28:38 -07001412 f2fs_flush_merged_writes(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001413
Yunlei He58cce382016-08-18 21:01:19 +08001414 /* this is the case of multiple fstrims without any changes */
Chao Yuc473f1a2017-04-27 20:40:39 +08001415 if (cpc->reason & CP_DISCARD) {
Chao Yu4d57b862018-05-30 00:20:41 +08001416 if (!f2fs_exist_trim_candidates(sbi, cpc)) {
Jaegeuk Kim25290fa2016-12-29 22:06:15 -08001417 unblock_operations(sbi);
1418 goto out;
1419 }
1420
Jaegeuk Kim0333ad42016-12-29 16:58:54 -08001421 if (NM_I(sbi)->dirty_nat_cnt == 0 &&
1422 SIT_I(sbi)->dirty_sentries == 0 &&
1423 prefree_segments(sbi) == 0) {
Chao Yu4d57b862018-05-30 00:20:41 +08001424 f2fs_flush_sit_entries(sbi, cpc);
1425 f2fs_clear_prefree_segments(sbi, cpc);
Jaegeuk Kim0333ad42016-12-29 16:58:54 -08001426 unblock_operations(sbi);
1427 goto out;
1428 }
Yunlei He58cce382016-08-18 21:01:19 +08001429 }
1430
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001431 /*
1432 * update checkpoint pack index
1433 * Increase the version number so that
1434 * SIT entries and seg summaries are written at correct place
1435 */
Jaegeuk Kimd71b5562013-08-09 15:03:21 +09001436 ckpt_ver = cur_cp_version(ckpt);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001437 ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);
1438
1439 /* write cached NAT/SIT entries to NAT/SIT area */
Chao Yu4d57b862018-05-30 00:20:41 +08001440 f2fs_flush_nat_entries(sbi, cpc);
1441 f2fs_flush_sit_entries(sbi, cpc);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001442
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001443 /* unlock all the fs_lock[] in do_checkpoint() */
Chao Yuc34f42e2015-12-23 17:50:30 +08001444 err = do_checkpoint(sbi, cpc);
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001445 if (err)
Chao Yu4d57b862018-05-30 00:20:41 +08001446 f2fs_release_discard_addrs(sbi);
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001447 else
Chao Yu4d57b862018-05-30 00:20:41 +08001448 f2fs_clear_prefree_segments(sbi, cpc);
Chao Yu275b66b2016-08-29 23:58:34 +08001449
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001450 unblock_operations(sbi);
Changman Lee942e0be2014-02-13 15:12:29 +09001451 stat_inc_cp_count(sbi->stat_info);
Jaegeuk Kim10027552015-04-09 17:03:53 -07001452
Chao Yuc473f1a2017-04-27 20:40:39 +08001453 if (cpc->reason & CP_RECOVERY)
Jaegeuk Kim10027552015-04-09 17:03:53 -07001454 f2fs_msg(sbi->sb, KERN_NOTICE,
1455 "checkpoint: version = %llx", ckpt_ver);
Jaegeuk Kim60b99b42015-10-05 14:49:57 -07001456
1457 /* do checkpoint periodically */
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001458 f2fs_update_time(sbi, CP_TIME);
Jaegeuk Kim55d1cdb2015-12-15 16:07:14 -08001459 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
Jaegeuk Kim85010172014-08-11 18:37:46 -07001460out:
1461 mutex_unlock(&sbi->cp_mutex);
Chao Yuc34f42e2015-12-23 17:50:30 +08001462 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001463}
1464
Chao Yu4d57b862018-05-30 00:20:41 +08001465void f2fs_init_ino_entry_info(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001466{
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001467 int i;
1468
1469 for (i = 0; i < MAX_INO_ENTRY; i++) {
Chao Yu67298802014-11-18 11:18:36 +08001470 struct inode_management *im = &sbi->im[i];
1471
1472 INIT_RADIX_TREE(&im->ino_root, GFP_ATOMIC);
1473 spin_lock_init(&im->ino_lock);
1474 INIT_LIST_HEAD(&im->ino_list);
1475 im->ino_num = 0;
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001476 }
1477
Chao Yub5b82202014-08-22 16:17:38 +08001478 sbi->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS -
Wanpeng Li14b42812015-02-27 17:38:13 +08001479 NR_CURSEG_TYPE - __cp_payload(sbi)) *
1480 F2FS_ORPHANS_PER_BLOCK;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001481}
1482
Chao Yu4d57b862018-05-30 00:20:41 +08001483int __init f2fs_create_checkpoint_caches(void)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001484{
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001485 ino_entry_slab = f2fs_kmem_cache_create("f2fs_ino_entry",
1486 sizeof(struct ino_entry));
1487 if (!ino_entry_slab)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001488 return -ENOMEM;
Chao Yu4d57b862018-05-30 00:20:41 +08001489 f2fs_inode_entry_slab = f2fs_kmem_cache_create("f2fs_inode_entry",
Chao Yu06292072014-12-29 15:56:18 +08001490 sizeof(struct inode_entry));
Chao Yu4d57b862018-05-30 00:20:41 +08001491 if (!f2fs_inode_entry_slab) {
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001492 kmem_cache_destroy(ino_entry_slab);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001493 return -ENOMEM;
1494 }
1495 return 0;
1496}
1497
Chao Yu4d57b862018-05-30 00:20:41 +08001498void f2fs_destroy_checkpoint_caches(void)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001499{
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001500 kmem_cache_destroy(ino_entry_slab);
Chao Yu4d57b862018-05-30 00:20:41 +08001501 kmem_cache_destroy(f2fs_inode_entry_slab);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001502}