blob: 2b2532903b433274e0c5d28ff0af33311290452b [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
Chao Yu3f8ab272016-04-29 20:13:37 +080070static struct fsync_inode_entry *add_fsync_inode(struct list_head *head,
71 struct inode *inode)
72{
73 struct fsync_inode_entry *entry;
74
75 entry = kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
76 if (!entry)
77 return NULL;
78
79 entry->inode = inode;
80 list_add_tail(&entry->list, head);
81
82 return entry;
83}
84
85static void del_fsync_inode(struct fsync_inode_entry *entry)
86{
87 iput(entry->inode);
88 list_del(&entry->list);
89 kmem_cache_free(fsync_entry_slab, entry);
90}
91
Chao Yuf61cce52016-05-07 16:15:05 +080092static int recover_dentry(struct inode *inode, struct page *ipage,
93 struct list_head *dir_list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +090094{
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +090095 struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
Jaegeuk Kim74d0b912013-05-15 16:40:02 +090096 nid_t pino = le32_to_cpu(raw_inode->i_pino);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +090097 struct f2fs_dir_entry *de;
Al Virob7f7a5e2013-01-25 16:15:43 -050098 struct qstr name;
Jaegeuk Kimd624c962012-11-02 17:13:32 +090099 struct page *page;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900100 struct inode *dir, *einode;
Chao Yuf61cce52016-05-07 16:15:05 +0800101 struct fsync_inode_entry *entry;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900102 int err = 0;
103
Chao Yuf61cce52016-05-07 16:15:05 +0800104 entry = get_fsync_inode(dir_list, pino);
105 if (!entry) {
106 dir = f2fs_iget(inode->i_sb, pino);
107 if (IS_ERR(dir)) {
108 err = PTR_ERR(dir);
109 goto out;
110 }
111
112 entry = add_fsync_inode(dir_list, dir);
113 if (!entry) {
114 err = -ENOMEM;
115 iput(dir);
116 goto out;
117 }
Jaegeuk Kimed57c272014-04-15 11:19:28 +0900118 }
119
Chao Yuf61cce52016-05-07 16:15:05 +0800120 dir = entry->inode;
121
122 if (file_enc_name(inode))
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700123 return 0;
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700124
Al Virob7f7a5e2013-01-25 16:15:43 -0500125 name.len = le32_to_cpu(raw_inode->i_namelen);
126 name.name = raw_inode->i_name;
Chao Yud96b14312013-12-23 11:12:21 +0800127
128 if (unlikely(name.len > F2FS_NAME_LEN)) {
129 WARN_ON(1);
130 err = -ENAMETOOLONG;
Chao Yuf61cce52016-05-07 16:15:05 +0800131 goto out;
Chao Yud96b14312013-12-23 11:12:21 +0800132 }
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900133retry:
134 de = f2fs_find_entry(dir, &name, &page);
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700135 if (de && inode->i_ino == le32_to_cpu(de->ino))
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500136 goto out_unmap_put;
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700137
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900138 if (de) {
139 einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino));
140 if (IS_ERR(einode)) {
141 WARN_ON(1);
Chao Yu5c1f9922014-04-28 17:58:34 +0800142 err = PTR_ERR(einode);
143 if (err == -ENOENT)
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900144 err = -EEXIST;
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500145 goto out_unmap_put;
146 }
Jaegeuk Kim40813632014-09-02 15:31:18 -0700147 err = acquire_orphan_inode(F2FS_I_SB(inode));
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500148 if (err) {
149 iput(einode);
150 goto out_unmap_put;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900151 }
Chao Yudbeacf02014-09-24 18:17:04 +0800152 f2fs_delete_entry(de, page, dir, einode);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900153 iput(einode);
154 goto retry;
155 }
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700156 err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);
Jaegeuk Kim86928f92014-06-07 03:05:03 +0900157
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500158 goto out;
159
160out_unmap_put:
Jaegeuk Kim9486ba42014-11-21 16:36:28 -0800161 f2fs_dentry_kunmap(dir, page);
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500162 f2fs_put_page(page, 0);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900163out:
Chris Fries6c311ec2014-01-17 14:44:39 -0600164 f2fs_msg(inode->i_sb, KERN_NOTICE,
165 "%s: ino = %x, name = %s, dir = %lx, err = %d",
166 __func__, ino_of_node(ipage), raw_inode->i_name,
Dan Carpenterf28c06f2013-05-23 13:02:13 +0300167 IS_ERR(dir) ? 0 : dir->i_ino, err);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900168 return err;
169}
170
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700171static void recover_inode(struct inode *inode, struct page *page)
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700172{
173 struct f2fs_inode *raw = F2FS_INODE(page);
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700174 char *name;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700175
176 inode->i_mode = le16_to_cpu(raw->i_mode);
177 i_size_write(inode, le64_to_cpu(raw->i_size));
178 inode->i_atime.tv_sec = le64_to_cpu(raw->i_mtime);
179 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
180 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
181 inode->i_atime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
182 inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
183 inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900184
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700185 if (file_enc_name(inode))
186 name = "<encrypted>";
187 else
188 name = F2FS_INODE(page)->i_name;
189
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900190 f2fs_msg(inode->i_sb, KERN_NOTICE, "recover_inode: ino = %x, name = %s",
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700191 ino_of_node(page), name);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900192}
193
Jaegeuk Kim807b1e12015-12-03 14:14:40 -0800194static bool is_same_inode(struct inode *inode, struct page *ipage)
195{
196 struct f2fs_inode *ri = F2FS_INODE(ipage);
197 struct timespec disk;
198
199 if (!IS_INODE(ipage))
200 return true;
201
202 disk.tv_sec = le64_to_cpu(ri->i_ctime);
203 disk.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
204 if (timespec_compare(&inode->i_ctime, &disk) > 0)
205 return false;
206
207 disk.tv_sec = le64_to_cpu(ri->i_atime);
208 disk.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
209 if (timespec_compare(&inode->i_atime, &disk) > 0)
210 return false;
211
212 disk.tv_sec = le64_to_cpu(ri->i_mtime);
213 disk.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
214 if (timespec_compare(&inode->i_mtime, &disk) > 0)
215 return false;
216
217 return true;
218}
219
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900220static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
221{
Jaegeuk Kimd71b5562013-08-09 15:03:21 +0900222 unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900223 struct curseg_info *curseg;
Chao Yu3f8ab272016-04-29 20:13:37 +0800224 struct inode *inode;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700225 struct page *page = NULL;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900226 block_t blkaddr;
227 int err = 0;
228
229 /* get node pages in the current segment */
230 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Chao Yu695fd1e2014-02-27 19:52:21 +0800231 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900232
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900233 while (1) {
234 struct fsync_inode_entry *entry;
235
Chao Yuf0c9cad2015-04-18 18:05:36 +0800236 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700237 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900238
Chao Yu2b947002015-10-12 17:04:21 +0800239 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim393ff912013-03-08 21:29:23 +0900240
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900241 if (cp_ver != cpver_of_node(page))
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900242 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900243
244 if (!is_fsync_dnode(page))
245 goto next;
246
247 entry = get_fsync_inode(head, ino_of_node(page));
Jaegeuk Kim807b1e12015-12-03 14:14:40 -0800248 if (entry) {
249 if (!is_same_inode(entry->inode, page))
250 goto next;
251 } else {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900252 if (IS_INODE(page) && is_dent_dnode(page)) {
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900253 err = recover_inode_page(sbi, page);
254 if (err)
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900255 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900256 }
257
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700258 /*
259 * CP | dnode(F) | inode(DF)
260 * For this case, we should not give up now.
261 */
Chao Yu3f8ab272016-04-29 20:13:37 +0800262 inode = f2fs_iget(sbi->sb, ino_of_node(page));
263 if (IS_ERR(inode)) {
264 err = PTR_ERR(inode);
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800265 if (err == -ENOENT) {
266 err = 0;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700267 goto next;
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800268 }
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900269 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900270 }
Chao Yu3f8ab272016-04-29 20:13:37 +0800271
272 /* add this fsync inode to the list */
273 entry = add_fsync_inode(head, inode);
274 if (!entry) {
275 err = -ENOMEM;
276 iput(inode);
277 break;
278 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900279 }
Jaegeuk Kimaddbe452013-05-15 10:49:13 +0900280 entry->blkaddr = blkaddr;
281
Jaegeuk Kim608514d2016-04-15 09:43:17 -0700282 if (IS_INODE(page) && is_dent_dnode(page))
283 entry->last_dentry = blkaddr;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900284next:
285 /* check next segment */
286 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700287 f2fs_put_page(page, 1);
Chao Yu635aee12014-12-08 15:02:52 +0800288
289 ra_meta_pages_cond(sbi, blkaddr);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900290 }
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700291 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900292 return err;
293}
294
Gu Zheng5ebefc52013-06-27 09:28:54 +0800295static void destroy_fsync_dnodes(struct list_head *head)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900296{
Dan Carpenterd8b79b22013-01-20 18:02:58 +0300297 struct fsync_inode_entry *entry, *tmp;
298
Chao Yu3f8ab272016-04-29 20:13:37 +0800299 list_for_each_entry_safe(entry, tmp, head, list)
300 del_fsync_inode(entry);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900301}
302
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900303static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900304 block_t blkaddr, struct dnode_of_data *dn)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900305{
306 struct seg_entry *sentry;
307 unsigned int segno = GET_SEGNO(sbi, blkaddr);
Jaegeuk Kim491c0852014-02-04 13:01:10 +0900308 unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900309 struct f2fs_summary_block *sum_node;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900310 struct f2fs_summary sum;
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900311 struct page *sum_page, *node_page;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700312 struct dnode_of_data tdn = *dn;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900313 nid_t ino, nid;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900314 struct inode *inode;
Jaegeuk Kimde936532013-08-12 21:08:03 +0900315 unsigned int offset;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900316 block_t bidx;
317 int i;
318
319 sentry = get_seg_entry(sbi, segno);
320 if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900321 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900322
323 /* Get the previous summary */
324 for (i = CURSEG_WARM_DATA; i <= CURSEG_COLD_DATA; i++) {
325 struct curseg_info *curseg = CURSEG_I(sbi, i);
326 if (curseg->segno == segno) {
327 sum = curseg->sum_blk->entries[blkoff];
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900328 goto got_it;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900329 }
330 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900331
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900332 sum_page = get_sum_page(sbi, segno);
333 sum_node = (struct f2fs_summary_block *)page_address(sum_page);
334 sum = sum_node->entries[blkoff];
335 f2fs_put_page(sum_page, 1);
336got_it:
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900337 /* Use the locked dnode page and inode */
338 nid = le32_to_cpu(sum.nid);
339 if (dn->inode->i_ino == nid) {
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900340 tdn.nid = nid;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700341 if (!dn->inode_page_locked)
342 lock_page(dn->inode_page);
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900343 tdn.node_page = dn->inode_page;
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900344 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700345 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900346 } else if (dn->nid == nid) {
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900347 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700348 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900349 }
350
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900351 /* Get the node page */
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900352 node_page = get_node_page(sbi, nid);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900353 if (IS_ERR(node_page))
354 return PTR_ERR(node_page);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900355
356 offset = ofs_of_node(node_page);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900357 ino = ino_of_node(node_page);
358 f2fs_put_page(node_page, 1);
359
Jaegeuk Kim60979112014-09-13 00:35:58 +0900360 if (ino != dn->inode->i_ino) {
361 /* Deallocate previous index in the node page */
362 inode = f2fs_iget(sbi->sb, ino);
363 if (IS_ERR(inode))
364 return PTR_ERR(inode);
365 } else {
366 inode = dn->inode;
367 }
Namjae Jeon06025f42012-12-22 12:09:43 +0900368
Chao Yu81ca7352016-01-26 15:39:35 +0800369 bidx = start_bidx_of_node(offset, inode) + le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900370
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700371 /*
372 * if inode page is locked, unlock temporarily, but its reference
373 * count keeps alive.
374 */
375 if (ino == dn->inode->i_ino && dn->inode_page_locked)
376 unlock_page(dn->inode_page);
377
378 set_new_dnode(&tdn, inode, NULL, NULL, 0);
379 if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
380 goto out;
381
382 if (tdn.data_blkaddr == blkaddr)
383 truncate_data_blocks_range(&tdn, 1);
384
385 f2fs_put_dnode(&tdn);
386out:
387 if (ino != dn->inode->i_ino)
Jaegeuk Kim60979112014-09-13 00:35:58 +0900388 iput(inode);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700389 else if (dn->inode_page_locked)
390 lock_page(dn->inode_page);
391 return 0;
392
393truncate_out:
394 if (datablock_addr(tdn.node_page, tdn.ofs_in_node) == blkaddr)
395 truncate_data_blocks_range(&tdn, 1);
396 if (dn->inode->i_ino == nid && !dn->inode_page_locked)
397 unlock_page(dn->inode_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900398 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900399}
400
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900401static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900402 struct page *page, block_t blkaddr)
403{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900404 struct dnode_of_data dn;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900405 struct node_info ni;
Chao Yu81ca7352016-01-26 15:39:35 +0800406 unsigned int start, end;
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900407 int err = 0, recovered = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900408
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700409 /* step 1: recover xattr */
410 if (IS_INODE(page)) {
411 recover_inline_xattr(inode, page);
412 } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
Jaegeuk Kimbc4a1f82015-01-22 14:48:28 -0800413 /*
414 * Deprecated; xattr blocks should be found from cold log.
415 * But, we should remain this for backward compatibility.
416 */
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700417 recover_xattr_data(inode, page, blkaddr);
418 goto out;
419 }
Chao Yu70cfed82014-08-02 15:26:04 +0800420
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700421 /* step 2: recover inline data */
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900422 if (recover_inline_data(inode, page))
423 goto out;
424
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700425 /* step 3: recover data indices */
Chao Yu81ca7352016-01-26 15:39:35 +0800426 start = start_bidx_of_node(ofs_of_node(page), inode);
427 end = start + ADDRS_PER_PAGE(page, inode);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900428
429 set_new_dnode(&dn, inode, NULL, NULL, 0);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900430
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900431 err = get_dnode_of_data(&dn, start, ALLOC_NODE);
Chao Yu72235542015-09-25 17:54:56 +0800432 if (err)
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900433 goto out;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900434
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800435 f2fs_wait_on_page_writeback(dn.node_page, NODE, true);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900436
437 get_node_info(sbi, dn.nid, &ni);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700438 f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
439 f2fs_bug_on(sbi, ofs_of_node(dn.node_page) != ofs_of_node(page));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900440
Chao Yu12a83432015-08-05 17:23:54 +0800441 for (; start < end; start++, dn.ofs_in_node++) {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900442 block_t src, dest;
443
444 src = datablock_addr(dn.node_page, dn.ofs_in_node);
445 dest = datablock_addr(page, dn.ofs_in_node);
446
Chao Yu12a83432015-08-05 17:23:54 +0800447 /* skip recovering if dest is the same as src */
448 if (src == dest)
449 continue;
450
451 /* dest is invalid, just invalidate src block */
452 if (dest == NULL_ADDR) {
453 truncate_data_blocks_range(&dn, 1);
454 continue;
455 }
456
457 /*
458 * dest is reserved block, invalidate src block
459 * and then reserve one new block in dnode page.
460 */
461 if (dest == NEW_ADDR) {
462 truncate_data_blocks_range(&dn, 1);
463 err = reserve_new_block(&dn);
464 f2fs_bug_on(sbi, err);
465 continue;
466 }
467
468 /* dest is valid block, try to recover from src to dest */
469 if (is_valid_blkaddr(sbi, dest, META_POR)) {
Jaegeuk Kime03b07d2015-04-01 19:38:20 -0700470
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900471 if (src == NULL_ADDR) {
Jaegeuk Kim5d56b672013-10-29 15:14:54 +0900472 err = reserve_new_block(&dn);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900473 /* We should not get -ENOSPC */
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700474 f2fs_bug_on(sbi, err);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900475 }
476
477 /* Check the previous node page having this index */
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900478 err = check_index_in_prev_nodes(sbi, dest, &dn);
479 if (err)
480 goto err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900481
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900482 /* write dummy data page */
Chao Yu528e3452015-05-28 19:15:35 +0800483 f2fs_replace_block(sbi, &dn, src, dest,
Chao Yu28bc1062016-02-06 14:40:34 +0800484 ni.version, false, false);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900485 recovered++;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900486 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900487 }
488
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900489 if (IS_INODE(dn.node_page))
490 sync_inode_page(&dn);
491
492 copy_node_footer(dn.node_page, page);
493 fill_node_footer(dn.node_page, dn.nid, ni.ino,
494 ofs_of_node(page), false);
495 set_page_dirty(dn.node_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900496err:
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900497 f2fs_put_dnode(&dn);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900498out:
Chris Fries6c311ec2014-01-17 14:44:39 -0600499 f2fs_msg(sbi->sb, KERN_NOTICE,
500 "recover_data: ino = %lx, recovered = %d blocks, err = %d",
501 inode->i_ino, recovered, err);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900502 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900503}
504
Chao Yuf61cce52016-05-07 16:15:05 +0800505static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
506 struct list_head *dir_list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900507{
Jaegeuk Kimd71b5562013-08-09 15:03:21 +0900508 unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900509 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700510 struct page *page = NULL;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900511 int err = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900512 block_t blkaddr;
513
514 /* get node pages in the current segment */
Chao Yub7973f22015-12-01 11:43:59 +0800515 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900516 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
517
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900518 while (1) {
519 struct fsync_inode_entry *entry;
520
Chao Yuf0c9cad2015-04-18 18:05:36 +0800521 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900522 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900523
Chao Yu635aee12014-12-08 15:02:52 +0800524 ra_meta_pages_cond(sbi, blkaddr);
525
Chao Yu2b947002015-10-12 17:04:21 +0800526 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700527
528 if (cp_ver != cpver_of_node(page)) {
529 f2fs_put_page(page, 1);
530 break;
531 }
532
Chao Yuf61cce52016-05-07 16:15:05 +0800533 entry = get_fsync_inode(inode_list, ino_of_node(page));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900534 if (!entry)
535 goto next;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700536 /*
537 * inode(x) | CP | inode(x) | dnode(F)
538 * In this case, we can lose the latest inode(x).
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700539 * So, call recover_inode for the inode update.
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700540 */
Jaegeuk Kim608514d2016-04-15 09:43:17 -0700541 if (IS_INODE(page))
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700542 recover_inode(entry->inode, page);
543 if (entry->last_dentry == blkaddr) {
Chao Yuf61cce52016-05-07 16:15:05 +0800544 err = recover_dentry(entry->inode, page, dir_list);
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700545 if (err) {
546 f2fs_put_page(page, 1);
547 break;
548 }
549 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900550 err = do_recover_data(sbi, entry->inode, page, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700551 if (err) {
552 f2fs_put_page(page, 1);
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900553 break;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700554 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900555
Chao Yu3f8ab272016-04-29 20:13:37 +0800556 if (entry->blkaddr == blkaddr)
557 del_fsync_inode(entry);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900558next:
559 /* check next segment */
560 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700561 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900562 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900563 if (!err)
564 allocate_new_segments(sbi);
565 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900566}
567
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700568int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900569{
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700570 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900571 struct list_head inode_list;
Chao Yuf61cce52016-05-07 16:15:05 +0800572 struct list_head dir_list;
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700573 block_t blkaddr;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900574 int err;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700575 int ret = 0;
Haicheng Liaabe5132013-10-23 12:39:32 +0800576 bool need_writecp = false;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900577
578 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
Gu Zhenge8512d22014-03-07 18:43:28 +0800579 sizeof(struct fsync_inode_entry));
Jaegeuk Kim6bacf522013-12-06 15:00:58 +0900580 if (!fsync_entry_slab)
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900581 return -ENOMEM;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900582
583 INIT_LIST_HEAD(&inode_list);
Chao Yuf61cce52016-05-07 16:15:05 +0800584 INIT_LIST_HEAD(&dir_list);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900585
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700586 /* prevent checkpoint */
587 mutex_lock(&sbi->cp_mutex);
588
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700589 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
590
Jaegeuk Kim315df832015-08-11 12:45:39 -0700591 /* step #1: find fsynced inode numbers */
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900592 err = find_fsync_dnodes(sbi, &inode_list);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700593 if (err || list_empty(&inode_list))
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900594 goto out;
595
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700596 if (check_only) {
597 ret = 1;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900598 goto out;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700599 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900600
Haicheng Liaabe5132013-10-23 12:39:32 +0800601 need_writecp = true;
Chao Yu691c6fd2013-09-24 09:26:24 +0800602
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900603 /* step #2: recover data */
Chao Yuf61cce52016-05-07 16:15:05 +0800604 err = recover_data(sbi, &inode_list, &dir_list);
Jaegeuk Kimb3073842014-08-08 10:18:43 -0700605 if (!err)
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700606 f2fs_bug_on(sbi, !list_empty(&inode_list));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900607out:
Gu Zheng5ebefc52013-06-27 09:28:54 +0800608 destroy_fsync_dnodes(&inode_list);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700609
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700610 /* truncate meta pages to be used by the recovery */
611 truncate_inode_pages_range(META_MAPPING(sbi),
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300612 (loff_t)MAIN_BLKADDR(sbi) << PAGE_SHIFT, -1);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700613
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700614 if (err) {
615 truncate_inode_pages_final(NODE_MAPPING(sbi));
616 truncate_inode_pages_final(META_MAPPING(sbi));
617 }
618
Chao Yucaf00472015-01-28 17:48:42 +0800619 clear_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700620 if (err) {
Chao Yue90c2d22015-07-28 18:36:47 +0800621 bool invalidate = false;
622
623 if (discard_next_dnode(sbi, blkaddr))
624 invalidate = true;
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700625
626 /* Flush all the NAT/SIT pages */
627 while (get_pages(sbi, F2FS_DIRTY_META))
628 sync_meta_pages(sbi, META, LONG_MAX);
Chao Yue90c2d22015-07-28 18:36:47 +0800629
630 /* invalidate temporary meta page */
631 if (invalidate)
632 invalidate_mapping_pages(META_MAPPING(sbi),
633 blkaddr, blkaddr);
634
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700635 set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
636 mutex_unlock(&sbi->cp_mutex);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700637 } else if (need_writecp) {
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700638 struct cp_control cpc = {
Jaegeuk Kim10027552015-04-09 17:03:53 -0700639 .reason = CP_RECOVERY,
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700640 };
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700641 mutex_unlock(&sbi->cp_mutex);
Chao Yuc34f42e2015-12-23 17:50:30 +0800642 err = write_checkpoint(sbi, &cpc);
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700643 } else {
644 mutex_unlock(&sbi->cp_mutex);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700645 }
Chao Yuf61cce52016-05-07 16:15:05 +0800646
647 destroy_fsync_dnodes(&dir_list);
648 kmem_cache_destroy(fsync_entry_slab);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700649 return ret ? ret: err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900650}