blob: c5e5c45130b5e880a8cd980f8d601f2300a809fa [file] [log] [blame]
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001/*
Jaegeuk Kimd624c962012-11-02 17:13:32 +09002 * fs/f2fs/recovery.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/f2fs_fs.h>
13#include "f2fs.h"
14#include "node.h"
15#include "segment.h"
16
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -070017/*
18 * Roll forward recovery scenarios.
19 *
20 * [Term] F: fsync_mark, D: dentry_mark
21 *
22 * 1. inode(x) | CP | inode(x) | dnode(F)
23 * -> Update the latest inode(x).
24 *
25 * 2. inode(x) | CP | inode(F) | dnode(F)
26 * -> No problem.
27 *
28 * 3. inode(x) | CP | dnode(F) | inode(x)
29 * -> Recover to the latest dnode(F), and drop the last inode(x)
30 *
31 * 4. inode(x) | CP | dnode(F) | inode(F)
32 * -> No problem.
33 *
34 * 5. CP | inode(x) | dnode(F)
35 * -> The inode(DF) was missing. Should drop this dnode(F).
36 *
37 * 6. CP | inode(DF) | dnode(F)
38 * -> No problem.
39 *
40 * 7. CP | dnode(F) | inode(DF)
41 * -> If f2fs_iget fails, then goto next to find inode(DF).
42 *
43 * 8. CP | dnode(F) | inode(x)
44 * -> If f2fs_iget fails, then goto next to find inode(DF).
45 * But it will fail due to no inode(DF).
46 */
47
Jaegeuk Kimd624c962012-11-02 17:13:32 +090048static struct kmem_cache *fsync_entry_slab;
49
50bool space_for_roll_forward(struct f2fs_sb_info *sbi)
51{
Jaegeuk Kim41382ec2016-05-16 11:06:50 -070052 s64 nalloc = percpu_counter_sum_positive(&sbi->alloc_valid_block_count);
53
54 if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)
Jaegeuk Kimd624c962012-11-02 17:13:32 +090055 return false;
56 return true;
57}
58
59static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
60 nid_t ino)
61{
Jaegeuk Kimd624c962012-11-02 17:13:32 +090062 struct fsync_inode_entry *entry;
63
Chao Yu2d7b8222014-03-29 11:33:17 +080064 list_for_each_entry(entry, head, list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +090065 if (entry->inode->i_ino == ino)
66 return entry;
Chao Yu2d7b8222014-03-29 11:33:17 +080067
Jaegeuk Kimd624c962012-11-02 17:13:32 +090068 return NULL;
69}
70
Jaegeuk Kimf4702d62016-09-09 16:48:15 -070071static struct fsync_inode_entry *add_fsync_inode(struct f2fs_sb_info *sbi,
Chao Yu4b2414d2017-08-08 10:54:31 +080072 struct list_head *head, nid_t ino, bool quota_inode)
Chao Yu3f8ab272016-04-29 20:13:37 +080073{
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -070074 struct inode *inode;
Chao Yu3f8ab272016-04-29 20:13:37 +080075 struct fsync_inode_entry *entry;
Chao Yu4b2414d2017-08-08 10:54:31 +080076 int err;
Chao Yu3f8ab272016-04-29 20:13:37 +080077
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -070078 inode = f2fs_iget_retry(sbi->sb, ino);
Jaegeuk Kimf4702d62016-09-09 16:48:15 -070079 if (IS_ERR(inode))
80 return ERR_CAST(inode);
81
Chao Yu4b2414d2017-08-08 10:54:31 +080082 err = dquot_initialize(inode);
83 if (err)
84 goto err_out;
85
86 if (quota_inode) {
87 err = dquot_alloc_inode(inode);
88 if (err)
89 goto err_out;
90 }
91
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -070092 entry = f2fs_kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
Chao Yu3f8ab272016-04-29 20:13:37 +080093 entry->inode = inode;
94 list_add_tail(&entry->list, head);
95
96 return entry;
Chao Yu4b2414d2017-08-08 10:54:31 +080097err_out:
98 iput(inode);
99 return ERR_PTR(err);
Chao Yu3f8ab272016-04-29 20:13:37 +0800100}
101
102static void del_fsync_inode(struct fsync_inode_entry *entry)
103{
104 iput(entry->inode);
105 list_del(&entry->list);
106 kmem_cache_free(fsync_entry_slab, entry);
107}
108
Chao Yuf61cce52016-05-07 16:15:05 +0800109static int recover_dentry(struct inode *inode, struct page *ipage,
110 struct list_head *dir_list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900111{
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +0900112 struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
Jaegeuk Kim74d0b912013-05-15 16:40:02 +0900113 nid_t pino = le32_to_cpu(raw_inode->i_pino);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900114 struct f2fs_dir_entry *de;
Shuoran Liue7ba1082016-08-29 11:27:56 +0800115 struct fscrypt_name fname;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900116 struct page *page;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900117 struct inode *dir, *einode;
Chao Yuf61cce52016-05-07 16:15:05 +0800118 struct fsync_inode_entry *entry;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900119 int err = 0;
Shuoran Liue7ba1082016-08-29 11:27:56 +0800120 char *name;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900121
Chao Yuf61cce52016-05-07 16:15:05 +0800122 entry = get_fsync_inode(dir_list, pino);
123 if (!entry) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800124 entry = add_fsync_inode(F2FS_I_SB(inode), dir_list,
125 pino, false);
Jaegeuk Kimf4702d62016-09-09 16:48:15 -0700126 if (IS_ERR(entry)) {
127 dir = ERR_CAST(entry);
128 err = PTR_ERR(entry);
Chao Yuf61cce52016-05-07 16:15:05 +0800129 goto out;
130 }
Jaegeuk Kimed57c272014-04-15 11:19:28 +0900131 }
132
Chao Yuf61cce52016-05-07 16:15:05 +0800133 dir = entry->inode;
134
Shuoran Liue7ba1082016-08-29 11:27:56 +0800135 memset(&fname, 0, sizeof(struct fscrypt_name));
136 fname.disk_name.len = le32_to_cpu(raw_inode->i_namelen);
137 fname.disk_name.name = raw_inode->i_name;
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700138
Shuoran Liue7ba1082016-08-29 11:27:56 +0800139 if (unlikely(fname.disk_name.len > F2FS_NAME_LEN)) {
Chao Yud96b14312013-12-23 11:12:21 +0800140 WARN_ON(1);
141 err = -ENAMETOOLONG;
Chao Yuf61cce52016-05-07 16:15:05 +0800142 goto out;
Chao Yud96b14312013-12-23 11:12:21 +0800143 }
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900144retry:
Shuoran Liue7ba1082016-08-29 11:27:56 +0800145 de = __f2fs_find_entry(dir, &fname, &page);
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700146 if (de && inode->i_ino == le32_to_cpu(de->ino))
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800147 goto out_put;
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700148
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900149 if (de) {
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700150 einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900151 if (IS_ERR(einode)) {
152 WARN_ON(1);
Chao Yu5c1f9922014-04-28 17:58:34 +0800153 err = PTR_ERR(einode);
154 if (err == -ENOENT)
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900155 err = -EEXIST;
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800156 goto out_put;
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500157 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800158
159 err = dquot_initialize(einode);
160 if (err) {
161 iput(einode);
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800162 goto out_put;
Chao Yu4b2414d2017-08-08 10:54:31 +0800163 }
164
Jaegeuk Kim40813632014-09-02 15:31:18 -0700165 err = acquire_orphan_inode(F2FS_I_SB(inode));
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500166 if (err) {
167 iput(einode);
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800168 goto out_put;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900169 }
Chao Yudbeacf02014-09-24 18:17:04 +0800170 f2fs_delete_entry(de, page, dir, einode);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900171 iput(einode);
172 goto retry;
Chao Yu91246c22016-07-19 08:27:47 +0800173 } else if (IS_ERR(page)) {
174 err = PTR_ERR(page);
175 } else {
Shuoran Liue7ba1082016-08-29 11:27:56 +0800176 err = __f2fs_do_add_link(dir, &fname, inode,
Chao Yu91246c22016-07-19 08:27:47 +0800177 inode->i_ino, inode->i_mode);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900178 }
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700179 if (err == -ENOMEM)
180 goto retry;
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500181 goto out;
182
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800183out_put:
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500184 f2fs_put_page(page, 0);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900185out:
Shuoran Liue7ba1082016-08-29 11:27:56 +0800186 if (file_enc_name(inode))
187 name = "<encrypted>";
188 else
189 name = raw_inode->i_name;
Chris Fries6c311ec2014-01-17 14:44:39 -0600190 f2fs_msg(inode->i_sb, KERN_NOTICE,
191 "%s: ino = %x, name = %s, dir = %lx, err = %d",
Shuoran Liue7ba1082016-08-29 11:27:56 +0800192 __func__, ino_of_node(ipage), name,
Dan Carpenterf28c06f2013-05-23 13:02:13 +0300193 IS_ERR(dir) ? 0 : dir->i_ino, err);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900194 return err;
195}
196
Jaegeuk Kim37a086f2018-01-19 20:01:40 -0800197static void recover_inline_flags(struct inode *inode, struct f2fs_inode *ri)
198{
199 if (ri->i_inline & F2FS_PIN_FILE)
200 set_inode_flag(inode, FI_PIN_FILE);
201 else
202 clear_inode_flag(inode, FI_PIN_FILE);
203 if (ri->i_inline & F2FS_DATA_EXIST)
204 set_inode_flag(inode, FI_DATA_EXIST);
205 else
206 clear_inode_flag(inode, FI_DATA_EXIST);
207 if (!(ri->i_inline & F2FS_INLINE_DOTS))
208 clear_inode_flag(inode, FI_INLINE_DOTS);
209}
210
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700211static void recover_inode(struct inode *inode, struct page *page)
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700212{
213 struct f2fs_inode *raw = F2FS_INODE(page);
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700214 char *name;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700215
216 inode->i_mode = le16_to_cpu(raw->i_mode);
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700217 f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
Chao Yu9f0552e2016-11-04 00:26:55 +0800218 inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700219 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
220 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
Chao Yu9f0552e2016-11-04 00:26:55 +0800221 inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700222 inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
223 inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900224
Jaegeuk Kim26787232016-11-28 15:33:38 -0800225 F2FS_I(inode)->i_advise = raw->i_advise;
226
Jaegeuk Kim37a086f2018-01-19 20:01:40 -0800227 recover_inline_flags(inode, raw);
228
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700229 if (file_enc_name(inode))
230 name = "<encrypted>";
231 else
232 name = F2FS_INODE(page)->i_name;
233
Jaegeuk Kim37a086f2018-01-19 20:01:40 -0800234 f2fs_msg(inode->i_sb, KERN_NOTICE,
235 "recover_inode: ino = %x, name = %s, inline = %x",
236 ino_of_node(page), name, raw->i_inline);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900237}
238
Jaegeuk Kimd40d30c2017-04-14 15:46:23 -0700239static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
240 bool check_only)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900241{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900242 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700243 struct page *page = NULL;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900244 block_t blkaddr;
245 int err = 0;
246
247 /* get node pages in the current segment */
248 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Chao Yu695fd1e2014-02-27 19:52:21 +0800249 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900250
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900251 while (1) {
252 struct fsync_inode_entry *entry;
253
Chao Yuf0c9cad2015-04-18 18:05:36 +0800254 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700255 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900256
Chao Yu2b947002015-10-12 17:04:21 +0800257 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim393ff912013-03-08 21:29:23 +0900258
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700259 if (!is_recoverable_dnode(page))
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900260 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900261
262 if (!is_fsync_dnode(page))
263 goto next;
264
265 entry = get_fsync_inode(head, ino_of_node(page));
Chao Yud47b8712016-11-05 11:12:40 +0800266 if (!entry) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800267 bool quota_inode = false;
268
Jaegeuk Kimd40d30c2017-04-14 15:46:23 -0700269 if (!check_only &&
270 IS_INODE(page) && is_dent_dnode(page)) {
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900271 err = recover_inode_page(sbi, page);
272 if (err)
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900273 break;
Chao Yu4b2414d2017-08-08 10:54:31 +0800274 quota_inode = true;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900275 }
276
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700277 /*
278 * CP | dnode(F) | inode(DF)
279 * For this case, we should not give up now.
280 */
Chao Yu4b2414d2017-08-08 10:54:31 +0800281 entry = add_fsync_inode(sbi, head, ino_of_node(page),
282 quota_inode);
Jaegeuk Kimf4702d62016-09-09 16:48:15 -0700283 if (IS_ERR(entry)) {
284 err = PTR_ERR(entry);
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800285 if (err == -ENOENT) {
286 err = 0;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700287 goto next;
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800288 }
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900289 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900290 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900291 }
Jaegeuk Kimaddbe452013-05-15 10:49:13 +0900292 entry->blkaddr = blkaddr;
293
Jaegeuk Kim608514d2016-04-15 09:43:17 -0700294 if (IS_INODE(page) && is_dent_dnode(page))
295 entry->last_dentry = blkaddr;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900296next:
297 /* check next segment */
298 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700299 f2fs_put_page(page, 1);
Chao Yu635aee12014-12-08 15:02:52 +0800300
301 ra_meta_pages_cond(sbi, blkaddr);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900302 }
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700303 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900304 return err;
305}
306
Gu Zheng5ebefc52013-06-27 09:28:54 +0800307static void destroy_fsync_dnodes(struct list_head *head)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900308{
Dan Carpenterd8b79b22013-01-20 18:02:58 +0300309 struct fsync_inode_entry *entry, *tmp;
310
Chao Yu3f8ab272016-04-29 20:13:37 +0800311 list_for_each_entry_safe(entry, tmp, head, list)
312 del_fsync_inode(entry);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900313}
314
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900315static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900316 block_t blkaddr, struct dnode_of_data *dn)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900317{
318 struct seg_entry *sentry;
319 unsigned int segno = GET_SEGNO(sbi, blkaddr);
Jaegeuk Kim491c0852014-02-04 13:01:10 +0900320 unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900321 struct f2fs_summary_block *sum_node;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900322 struct f2fs_summary sum;
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900323 struct page *sum_page, *node_page;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700324 struct dnode_of_data tdn = *dn;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900325 nid_t ino, nid;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900326 struct inode *inode;
Jaegeuk Kimde936532013-08-12 21:08:03 +0900327 unsigned int offset;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900328 block_t bidx;
329 int i;
330
331 sentry = get_seg_entry(sbi, segno);
332 if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900333 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900334
335 /* Get the previous summary */
Jaegeuk Kim125c9fb2017-08-12 21:33:23 -0700336 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900337 struct curseg_info *curseg = CURSEG_I(sbi, i);
338 if (curseg->segno == segno) {
339 sum = curseg->sum_blk->entries[blkoff];
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900340 goto got_it;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900341 }
342 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900343
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900344 sum_page = get_sum_page(sbi, segno);
345 sum_node = (struct f2fs_summary_block *)page_address(sum_page);
346 sum = sum_node->entries[blkoff];
347 f2fs_put_page(sum_page, 1);
348got_it:
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900349 /* Use the locked dnode page and inode */
350 nid = le32_to_cpu(sum.nid);
351 if (dn->inode->i_ino == nid) {
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900352 tdn.nid = nid;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700353 if (!dn->inode_page_locked)
354 lock_page(dn->inode_page);
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900355 tdn.node_page = dn->inode_page;
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900356 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700357 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900358 } else if (dn->nid == nid) {
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900359 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700360 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900361 }
362
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900363 /* Get the node page */
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900364 node_page = get_node_page(sbi, nid);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900365 if (IS_ERR(node_page))
366 return PTR_ERR(node_page);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900367
368 offset = ofs_of_node(node_page);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900369 ino = ino_of_node(node_page);
370 f2fs_put_page(node_page, 1);
371
Jaegeuk Kim60979112014-09-13 00:35:58 +0900372 if (ino != dn->inode->i_ino) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800373 int ret;
374
Jaegeuk Kim60979112014-09-13 00:35:58 +0900375 /* Deallocate previous index in the node page */
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700376 inode = f2fs_iget_retry(sbi->sb, ino);
Jaegeuk Kim60979112014-09-13 00:35:58 +0900377 if (IS_ERR(inode))
378 return PTR_ERR(inode);
Chao Yu4b2414d2017-08-08 10:54:31 +0800379
380 ret = dquot_initialize(inode);
381 if (ret) {
382 iput(inode);
383 return ret;
384 }
Jaegeuk Kim60979112014-09-13 00:35:58 +0900385 } else {
386 inode = dn->inode;
387 }
Namjae Jeon06025f42012-12-22 12:09:43 +0900388
Chao Yu81ca7352016-01-26 15:39:35 +0800389 bidx = start_bidx_of_node(offset, inode) + le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900390
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700391 /*
392 * if inode page is locked, unlock temporarily, but its reference
393 * count keeps alive.
394 */
395 if (ino == dn->inode->i_ino && dn->inode_page_locked)
396 unlock_page(dn->inode_page);
397
398 set_new_dnode(&tdn, inode, NULL, NULL, 0);
399 if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
400 goto out;
401
402 if (tdn.data_blkaddr == blkaddr)
403 truncate_data_blocks_range(&tdn, 1);
404
405 f2fs_put_dnode(&tdn);
406out:
407 if (ino != dn->inode->i_ino)
Jaegeuk Kim60979112014-09-13 00:35:58 +0900408 iput(inode);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700409 else if (dn->inode_page_locked)
410 lock_page(dn->inode_page);
411 return 0;
412
413truncate_out:
Chao Yu7a2af762017-07-19 00:19:06 +0800414 if (datablock_addr(tdn.inode, tdn.node_page,
415 tdn.ofs_in_node) == blkaddr)
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700416 truncate_data_blocks_range(&tdn, 1);
417 if (dn->inode->i_ino == nid && !dn->inode_page_locked)
418 unlock_page(dn->inode_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900419 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900420}
421
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900422static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
Sheng Yonge17d4882017-11-22 18:23:40 +0800423 struct page *page)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900424{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900425 struct dnode_of_data dn;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900426 struct node_info ni;
Chao Yu81ca7352016-01-26 15:39:35 +0800427 unsigned int start, end;
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900428 int err = 0, recovered = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900429
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700430 /* step 1: recover xattr */
431 if (IS_INODE(page)) {
432 recover_inline_xattr(inode, page);
433 } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
Sheng Yonge17d4882017-11-22 18:23:40 +0800434 err = recover_xattr_data(inode, page);
Chao Yud2600812017-02-08 17:39:45 +0800435 if (!err)
436 recovered++;
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700437 goto out;
438 }
Chao Yu70cfed82014-08-02 15:26:04 +0800439
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700440 /* step 2: recover inline data */
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900441 if (recover_inline_data(inode, page))
442 goto out;
443
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700444 /* step 3: recover data indices */
Chao Yu81ca7352016-01-26 15:39:35 +0800445 start = start_bidx_of_node(ofs_of_node(page), inode);
446 end = start + ADDRS_PER_PAGE(page, inode);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900447
448 set_new_dnode(&dn, inode, NULL, NULL, 0);
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700449retry_dn:
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900450 err = get_dnode_of_data(&dn, start, ALLOC_NODE);
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700451 if (err) {
452 if (err == -ENOMEM) {
453 congestion_wait(BLK_RW_ASYNC, HZ/50);
454 goto retry_dn;
455 }
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900456 goto out;
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700457 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900458
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800459 f2fs_wait_on_page_writeback(dn.node_page, NODE, true);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900460
461 get_node_info(sbi, dn.nid, &ni);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700462 f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
463 f2fs_bug_on(sbi, ofs_of_node(dn.node_page) != ofs_of_node(page));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900464
Chao Yu12a83432015-08-05 17:23:54 +0800465 for (; start < end; start++, dn.ofs_in_node++) {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900466 block_t src, dest;
467
Chao Yu7a2af762017-07-19 00:19:06 +0800468 src = datablock_addr(dn.inode, dn.node_page, dn.ofs_in_node);
469 dest = datablock_addr(dn.inode, page, dn.ofs_in_node);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900470
Chao Yu12a83432015-08-05 17:23:54 +0800471 /* skip recovering if dest is the same as src */
472 if (src == dest)
473 continue;
474
475 /* dest is invalid, just invalidate src block */
476 if (dest == NULL_ADDR) {
477 truncate_data_blocks_range(&dn, 1);
478 continue;
479 }
480
Jaegeuk Kim26787232016-11-28 15:33:38 -0800481 if (!file_keep_isize(inode) &&
Chao Yudba79f32017-01-25 10:52:39 +0800482 (i_size_read(inode) <= ((loff_t)start << PAGE_SHIFT)))
483 f2fs_i_size_write(inode,
484 (loff_t)(start + 1) << PAGE_SHIFT);
Jaegeuk Kim26de9b12016-05-20 20:42:37 -0700485
Chao Yu12a83432015-08-05 17:23:54 +0800486 /*
487 * dest is reserved block, invalidate src block
488 * and then reserve one new block in dnode page.
489 */
490 if (dest == NEW_ADDR) {
491 truncate_data_blocks_range(&dn, 1);
Jaegeuk Kim3b9b10f2016-05-11 09:13:13 -0700492 reserve_new_block(&dn);
Chao Yu12a83432015-08-05 17:23:54 +0800493 continue;
494 }
495
496 /* dest is valid block, try to recover from src to dest */
497 if (is_valid_blkaddr(sbi, dest, META_POR)) {
Jaegeuk Kime03b07d2015-04-01 19:38:20 -0700498
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900499 if (src == NULL_ADDR) {
Jaegeuk Kim5d56b672013-10-29 15:14:54 +0900500 err = reserve_new_block(&dn);
Jaegeuk Kim975756c2016-05-19 11:57:21 -0700501#ifdef CONFIG_F2FS_FAULT_INJECTION
502 while (err)
503 err = reserve_new_block(&dn);
504#endif
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900505 /* We should not get -ENOSPC */
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700506 f2fs_bug_on(sbi, err);
Jaegeuk Kim6f3ec992016-07-19 19:30:06 -0700507 if (err)
508 goto err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900509 }
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700510retry_prev:
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900511 /* Check the previous node page having this index */
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900512 err = check_index_in_prev_nodes(sbi, dest, &dn);
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700513 if (err) {
514 if (err == -ENOMEM) {
515 congestion_wait(BLK_RW_ASYNC, HZ/50);
516 goto retry_prev;
517 }
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900518 goto err;
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700519 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900520
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900521 /* write dummy data page */
Chao Yu528e3452015-05-28 19:15:35 +0800522 f2fs_replace_block(sbi, &dn, src, dest,
Chao Yu28bc1062016-02-06 14:40:34 +0800523 ni.version, false, false);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900524 recovered++;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900525 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900526 }
527
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900528 copy_node_footer(dn.node_page, page);
529 fill_node_footer(dn.node_page, dn.nid, ni.ino,
530 ofs_of_node(page), false);
531 set_page_dirty(dn.node_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900532err:
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900533 f2fs_put_dnode(&dn);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900534out:
Chris Fries6c311ec2014-01-17 14:44:39 -0600535 f2fs_msg(sbi->sb, KERN_NOTICE,
Jaegeuk Kim26787232016-11-28 15:33:38 -0800536 "recover_data: ino = %lx (i_size: %s) recovered = %d, err = %d",
537 inode->i_ino,
538 file_keep_isize(inode) ? "keep" : "recover",
539 recovered, err);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900540 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900541}
542
Chao Yuf61cce52016-05-07 16:15:05 +0800543static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
544 struct list_head *dir_list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900545{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900546 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700547 struct page *page = NULL;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900548 int err = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900549 block_t blkaddr;
550
551 /* get node pages in the current segment */
Chao Yub7973f22015-12-01 11:43:59 +0800552 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900553 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
554
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900555 while (1) {
556 struct fsync_inode_entry *entry;
557
Chao Yuf0c9cad2015-04-18 18:05:36 +0800558 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900559 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900560
Chao Yu635aee12014-12-08 15:02:52 +0800561 ra_meta_pages_cond(sbi, blkaddr);
562
Chao Yu2b947002015-10-12 17:04:21 +0800563 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700564
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700565 if (!is_recoverable_dnode(page)) {
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700566 f2fs_put_page(page, 1);
567 break;
568 }
569
Chao Yuf61cce52016-05-07 16:15:05 +0800570 entry = get_fsync_inode(inode_list, ino_of_node(page));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900571 if (!entry)
572 goto next;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700573 /*
574 * inode(x) | CP | inode(x) | dnode(F)
575 * In this case, we can lose the latest inode(x).
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700576 * So, call recover_inode for the inode update.
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700577 */
Jaegeuk Kim608514d2016-04-15 09:43:17 -0700578 if (IS_INODE(page))
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700579 recover_inode(entry->inode, page);
580 if (entry->last_dentry == blkaddr) {
Chao Yuf61cce52016-05-07 16:15:05 +0800581 err = recover_dentry(entry->inode, page, dir_list);
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700582 if (err) {
583 f2fs_put_page(page, 1);
584 break;
585 }
586 }
Sheng Yonge17d4882017-11-22 18:23:40 +0800587 err = do_recover_data(sbi, entry->inode, page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700588 if (err) {
589 f2fs_put_page(page, 1);
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900590 break;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700591 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900592
Chao Yu3f8ab272016-04-29 20:13:37 +0800593 if (entry->blkaddr == blkaddr)
594 del_fsync_inode(entry);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900595next:
596 /* check next segment */
597 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700598 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900599 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900600 if (!err)
601 allocate_new_segments(sbi);
602 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900603}
604
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700605int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900606{
607 struct list_head inode_list;
Chao Yuf61cce52016-05-07 16:15:05 +0800608 struct list_head dir_list;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900609 int err;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700610 int ret = 0;
Chao Yu4b2414d2017-08-08 10:54:31 +0800611 unsigned long s_flags = sbi->sb->s_flags;
Haicheng Liaabe5132013-10-23 12:39:32 +0800612 bool need_writecp = false;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700613#ifdef CONFIG_QUOTA
614 int quota_enabled;
615#endif
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900616
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800617 if (s_flags & SB_RDONLY) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800618 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800619 sbi->sb->s_flags &= ~SB_RDONLY;
Chao Yu4b2414d2017-08-08 10:54:31 +0800620 }
621
622#ifdef CONFIG_QUOTA
623 /* Needed for iput() to work correctly and not trash data */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800624 sbi->sb->s_flags |= SB_ACTIVE;
Chao Yu4b2414d2017-08-08 10:54:31 +0800625 /* Turn on quotas so that they are updated correctly */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800626 quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
Chao Yu4b2414d2017-08-08 10:54:31 +0800627#endif
628
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900629 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
Gu Zhenge8512d22014-03-07 18:43:28 +0800630 sizeof(struct fsync_inode_entry));
Chao Yu4b2414d2017-08-08 10:54:31 +0800631 if (!fsync_entry_slab) {
632 err = -ENOMEM;
633 goto out;
634 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900635
636 INIT_LIST_HEAD(&inode_list);
Chao Yuf61cce52016-05-07 16:15:05 +0800637 INIT_LIST_HEAD(&dir_list);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900638
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700639 /* prevent checkpoint */
640 mutex_lock(&sbi->cp_mutex);
641
Jaegeuk Kim315df832015-08-11 12:45:39 -0700642 /* step #1: find fsynced inode numbers */
Jaegeuk Kimd40d30c2017-04-14 15:46:23 -0700643 err = find_fsync_dnodes(sbi, &inode_list, check_only);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700644 if (err || list_empty(&inode_list))
Chao Yu4b2414d2017-08-08 10:54:31 +0800645 goto skip;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900646
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700647 if (check_only) {
648 ret = 1;
Chao Yu4b2414d2017-08-08 10:54:31 +0800649 goto skip;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700650 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900651
Haicheng Liaabe5132013-10-23 12:39:32 +0800652 need_writecp = true;
Chao Yu691c6fd2013-09-24 09:26:24 +0800653
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900654 /* step #2: recover data */
Chao Yuf61cce52016-05-07 16:15:05 +0800655 err = recover_data(sbi, &inode_list, &dir_list);
Jaegeuk Kimb3073842014-08-08 10:18:43 -0700656 if (!err)
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700657 f2fs_bug_on(sbi, !list_empty(&inode_list));
Chao Yu4b2414d2017-08-08 10:54:31 +0800658skip:
Gu Zheng5ebefc52013-06-27 09:28:54 +0800659 destroy_fsync_dnodes(&inode_list);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700660
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700661 /* truncate meta pages to be used by the recovery */
662 truncate_inode_pages_range(META_MAPPING(sbi),
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300663 (loff_t)MAIN_BLKADDR(sbi) << PAGE_SHIFT, -1);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700664
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700665 if (err) {
666 truncate_inode_pages_final(NODE_MAPPING(sbi));
667 truncate_inode_pages_final(META_MAPPING(sbi));
668 }
669
Chao Yucaf00472015-01-28 17:48:42 +0800670 clear_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700671 mutex_unlock(&sbi->cp_mutex);
672
Jaegeuk Kim9e1e6df2016-09-19 18:13:54 -0700673 /* let's drop all the directory inodes for clean checkpoint */
674 destroy_fsync_dnodes(&dir_list);
675
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700676 if (!err && need_writecp) {
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700677 struct cp_control cpc = {
Jaegeuk Kim10027552015-04-09 17:03:53 -0700678 .reason = CP_RECOVERY,
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700679 };
Chao Yuc34f42e2015-12-23 17:50:30 +0800680 err = write_checkpoint(sbi, &cpc);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700681 }
Chao Yuf61cce52016-05-07 16:15:05 +0800682
Chao Yuf61cce52016-05-07 16:15:05 +0800683 kmem_cache_destroy(fsync_entry_slab);
Chao Yu4b2414d2017-08-08 10:54:31 +0800684out:
685#ifdef CONFIG_QUOTA
686 /* Turn quotas off */
Jaegeuk Kimea676732017-10-06 09:14:28 -0700687 if (quota_enabled)
688 f2fs_quota_off_umount(sbi->sb);
Chao Yu4b2414d2017-08-08 10:54:31 +0800689#endif
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800690 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
Chao Yu4b2414d2017-08-08 10:54:31 +0800691
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700692 return ret ? ret: err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900693}