blob: 9bcd77db980dfe2d22499a829d774c36da4f4fd4 [file] [log] [blame]
Chao Yu7c1a0002018-09-12 09:16:07 +08001// SPDX-License-Identifier: GPL-2.0
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09002/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +09003 * fs/f2fs/checkpoint.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
Jaegeuk Kim127e6702012-11-02 17:08:18 +09007 */
8#include <linux/fs.h>
9#include <linux/bio.h>
10#include <linux/mpage.h>
11#include <linux/writeback.h>
12#include <linux/blkdev.h>
13#include <linux/f2fs_fs.h>
14#include <linux/pagevec.h>
15#include <linux/swap.h>
16
17#include "f2fs.h"
18#include "node.h"
19#include "segment.h"
Jaegeuk Kim9e4ded32014-12-17 19:58:58 -080020#include "trace.h"
Namjae Jeon2af4bd62013-04-23 18:26:54 +090021#include <trace/events/f2fs.h>
Jaegeuk Kim127e6702012-11-02 17:08:18 +090022
Jaegeuk Kim6451e042014-07-25 15:47:17 -070023static struct kmem_cache *ino_entry_slab;
Chao Yu4d57b862018-05-30 00:20:41 +080024struct kmem_cache *f2fs_inode_entry_slab;
Jaegeuk Kim127e6702012-11-02 17:08:18 +090025
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -070026void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)
27{
Chao Yud4945002018-08-08 17:36:41 +080028 f2fs_build_fault_attr(sbi, 0, 0);
Chao Yuaaec2b12016-09-20 11:04:18 +080029 set_ckpt_flags(sbi, CP_ERROR_FLAG);
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -070030 if (!end_io)
Jaegeuk Kimb9109b02017-05-10 11:28:38 -070031 f2fs_flush_merged_writes(sbi);
Jaegeuk Kim38f91ca2016-05-18 14:07:56 -070032}
33
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +090034/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +090035 * We guarantee no failure on the returned page.
36 */
Chao Yu4d57b862018-05-30 00:20:41 +080037struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
Jaegeuk Kim127e6702012-11-02 17:08:18 +090038{
Gu Zheng9df27d92014-01-20 18:37:04 +080039 struct address_space *mapping = META_MAPPING(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090040 struct page *page = NULL;
41repeat:
Jaegeuk Kim300e1292016-04-29 16:11:53 -070042 page = f2fs_grab_cache_page(mapping, index, false);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090043 if (!page) {
44 cond_resched();
45 goto repeat;
46 }
Chao Yubae0ee72018-12-25 17:43:42 +080047 f2fs_wait_on_page_writeback(page, META, true, true);
Jaegeuk Kim237c0792016-06-30 18:49:15 -070048 if (!PageUptodate(page))
49 SetPageUptodate(page);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090050 return page;
51}
52
Chao Yu2b947002015-10-12 17:04:21 +080053static struct page *__get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index,
54 bool is_meta)
Jaegeuk Kim127e6702012-11-02 17:08:18 +090055{
Gu Zheng9df27d92014-01-20 18:37:04 +080056 struct address_space *mapping = META_MAPPING(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090057 struct page *page;
Jaegeuk Kimcf04e8e2014-12-17 19:33:13 -080058 struct f2fs_io_info fio = {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -070059 .sbi = sbi,
Jaegeuk Kimcf04e8e2014-12-17 19:33:13 -080060 .type = META,
Mike Christie04d328d2016-06-05 14:31:55 -050061 .op = REQ_OP_READ,
Christoph Hellwig70fd7612016-11-01 07:40:10 -060062 .op_flags = REQ_META | REQ_PRIO,
Chao Yu7a9d7542016-02-22 18:36:38 +080063 .old_blkaddr = index,
64 .new_blkaddr = index,
Jaegeuk Kim4375a332015-04-23 12:04:33 -070065 .encrypted_page = NULL,
Chao Yu6dc3a122019-04-15 15:26:31 +080066 .is_por = !is_meta,
Jaegeuk Kimcf04e8e2014-12-17 19:33:13 -080067 };
Chao Yu77357302018-07-17 00:02:17 +080068 int err;
Chao Yu2b947002015-10-12 17:04:21 +080069
70 if (unlikely(!is_meta))
Mike Christie04d328d2016-06-05 14:31:55 -050071 fio.op_flags &= ~REQ_META;
Jaegeuk Kim127e6702012-11-02 17:08:18 +090072repeat:
Jaegeuk Kim300e1292016-04-29 16:11:53 -070073 page = f2fs_grab_cache_page(mapping, index, false);
Jaegeuk Kim127e6702012-11-02 17:08:18 +090074 if (!page) {
75 cond_resched();
76 goto repeat;
77 }
Jaegeuk Kim393ff912013-03-08 21:29:23 +090078 if (PageUptodate(page))
79 goto out;
Jaegeuk Kim127e6702012-11-02 17:08:18 +090080
Jaegeuk Kim05ca3632015-04-23 14:38:15 -070081 fio.page = page;
82
Chao Yu77357302018-07-17 00:02:17 +080083 err = f2fs_submit_page_bio(&fio);
84 if (err) {
85 f2fs_put_page(page, 1);
86 return ERR_PTR(err);
Jaegeuk Kim86531d62015-07-15 13:08:21 -070087 }
Jaegeuk Kim393ff912013-03-08 21:29:23 +090088
Chao Yu8b83ac82020-04-16 18:16:56 +080089 f2fs_update_iostat(sbi, FS_META_READ_IO, F2FS_BLKSIZE);
90
Jaegeuk Kim393ff912013-03-08 21:29:23 +090091 lock_page(page);
Jaegeuk Kim6bacf522013-12-06 15:00:58 +090092 if (unlikely(page->mapping != mapping)) {
Jaegeuk Kimafcb7ca02013-04-26 11:55:17 +090093 f2fs_put_page(page, 1);
94 goto repeat;
95 }
Chao Yuf3f338c2015-07-29 17:33:13 +080096
Chao Yu81114ba2018-04-09 20:25:06 +080097 if (unlikely(!PageUptodate(page))) {
Chao Yu77357302018-07-17 00:02:17 +080098 f2fs_put_page(page, 1);
99 return ERR_PTR(-EIO);
Chao Yu81114ba2018-04-09 20:25:06 +0800100 }
Jaegeuk Kim393ff912013-03-08 21:29:23 +0900101out:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900102 return page;
103}
104
Chao Yu4d57b862018-05-30 00:20:41 +0800105struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu2b947002015-10-12 17:04:21 +0800106{
107 return __get_meta_page(sbi, index, true);
108}
109
Jaegeuk Kim86f33602020-10-02 14:17:35 -0700110struct page *f2fs_get_meta_page_retry(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu77357302018-07-17 00:02:17 +0800111{
112 struct page *page;
113 int count = 0;
114
115retry:
116 page = __get_meta_page(sbi, index, true);
117 if (IS_ERR(page)) {
118 if (PTR_ERR(page) == -EIO &&
119 ++count <= DEFAULT_RETRY_IO_COUNT)
120 goto retry;
Chao Yu77357302018-07-17 00:02:17 +0800121 f2fs_stop_checkpoint(sbi, false);
Chao Yu77357302018-07-17 00:02:17 +0800122 }
Chao Yu77357302018-07-17 00:02:17 +0800123 return page;
124}
125
Chao Yu2b947002015-10-12 17:04:21 +0800126/* for POR only */
Chao Yu4d57b862018-05-30 00:20:41 +0800127struct page *f2fs_get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu2b947002015-10-12 17:04:21 +0800128{
129 return __get_meta_page(sbi, index, false);
130}
131
Chao Yu93770ab2019-04-15 15:26:32 +0800132static bool __is_bitmap_valid(struct f2fs_sb_info *sbi, block_t blkaddr,
133 int type)
134{
135 struct seg_entry *se;
136 unsigned int segno, offset;
137 bool exist;
138
139 if (type != DATA_GENERIC_ENHANCE && type != DATA_GENERIC_ENHANCE_READ)
140 return true;
141
142 segno = GET_SEGNO(sbi, blkaddr);
143 offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
144 se = get_seg_entry(sbi, segno);
145
146 exist = f2fs_test_bit(offset, se->cur_valid_map);
147 if (!exist && type == DATA_GENERIC_ENHANCE) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800148 f2fs_err(sbi, "Inconsistent error blkaddr:%u, sit bitmap:%d",
149 blkaddr, exist);
Chao Yu93770ab2019-04-15 15:26:32 +0800150 set_sbi_flag(sbi, SBI_NEED_FSCK);
151 WARN_ON(1);
152 }
153 return exist;
154}
155
Chao Yue1da7872018-06-05 17:44:11 +0800156bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
Chao Yu4d57b862018-05-30 00:20:41 +0800157 block_t blkaddr, int type)
Chao Yu662befd2014-02-07 16:11:53 +0800158{
159 switch (type) {
160 case META_NAT:
Chao Yu66b00c12014-12-08 14:59:17 +0800161 break;
Chao Yu662befd2014-02-07 16:11:53 +0800162 case META_SIT:
Chao Yu66b00c12014-12-08 14:59:17 +0800163 if (unlikely(blkaddr >= SIT_BLK_CNT(sbi)))
164 return false;
165 break;
Chao Yu81c1a0f12014-02-27 19:12:24 +0800166 case META_SSA:
Chao Yu66b00c12014-12-08 14:59:17 +0800167 if (unlikely(blkaddr >= MAIN_BLKADDR(sbi) ||
168 blkaddr < SM_I(sbi)->ssa_blkaddr))
169 return false;
170 break;
Chao Yu662befd2014-02-07 16:11:53 +0800171 case META_CP:
Chao Yu66b00c12014-12-08 14:59:17 +0800172 if (unlikely(blkaddr >= SIT_I(sbi)->sit_base_addr ||
173 blkaddr < __start_cp_addr(sbi)))
174 return false;
175 break;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700176 case META_POR:
Chao Yu66b00c12014-12-08 14:59:17 +0800177 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
Chao Yu93770ab2019-04-15 15:26:32 +0800178 blkaddr < MAIN_BLKADDR(sbi)))
Chao Yu66b00c12014-12-08 14:59:17 +0800179 return false;
Chao Yu93770ab2019-04-15 15:26:32 +0800180 break;
181 case DATA_GENERIC:
182 case DATA_GENERIC_ENHANCE:
183 case DATA_GENERIC_ENHANCE_READ:
184 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
185 blkaddr < MAIN_BLKADDR(sbi))) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800186 f2fs_warn(sbi, "access invalid blkaddr:%u",
187 blkaddr);
Chao Yu93770ab2019-04-15 15:26:32 +0800188 set_sbi_flag(sbi, SBI_NEED_FSCK);
189 WARN_ON(1);
190 return false;
191 } else {
192 return __is_bitmap_valid(sbi, blkaddr, type);
Chao Yuc9b60782018-08-01 19:13:44 +0800193 }
Chao Yu66b00c12014-12-08 14:59:17 +0800194 break;
Chao Yue1da7872018-06-05 17:44:11 +0800195 case META_GENERIC:
196 if (unlikely(blkaddr < SEG0_BLKADDR(sbi) ||
197 blkaddr >= MAIN_BLKADDR(sbi)))
198 return false;
199 break;
Chao Yu662befd2014-02-07 16:11:53 +0800200 default:
201 BUG();
202 }
Chao Yu66b00c12014-12-08 14:59:17 +0800203
204 return true;
Chao Yu662befd2014-02-07 16:11:53 +0800205}
206
207/*
Chao Yu7a88ddb2020-02-27 19:30:05 +0800208 * Readahead CP/NAT/SIT/SSA/POR pages
Chao Yu662befd2014-02-07 16:11:53 +0800209 */
Chao Yu4d57b862018-05-30 00:20:41 +0800210int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
Chao Yu26879fb2015-10-12 17:05:59 +0800211 int type, bool sync)
Chao Yu662befd2014-02-07 16:11:53 +0800212{
Chao Yu662befd2014-02-07 16:11:53 +0800213 struct page *page;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700214 block_t blkno = start;
Chao Yu662befd2014-02-07 16:11:53 +0800215 struct f2fs_io_info fio = {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700216 .sbi = sbi,
Chao Yu662befd2014-02-07 16:11:53 +0800217 .type = META,
Mike Christie04d328d2016-06-05 14:31:55 -0500218 .op = REQ_OP_READ,
Christoph Hellwig70fd7612016-11-01 07:40:10 -0600219 .op_flags = sync ? (REQ_META | REQ_PRIO) : REQ_RAHEAD,
Jaegeuk Kim4375a332015-04-23 12:04:33 -0700220 .encrypted_page = NULL,
Chao Yufb830fc2017-05-19 23:37:01 +0800221 .in_list = false,
Chao Yu6dc3a122019-04-15 15:26:31 +0800222 .is_por = (type == META_POR),
Chao Yu662befd2014-02-07 16:11:53 +0800223 };
Chao Yue9f5b8b2016-02-14 18:54:33 +0800224 struct blk_plug plug;
Chao Yuce4c6382020-04-10 18:07:20 +0800225 int err;
Chao Yu662befd2014-02-07 16:11:53 +0800226
Chao Yu2b947002015-10-12 17:04:21 +0800227 if (unlikely(type == META_POR))
Mike Christie04d328d2016-06-05 14:31:55 -0500228 fio.op_flags &= ~REQ_META;
Chao Yu2b947002015-10-12 17:04:21 +0800229
Chao Yue9f5b8b2016-02-14 18:54:33 +0800230 blk_start_plug(&plug);
Chao Yu662befd2014-02-07 16:11:53 +0800231 for (; nrpages-- > 0; blkno++) {
Chao Yu662befd2014-02-07 16:11:53 +0800232
Chao Yue1da7872018-06-05 17:44:11 +0800233 if (!f2fs_is_valid_blkaddr(sbi, blkno, type))
Chao Yu66b00c12014-12-08 14:59:17 +0800234 goto out;
235
Chao Yu662befd2014-02-07 16:11:53 +0800236 switch (type) {
237 case META_NAT:
Chao Yu66b00c12014-12-08 14:59:17 +0800238 if (unlikely(blkno >=
239 NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid)))
Chao Yu662befd2014-02-07 16:11:53 +0800240 blkno = 0;
Chao Yu66b00c12014-12-08 14:59:17 +0800241 /* get nat block addr */
Chao Yu7a9d7542016-02-22 18:36:38 +0800242 fio.new_blkaddr = current_nat_addr(sbi,
Chao Yu662befd2014-02-07 16:11:53 +0800243 blkno * NAT_ENTRY_PER_BLOCK);
244 break;
245 case META_SIT:
Chao Yu6a257472020-09-29 09:23:12 +0800246 if (unlikely(blkno >= TOTAL_SEGS(sbi)))
247 goto out;
Chao Yu662befd2014-02-07 16:11:53 +0800248 /* get sit block addr */
Chao Yu7a9d7542016-02-22 18:36:38 +0800249 fio.new_blkaddr = current_sit_addr(sbi,
Chao Yu662befd2014-02-07 16:11:53 +0800250 blkno * SIT_ENTRY_PER_BLOCK);
Chao Yu662befd2014-02-07 16:11:53 +0800251 break;
Chao Yu81c1a0f12014-02-27 19:12:24 +0800252 case META_SSA:
Chao Yu662befd2014-02-07 16:11:53 +0800253 case META_CP:
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700254 case META_POR:
Chao Yu7a9d7542016-02-22 18:36:38 +0800255 fio.new_blkaddr = blkno;
Chao Yu662befd2014-02-07 16:11:53 +0800256 break;
257 default:
258 BUG();
259 }
260
Jaegeuk Kim300e1292016-04-29 16:11:53 -0700261 page = f2fs_grab_cache_page(META_MAPPING(sbi),
262 fio.new_blkaddr, false);
Chao Yu662befd2014-02-07 16:11:53 +0800263 if (!page)
264 continue;
265 if (PageUptodate(page)) {
Chao Yu662befd2014-02-07 16:11:53 +0800266 f2fs_put_page(page, 1);
267 continue;
268 }
269
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700270 fio.page = page;
Chao Yuce4c6382020-04-10 18:07:20 +0800271 err = f2fs_submit_page_bio(&fio);
272 f2fs_put_page(page, err ? 1 : 0);
Chao Yu8b83ac82020-04-16 18:16:56 +0800273
274 if (!err)
275 f2fs_update_iostat(sbi, FS_META_READ_IO, F2FS_BLKSIZE);
Chao Yu662befd2014-02-07 16:11:53 +0800276 }
277out:
Chao Yue9f5b8b2016-02-14 18:54:33 +0800278 blk_finish_plug(&plug);
Chao Yu662befd2014-02-07 16:11:53 +0800279 return blkno - start;
280}
281
Chao Yu4d57b862018-05-30 00:20:41 +0800282void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index)
Chao Yu635aee12014-12-08 15:02:52 +0800283{
284 struct page *page;
285 bool readahead = false;
286
287 page = find_get_page(META_MAPPING(sbi), index);
Jaegeuk Kim4da7bf52016-04-06 11:27:03 -0700288 if (!page || !PageUptodate(page))
Chao Yu635aee12014-12-08 15:02:52 +0800289 readahead = true;
290 f2fs_put_page(page, 0);
291
292 if (readahead)
Chao Yu4d57b862018-05-30 00:20:41 +0800293 f2fs_ra_meta_pages(sbi, index, BIO_MAX_PAGES, META_POR, true);
Chao Yu635aee12014-12-08 15:02:52 +0800294}
295
Chao Yub0af6d42017-08-02 23:21:48 +0800296static int __f2fs_write_meta_page(struct page *page,
297 struct writeback_control *wbc,
298 enum iostat_type io_type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900299{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700300 struct f2fs_sb_info *sbi = F2FS_P_SB(page);
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900301
Chao Yuecda0de2014-05-06 16:48:26 +0800302 trace_f2fs_writepage(page, META);
303
Jaegeuk Kimaf697c02018-07-11 18:30:42 -0700304 if (unlikely(f2fs_cp_error(sbi)))
305 goto redirty_out;
Chao Yucaf00472015-01-28 17:48:42 +0800306 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
Chao Yucfb271d2013-12-05 17:15:22 +0800307 goto redirty_out;
Jaegeuk Kim857dc4e2014-11-19 11:03:34 -0800308 if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0))
Chao Yucfb271d2013-12-05 17:15:22 +0800309 goto redirty_out;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900310
Chao Yu4d57b862018-05-30 00:20:41 +0800311 f2fs_do_write_meta_page(sbi, page, io_type);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900312 dec_page_count(sbi, F2FS_DIRTY_META);
Chao Yu0c3a5792016-01-18 18:28:11 +0800313
314 if (wbc->for_reclaim)
Chao Yubab475c2018-09-27 23:41:16 +0800315 f2fs_submit_merged_write_cond(sbi, NULL, page, 0, META);
Chao Yu0c3a5792016-01-18 18:28:11 +0800316
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900317 unlock_page(page);
Jaegeuk Kim857dc4e2014-11-19 11:03:34 -0800318
Chao Yu0c3a5792016-01-18 18:28:11 +0800319 if (unlikely(f2fs_cp_error(sbi)))
Jaegeuk Kimb9109b02017-05-10 11:28:38 -0700320 f2fs_submit_merged_write(sbi, META);
Chao Yu0c3a5792016-01-18 18:28:11 +0800321
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900322 return 0;
Chao Yucfb271d2013-12-05 17:15:22 +0800323
324redirty_out:
Jaegeuk Kim76f60262014-04-15 16:04:15 +0900325 redirty_page_for_writepage(wbc, page);
Chao Yucfb271d2013-12-05 17:15:22 +0800326 return AOP_WRITEPAGE_ACTIVATE;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900327}
328
Chao Yub0af6d42017-08-02 23:21:48 +0800329static int f2fs_write_meta_page(struct page *page,
330 struct writeback_control *wbc)
331{
332 return __f2fs_write_meta_page(page, wbc, FS_META_IO);
333}
334
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900335static int f2fs_write_meta_pages(struct address_space *mapping,
336 struct writeback_control *wbc)
337{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700338 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900339 long diff, written;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900340
Chao Yu0771fcc2017-06-29 23:20:45 +0800341 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
342 goto skip_write;
343
Jaegeuk Kim5459aa92013-12-17 17:28:41 +0900344 /* collect a number of dirty meta pages and write together */
Jaegeuk Kim812a9592019-01-22 14:04:33 -0800345 if (wbc->sync_mode != WB_SYNC_ALL &&
346 get_pages(sbi, F2FS_DIRTY_META) <
347 nr_pages_to_skip(sbi, META))
Jaegeuk Kimd3baf952014-03-18 13:43:05 +0900348 goto skip_write;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900349
Yunlei Hea29d0e02017-03-01 18:07:10 +0800350 /* if locked failed, cp will flush dirty pages instead */
351 if (!mutex_trylock(&sbi->cp_mutex))
352 goto skip_write;
Yunlei Hed31c7c32016-02-04 16:14:00 +0800353
Yunlei Hea29d0e02017-03-01 18:07:10 +0800354 trace_f2fs_writepages(mapping->host, wbc, META);
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900355 diff = nr_pages_to_write(sbi, META, wbc);
Chao Yu4d57b862018-05-30 00:20:41 +0800356 written = f2fs_sync_meta_pages(sbi, META, wbc->nr_to_write, FS_META_IO);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900357 mutex_unlock(&sbi->cp_mutex);
Jaegeuk Kim50c8cdb2014-03-18 13:47:11 +0900358 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900359 return 0;
Jaegeuk Kimd3baf952014-03-18 13:43:05 +0900360
361skip_write:
362 wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_META);
Yunlei Hed31c7c32016-02-04 16:14:00 +0800363 trace_f2fs_writepages(mapping->host, wbc, META);
Jaegeuk Kimd3baf952014-03-18 13:43:05 +0900364 return 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900365}
366
Chao Yu4d57b862018-05-30 00:20:41 +0800367long f2fs_sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
Chao Yub0af6d42017-08-02 23:21:48 +0800368 long nr_to_write, enum iostat_type io_type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900369{
Gu Zheng9df27d92014-01-20 18:37:04 +0800370 struct address_space *mapping = META_MAPPING(sbi);
Jan Kara028a63a2017-11-15 17:34:51 -0800371 pgoff_t index = 0, prev = ULONG_MAX;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900372 struct pagevec pvec;
373 long nwritten = 0;
Jan Kara028a63a2017-11-15 17:34:51 -0800374 int nr_pages;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900375 struct writeback_control wbc = {
376 .for_reclaim = 0,
377 };
Chao Yue9f5b8b2016-02-14 18:54:33 +0800378 struct blk_plug plug;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900379
Mel Gorman86679822017-11-15 17:37:52 -0800380 pagevec_init(&pvec);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900381
Chao Yue9f5b8b2016-02-14 18:54:33 +0800382 blk_start_plug(&plug);
383
Jan Kara028a63a2017-11-15 17:34:51 -0800384 while ((nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
Jan Kara67fd7072017-11-15 17:35:19 -0800385 PAGECACHE_TAG_DIRTY))) {
Jan Kara028a63a2017-11-15 17:34:51 -0800386 int i;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900387
388 for (i = 0; i < nr_pages; i++) {
389 struct page *page = pvec.pages[i];
Jaegeuk Kim203681f2014-02-05 13:03:57 +0900390
Chao Yu80dd9c02016-02-24 17:20:44 +0800391 if (prev == ULONG_MAX)
Jaegeuk Kim6066d8c2015-10-01 16:42:55 -0700392 prev = page->index - 1;
393 if (nr_to_write != LONG_MAX && page->index != prev + 1) {
394 pagevec_release(&pvec);
395 goto stop;
396 }
397
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900398 lock_page(page);
Jaegeuk Kim203681f2014-02-05 13:03:57 +0900399
400 if (unlikely(page->mapping != mapping)) {
401continue_unlock:
402 unlock_page(page);
403 continue;
404 }
405 if (!PageDirty(page)) {
406 /* someone wrote it for us */
407 goto continue_unlock;
408 }
409
Chao Yubae0ee72018-12-25 17:43:42 +0800410 f2fs_wait_on_page_writeback(page, META, true, true);
Jaegeuk Kimfa3d2bd2016-01-28 11:48:52 -0800411
Jaegeuk Kim203681f2014-02-05 13:03:57 +0900412 if (!clear_page_dirty_for_io(page))
413 goto continue_unlock;
414
Chao Yub0af6d42017-08-02 23:21:48 +0800415 if (__f2fs_write_meta_page(page, &wbc, io_type)) {
Jaegeuk Kim577e3492013-01-24 19:56:11 +0900416 unlock_page(page);
417 break;
418 }
Chao Yucfb271d2013-12-05 17:15:22 +0800419 nwritten++;
Jaegeuk Kim6066d8c2015-10-01 16:42:55 -0700420 prev = page->index;
Chao Yucfb271d2013-12-05 17:15:22 +0800421 if (unlikely(nwritten >= nr_to_write))
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900422 break;
423 }
424 pagevec_release(&pvec);
425 cond_resched();
426 }
Jaegeuk Kim6066d8c2015-10-01 16:42:55 -0700427stop:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900428 if (nwritten)
Jaegeuk Kimb9109b02017-05-10 11:28:38 -0700429 f2fs_submit_merged_write(sbi, type);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900430
Chao Yue9f5b8b2016-02-14 18:54:33 +0800431 blk_finish_plug(&plug);
432
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900433 return nwritten;
434}
435
436static int f2fs_set_meta_page_dirty(struct page *page)
437{
Jaegeuk Kim26c6b882013-10-24 17:53:29 +0900438 trace_f2fs_set_page_dirty(page, META);
439
Jaegeuk Kim237c0792016-06-30 18:49:15 -0700440 if (!PageUptodate(page))
441 SetPageUptodate(page);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900442 if (!PageDirty(page)) {
Jaegeuk Kimb87078a2018-04-20 19:29:52 -0700443 __set_page_dirty_nobuffers(page);
Jaegeuk Kim40813632014-09-02 15:31:18 -0700444 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);
Chao Yu240a5912019-03-06 17:30:59 +0800445 f2fs_set_page_private(page, 0);
Jaegeuk Kim9e4ded32014-12-17 19:58:58 -0800446 f2fs_trace_pid(page);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900447 return 1;
448 }
449 return 0;
450}
451
452const struct address_space_operations f2fs_meta_aops = {
453 .writepage = f2fs_write_meta_page,
454 .writepages = f2fs_write_meta_pages,
455 .set_page_dirty = f2fs_set_meta_page_dirty,
Chao Yu487261f2015-02-05 17:44:29 +0800456 .invalidatepage = f2fs_invalidate_page,
457 .releasepage = f2fs_release_page,
Weichao Guo5b7a4872016-09-20 05:03:27 +0800458#ifdef CONFIG_MIGRATION
459 .migratepage = f2fs_migrate_page,
460#endif
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900461};
462
Chao Yu39d787b2017-09-29 13:59:38 +0800463static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino,
464 unsigned int devidx, int type)
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700465{
Chao Yu67298802014-11-18 11:18:36 +0800466 struct inode_management *im = &sbi->im[type];
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700467 struct ino_entry *e, *tmp;
468
469 tmp = f2fs_kmem_cache_alloc(ino_entry_slab, GFP_NOFS);
Chao Yu19526d72017-11-10 09:30:42 +0800470
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700471 radix_tree_preload(GFP_NOFS | __GFP_NOFAIL);
Jaegeuk Kim769ec6e2014-12-03 20:47:26 -0800472
Chao Yu67298802014-11-18 11:18:36 +0800473 spin_lock(&im->ino_lock);
Chao Yu67298802014-11-18 11:18:36 +0800474 e = radix_tree_lookup(&im->ino_root, ino);
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700475 if (!e) {
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700476 e = tmp;
Chao Yu19526d72017-11-10 09:30:42 +0800477 if (unlikely(radix_tree_insert(&im->ino_root, ino, e)))
478 f2fs_bug_on(sbi, 1);
479
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700480 memset(e, 0, sizeof(struct ino_entry));
481 e->ino = ino;
482
Chao Yu67298802014-11-18 11:18:36 +0800483 list_add_tail(&e->list, &im->ino_list);
Jaegeuk Kim8c402942014-11-06 15:16:04 -0800484 if (type != ORPHAN_INO)
Chao Yu67298802014-11-18 11:18:36 +0800485 im->ino_num++;
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700486 }
Chao Yu39d787b2017-09-29 13:59:38 +0800487
488 if (type == FLUSH_INO)
489 f2fs_set_bit(devidx, (char *)&e->dirty_device);
490
Chao Yu67298802014-11-18 11:18:36 +0800491 spin_unlock(&im->ino_lock);
Jaegeuk Kim769ec6e2014-12-03 20:47:26 -0800492 radix_tree_preload_end();
Jaegeuk Kim80c54502015-08-20 08:51:56 -0700493
494 if (e != tmp)
495 kmem_cache_free(ino_entry_slab, tmp);
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700496}
497
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700498static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700499{
Chao Yu67298802014-11-18 11:18:36 +0800500 struct inode_management *im = &sbi->im[type];
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700501 struct ino_entry *e;
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700502
Chao Yu67298802014-11-18 11:18:36 +0800503 spin_lock(&im->ino_lock);
504 e = radix_tree_lookup(&im->ino_root, ino);
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700505 if (e) {
506 list_del(&e->list);
Chao Yu67298802014-11-18 11:18:36 +0800507 radix_tree_delete(&im->ino_root, ino);
508 im->ino_num--;
509 spin_unlock(&im->ino_lock);
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700510 kmem_cache_free(ino_entry_slab, e);
511 return;
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700512 }
Chao Yu67298802014-11-18 11:18:36 +0800513 spin_unlock(&im->ino_lock);
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700514}
515
Chao Yu4d57b862018-05-30 00:20:41 +0800516void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700517{
518 /* add new dirty ino entry into list */
Chao Yu39d787b2017-09-29 13:59:38 +0800519 __add_ino_entry(sbi, ino, 0, type);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700520}
521
Chao Yu4d57b862018-05-30 00:20:41 +0800522void f2fs_remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700523{
524 /* remove dirty ino entry from list */
525 __remove_ino_entry(sbi, ino, type);
526}
527
Jack Qiu1f07cc52020-07-25 18:05:27 +0800528/* mode should be APPEND_INO, UPDATE_INO or TRANS_DIR_INO */
Chao Yu4d57b862018-05-30 00:20:41 +0800529bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700530{
Chao Yu67298802014-11-18 11:18:36 +0800531 struct inode_management *im = &sbi->im[mode];
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700532 struct ino_entry *e;
Chao Yu67298802014-11-18 11:18:36 +0800533
534 spin_lock(&im->ino_lock);
535 e = radix_tree_lookup(&im->ino_root, ino);
536 spin_unlock(&im->ino_lock);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700537 return e ? true : false;
538}
539
Chao Yu4d57b862018-05-30 00:20:41 +0800540void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700541{
542 struct ino_entry *e, *tmp;
543 int i;
544
Chao Yu39d787b2017-09-29 13:59:38 +0800545 for (i = all ? ORPHAN_INO : APPEND_INO; i < MAX_INO_ENTRY; i++) {
Chao Yu67298802014-11-18 11:18:36 +0800546 struct inode_management *im = &sbi->im[i];
547
548 spin_lock(&im->ino_lock);
549 list_for_each_entry_safe(e, tmp, &im->ino_list, list) {
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700550 list_del(&e->list);
Chao Yu67298802014-11-18 11:18:36 +0800551 radix_tree_delete(&im->ino_root, e->ino);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700552 kmem_cache_free(ino_entry_slab, e);
Chao Yu67298802014-11-18 11:18:36 +0800553 im->ino_num--;
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700554 }
Chao Yu67298802014-11-18 11:18:36 +0800555 spin_unlock(&im->ino_lock);
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700556 }
557}
558
Chao Yu4d57b862018-05-30 00:20:41 +0800559void f2fs_set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
Chao Yu39d787b2017-09-29 13:59:38 +0800560 unsigned int devidx, int type)
561{
562 __add_ino_entry(sbi, ino, devidx, type);
563}
564
Chao Yu4d57b862018-05-30 00:20:41 +0800565bool f2fs_is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
Chao Yu39d787b2017-09-29 13:59:38 +0800566 unsigned int devidx, int type)
567{
568 struct inode_management *im = &sbi->im[type];
569 struct ino_entry *e;
570 bool is_dirty = false;
571
572 spin_lock(&im->ino_lock);
573 e = radix_tree_lookup(&im->ino_root, ino);
574 if (e && f2fs_test_bit(devidx, (char *)&e->dirty_device))
575 is_dirty = true;
576 spin_unlock(&im->ino_lock);
577 return is_dirty;
578}
579
Chao Yu4d57b862018-05-30 00:20:41 +0800580int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900581{
Chao Yu67298802014-11-18 11:18:36 +0800582 struct inode_management *im = &sbi->im[ORPHAN_INO];
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900583 int err = 0;
584
Chao Yu67298802014-11-18 11:18:36 +0800585 spin_lock(&im->ino_lock);
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700586
Chao Yu1ecc0c52016-09-23 21:30:09 +0800587 if (time_to_inject(sbi, FAULT_ORPHAN)) {
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700588 spin_unlock(&im->ino_lock);
Chao Yuc45d6002019-11-01 17:53:23 +0800589 f2fs_show_injection_info(sbi, FAULT_ORPHAN);
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700590 return -ENOSPC;
591 }
Arnd Bergmann7fa750a2018-08-13 23:38:06 +0200592
Chao Yu67298802014-11-18 11:18:36 +0800593 if (unlikely(im->ino_num >= sbi->max_orphans))
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900594 err = -ENOSPC;
Jaegeuk Kimcbd56e72013-07-30 11:36:53 +0900595 else
Chao Yu67298802014-11-18 11:18:36 +0800596 im->ino_num++;
597 spin_unlock(&im->ino_lock);
Gu Zheng0d47c1a2013-12-26 18:24:19 +0800598
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900599 return err;
600}
601
Chao Yu4d57b862018-05-30 00:20:41 +0800602void f2fs_release_orphan_inode(struct f2fs_sb_info *sbi)
Jaegeuk Kimcbd56e72013-07-30 11:36:53 +0900603{
Chao Yu67298802014-11-18 11:18:36 +0800604 struct inode_management *im = &sbi->im[ORPHAN_INO];
605
606 spin_lock(&im->ino_lock);
607 f2fs_bug_on(sbi, im->ino_num == 0);
608 im->ino_num--;
609 spin_unlock(&im->ino_lock);
Jaegeuk Kimcbd56e72013-07-30 11:36:53 +0900610}
611
Chao Yu4d57b862018-05-30 00:20:41 +0800612void f2fs_add_orphan_inode(struct inode *inode)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900613{
Jaegeuk Kim39efac42014-07-24 18:15:17 -0700614 /* add new orphan ino entry into list */
Chao Yu39d787b2017-09-29 13:59:38 +0800615 __add_ino_entry(F2FS_I_SB(inode), inode->i_ino, 0, ORPHAN_INO);
Chao Yu4d57b862018-05-30 00:20:41 +0800616 f2fs_update_inode_page(inode);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900617}
618
Chao Yu4d57b862018-05-30 00:20:41 +0800619void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900620{
Jaegeuk Kim953e6cc2014-07-25 15:47:16 -0700621 /* remove orphan entry from orphan list */
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700622 __remove_ino_entry(sbi, ino, ORPHAN_INO);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900623}
624
Chao Yu8c14bfa2015-08-07 17:58:43 +0800625static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900626{
Chao Yu8c14bfa2015-08-07 17:58:43 +0800627 struct inode *inode;
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700628 struct node_info ni;
Chao Yu76a45e32018-06-06 23:55:01 +0800629 int err;
Chao Yu8c14bfa2015-08-07 17:58:43 +0800630
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700631 inode = f2fs_iget_retry(sbi->sb, ino);
Chao Yu8c14bfa2015-08-07 17:58:43 +0800632 if (IS_ERR(inode)) {
633 /*
634 * there should be a bug that we can't find the entry
635 * to orphan inode.
636 */
637 f2fs_bug_on(sbi, PTR_ERR(inode) == -ENOENT);
638 return PTR_ERR(inode);
639 }
640
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800641 err = dquot_initialize(inode);
Sheng Yonga515d122018-04-21 14:12:50 +0800642 if (err) {
643 iput(inode);
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800644 goto err_out;
Sheng Yonga515d122018-04-21 14:12:50 +0800645 }
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800646
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900647 clear_nlink(inode);
648
649 /* truncate all the data during iput */
650 iput(inode);
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700651
Chao Yu77357302018-07-17 00:02:17 +0800652 err = f2fs_get_node_info(sbi, ino, &ni);
653 if (err)
654 goto err_out;
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700655
656 /* ENOMEM was fully retried in f2fs_evict_inode. */
657 if (ni.blk_addr != NULL_ADDR) {
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800658 err = -EIO;
659 goto err_out;
Jaegeuk Kim5905f9a2016-09-12 15:08:37 -0700660 }
Chao Yu8c14bfa2015-08-07 17:58:43 +0800661 return 0;
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800662
663err_out:
664 set_sbi_flag(sbi, SBI_NEED_FSCK);
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800665 f2fs_warn(sbi, "%s: orphan failed (ino=%x), run fsck to fix.",
666 __func__, ino);
Jaegeuk Kim0f9ec2a2018-02-07 17:01:48 -0800667 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900668}
669
Chao Yu4d57b862018-05-30 00:20:41 +0800670int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900671{
Wanpeng Li3c642982015-02-26 07:57:21 +0800672 block_t start_blk, orphan_blocks, i, j;
Chao Yu4b2414d2017-08-08 10:54:31 +0800673 unsigned int s_flags = sbi->sb->s_flags;
674 int err = 0;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700675#ifdef CONFIG_QUOTA
676 int quota_enabled;
677#endif
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900678
Chao Yuaaec2b12016-09-20 11:04:18 +0800679 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
Chao Yu8c14bfa2015-08-07 17:58:43 +0800680 return 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900681
Chao Yub61af312019-04-22 20:22:37 +0800682 if (bdev_read_only(sbi->sb->s_bdev)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800683 f2fs_info(sbi, "write access unavailable, skipping orphan cleanup");
Chao Yub61af312019-04-22 20:22:37 +0800684 return 0;
685 }
686
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800687 if (s_flags & SB_RDONLY) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800688 f2fs_info(sbi, "orphan cleanup on readonly fs");
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800689 sbi->sb->s_flags &= ~SB_RDONLY;
Chao Yu4b2414d2017-08-08 10:54:31 +0800690 }
691
692#ifdef CONFIG_QUOTA
693 /* Needed for iput() to work correctly and not trash data */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800694 sbi->sb->s_flags |= SB_ACTIVE;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700695
Sheng Yong76cf05d2018-07-26 19:24:25 +0800696 /*
697 * Turn on quotas which were not enabled for read-only mounts if
698 * filesystem has quota feature, so that they are updated correctly.
699 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800700 quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
Chao Yu4b2414d2017-08-08 10:54:31 +0800701#endif
702
Wanpeng Li55141482015-02-26 07:57:20 +0800703 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
Wanpeng Li3c642982015-02-26 07:57:21 +0800704 orphan_blocks = __start_sum_addr(sbi) - 1 - __cp_payload(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900705
Chao Yu4d57b862018-05-30 00:20:41 +0800706 f2fs_ra_meta_pages(sbi, start_blk, orphan_blocks, META_CP, true);
Chao Yu662befd2014-02-07 16:11:53 +0800707
Wanpeng Li3c642982015-02-26 07:57:21 +0800708 for (i = 0; i < orphan_blocks; i++) {
Chao Yu77357302018-07-17 00:02:17 +0800709 struct page *page;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900710 struct f2fs_orphan_block *orphan_blk;
711
Chao Yu77357302018-07-17 00:02:17 +0800712 page = f2fs_get_meta_page(sbi, start_blk + i);
713 if (IS_ERR(page)) {
714 err = PTR_ERR(page);
715 goto out;
716 }
717
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900718 orphan_blk = (struct f2fs_orphan_block *)page_address(page);
719 for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
720 nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
Chao Yu8c14bfa2015-08-07 17:58:43 +0800721 err = recover_orphan_inode(sbi, ino);
722 if (err) {
723 f2fs_put_page(page, 1);
Chao Yu4b2414d2017-08-08 10:54:31 +0800724 goto out;
Chao Yu8c14bfa2015-08-07 17:58:43 +0800725 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900726 }
727 f2fs_put_page(page, 1);
728 }
729 /* clear Orphan Flag */
Chao Yuaaec2b12016-09-20 11:04:18 +0800730 clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG);
Chao Yu4b2414d2017-08-08 10:54:31 +0800731out:
Chao Yu13787522018-08-22 17:11:05 +0800732 set_sbi_flag(sbi, SBI_IS_RECOVERED);
733
Chao Yu4b2414d2017-08-08 10:54:31 +0800734#ifdef CONFIG_QUOTA
735 /* Turn quotas off */
Jaegeuk Kimea676732017-10-06 09:14:28 -0700736 if (quota_enabled)
737 f2fs_quota_off_umount(sbi->sb);
Chao Yu4b2414d2017-08-08 10:54:31 +0800738#endif
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800739 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
Chao Yu4b2414d2017-08-08 10:54:31 +0800740
741 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900742}
743
744static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk)
745{
Gu Zheng502c6e02013-11-19 18:03:58 +0800746 struct list_head *head;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900747 struct f2fs_orphan_block *orphan_blk = NULL;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900748 unsigned int nentries = 0;
Chao Yubd936f82015-07-13 17:44:25 +0800749 unsigned short index = 1;
Jaegeuk Kim8c402942014-11-06 15:16:04 -0800750 unsigned short orphan_blocks;
Gu Zheng45319292014-01-10 18:09:02 +0800751 struct page *page = NULL;
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700752 struct ino_entry *orphan = NULL;
Chao Yu67298802014-11-18 11:18:36 +0800753 struct inode_management *im = &sbi->im[ORPHAN_INO];
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900754
Chao Yu67298802014-11-18 11:18:36 +0800755 orphan_blocks = GET_ORPHAN_BLOCKS(im->ino_num);
Jaegeuk Kim8c402942014-11-06 15:16:04 -0800756
Jaegeuk Kimd6c67a42015-05-01 11:08:59 -0700757 /*
758 * we don't need to do spin_lock(&im->ino_lock) here, since all the
759 * orphan inode operations are covered under f2fs_lock_op().
760 * And, spin_lock should be avoided due to page operations below.
761 */
Chao Yu67298802014-11-18 11:18:36 +0800762 head = &im->ino_list;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900763
764 /* loop for each orphan inode entry and write them in Jornal block */
Gu Zheng502c6e02013-11-19 18:03:58 +0800765 list_for_each_entry(orphan, head, list) {
766 if (!page) {
Chao Yu4d57b862018-05-30 00:20:41 +0800767 page = f2fs_grab_meta_page(sbi, start_blk++);
Gu Zheng502c6e02013-11-19 18:03:58 +0800768 orphan_blk =
769 (struct f2fs_orphan_block *)page_address(page);
770 memset(orphan_blk, 0, sizeof(*orphan_blk));
771 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900772
Gu Zheng36795562013-11-26 16:44:16 +0800773 orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900774
Gu Zheng36795562013-11-26 16:44:16 +0800775 if (nentries == F2FS_ORPHANS_PER_BLOCK) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900776 /*
777 * an orphan block is full of 1020 entries,
778 * then we need to flush current orphan blocks
779 * and bring another one in memory
780 */
781 orphan_blk->blk_addr = cpu_to_le16(index);
782 orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
783 orphan_blk->entry_count = cpu_to_le32(nentries);
784 set_page_dirty(page);
785 f2fs_put_page(page, 1);
786 index++;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900787 nentries = 0;
788 page = NULL;
789 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900790 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900791
Gu Zheng502c6e02013-11-19 18:03:58 +0800792 if (page) {
793 orphan_blk->blk_addr = cpu_to_le16(index);
794 orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
795 orphan_blk->entry_count = cpu_to_le32(nentries);
796 set_page_dirty(page);
797 f2fs_put_page(page, 1);
798 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900799}
800
Chao Yud7eb8f12019-04-22 17:33:52 +0800801static __u32 f2fs_checkpoint_chksum(struct f2fs_sb_info *sbi,
802 struct f2fs_checkpoint *ckpt)
803{
804 unsigned int chksum_ofs = le32_to_cpu(ckpt->checksum_offset);
805 __u32 chksum;
806
807 chksum = f2fs_crc32(sbi, ckpt, chksum_ofs);
808 if (chksum_ofs < CP_CHKSUM_OFFSET) {
809 chksum_ofs += sizeof(chksum);
810 chksum = f2fs_chksum(sbi, chksum, (__u8 *)ckpt + chksum_ofs,
811 F2FS_BLKSIZE - chksum_ofs);
812 }
813 return chksum;
814}
815
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800816static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr,
817 struct f2fs_checkpoint **cp_block, struct page **cp_page,
818 unsigned long long *version)
819{
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800820 size_t crc_offset = 0;
Chao Yud7eb8f12019-04-22 17:33:52 +0800821 __u32 crc;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800822
Chao Yu4d57b862018-05-30 00:20:41 +0800823 *cp_page = f2fs_get_meta_page(sbi, cp_addr);
Chao Yu77357302018-07-17 00:02:17 +0800824 if (IS_ERR(*cp_page))
825 return PTR_ERR(*cp_page);
826
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800827 *cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);
828
829 crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
Chao Yud7eb8f12019-04-22 17:33:52 +0800830 if (crc_offset < CP_MIN_CHKSUM_OFFSET ||
831 crc_offset > CP_CHKSUM_OFFSET) {
Chao Yud3f07c02018-08-02 22:59:12 +0800832 f2fs_put_page(*cp_page, 1);
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800833 f2fs_warn(sbi, "invalid crc_offset: %zu", crc_offset);
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800834 return -EINVAL;
835 }
836
Chao Yud7eb8f12019-04-22 17:33:52 +0800837 crc = f2fs_checkpoint_chksum(sbi, *cp_block);
838 if (crc != cur_cp_crc(*cp_block)) {
Chao Yud3f07c02018-08-02 22:59:12 +0800839 f2fs_put_page(*cp_page, 1);
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800840 f2fs_warn(sbi, "invalid crc value");
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800841 return -EINVAL;
842 }
843
844 *version = cur_cp_version(*cp_block);
845 return 0;
846}
847
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900848static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
849 block_t cp_addr, unsigned long long *version)
850{
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800851 struct page *cp_page_1 = NULL, *cp_page_2 = NULL;
852 struct f2fs_checkpoint *cp_block = NULL;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900853 unsigned long long cur_version = 0, pre_version = 0;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800854 int err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900855
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800856 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
857 &cp_page_1, version);
858 if (err)
Chao Yud3f07c02018-08-02 22:59:12 +0800859 return NULL;
Chao Yuc9b60782018-08-01 19:13:44 +0800860
861 if (le32_to_cpu(cp_block->cp_pack_total_block_count) >
862 sbi->blocks_per_seg) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800863 f2fs_warn(sbi, "invalid cp_pack_total_block_count:%u",
864 le32_to_cpu(cp_block->cp_pack_total_block_count));
Chao Yud3f07c02018-08-02 22:59:12 +0800865 goto invalid_cp;
Chao Yuc9b60782018-08-01 19:13:44 +0800866 }
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800867 pre_version = *version;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900868
Jaegeuk Kim25ca9232012-11-28 16:12:41 +0900869 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800870 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
871 &cp_page_2, version);
872 if (err)
Chao Yud3f07c02018-08-02 22:59:12 +0800873 goto invalid_cp;
Tiezhu Yangfc0065a2016-09-30 08:24:53 +0800874 cur_version = *version;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900875
876 if (cur_version == pre_version) {
877 *version = cur_version;
878 f2fs_put_page(cp_page_2, 1);
879 return cp_page_1;
880 }
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900881 f2fs_put_page(cp_page_2, 1);
Chao Yud3f07c02018-08-02 22:59:12 +0800882invalid_cp:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900883 f2fs_put_page(cp_page_1, 1);
884 return NULL;
885}
886
Chao Yu4d57b862018-05-30 00:20:41 +0800887int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900888{
889 struct f2fs_checkpoint *cp_block;
890 struct f2fs_super_block *fsb = sbi->raw_super;
891 struct page *cp1, *cp2, *cur_page;
892 unsigned long blk_size = sbi->blocksize;
893 unsigned long long cp1_version = 0, cp2_version = 0;
894 unsigned long long cp_start_blk_no;
Wanpeng Li55141482015-02-26 07:57:20 +0800895 unsigned int cp_blks = 1 + __cp_payload(sbi);
Changman Lee1dbe4152014-05-12 12:27:43 +0900896 block_t cp_blk_no;
897 int i;
Chao Yu10f966b2019-06-20 11:36:14 +0800898 int err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900899
Eric Biggers0b6d4ca2020-06-04 21:57:48 -0700900 sbi->ckpt = f2fs_kvzalloc(sbi, array_size(blk_size, cp_blks),
901 GFP_KERNEL);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900902 if (!sbi->ckpt)
903 return -ENOMEM;
904 /*
905 * Finding out valid cp block involves read both
Chao Yu7a88ddb2020-02-27 19:30:05 +0800906 * sets( cp pack 1 and cp pack 2)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900907 */
908 cp_start_blk_no = le32_to_cpu(fsb->cp_blkaddr);
909 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
910
911 /* The second checkpoint pack should start at the next segment */
Jaegeuk Kimf9a4e6d2013-11-28 12:44:05 +0900912 cp_start_blk_no += ((unsigned long long)1) <<
913 le32_to_cpu(fsb->log_blocks_per_seg);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900914 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
915
916 if (cp1 && cp2) {
917 if (ver_after(cp2_version, cp1_version))
918 cur_page = cp2;
919 else
920 cur_page = cp1;
921 } else if (cp1) {
922 cur_page = cp1;
923 } else if (cp2) {
924 cur_page = cp2;
925 } else {
Chao Yu10f966b2019-06-20 11:36:14 +0800926 err = -EFSCORRUPTED;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900927 goto fail_no_cp;
928 }
929
930 cp_block = (struct f2fs_checkpoint *)page_address(cur_page);
931 memcpy(sbi->ckpt, cp_block, blk_size);
932
Jaegeuk Kim8508e442016-11-24 12:45:15 -0800933 if (cur_page == cp1)
934 sbi->cur_cp_pack = 1;
935 else
936 sbi->cur_cp_pack = 2;
Shawn Lin984ec632016-02-17 11:26:32 +0800937
Chao Yue494c2f2018-08-01 19:16:11 +0800938 /* Sanity checking of checkpoint */
Chao Yu10f966b2019-06-20 11:36:14 +0800939 if (f2fs_sanity_check_ckpt(sbi)) {
940 err = -EFSCORRUPTED;
Chao Yue494c2f2018-08-01 19:16:11 +0800941 goto free_fail_no_cp;
Chao Yu10f966b2019-06-20 11:36:14 +0800942 }
Chao Yue494c2f2018-08-01 19:16:11 +0800943
Changman Lee1dbe4152014-05-12 12:27:43 +0900944 if (cp_blks <= 1)
945 goto done;
946
947 cp_blk_no = le32_to_cpu(fsb->cp_blkaddr);
948 if (cur_page == cp2)
949 cp_blk_no += 1 << le32_to_cpu(fsb->log_blocks_per_seg);
950
951 for (i = 1; i < cp_blks; i++) {
952 void *sit_bitmap_ptr;
953 unsigned char *ckpt = (unsigned char *)sbi->ckpt;
954
Chao Yu4d57b862018-05-30 00:20:41 +0800955 cur_page = f2fs_get_meta_page(sbi, cp_blk_no + i);
Chao Yu10f966b2019-06-20 11:36:14 +0800956 if (IS_ERR(cur_page)) {
957 err = PTR_ERR(cur_page);
Chao Yu77357302018-07-17 00:02:17 +0800958 goto free_fail_no_cp;
Chao Yu10f966b2019-06-20 11:36:14 +0800959 }
Changman Lee1dbe4152014-05-12 12:27:43 +0900960 sit_bitmap_ptr = page_address(cur_page);
961 memcpy(ckpt + i * blk_size, sit_bitmap_ptr, blk_size);
962 f2fs_put_page(cur_page, 1);
963 }
964done:
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900965 f2fs_put_page(cp1, 1);
966 f2fs_put_page(cp2, 1);
967 return 0;
968
Jaegeuk Kima2125ff2016-12-05 17:25:32 -0800969free_fail_no_cp:
970 f2fs_put_page(cp1, 1);
971 f2fs_put_page(cp2, 1);
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900972fail_no_cp:
Jaegeuk Kim52225952018-12-13 18:38:33 -0800973 kvfree(sbi->ckpt);
Chao Yu10f966b2019-06-20 11:36:14 +0800974 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900975}
976
Chao Yuc227f912015-12-16 13:09:20 +0800977static void __add_dirty_inode(struct inode *inode, enum inode_type type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900978{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700979 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yuc227f912015-12-16 13:09:20 +0800980 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE;
Jaegeuk Kim127e6702012-11-02 17:08:18 +0900981
Jaegeuk Kim91942322016-05-20 10:13:22 -0700982 if (is_inode_flag_set(inode, flag))
Chao Yu2710fd72015-12-15 13:30:45 +0800983 return;
Chao Yu2d7b8222014-03-29 11:33:17 +0800984
Jaegeuk Kim91942322016-05-20 10:13:22 -0700985 set_inode_flag(inode, flag);
Chao Yu99f4b912017-03-22 17:23:46 +0800986 if (!f2fs_is_volatile_file(inode))
987 list_add_tail(&F2FS_I(inode)->dirty_list,
988 &sbi->inode_list[type]);
Chao Yu33fbd512015-12-17 17:14:44 +0800989 stat_inc_dirty_inode(sbi, type);
Jaegeuk Kim5deb8262013-06-05 17:42:45 +0900990}
991
Chao Yuc227f912015-12-16 13:09:20 +0800992static void __remove_dirty_inode(struct inode *inode, enum inode_type type)
Chao Yu6ad76092015-12-15 13:31:40 +0800993{
Chao Yuc227f912015-12-16 13:09:20 +0800994 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE;
Chao Yu6ad76092015-12-15 13:31:40 +0800995
Jaegeuk Kim91942322016-05-20 10:13:22 -0700996 if (get_dirty_pages(inode) || !is_inode_flag_set(inode, flag))
Chao Yu6ad76092015-12-15 13:31:40 +0800997 return;
998
Jaegeuk Kim91942322016-05-20 10:13:22 -0700999 list_del_init(&F2FS_I(inode)->dirty_list);
1000 clear_inode_flag(inode, flag);
Chao Yu33fbd512015-12-17 17:14:44 +08001001 stat_dec_dirty_inode(F2FS_I_SB(inode), type);
Chao Yu6ad76092015-12-15 13:31:40 +08001002}
1003
Chao Yu4d57b862018-05-30 00:20:41 +08001004void f2fs_update_dirty_page(struct inode *inode, struct page *page)
Jaegeuk Kim5deb8262013-06-05 17:42:45 +09001005{
Jaegeuk Kim40813632014-09-02 15:31:18 -07001006 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yuc227f912015-12-16 13:09:20 +08001007 enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
Jaegeuk Kim5deb8262013-06-05 17:42:45 +09001008
Chao Yu5ac9f362015-06-29 18:14:10 +08001009 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
1010 !S_ISLNK(inode->i_mode))
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001011 return;
Gu Zheng7bd59382013-10-22 14:52:26 +08001012
Jaegeuk Kim1c4bf762016-06-01 20:55:51 -07001013 spin_lock(&sbi->inode_lock[type]);
1014 if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH))
Jaegeuk Kim10aa97c2016-05-16 10:33:40 -07001015 __add_dirty_inode(inode, type);
Yunlei Heb951a4e2016-05-13 14:57:43 +08001016 inode_inc_dirty_pages(inode);
Jaegeuk Kim1c4bf762016-06-01 20:55:51 -07001017 spin_unlock(&sbi->inode_lock[type]);
1018
Chao Yu240a5912019-03-06 17:30:59 +08001019 f2fs_set_page_private(page, 0);
Jaegeuk Kim9e4ded32014-12-17 19:58:58 -08001020 f2fs_trace_pid(page);
Jaegeuk Kim5deb8262013-06-05 17:42:45 +09001021}
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001022
Chao Yu4d57b862018-05-30 00:20:41 +08001023void f2fs_remove_dirty_inode(struct inode *inode)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001024{
Jaegeuk Kim40813632014-09-02 15:31:18 -07001025 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yuc227f912015-12-16 13:09:20 +08001026 enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001027
Chao Yuc227f912015-12-16 13:09:20 +08001028 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
1029 !S_ISLNK(inode->i_mode))
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001030 return;
1031
Jaegeuk Kim10aa97c2016-05-16 10:33:40 -07001032 if (type == FILE_INODE && !test_opt(sbi, DATA_FLUSH))
1033 return;
1034
Chao Yuc227f912015-12-16 13:09:20 +08001035 spin_lock(&sbi->inode_lock[type]);
1036 __remove_dirty_inode(inode, type);
1037 spin_unlock(&sbi->inode_lock[type]);
Jaegeuk Kim74d0b912013-05-15 16:40:02 +09001038}
1039
Chao Yu4d57b862018-05-30 00:20:41 +08001040int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001041{
Gu Zhengce3b7d82013-11-19 18:03:47 +08001042 struct list_head *head;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001043 struct inode *inode;
Chao Yu2710fd72015-12-15 13:30:45 +08001044 struct f2fs_inode_info *fi;
Chao Yu4cf18532015-12-17 17:17:16 +08001045 bool is_dir = (type == DIR_INODE);
Jaegeuk Kim4db08d02017-07-14 11:45:21 -07001046 unsigned long ino = 0;
Chao Yu4cf18532015-12-17 17:17:16 +08001047
1048 trace_f2fs_sync_dirty_inodes_enter(sbi->sb, is_dir,
1049 get_pages(sbi, is_dir ?
1050 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA));
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001051retry:
Zhang Qilong9b664822020-09-21 20:45:44 +08001052 if (unlikely(f2fs_cp_error(sbi))) {
1053 trace_f2fs_sync_dirty_inodes_exit(sbi->sb, is_dir,
1054 get_pages(sbi, is_dir ?
1055 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA));
Chao Yu6d5a1492015-12-24 18:04:56 +08001056 return -EIO;
Zhang Qilong9b664822020-09-21 20:45:44 +08001057 }
Jaegeuk Kimaf41d3e2014-10-17 14:14:16 -07001058
Chao Yuc227f912015-12-16 13:09:20 +08001059 spin_lock(&sbi->inode_lock[type]);
Gu Zhengce3b7d82013-11-19 18:03:47 +08001060
Chao Yuc227f912015-12-16 13:09:20 +08001061 head = &sbi->inode_list[type];
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001062 if (list_empty(head)) {
Chao Yuc227f912015-12-16 13:09:20 +08001063 spin_unlock(&sbi->inode_lock[type]);
Chao Yu4cf18532015-12-17 17:17:16 +08001064 trace_f2fs_sync_dirty_inodes_exit(sbi->sb, is_dir,
1065 get_pages(sbi, is_dir ?
1066 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA));
Chao Yu6d5a1492015-12-24 18:04:56 +08001067 return 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001068 }
Chao Yu939afa92017-01-07 18:49:42 +08001069 fi = list_first_entry(head, struct f2fs_inode_info, dirty_list);
Chao Yu2710fd72015-12-15 13:30:45 +08001070 inode = igrab(&fi->vfs_inode);
Chao Yuc227f912015-12-16 13:09:20 +08001071 spin_unlock(&sbi->inode_lock[type]);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001072 if (inode) {
Jaegeuk Kim4db08d02017-07-14 11:45:21 -07001073 unsigned long cur_ino = inode->i_ino;
1074
Chao Yu186857c2019-04-02 18:52:19 +08001075 F2FS_I(inode)->cp_task = current;
Chao Yub0af6d42017-08-02 23:21:48 +08001076
Jaegeuk Kim87d6f892014-03-18 12:40:49 +09001077 filemap_fdatawrite(inode->i_mapping);
Chao Yub0af6d42017-08-02 23:21:48 +08001078
Chao Yu186857c2019-04-02 18:52:19 +08001079 F2FS_I(inode)->cp_task = NULL;
Chao Yub0af6d42017-08-02 23:21:48 +08001080
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001081 iput(inode);
Jaegeuk Kim4db08d02017-07-14 11:45:21 -07001082 /* We need to give cpu to another writers. */
Yunlei He2a635312018-06-21 14:49:06 +08001083 if (ino == cur_ino)
Jaegeuk Kim4db08d02017-07-14 11:45:21 -07001084 cond_resched();
Yunlei He2a635312018-06-21 14:49:06 +08001085 else
Jaegeuk Kim4db08d02017-07-14 11:45:21 -07001086 ino = cur_ino;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001087 } else {
1088 /*
1089 * We should submit bio, since it exists several
1090 * wribacking dentry pages in the freeing inode.
1091 */
Jaegeuk Kimb9109b02017-05-10 11:28:38 -07001092 f2fs_submit_merged_write(sbi, DATA);
Sebastian Andrzej Siewior7ecebe52015-02-27 13:13:14 +01001093 cond_resched();
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001094 }
1095 goto retry;
1096}
1097
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001098int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi)
1099{
1100 struct list_head *head = &sbi->inode_list[DIRTY_META];
1101 struct inode *inode;
1102 struct f2fs_inode_info *fi;
1103 s64 total = get_pages(sbi, F2FS_DIRTY_IMETA);
1104
1105 while (total--) {
1106 if (unlikely(f2fs_cp_error(sbi)))
1107 return -EIO;
1108
1109 spin_lock(&sbi->inode_lock[DIRTY_META]);
1110 if (list_empty(head)) {
1111 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1112 return 0;
1113 }
Chao Yu939afa92017-01-07 18:49:42 +08001114 fi = list_first_entry(head, struct f2fs_inode_info,
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001115 gdirty_list);
1116 inode = igrab(&fi->vfs_inode);
1117 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1118 if (inode) {
Jaegeuk Kim18340ed2016-10-19 18:27:56 -07001119 sync_inode_metadata(inode, 0);
1120
1121 /* it's on eviction */
1122 if (is_inode_flag_set(inode, FI_DIRTY_INODE))
Chao Yu4d57b862018-05-30 00:20:41 +08001123 f2fs_update_inode_page(inode);
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001124 iput(inode);
1125 }
Chao Yudee668c2017-11-02 20:41:01 +08001126 }
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001127 return 0;
1128}
1129
Yunlei He59c90812017-03-13 20:22:18 +08001130static void __prepare_cp_block(struct f2fs_sb_info *sbi)
1131{
1132 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1133 struct f2fs_nm_info *nm_i = NM_I(sbi);
1134 nid_t last_nid = nm_i->next_scan_nid;
1135
1136 next_free_nid(sbi, &last_nid);
1137 ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi));
1138 ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi));
1139 ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi));
1140 ckpt->next_free_nid = cpu_to_le32(last_nid);
1141}
1142
Chao Yuaf033b22018-09-20 20:05:00 +08001143static bool __need_flush_quota(struct f2fs_sb_info *sbi)
1144{
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07001145 bool ret = false;
1146
Chao Yuaf033b22018-09-20 20:05:00 +08001147 if (!is_journalled_quota(sbi))
1148 return false;
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07001149
Chao Yu384111e2021-09-03 10:38:11 +08001150 if (!down_write_trylock(&sbi->quota_sem))
1151 return true;
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07001152 if (is_sbi_flag_set(sbi, SBI_QUOTA_SKIP_FLUSH)) {
1153 ret = false;
1154 } else if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR)) {
1155 ret = false;
1156 } else if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_FLUSH)) {
1157 clear_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);
1158 ret = true;
1159 } else if (get_pages(sbi, F2FS_DIRTY_QDATA)) {
1160 ret = true;
1161 }
1162 up_write(&sbi->quota_sem);
1163 return ret;
Chao Yuaf033b22018-09-20 20:05:00 +08001164}
1165
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001166/*
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001167 * Freeze all the FS-operations for checkpoint.
1168 */
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001169static int block_operations(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001170{
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001171 struct writeback_control wbc = {
1172 .sync_mode = WB_SYNC_ALL,
1173 .nr_to_write = LONG_MAX,
1174 .for_reclaim = 0,
1175 };
Chao Yuaf033b22018-09-20 20:05:00 +08001176 int err = 0, cnt = 0;
Jaegeuk Kimc718379b2013-04-24 13:19:56 +09001177
Sayali Lokhande34c061a2020-04-30 16:28:29 +05301178 /*
1179 * Let's flush inline_data in dirty node pages.
1180 */
1181 f2fs_flush_inline_data(sbi);
1182
Chao Yuaf033b22018-09-20 20:05:00 +08001183retry_flush_quotas:
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07001184 f2fs_lock_all(sbi);
Chao Yuaf033b22018-09-20 20:05:00 +08001185 if (__need_flush_quota(sbi)) {
1186 int locked;
1187
1188 if (++cnt > DEFAULT_RETRY_QUOTA_FLUSH_COUNT) {
1189 set_sbi_flag(sbi, SBI_QUOTA_SKIP_FLUSH);
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07001190 set_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);
Chao Yuaf033b22018-09-20 20:05:00 +08001191 goto retry_flush_dents;
1192 }
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07001193 f2fs_unlock_all(sbi);
Chao Yuaf033b22018-09-20 20:05:00 +08001194
1195 /* only failed during mount/umount/freeze/quotactl */
1196 locked = down_read_trylock(&sbi->sb->s_umount);
1197 f2fs_quota_sync(sbi->sb, -1);
1198 if (locked)
1199 up_read(&sbi->sb->s_umount);
Chao Yuaf033b22018-09-20 20:05:00 +08001200 cond_resched();
1201 goto retry_flush_quotas;
1202 }
1203
1204retry_flush_dents:
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001205 /* write all the dirty dentry pages */
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001206 if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
Gu Zhenge4795562013-09-27 18:08:30 +08001207 f2fs_unlock_all(sbi);
Chao Yu4d57b862018-05-30 00:20:41 +08001208 err = f2fs_sync_dirty_inodes(sbi, DIR_INODE);
Chao Yu6d5a1492015-12-24 18:04:56 +08001209 if (err)
Jaegeuk Kim1f5f11a2020-05-08 12:25:45 -07001210 return err;
Jaegeuk Kim30973882017-04-11 19:15:33 -07001211 cond_resched();
Chao Yuaf033b22018-09-20 20:05:00 +08001212 goto retry_flush_quotas;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001213 }
1214
Yunlei He59c90812017-03-13 20:22:18 +08001215 /*
1216 * POR: we should ensure that there are no dirty node pages
1217 * until finishing nat/sit flush. inode->i_blocks can be updated.
1218 */
1219 down_write(&sbi->node_change);
1220
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001221 if (get_pages(sbi, F2FS_DIRTY_IMETA)) {
Yunlei He59c90812017-03-13 20:22:18 +08001222 up_write(&sbi->node_change);
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001223 f2fs_unlock_all(sbi);
1224 err = f2fs_sync_inode_meta(sbi);
1225 if (err)
Jaegeuk Kim1f5f11a2020-05-08 12:25:45 -07001226 return err;
Jaegeuk Kim30973882017-04-11 19:15:33 -07001227 cond_resched();
Chao Yuaf033b22018-09-20 20:05:00 +08001228 goto retry_flush_quotas;
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001229 }
1230
Jaegeuk Kim39936832012-11-22 16:21:29 +09001231retry_flush_nodes:
Chao Yub3582c62014-07-03 18:58:39 +08001232 down_write(&sbi->node_write);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001233
1234 if (get_pages(sbi, F2FS_DIRTY_NODES)) {
Chao Yub3582c62014-07-03 18:58:39 +08001235 up_write(&sbi->node_write);
Chao Yuc29fd0c2018-06-04 23:20:36 +08001236 atomic_inc(&sbi->wb_sync_req[NODE]);
Chao Yu4d57b862018-05-30 00:20:41 +08001237 err = f2fs_sync_node_pages(sbi, &wbc, false, FS_CP_NODE_IO);
Chao Yuc29fd0c2018-06-04 23:20:36 +08001238 atomic_dec(&sbi->wb_sync_req[NODE]);
Chao Yu6d5a1492015-12-24 18:04:56 +08001239 if (err) {
Yunlei He59c90812017-03-13 20:22:18 +08001240 up_write(&sbi->node_change);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001241 f2fs_unlock_all(sbi);
Jaegeuk Kim1f5f11a2020-05-08 12:25:45 -07001242 return err;
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001243 }
Jaegeuk Kim30973882017-04-11 19:15:33 -07001244 cond_resched();
Jaegeuk Kim39936832012-11-22 16:21:29 +09001245 goto retry_flush_nodes;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001246 }
Yunlei He59c90812017-03-13 20:22:18 +08001247
1248 /*
1249 * sbi->node_change is used only for AIO write_begin path which produces
1250 * dirty node blocks and some checkpoint values by block allocation.
1251 */
1252 __prepare_cp_block(sbi);
1253 up_write(&sbi->node_change);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001254 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001255}
1256
1257static void unblock_operations(struct f2fs_sb_info *sbi)
1258{
Chao Yub3582c62014-07-03 18:58:39 +08001259 up_write(&sbi->node_write);
Gu Zhenge4795562013-09-27 18:08:30 +08001260 f2fs_unlock_all(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001261}
1262
Sahitya Tummalabf22c3c2020-02-18 09:19:07 +05301263void f2fs_wait_on_all_pages(struct f2fs_sb_info *sbi, int type)
Changman Leefb51b5e2013-11-07 12:48:25 +09001264{
1265 DEFINE_WAIT(wait);
1266
1267 for (;;) {
Sahitya Tummalabf22c3c2020-02-18 09:19:07 +05301268 if (!get_pages(sbi, type))
Changman Leefb51b5e2013-11-07 12:48:25 +09001269 break;
1270
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001271 if (unlikely(f2fs_cp_error(sbi)))
1272 break;
1273
Jaegeuk Kim9c30df72020-05-13 21:12:53 -07001274 if (type == F2FS_DIRTY_META)
1275 f2fs_sync_meta_pages(sbi, META, LONG_MAX,
1276 FS_CP_META_IO);
Jaegeuk Kim1fd28012020-07-28 08:26:11 -07001277 else if (type == F2FS_WB_CP_DATA)
1278 f2fs_submit_merged_write(sbi, DATA);
Jaegeuk Kim828add72020-08-03 19:37:12 -07001279
1280 prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);
Chao Yu5df7731f2020-02-17 17:45:44 +08001281 io_schedule_timeout(DEFAULT_IO_TIMEOUT);
Changman Leefb51b5e2013-11-07 12:48:25 +09001282 }
1283 finish_wait(&sbi->cp_wait, &wait);
1284}
1285
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001286static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1287{
1288 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;
1289 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Chao Yud1aa2452017-07-07 14:10:15 +08001290 unsigned long flags;
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001291
Chao Yud1aa2452017-07-07 14:10:15 +08001292 spin_lock_irqsave(&sbi->cp_lock, flags);
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001293
Chao Yuc473f1a2017-04-27 20:40:39 +08001294 if ((cpc->reason & CP_UMOUNT) &&
Kinglong Mee10047f52017-03-11 21:18:01 +08001295 le32_to_cpu(ckpt->cp_pack_total_block_count) >
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001296 sbi->blocks_per_seg - NM_I(sbi)->nat_bits_blocks)
1297 disable_nat_bits(sbi, false);
1298
Chao Yu1f43e2a2017-04-28 13:56:08 +08001299 if (cpc->reason & CP_TRIMMED)
1300 __set_ckpt_flags(ckpt, CP_TRIMMED_FLAG);
Chao Yucd36d7a2018-01-31 09:30:34 +08001301 else
1302 __clear_ckpt_flags(ckpt, CP_TRIMMED_FLAG);
Chao Yu1f43e2a2017-04-28 13:56:08 +08001303
Chao Yuc473f1a2017-04-27 20:40:39 +08001304 if (cpc->reason & CP_UMOUNT)
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001305 __set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1306 else
1307 __clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1308
Chao Yuc473f1a2017-04-27 20:40:39 +08001309 if (cpc->reason & CP_FASTBOOT)
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001310 __set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1311 else
1312 __clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1313
1314 if (orphan_num)
1315 __set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1316 else
1317 __clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1318
Sahitya Tummalac84ef3c2020-03-03 19:59:26 +05301319 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001320 __set_ckpt_flags(ckpt, CP_FSCK_FLAG);
1321
Sahitya Tummalac84ef3c2020-03-03 19:59:26 +05301322 if (is_sbi_flag_set(sbi, SBI_IS_RESIZEFS))
1323 __set_ckpt_flags(ckpt, CP_RESIZEFS_FLAG);
1324 else
1325 __clear_ckpt_flags(ckpt, CP_RESIZEFS_FLAG);
1326
Daniel Rosenberg43549942018-08-20 19:21:43 -07001327 if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))
1328 __set_ckpt_flags(ckpt, CP_DISABLED_FLAG);
1329 else
1330 __clear_ckpt_flags(ckpt, CP_DISABLED_FLAG);
1331
Jaegeuk Kimdb610a62019-01-24 17:48:38 -08001332 if (is_sbi_flag_set(sbi, SBI_CP_DISABLED_QUICK))
1333 __set_ckpt_flags(ckpt, CP_DISABLED_QUICK_FLAG);
1334 else
1335 __clear_ckpt_flags(ckpt, CP_DISABLED_QUICK_FLAG);
1336
Chao Yuaf033b22018-09-20 20:05:00 +08001337 if (is_sbi_flag_set(sbi, SBI_QUOTA_SKIP_FLUSH))
1338 __set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);
Jaegeuk Kimbc88ac92019-05-20 16:17:56 -07001339 else
1340 __clear_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);
Chao Yuaf033b22018-09-20 20:05:00 +08001341
1342 if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR))
1343 __set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);
1344
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001345 /* set this flag to activate crc|cp_ver for recovery */
1346 __set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);
Jaegeuk Kimf2367922018-01-19 13:42:33 -08001347 __clear_ckpt_flags(ckpt, CP_NOCRC_RECOVERY_FLAG);
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001348
Chao Yud1aa2452017-07-07 14:10:15 +08001349 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001350}
1351
Gao Xiang46706d52018-02-10 12:12:51 +08001352static void commit_checkpoint(struct f2fs_sb_info *sbi,
1353 void *src, block_t blk_addr)
1354{
1355 struct writeback_control wbc = {
1356 .for_reclaim = 0,
1357 };
1358
1359 /*
1360 * pagevec_lookup_tag and lock_page again will take
Chao Yu4d57b862018-05-30 00:20:41 +08001361 * some extra time. Therefore, f2fs_update_meta_pages and
1362 * f2fs_sync_meta_pages are combined in this function.
Gao Xiang46706d52018-02-10 12:12:51 +08001363 */
Chao Yu4d57b862018-05-30 00:20:41 +08001364 struct page *page = f2fs_grab_meta_page(sbi, blk_addr);
Gao Xiang46706d52018-02-10 12:12:51 +08001365 int err;
1366
Chao Yubae0ee72018-12-25 17:43:42 +08001367 f2fs_wait_on_page_writeback(page, META, true, true);
Chao Yu8d64d362018-12-12 18:12:30 +08001368
1369 memcpy(page_address(page), src, PAGE_SIZE);
1370
1371 set_page_dirty(page);
Gao Xiang46706d52018-02-10 12:12:51 +08001372 if (unlikely(!clear_page_dirty_for_io(page)))
1373 f2fs_bug_on(sbi, 1);
1374
1375 /* writeout cp pack 2 page */
1376 err = __f2fs_write_meta_page(page, &wbc, FS_CP_META_IO);
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001377 if (unlikely(err && f2fs_cp_error(sbi))) {
1378 f2fs_put_page(page, 1);
1379 return;
1380 }
Gao Xiang46706d52018-02-10 12:12:51 +08001381
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001382 f2fs_bug_on(sbi, err);
Gao Xiang46706d52018-02-10 12:12:51 +08001383 f2fs_put_page(page, 0);
1384
1385 /* submit checkpoint (with barrier if NOBARRIER is not set) */
1386 f2fs_submit_merged_write(sbi, META_FLUSH);
1387}
1388
Chao Yuc34f42e2015-12-23 17:50:30 +08001389static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001390{
1391 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Huang Ying77041822014-09-12 20:19:48 +08001392 struct f2fs_nm_info *nm_i = NM_I(sbi);
Chao Yud1aa2452017-07-07 14:10:15 +08001393 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num, flags;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001394 block_t start_blk;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001395 unsigned int data_sum_blocks, orphan_blocks;
Jaegeuk Kim7e586fa2013-06-19 20:47:19 +09001396 __u32 crc32 = 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001397 int i;
Wanpeng Li55141482015-02-26 07:57:20 +08001398 int cp_payload_blks = __cp_payload(sbi);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001399 struct super_block *sb = sbi->sb;
1400 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
1401 u64 kbytes_written;
Chao Yu1228b482017-09-29 13:59:39 +08001402 int err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001403
1404 /* Flush all the NAT/SIT pages */
Chao Yu8ec18bf2018-12-12 18:12:32 +08001405 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001406
Chao Yu7a88ddb2020-02-27 19:30:05 +08001407 /* start to update checkpoint, cp ver is already updated previously */
Chao Yua1f72ac22018-06-04 23:20:17 +08001408 ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi, true));
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001409 ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));
Chao Yub5b82202014-08-22 16:17:38 +08001410 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001411 ckpt->cur_node_segno[i] =
1412 cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE));
1413 ckpt->cur_node_blkoff[i] =
1414 cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_NODE));
1415 ckpt->alloc_type[i + CURSEG_HOT_NODE] =
1416 curseg_alloc_type(sbi, i + CURSEG_HOT_NODE);
1417 }
Chao Yub5b82202014-08-22 16:17:38 +08001418 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001419 ckpt->cur_data_segno[i] =
1420 cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA));
1421 ckpt->cur_data_blkoff[i] =
1422 cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_DATA));
1423 ckpt->alloc_type[i + CURSEG_HOT_DATA] =
1424 curseg_alloc_type(sbi, i + CURSEG_HOT_DATA);
1425 }
1426
Jack Qiua87aff12020-07-24 16:55:28 +08001427 /* 2 cp + n data seg summary + orphan inode blocks */
Chao Yu4d57b862018-05-30 00:20:41 +08001428 data_sum_blocks = f2fs_npages_for_summary_flush(sbi, false);
Chao Yud1aa2452017-07-07 14:10:15 +08001429 spin_lock_irqsave(&sbi->cp_lock, flags);
Chao Yub5b82202014-08-22 16:17:38 +08001430 if (data_sum_blocks < NR_CURSEG_DATA_TYPE)
Chao Yuaaec2b12016-09-20 11:04:18 +08001431 __set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001432 else
Chao Yuaaec2b12016-09-20 11:04:18 +08001433 __clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
Chao Yud1aa2452017-07-07 14:10:15 +08001434 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001435
Chao Yu67298802014-11-18 11:18:36 +08001436 orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num);
Changman Lee1dbe4152014-05-12 12:27:43 +09001437 ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
1438 orphan_blocks);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001439
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001440 if (__remain_node_summaries(cpc->reason))
Chao Yub5b82202014-08-22 16:17:38 +08001441 ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+
Changman Lee1dbe4152014-05-12 12:27:43 +09001442 cp_payload_blks + data_sum_blocks +
1443 orphan_blocks + NR_CURSEG_NODE_TYPE);
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001444 else
Chao Yub5b82202014-08-22 16:17:38 +08001445 ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS +
Changman Lee1dbe4152014-05-12 12:27:43 +09001446 cp_payload_blks + data_sum_blocks +
1447 orphan_blocks);
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001448
Jaegeuk Kime4c5d842016-09-30 17:37:43 -07001449 /* update ckpt flag for checkpoint */
1450 update_ckpt_flags(sbi, cpc);
Jaegeuk Kima468f0e2016-09-19 17:55:10 -07001451
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001452 /* update SIT/NAT bitmap */
1453 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
1454 get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
1455
Chao Yud7eb8f12019-04-22 17:33:52 +08001456 crc32 = f2fs_checkpoint_chksum(sbi, ckpt);
Jaegeuk Kim7e586fa2013-06-19 20:47:19 +09001457 *((__le32 *)((unsigned char *)ckpt +
1458 le32_to_cpu(ckpt->checksum_offset)))
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001459 = cpu_to_le32(crc32);
1460
Jaegeuk Kim8508e442016-11-24 12:45:15 -08001461 start_blk = __start_cp_next_addr(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001462
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001463 /* write nat bits */
1464 if (enabled_nat_bits(sbi, cpc)) {
1465 __u64 cp_ver = cur_cp_version(ckpt);
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001466 block_t blk;
1467
1468 cp_ver |= ((__u64)crc32 << 32);
1469 *(__le64 *)nm_i->nat_bits = cpu_to_le64(cp_ver);
1470
1471 blk = start_blk + sbi->blocks_per_seg - nm_i->nat_bits_blocks;
1472 for (i = 0; i < nm_i->nat_bits_blocks; i++)
Chao Yu4d57b862018-05-30 00:20:41 +08001473 f2fs_update_meta_page(sbi, nm_i->nat_bits +
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001474 (i << F2FS_BLKSIZE_BITS), blk + i);
Jaegeuk Kim22ad0b62017-02-09 10:38:09 -08001475 }
1476
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001477 /* write out checkpoint buffer at block 0 */
Chao Yu4d57b862018-05-30 00:20:41 +08001478 f2fs_update_meta_page(sbi, ckpt, start_blk++);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001479
Chao Yu381722d2015-05-19 17:40:04 +08001480 for (i = 1; i < 1 + cp_payload_blks; i++)
Chao Yu4d57b862018-05-30 00:20:41 +08001481 f2fs_update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE,
Chao Yu381722d2015-05-19 17:40:04 +08001482 start_blk++);
Changman Lee1dbe4152014-05-12 12:27:43 +09001483
Chao Yu67298802014-11-18 11:18:36 +08001484 if (orphan_num) {
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001485 write_orphan_inodes(sbi, start_blk);
1486 start_blk += orphan_blocks;
1487 }
1488
Chao Yu4d57b862018-05-30 00:20:41 +08001489 f2fs_write_data_summaries(sbi, start_blk);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001490 start_blk += data_sum_blocks;
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001491
1492 /* Record write statistics in the hot node summary */
1493 kbytes_written = sbi->kbytes_written;
1494 if (sb->s_bdev->bd_part)
1495 kbytes_written += BD_PART_WRITTEN(sbi);
1496
Chao Yub7ad7512016-02-19 18:08:46 +08001497 seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001498
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001499 if (__remain_node_summaries(cpc->reason)) {
Chao Yu4d57b862018-05-30 00:20:41 +08001500 f2fs_write_node_summaries(sbi, start_blk);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001501 start_blk += NR_CURSEG_NODE_TYPE;
1502 }
1503
Gao Xiang46706d52018-02-10 12:12:51 +08001504 /* update user_block_counts */
1505 sbi->last_valid_block_count = sbi->total_valid_block_count;
1506 percpu_counter_set(&sbi->alloc_valid_block_count, 0);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001507
Gao Xiang46706d52018-02-10 12:12:51 +08001508 /* Here, we have one bio having CP pack except cp pack 2 page */
Chao Yu4d57b862018-05-30 00:20:41 +08001509 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);
Sahitya Tummalabf22c3c2020-02-18 09:19:07 +05301510 /* Wait for all dirty meta pages to be submitted for IO */
1511 f2fs_wait_on_all_pages(sbi, F2FS_DIRTY_META);
Gao Xiang46706d52018-02-10 12:12:51 +08001512
1513 /* wait for previous submitted meta pages writeback */
Sahitya Tummalabf22c3c2020-02-18 09:19:07 +05301514 f2fs_wait_on_all_pages(sbi, F2FS_WB_CP_DATA);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001515
Gao Xiang46706d52018-02-10 12:12:51 +08001516 /* flush all device cache */
1517 err = f2fs_flush_device_cache(sbi);
1518 if (err)
1519 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001520
Gao Xiang46706d52018-02-10 12:12:51 +08001521 /* barrier and flush checkpoint cp pack 2 page if it can */
1522 commit_checkpoint(sbi, ckpt, start_blk);
Sahitya Tummalabf22c3c2020-02-18 09:19:07 +05301523 f2fs_wait_on_all_pages(sbi, F2FS_WB_CP_DATA);
Jaegeuk Kim6a8f8ca2014-10-29 14:37:22 -07001524
Chao Yu18767e62018-07-27 18:15:13 +08001525 /*
Eric Biggers542989b2019-12-09 12:00:55 -08001526 * invalidate intermediate page cache borrowed from meta inode which are
Chao Yuaff6fbb2020-07-07 09:35:41 +08001527 * used for migration of encrypted, verity or compressed inode's blocks.
Chao Yu18767e62018-07-27 18:15:13 +08001528 */
Chao Yuaff6fbb2020-07-07 09:35:41 +08001529 if (f2fs_sb_has_encrypt(sbi) || f2fs_sb_has_verity(sbi) ||
1530 f2fs_sb_has_compression(sbi))
Chao Yu18767e62018-07-27 18:15:13 +08001531 invalidate_mapping_pages(META_MAPPING(sbi),
1532 MAIN_BLKADDR(sbi), MAX_BLKADDR(sbi) - 1);
1533
Chao Yu4d57b862018-05-30 00:20:41 +08001534 f2fs_release_ino_entry(sbi, false);
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001535
Chao Yu50fa53e2018-08-02 23:03:19 +08001536 f2fs_reset_fsync_node_info(sbi);
1537
Chao Yucaf00472015-01-28 17:48:42 +08001538 clear_sbi_flag(sbi, SBI_IS_DIRTY);
Jaegeuk Kimbbf156f2016-08-29 18:23:45 -07001539 clear_sbi_flag(sbi, SBI_NEED_CP);
Chao Yuaf033b22018-09-20 20:05:00 +08001540 clear_sbi_flag(sbi, SBI_QUOTA_SKIP_FLUSH);
Chao Yuc9c8ed52019-05-05 11:40:46 +08001541
1542 spin_lock(&sbi->stat_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001543 sbi->unusable_block_count = 0;
Chao Yuc9c8ed52019-05-05 11:40:46 +08001544 spin_unlock(&sbi->stat_lock);
1545
Jaegeuk Kim8508e442016-11-24 12:45:15 -08001546 __set_cp_next_pack(sbi);
Chao Yuc34f42e2015-12-23 17:50:30 +08001547
Chao Yuc2a080a2016-08-31 10:43:19 +08001548 /*
1549 * redirty superblock if metadata like node page or inode cache is
1550 * updated during writing checkpoint.
1551 */
1552 if (get_pages(sbi, F2FS_DIRTY_NODES) ||
1553 get_pages(sbi, F2FS_DIRTY_IMETA))
1554 set_sbi_flag(sbi, SBI_IS_DIRTY);
1555
1556 f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS));
1557
Jaegeuk Kimaf697c02018-07-11 18:30:42 -07001558 return unlikely(f2fs_cp_error(sbi)) ? -EIO : 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001559}
1560
Chao Yu4d57b862018-05-30 00:20:41 +08001561int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001562{
1563 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1564 unsigned long long ckpt_ver;
Chao Yuc34f42e2015-12-23 17:50:30 +08001565 int err = 0;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001566
Chao Yuf5a131bb2019-04-22 20:22:38 +08001567 if (f2fs_readonly(sbi->sb) || f2fs_hw_is_readonly(sbi))
1568 return -EROFS;
1569
Daniel Rosenberg43549942018-08-20 19:21:43 -07001570 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
1571 if (cpc->reason != CP_PAUSE)
1572 return 0;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001573 f2fs_warn(sbi, "Start checkpoint disabled!");
Daniel Rosenberg43549942018-08-20 19:21:43 -07001574 }
Jaegeuk Kimb4b10062020-03-31 11:43:07 -07001575 if (cpc->reason != CP_RESIZE)
1576 mutex_lock(&sbi->cp_mutex);
Jaegeuk Kim85010172014-08-11 18:37:46 -07001577
Chao Yucaf00472015-01-28 17:48:42 +08001578 if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
Chao Yuc473f1a2017-04-27 20:40:39 +08001579 ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
1580 ((cpc->reason & CP_DISCARD) && !sbi->discard_blks)))
Jaegeuk Kim85010172014-08-11 18:37:46 -07001581 goto out;
Chao Yuc34f42e2015-12-23 17:50:30 +08001582 if (unlikely(f2fs_cp_error(sbi))) {
1583 err = -EIO;
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001584 goto out;
Chao Yuc34f42e2015-12-23 17:50:30 +08001585 }
Wanpeng Li2bda5422015-02-27 15:56:16 +08001586
1587 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
1588
Chao Yuc34f42e2015-12-23 17:50:30 +08001589 err = block_operations(sbi);
1590 if (err)
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001591 goto out;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001592
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -07001593 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
Namjae Jeon2af4bd62013-04-23 18:26:54 +09001594
Jaegeuk Kimb9109b02017-05-10 11:28:38 -07001595 f2fs_flush_merged_writes(sbi);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001596
Yunlei He58cce382016-08-18 21:01:19 +08001597 /* this is the case of multiple fstrims without any changes */
Chao Yuc473f1a2017-04-27 20:40:39 +08001598 if (cpc->reason & CP_DISCARD) {
Chao Yu4d57b862018-05-30 00:20:41 +08001599 if (!f2fs_exist_trim_candidates(sbi, cpc)) {
Jaegeuk Kim25290fa2016-12-29 22:06:15 -08001600 unblock_operations(sbi);
1601 goto out;
1602 }
1603
Jaegeuk Kimee3f8ae2020-11-06 13:22:05 -08001604 if (NM_I(sbi)->nat_cnt[DIRTY_NAT] == 0 &&
Jaegeuk Kim0333ad42016-12-29 16:58:54 -08001605 SIT_I(sbi)->dirty_sentries == 0 &&
1606 prefree_segments(sbi) == 0) {
Chao Yu4d57b862018-05-30 00:20:41 +08001607 f2fs_flush_sit_entries(sbi, cpc);
1608 f2fs_clear_prefree_segments(sbi, cpc);
Jaegeuk Kim0333ad42016-12-29 16:58:54 -08001609 unblock_operations(sbi);
1610 goto out;
1611 }
Yunlei He58cce382016-08-18 21:01:19 +08001612 }
1613
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001614 /*
1615 * update checkpoint pack index
1616 * Increase the version number so that
1617 * SIT entries and seg summaries are written at correct place
1618 */
Jaegeuk Kimd71b5562013-08-09 15:03:21 +09001619 ckpt_ver = cur_cp_version(ckpt);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001620 ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);
1621
1622 /* write cached NAT/SIT entries to NAT/SIT area */
Jaegeuk Kimedc55aa2018-09-17 17:36:06 -07001623 err = f2fs_flush_nat_entries(sbi, cpc);
1624 if (err)
1625 goto stop;
1626
Chao Yu4d57b862018-05-30 00:20:41 +08001627 f2fs_flush_sit_entries(sbi, cpc);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001628
Chao Yud0b9e422020-08-04 21:14:45 +08001629 /* save inmem log status */
Chao Yu093749e2020-08-04 21:14:49 +08001630 f2fs_save_inmem_curseg(sbi);
Chao Yud0b9e422020-08-04 21:14:45 +08001631
Chao Yuc34f42e2015-12-23 17:50:30 +08001632 err = do_checkpoint(sbi, cpc);
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001633 if (err)
Chao Yu4d57b862018-05-30 00:20:41 +08001634 f2fs_release_discard_addrs(sbi);
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001635 else
Chao Yu4d57b862018-05-30 00:20:41 +08001636 f2fs_clear_prefree_segments(sbi, cpc);
Chao Yud0b9e422020-08-04 21:14:45 +08001637
Chao Yu093749e2020-08-04 21:14:49 +08001638 f2fs_restore_inmem_curseg(sbi);
Jaegeuk Kimedc55aa2018-09-17 17:36:06 -07001639stop:
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001640 unblock_operations(sbi);
Changman Lee942e0be2014-02-13 15:12:29 +09001641 stat_inc_cp_count(sbi->stat_info);
Jaegeuk Kim10027552015-04-09 17:03:53 -07001642
Chao Yuc473f1a2017-04-27 20:40:39 +08001643 if (cpc->reason & CP_RECOVERY)
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001644 f2fs_notice(sbi, "checkpoint: version = %llx", ckpt_ver);
Jaegeuk Kim60b99b42015-10-05 14:49:57 -07001645
Chao Yu7a88ddb2020-02-27 19:30:05 +08001646 /* update CP_TIME to trigger checkpoint periodically */
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001647 f2fs_update_time(sbi, CP_TIME);
Jaegeuk Kim55d1cdb2015-12-15 16:07:14 -08001648 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
Jaegeuk Kim85010172014-08-11 18:37:46 -07001649out:
Jaegeuk Kimb4b10062020-03-31 11:43:07 -07001650 if (cpc->reason != CP_RESIZE)
1651 mutex_unlock(&sbi->cp_mutex);
Chao Yuc34f42e2015-12-23 17:50:30 +08001652 return err;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001653}
1654
Chao Yu4d57b862018-05-30 00:20:41 +08001655void f2fs_init_ino_entry_info(struct f2fs_sb_info *sbi)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001656{
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001657 int i;
1658
1659 for (i = 0; i < MAX_INO_ENTRY; i++) {
Chao Yu67298802014-11-18 11:18:36 +08001660 struct inode_management *im = &sbi->im[i];
1661
1662 INIT_RADIX_TREE(&im->ino_root, GFP_ATOMIC);
1663 spin_lock_init(&im->ino_lock);
1664 INIT_LIST_HEAD(&im->ino_list);
1665 im->ino_num = 0;
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001666 }
1667
Chao Yub5b82202014-08-22 16:17:38 +08001668 sbi->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS -
Chao Yud0b9e422020-08-04 21:14:45 +08001669 NR_CURSEG_PERSIST_TYPE - __cp_payload(sbi)) *
Wanpeng Li14b42812015-02-27 17:38:13 +08001670 F2FS_ORPHANS_PER_BLOCK;
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001671}
1672
Chao Yu4d57b862018-05-30 00:20:41 +08001673int __init f2fs_create_checkpoint_caches(void)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001674{
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001675 ino_entry_slab = f2fs_kmem_cache_create("f2fs_ino_entry",
1676 sizeof(struct ino_entry));
1677 if (!ino_entry_slab)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001678 return -ENOMEM;
Chao Yu4d57b862018-05-30 00:20:41 +08001679 f2fs_inode_entry_slab = f2fs_kmem_cache_create("f2fs_inode_entry",
Chao Yu06292072014-12-29 15:56:18 +08001680 sizeof(struct inode_entry));
Chao Yu4d57b862018-05-30 00:20:41 +08001681 if (!f2fs_inode_entry_slab) {
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001682 kmem_cache_destroy(ino_entry_slab);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001683 return -ENOMEM;
1684 }
1685 return 0;
1686}
1687
Chao Yu4d57b862018-05-30 00:20:41 +08001688void f2fs_destroy_checkpoint_caches(void)
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001689{
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001690 kmem_cache_destroy(ino_entry_slab);
Chao Yu4d57b862018-05-30 00:20:41 +08001691 kmem_cache_destroy(f2fs_inode_entry_slab);
Jaegeuk Kim127e6702012-11-02 17:08:18 +09001692}