blob: 589b20b8677b8cc1dcf3d16a6f7e0943ce0283eb [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{
52 if (sbi->last_valid_block_count + sbi->alloc_valid_block_count
53 > sbi->user_block_count)
54 return false;
55 return true;
56}
57
58static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
59 nid_t ino)
60{
Jaegeuk Kimd624c962012-11-02 17:13:32 +090061 struct fsync_inode_entry *entry;
62
Chao Yu2d7b8222014-03-29 11:33:17 +080063 list_for_each_entry(entry, head, list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +090064 if (entry->inode->i_ino == ino)
65 return entry;
Chao Yu2d7b8222014-03-29 11:33:17 +080066
Jaegeuk Kimd624c962012-11-02 17:13:32 +090067 return NULL;
68}
69
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -070070static int recover_dentry(struct inode *inode, struct page *ipage)
Jaegeuk Kimd624c962012-11-02 17:13:32 +090071{
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +090072 struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
Jaegeuk Kim74d0b912013-05-15 16:40:02 +090073 nid_t pino = le32_to_cpu(raw_inode->i_pino);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +090074 struct f2fs_dir_entry *de;
Al Virob7f7a5e2013-01-25 16:15:43 -050075 struct qstr name;
Jaegeuk Kimd624c962012-11-02 17:13:32 +090076 struct page *page;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +090077 struct inode *dir, *einode;
Jaegeuk Kimd624c962012-11-02 17:13:32 +090078 int err = 0;
79
Jaegeuk Kimed57c272014-04-15 11:19:28 +090080 dir = f2fs_iget(inode->i_sb, pino);
81 if (IS_ERR(dir)) {
82 err = PTR_ERR(dir);
83 goto out;
84 }
85
Jaegeuk Kime7d55452015-04-29 17:02:18 -070086 if (file_enc_name(inode)) {
87 iput(dir);
88 return 0;
89 }
90
Al Virob7f7a5e2013-01-25 16:15:43 -050091 name.len = le32_to_cpu(raw_inode->i_namelen);
92 name.name = raw_inode->i_name;
Chao Yud96b14312013-12-23 11:12:21 +080093
94 if (unlikely(name.len > F2FS_NAME_LEN)) {
95 WARN_ON(1);
96 err = -ENAMETOOLONG;
Jaegeuk Kim86928f92014-06-07 03:05:03 +090097 goto out_err;
Chao Yud96b14312013-12-23 11:12:21 +080098 }
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +090099retry:
100 de = f2fs_find_entry(dir, &name, &page);
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700101 if (de && inode->i_ino == le32_to_cpu(de->ino))
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500102 goto out_unmap_put;
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700103
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900104 if (de) {
105 einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino));
106 if (IS_ERR(einode)) {
107 WARN_ON(1);
Chao Yu5c1f9922014-04-28 17:58:34 +0800108 err = PTR_ERR(einode);
109 if (err == -ENOENT)
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900110 err = -EEXIST;
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500111 goto out_unmap_put;
112 }
Jaegeuk Kim40813632014-09-02 15:31:18 -0700113 err = acquire_orphan_inode(F2FS_I_SB(inode));
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500114 if (err) {
115 iput(einode);
116 goto out_unmap_put;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900117 }
Chao Yudbeacf02014-09-24 18:17:04 +0800118 f2fs_delete_entry(de, page, dir, einode);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900119 iput(einode);
120 goto retry;
121 }
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700122 err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);
Jaegeuk Kim86928f92014-06-07 03:05:03 +0900123 if (err)
124 goto out_err;
125
126 if (is_inode_flag_set(F2FS_I(dir), FI_DELAY_IPUT)) {
127 iput(dir);
128 } else {
129 add_dirty_dir_inode(dir);
130 set_inode_flag(F2FS_I(dir), FI_DELAY_IPUT);
131 }
132
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500133 goto out;
134
135out_unmap_put:
Jaegeuk Kim9486ba42014-11-21 16:36:28 -0800136 f2fs_dentry_kunmap(dir, page);
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500137 f2fs_put_page(page, 0);
Jaegeuk Kim86928f92014-06-07 03:05:03 +0900138out_err:
139 iput(dir);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900140out:
Chris Fries6c311ec2014-01-17 14:44:39 -0600141 f2fs_msg(inode->i_sb, KERN_NOTICE,
142 "%s: ino = %x, name = %s, dir = %lx, err = %d",
143 __func__, ino_of_node(ipage), raw_inode->i_name,
Dan Carpenterf28c06f2013-05-23 13:02:13 +0300144 IS_ERR(dir) ? 0 : dir->i_ino, err);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900145 return err;
146}
147
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700148static void recover_inode(struct inode *inode, struct page *page)
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700149{
150 struct f2fs_inode *raw = F2FS_INODE(page);
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700151 char *name;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700152
153 inode->i_mode = le16_to_cpu(raw->i_mode);
154 i_size_write(inode, le64_to_cpu(raw->i_size));
155 inode->i_atime.tv_sec = le64_to_cpu(raw->i_mtime);
156 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
157 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
158 inode->i_atime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
159 inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
160 inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900161
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700162 if (file_enc_name(inode))
163 name = "<encrypted>";
164 else
165 name = F2FS_INODE(page)->i_name;
166
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900167 f2fs_msg(inode->i_sb, KERN_NOTICE, "recover_inode: ino = %x, name = %s",
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700168 ino_of_node(page), name);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900169}
170
Jaegeuk Kim807b1e12015-12-03 14:14:40 -0800171static bool is_same_inode(struct inode *inode, struct page *ipage)
172{
173 struct f2fs_inode *ri = F2FS_INODE(ipage);
174 struct timespec disk;
175
176 if (!IS_INODE(ipage))
177 return true;
178
179 disk.tv_sec = le64_to_cpu(ri->i_ctime);
180 disk.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
181 if (timespec_compare(&inode->i_ctime, &disk) > 0)
182 return false;
183
184 disk.tv_sec = le64_to_cpu(ri->i_atime);
185 disk.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
186 if (timespec_compare(&inode->i_atime, &disk) > 0)
187 return false;
188
189 disk.tv_sec = le64_to_cpu(ri->i_mtime);
190 disk.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
191 if (timespec_compare(&inode->i_mtime, &disk) > 0)
192 return false;
193
194 return true;
195}
196
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900197static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
198{
Jaegeuk Kimd71b5562013-08-09 15:03:21 +0900199 unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900200 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700201 struct page *page = NULL;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900202 block_t blkaddr;
203 int err = 0;
204
205 /* get node pages in the current segment */
206 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Chao Yu695fd1e2014-02-27 19:52:21 +0800207 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900208
Chao Yu26879fb2015-10-12 17:05:59 +0800209 ra_meta_pages(sbi, blkaddr, 1, META_POR, true);
Chao Yu635aee12014-12-08 15:02:52 +0800210
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900211 while (1) {
212 struct fsync_inode_entry *entry;
213
Chao Yuf0c9cad2015-04-18 18:05:36 +0800214 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700215 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900216
Chao Yu2b947002015-10-12 17:04:21 +0800217 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim393ff912013-03-08 21:29:23 +0900218
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900219 if (cp_ver != cpver_of_node(page))
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900220 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900221
222 if (!is_fsync_dnode(page))
223 goto next;
224
225 entry = get_fsync_inode(head, ino_of_node(page));
Jaegeuk Kim807b1e12015-12-03 14:14:40 -0800226 if (entry) {
227 if (!is_same_inode(entry->inode, page))
228 goto next;
229 } else {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900230 if (IS_INODE(page) && is_dent_dnode(page)) {
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900231 err = recover_inode_page(sbi, page);
232 if (err)
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900233 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900234 }
235
236 /* add this fsync inode to the list */
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700237 entry = kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900238 if (!entry) {
239 err = -ENOMEM;
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900240 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900241 }
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700242 /*
243 * CP | dnode(F) | inode(DF)
244 * For this case, we should not give up now.
245 */
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900246 entry->inode = f2fs_iget(sbi->sb, ino_of_node(page));
247 if (IS_ERR(entry->inode)) {
248 err = PTR_ERR(entry->inode);
Namjae Jeonfd8bb652012-12-22 12:10:12 +0900249 kmem_cache_free(fsync_entry_slab, entry);
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800250 if (err == -ENOENT) {
251 err = 0;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700252 goto next;
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800253 }
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900254 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900255 }
Namjae Jeonfd8bb652012-12-22 12:10:12 +0900256 list_add_tail(&entry->list, head);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900257 }
Jaegeuk Kimaddbe452013-05-15 10:49:13 +0900258 entry->blkaddr = blkaddr;
259
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700260 if (IS_INODE(page)) {
261 entry->last_inode = blkaddr;
262 if (is_dent_dnode(page))
263 entry->last_dentry = blkaddr;
264 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900265next:
266 /* check next segment */
267 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700268 f2fs_put_page(page, 1);
Chao Yu635aee12014-12-08 15:02:52 +0800269
270 ra_meta_pages_cond(sbi, blkaddr);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900271 }
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700272 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900273 return err;
274}
275
Gu Zheng5ebefc52013-06-27 09:28:54 +0800276static void destroy_fsync_dnodes(struct list_head *head)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900277{
Dan Carpenterd8b79b22013-01-20 18:02:58 +0300278 struct fsync_inode_entry *entry, *tmp;
279
280 list_for_each_entry_safe(entry, tmp, head, list) {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900281 iput(entry->inode);
282 list_del(&entry->list);
283 kmem_cache_free(fsync_entry_slab, entry);
284 }
285}
286
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900287static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900288 block_t blkaddr, struct dnode_of_data *dn)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900289{
290 struct seg_entry *sentry;
291 unsigned int segno = GET_SEGNO(sbi, blkaddr);
Jaegeuk Kim491c0852014-02-04 13:01:10 +0900292 unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900293 struct f2fs_summary_block *sum_node;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900294 struct f2fs_summary sum;
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900295 struct page *sum_page, *node_page;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700296 struct dnode_of_data tdn = *dn;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900297 nid_t ino, nid;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900298 struct inode *inode;
Jaegeuk Kimde936532013-08-12 21:08:03 +0900299 unsigned int offset;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900300 block_t bidx;
301 int i;
302
303 sentry = get_seg_entry(sbi, segno);
304 if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900305 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900306
307 /* Get the previous summary */
308 for (i = CURSEG_WARM_DATA; i <= CURSEG_COLD_DATA; i++) {
309 struct curseg_info *curseg = CURSEG_I(sbi, i);
310 if (curseg->segno == segno) {
311 sum = curseg->sum_blk->entries[blkoff];
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900312 goto got_it;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900313 }
314 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900315
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900316 sum_page = get_sum_page(sbi, segno);
317 sum_node = (struct f2fs_summary_block *)page_address(sum_page);
318 sum = sum_node->entries[blkoff];
319 f2fs_put_page(sum_page, 1);
320got_it:
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900321 /* Use the locked dnode page and inode */
322 nid = le32_to_cpu(sum.nid);
323 if (dn->inode->i_ino == nid) {
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900324 tdn.nid = nid;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700325 if (!dn->inode_page_locked)
326 lock_page(dn->inode_page);
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900327 tdn.node_page = dn->inode_page;
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900328 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700329 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900330 } else if (dn->nid == nid) {
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900331 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700332 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900333 }
334
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900335 /* Get the node page */
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900336 node_page = get_node_page(sbi, nid);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900337 if (IS_ERR(node_page))
338 return PTR_ERR(node_page);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900339
340 offset = ofs_of_node(node_page);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900341 ino = ino_of_node(node_page);
342 f2fs_put_page(node_page, 1);
343
Jaegeuk Kim60979112014-09-13 00:35:58 +0900344 if (ino != dn->inode->i_ino) {
345 /* Deallocate previous index in the node page */
346 inode = f2fs_iget(sbi->sb, ino);
347 if (IS_ERR(inode))
348 return PTR_ERR(inode);
349 } else {
350 inode = dn->inode;
351 }
Namjae Jeon06025f42012-12-22 12:09:43 +0900352
Jaegeuk Kimde936532013-08-12 21:08:03 +0900353 bidx = start_bidx_of_node(offset, F2FS_I(inode)) +
Jaegeuk Kim60979112014-09-13 00:35:58 +0900354 le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900355
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700356 /*
357 * if inode page is locked, unlock temporarily, but its reference
358 * count keeps alive.
359 */
360 if (ino == dn->inode->i_ino && dn->inode_page_locked)
361 unlock_page(dn->inode_page);
362
363 set_new_dnode(&tdn, inode, NULL, NULL, 0);
364 if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
365 goto out;
366
367 if (tdn.data_blkaddr == blkaddr)
368 truncate_data_blocks_range(&tdn, 1);
369
370 f2fs_put_dnode(&tdn);
371out:
372 if (ino != dn->inode->i_ino)
Jaegeuk Kim60979112014-09-13 00:35:58 +0900373 iput(inode);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700374 else if (dn->inode_page_locked)
375 lock_page(dn->inode_page);
376 return 0;
377
378truncate_out:
379 if (datablock_addr(tdn.node_page, tdn.ofs_in_node) == blkaddr)
380 truncate_data_blocks_range(&tdn, 1);
381 if (dn->inode->i_ino == nid && !dn->inode_page_locked)
382 unlock_page(dn->inode_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900383 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900384}
385
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900386static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900387 struct page *page, block_t blkaddr)
388{
Jaegeuk Kimde936532013-08-12 21:08:03 +0900389 struct f2fs_inode_info *fi = F2FS_I(inode);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900390 unsigned int start, end;
391 struct dnode_of_data dn;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900392 struct node_info ni;
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900393 int err = 0, recovered = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900394
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700395 /* step 1: recover xattr */
396 if (IS_INODE(page)) {
397 recover_inline_xattr(inode, page);
398 } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
Jaegeuk Kimbc4a1f82015-01-22 14:48:28 -0800399 /*
400 * Deprecated; xattr blocks should be found from cold log.
401 * But, we should remain this for backward compatibility.
402 */
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700403 recover_xattr_data(inode, page, blkaddr);
404 goto out;
405 }
Chao Yu70cfed82014-08-02 15:26:04 +0800406
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700407 /* step 2: recover inline data */
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900408 if (recover_inline_data(inode, page))
409 goto out;
410
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700411 /* step 3: recover data indices */
Jaegeuk Kimde936532013-08-12 21:08:03 +0900412 start = start_bidx_of_node(ofs_of_node(page), fi);
Chao Yu6403eb12014-04-26 19:59:52 +0800413 end = start + ADDRS_PER_PAGE(page, fi);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900414
415 set_new_dnode(&dn, inode, NULL, NULL, 0);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900416
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900417 err = get_dnode_of_data(&dn, start, ALLOC_NODE);
Chao Yu72235542015-09-25 17:54:56 +0800418 if (err)
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900419 goto out;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900420
Jaegeuk Kim3cb5ad12014-03-18 13:29:07 +0900421 f2fs_wait_on_page_writeback(dn.node_page, NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900422
423 get_node_info(sbi, dn.nid, &ni);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700424 f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
425 f2fs_bug_on(sbi, ofs_of_node(dn.node_page) != ofs_of_node(page));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900426
Chao Yu12a83432015-08-05 17:23:54 +0800427 for (; start < end; start++, dn.ofs_in_node++) {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900428 block_t src, dest;
429
430 src = datablock_addr(dn.node_page, dn.ofs_in_node);
431 dest = datablock_addr(page, dn.ofs_in_node);
432
Chao Yu12a83432015-08-05 17:23:54 +0800433 /* skip recovering if dest is the same as src */
434 if (src == dest)
435 continue;
436
437 /* dest is invalid, just invalidate src block */
438 if (dest == NULL_ADDR) {
439 truncate_data_blocks_range(&dn, 1);
440 continue;
441 }
442
443 /*
444 * dest is reserved block, invalidate src block
445 * and then reserve one new block in dnode page.
446 */
447 if (dest == NEW_ADDR) {
448 truncate_data_blocks_range(&dn, 1);
449 err = reserve_new_block(&dn);
450 f2fs_bug_on(sbi, err);
451 continue;
452 }
453
454 /* dest is valid block, try to recover from src to dest */
455 if (is_valid_blkaddr(sbi, dest, META_POR)) {
Jaegeuk Kime03b07d2015-04-01 19:38:20 -0700456
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900457 if (src == NULL_ADDR) {
Jaegeuk Kim5d56b672013-10-29 15:14:54 +0900458 err = reserve_new_block(&dn);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900459 /* We should not get -ENOSPC */
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700460 f2fs_bug_on(sbi, err);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900461 }
462
463 /* Check the previous node page having this index */
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900464 err = check_index_in_prev_nodes(sbi, dest, &dn);
465 if (err)
466 goto err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900467
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900468 /* write dummy data page */
Chao Yu528e3452015-05-28 19:15:35 +0800469 f2fs_replace_block(sbi, &dn, src, dest,
470 ni.version, false);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900471 recovered++;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900472 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900473 }
474
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900475 if (IS_INODE(dn.node_page))
476 sync_inode_page(&dn);
477
478 copy_node_footer(dn.node_page, page);
479 fill_node_footer(dn.node_page, dn.nid, ni.ino,
480 ofs_of_node(page), false);
481 set_page_dirty(dn.node_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900482err:
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900483 f2fs_put_dnode(&dn);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900484out:
Chris Fries6c311ec2014-01-17 14:44:39 -0600485 f2fs_msg(sbi->sb, KERN_NOTICE,
486 "recover_data: ino = %lx, recovered = %d blocks, err = %d",
487 inode->i_ino, recovered, err);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900488 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900489}
490
Chao Yub7973f22015-12-01 11:43:59 +0800491static int recover_data(struct f2fs_sb_info *sbi, struct list_head *head)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900492{
Jaegeuk Kimd71b5562013-08-09 15:03:21 +0900493 unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900494 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700495 struct page *page = NULL;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900496 int err = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900497 block_t blkaddr;
498
499 /* get node pages in the current segment */
Chao Yub7973f22015-12-01 11:43:59 +0800500 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900501 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
502
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900503 while (1) {
504 struct fsync_inode_entry *entry;
505
Chao Yuf0c9cad2015-04-18 18:05:36 +0800506 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900507 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900508
Chao Yu635aee12014-12-08 15:02:52 +0800509 ra_meta_pages_cond(sbi, blkaddr);
510
Chao Yu2b947002015-10-12 17:04:21 +0800511 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700512
513 if (cp_ver != cpver_of_node(page)) {
514 f2fs_put_page(page, 1);
515 break;
516 }
517
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900518 entry = get_fsync_inode(head, ino_of_node(page));
519 if (!entry)
520 goto next;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700521 /*
522 * inode(x) | CP | inode(x) | dnode(F)
523 * In this case, we can lose the latest inode(x).
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700524 * So, call recover_inode for the inode update.
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700525 */
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700526 if (entry->last_inode == blkaddr)
527 recover_inode(entry->inode, page);
528 if (entry->last_dentry == blkaddr) {
529 err = recover_dentry(entry->inode, page);
530 if (err) {
531 f2fs_put_page(page, 1);
532 break;
533 }
534 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900535 err = do_recover_data(sbi, entry->inode, page, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700536 if (err) {
537 f2fs_put_page(page, 1);
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900538 break;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700539 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900540
541 if (entry->blkaddr == blkaddr) {
542 iput(entry->inode);
543 list_del(&entry->list);
544 kmem_cache_free(fsync_entry_slab, entry);
545 }
546next:
547 /* check next segment */
548 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700549 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900550 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900551 if (!err)
552 allocate_new_segments(sbi);
553 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900554}
555
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900556int recover_fsync_data(struct f2fs_sb_info *sbi)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900557{
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700558 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900559 struct list_head inode_list;
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700560 block_t blkaddr;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900561 int err;
Haicheng Liaabe5132013-10-23 12:39:32 +0800562 bool need_writecp = false;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900563
564 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
Gu Zhenge8512d22014-03-07 18:43:28 +0800565 sizeof(struct fsync_inode_entry));
Jaegeuk Kim6bacf522013-12-06 15:00:58 +0900566 if (!fsync_entry_slab)
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900567 return -ENOMEM;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900568
569 INIT_LIST_HEAD(&inode_list);
570
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700571 /* prevent checkpoint */
572 mutex_lock(&sbi->cp_mutex);
573
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700574 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
575
Jaegeuk Kim315df832015-08-11 12:45:39 -0700576 /* step #1: find fsynced inode numbers */
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900577 err = find_fsync_dnodes(sbi, &inode_list);
578 if (err)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900579 goto out;
580
581 if (list_empty(&inode_list))
582 goto out;
583
Haicheng Liaabe5132013-10-23 12:39:32 +0800584 need_writecp = true;
Chao Yu691c6fd2013-09-24 09:26:24 +0800585
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900586 /* step #2: recover data */
Chao Yub7973f22015-12-01 11:43:59 +0800587 err = recover_data(sbi, &inode_list);
Jaegeuk Kimb3073842014-08-08 10:18:43 -0700588 if (!err)
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700589 f2fs_bug_on(sbi, !list_empty(&inode_list));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900590out:
Gu Zheng5ebefc52013-06-27 09:28:54 +0800591 destroy_fsync_dnodes(&inode_list);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900592 kmem_cache_destroy(fsync_entry_slab);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700593
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700594 /* truncate meta pages to be used by the recovery */
595 truncate_inode_pages_range(META_MAPPING(sbi),
Chao Yu9edcdab2015-09-11 14:43:52 +0800596 (loff_t)MAIN_BLKADDR(sbi) << PAGE_CACHE_SHIFT, -1);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700597
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700598 if (err) {
599 truncate_inode_pages_final(NODE_MAPPING(sbi));
600 truncate_inode_pages_final(META_MAPPING(sbi));
601 }
602
Chao Yucaf00472015-01-28 17:48:42 +0800603 clear_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700604 if (err) {
Chao Yue90c2d22015-07-28 18:36:47 +0800605 bool invalidate = false;
606
607 if (discard_next_dnode(sbi, blkaddr))
608 invalidate = true;
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700609
610 /* Flush all the NAT/SIT pages */
611 while (get_pages(sbi, F2FS_DIRTY_META))
612 sync_meta_pages(sbi, META, LONG_MAX);
Chao Yue90c2d22015-07-28 18:36:47 +0800613
614 /* invalidate temporary meta page */
615 if (invalidate)
616 invalidate_mapping_pages(META_MAPPING(sbi),
617 blkaddr, blkaddr);
618
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700619 set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
620 mutex_unlock(&sbi->cp_mutex);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700621 } else if (need_writecp) {
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700622 struct cp_control cpc = {
Jaegeuk Kim10027552015-04-09 17:03:53 -0700623 .reason = CP_RECOVERY,
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700624 };
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700625 mutex_unlock(&sbi->cp_mutex);
Chao Yuc34f42e2015-12-23 17:50:30 +0800626 err = write_checkpoint(sbi, &cpc);
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700627 } else {
628 mutex_unlock(&sbi->cp_mutex);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700629 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900630 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900631}