blob: 2fc84a99132526cdd547eefdbab088f15d437531 [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,
72 struct list_head *head, nid_t ino)
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;
76
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -070077 inode = f2fs_iget_retry(sbi->sb, ino);
Jaegeuk Kimf4702d62016-09-09 16:48:15 -070078 if (IS_ERR(inode))
79 return ERR_CAST(inode);
80
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -070081 entry = f2fs_kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
Chao Yu3f8ab272016-04-29 20:13:37 +080082 entry->inode = inode;
83 list_add_tail(&entry->list, head);
84
85 return entry;
86}
87
88static void del_fsync_inode(struct fsync_inode_entry *entry)
89{
90 iput(entry->inode);
91 list_del(&entry->list);
92 kmem_cache_free(fsync_entry_slab, entry);
93}
94
Chao Yuf61cce52016-05-07 16:15:05 +080095static int recover_dentry(struct inode *inode, struct page *ipage,
96 struct list_head *dir_list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +090097{
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +090098 struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
Jaegeuk Kim74d0b912013-05-15 16:40:02 +090099 nid_t pino = le32_to_cpu(raw_inode->i_pino);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900100 struct f2fs_dir_entry *de;
Shuoran Liue7ba1082016-08-29 11:27:56 +0800101 struct fscrypt_name fname;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900102 struct page *page;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900103 struct inode *dir, *einode;
Chao Yuf61cce52016-05-07 16:15:05 +0800104 struct fsync_inode_entry *entry;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900105 int err = 0;
Shuoran Liue7ba1082016-08-29 11:27:56 +0800106 char *name;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900107
Chao Yuf61cce52016-05-07 16:15:05 +0800108 entry = get_fsync_inode(dir_list, pino);
109 if (!entry) {
Jaegeuk Kimf4702d62016-09-09 16:48:15 -0700110 entry = add_fsync_inode(F2FS_I_SB(inode), dir_list, pino);
111 if (IS_ERR(entry)) {
112 dir = ERR_CAST(entry);
113 err = PTR_ERR(entry);
Chao Yuf61cce52016-05-07 16:15:05 +0800114 goto out;
115 }
Jaegeuk Kimed57c272014-04-15 11:19:28 +0900116 }
117
Chao Yuf61cce52016-05-07 16:15:05 +0800118 dir = entry->inode;
119
Shuoran Liue7ba1082016-08-29 11:27:56 +0800120 memset(&fname, 0, sizeof(struct fscrypt_name));
121 fname.disk_name.len = le32_to_cpu(raw_inode->i_namelen);
122 fname.disk_name.name = raw_inode->i_name;
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700123
Shuoran Liue7ba1082016-08-29 11:27:56 +0800124 if (unlikely(fname.disk_name.len > F2FS_NAME_LEN)) {
Chao Yud96b14312013-12-23 11:12:21 +0800125 WARN_ON(1);
126 err = -ENAMETOOLONG;
Chao Yuf61cce52016-05-07 16:15:05 +0800127 goto out;
Chao Yud96b14312013-12-23 11:12:21 +0800128 }
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900129retry:
Shuoran Liue7ba1082016-08-29 11:27:56 +0800130 de = __f2fs_find_entry(dir, &fname, &page);
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700131 if (de && inode->i_ino == le32_to_cpu(de->ino))
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500132 goto out_unmap_put;
Jaegeuk Kim418f6c22015-03-31 18:03:29 -0700133
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900134 if (de) {
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700135 einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900136 if (IS_ERR(einode)) {
137 WARN_ON(1);
Chao Yu5c1f9922014-04-28 17:58:34 +0800138 err = PTR_ERR(einode);
139 if (err == -ENOENT)
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900140 err = -EEXIST;
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500141 goto out_unmap_put;
142 }
Jaegeuk Kim40813632014-09-02 15:31:18 -0700143 err = acquire_orphan_inode(F2FS_I_SB(inode));
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500144 if (err) {
145 iput(einode);
146 goto out_unmap_put;
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900147 }
Chao Yudbeacf02014-09-24 18:17:04 +0800148 f2fs_delete_entry(de, page, dir, einode);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900149 iput(einode);
150 goto retry;
Chao Yu91246c22016-07-19 08:27:47 +0800151 } else if (IS_ERR(page)) {
152 err = PTR_ERR(page);
153 } else {
Shuoran Liue7ba1082016-08-29 11:27:56 +0800154 err = __f2fs_do_add_link(dir, &fname, inode,
Chao Yu91246c22016-07-19 08:27:47 +0800155 inode->i_ino, inode->i_mode);
Jaegeuk Kim6b8213d2013-05-28 09:19:22 +0900156 }
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700157 if (err == -ENOMEM)
158 goto retry;
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500159 goto out;
160
161out_unmap_put:
Jaegeuk Kim9486ba4422014-11-21 16:36:28 -0800162 f2fs_dentry_kunmap(dir, page);
Russ W. Knize2e5558f2013-09-24 09:40:57 -0500163 f2fs_put_page(page, 0);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900164out:
Shuoran Liue7ba1082016-08-29 11:27:56 +0800165 if (file_enc_name(inode))
166 name = "<encrypted>";
167 else
168 name = raw_inode->i_name;
Chris Fries6c311ec2014-01-17 14:44:39 -0600169 f2fs_msg(inode->i_sb, KERN_NOTICE,
170 "%s: ino = %x, name = %s, dir = %lx, err = %d",
Shuoran Liue7ba1082016-08-29 11:27:56 +0800171 __func__, ino_of_node(ipage), name,
Dan Carpenterf28c06f2013-05-23 13:02:13 +0300172 IS_ERR(dir) ? 0 : dir->i_ino, err);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900173 return err;
174}
175
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700176static void recover_inode(struct inode *inode, struct page *page)
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700177{
178 struct f2fs_inode *raw = F2FS_INODE(page);
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700179 char *name;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700180
181 inode->i_mode = le16_to_cpu(raw->i_mode);
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700182 f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700183 inode->i_atime.tv_sec = le64_to_cpu(raw->i_mtime);
184 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
185 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
186 inode->i_atime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
187 inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
188 inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900189
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700190 if (file_enc_name(inode))
191 name = "<encrypted>";
192 else
193 name = F2FS_INODE(page)->i_name;
194
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900195 f2fs_msg(inode->i_sb, KERN_NOTICE, "recover_inode: ino = %x, name = %s",
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700196 ino_of_node(page), name);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900197}
198
Jaegeuk Kim807b1e12015-12-03 14:14:40 -0800199static bool is_same_inode(struct inode *inode, struct page *ipage)
200{
201 struct f2fs_inode *ri = F2FS_INODE(ipage);
202 struct timespec disk;
203
204 if (!IS_INODE(ipage))
205 return true;
206
207 disk.tv_sec = le64_to_cpu(ri->i_ctime);
208 disk.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
209 if (timespec_compare(&inode->i_ctime, &disk) > 0)
210 return false;
211
212 disk.tv_sec = le64_to_cpu(ri->i_atime);
213 disk.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
214 if (timespec_compare(&inode->i_atime, &disk) > 0)
215 return false;
216
217 disk.tv_sec = le64_to_cpu(ri->i_mtime);
218 disk.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
219 if (timespec_compare(&inode->i_mtime, &disk) > 0)
220 return false;
221
222 return true;
223}
224
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900225static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
226{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900227 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700228 struct page *page = NULL;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900229 block_t blkaddr;
230 int err = 0;
231
232 /* get node pages in the current segment */
233 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Chao Yu695fd1e2014-02-27 19:52:21 +0800234 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900235
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900236 while (1) {
237 struct fsync_inode_entry *entry;
238
Chao Yuf0c9cad2015-04-18 18:05:36 +0800239 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700240 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900241
Chao Yu2b947002015-10-12 17:04:21 +0800242 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim393ff912013-03-08 21:29:23 +0900243
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700244 if (!is_recoverable_dnode(page))
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900245 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900246
247 if (!is_fsync_dnode(page))
248 goto next;
249
250 entry = get_fsync_inode(head, ino_of_node(page));
Jaegeuk Kim807b1e12015-12-03 14:14:40 -0800251 if (entry) {
252 if (!is_same_inode(entry->inode, page))
253 goto next;
254 } else {
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900255 if (IS_INODE(page) && is_dent_dnode(page)) {
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900256 err = recover_inode_page(sbi, page);
257 if (err)
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900258 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900259 }
260
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700261 /*
262 * CP | dnode(F) | inode(DF)
263 * For this case, we should not give up now.
264 */
Jaegeuk Kimf4702d62016-09-09 16:48:15 -0700265 entry = add_fsync_inode(sbi, head, ino_of_node(page));
266 if (IS_ERR(entry)) {
267 err = PTR_ERR(entry);
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800268 if (err == -ENOENT) {
269 err = 0;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700270 goto next;
Jaegeuk Kim8fbc4182015-02-24 18:01:46 -0800271 }
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900272 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900273 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900274 }
Jaegeuk Kimaddbe452013-05-15 10:49:13 +0900275 entry->blkaddr = blkaddr;
276
Jaegeuk Kim608514d2016-04-15 09:43:17 -0700277 if (IS_INODE(page) && is_dent_dnode(page))
278 entry->last_dentry = blkaddr;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900279next:
280 /* check next segment */
281 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700282 f2fs_put_page(page, 1);
Chao Yu635aee12014-12-08 15:02:52 +0800283
284 ra_meta_pages_cond(sbi, blkaddr);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900285 }
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700286 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900287 return err;
288}
289
Gu Zheng5ebefc52013-06-27 09:28:54 +0800290static void destroy_fsync_dnodes(struct list_head *head)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900291{
Dan Carpenterd8b79b22013-01-20 18:02:58 +0300292 struct fsync_inode_entry *entry, *tmp;
293
Chao Yu3f8ab272016-04-29 20:13:37 +0800294 list_for_each_entry_safe(entry, tmp, head, list)
295 del_fsync_inode(entry);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900296}
297
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900298static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900299 block_t blkaddr, struct dnode_of_data *dn)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900300{
301 struct seg_entry *sentry;
302 unsigned int segno = GET_SEGNO(sbi, blkaddr);
Jaegeuk Kim491c0852014-02-04 13:01:10 +0900303 unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900304 struct f2fs_summary_block *sum_node;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900305 struct f2fs_summary sum;
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900306 struct page *sum_page, *node_page;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700307 struct dnode_of_data tdn = *dn;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900308 nid_t ino, nid;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900309 struct inode *inode;
Jaegeuk Kimde936532013-08-12 21:08:03 +0900310 unsigned int offset;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900311 block_t bidx;
312 int i;
313
314 sentry = get_seg_entry(sbi, segno);
315 if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900316 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900317
318 /* Get the previous summary */
319 for (i = CURSEG_WARM_DATA; i <= CURSEG_COLD_DATA; i++) {
320 struct curseg_info *curseg = CURSEG_I(sbi, i);
321 if (curseg->segno == segno) {
322 sum = curseg->sum_blk->entries[blkoff];
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900323 goto got_it;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900324 }
325 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900326
Jaegeuk Kimf6517cf2014-01-28 14:54:07 +0900327 sum_page = get_sum_page(sbi, segno);
328 sum_node = (struct f2fs_summary_block *)page_address(sum_page);
329 sum = sum_node->entries[blkoff];
330 f2fs_put_page(sum_page, 1);
331got_it:
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900332 /* Use the locked dnode page and inode */
333 nid = le32_to_cpu(sum.nid);
334 if (dn->inode->i_ino == nid) {
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900335 tdn.nid = nid;
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700336 if (!dn->inode_page_locked)
337 lock_page(dn->inode_page);
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900338 tdn.node_page = dn->inode_page;
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900339 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700340 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900341 } else if (dn->nid == nid) {
Jaegeuk Kim060dd672013-06-24 07:47:23 +0900342 tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700343 goto truncate_out;
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900344 }
345
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900346 /* Get the node page */
Jaegeuk Kimb292dcab2013-05-22 08:02:02 +0900347 node_page = get_node_page(sbi, nid);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900348 if (IS_ERR(node_page))
349 return PTR_ERR(node_page);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900350
351 offset = ofs_of_node(node_page);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900352 ino = ino_of_node(node_page);
353 f2fs_put_page(node_page, 1);
354
Jaegeuk Kim60979112014-09-13 00:35:58 +0900355 if (ino != dn->inode->i_ino) {
356 /* Deallocate previous index in the node page */
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700357 inode = f2fs_iget_retry(sbi->sb, ino);
Jaegeuk Kim60979112014-09-13 00:35:58 +0900358 if (IS_ERR(inode))
359 return PTR_ERR(inode);
360 } else {
361 inode = dn->inode;
362 }
Namjae Jeon06025f42012-12-22 12:09:43 +0900363
Chao Yu81ca7352016-01-26 15:39:35 +0800364 bidx = start_bidx_of_node(offset, inode) + le16_to_cpu(sum.ofs_in_node);
Jaegeuk Kimde936532013-08-12 21:08:03 +0900365
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700366 /*
367 * if inode page is locked, unlock temporarily, but its reference
368 * count keeps alive.
369 */
370 if (ino == dn->inode->i_ino && dn->inode_page_locked)
371 unlock_page(dn->inode_page);
372
373 set_new_dnode(&tdn, inode, NULL, NULL, 0);
374 if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
375 goto out;
376
377 if (tdn.data_blkaddr == blkaddr)
378 truncate_data_blocks_range(&tdn, 1);
379
380 f2fs_put_dnode(&tdn);
381out:
382 if (ino != dn->inode->i_ino)
Jaegeuk Kim60979112014-09-13 00:35:58 +0900383 iput(inode);
Jaegeuk Kimc9ef4812015-03-26 18:46:38 -0700384 else if (dn->inode_page_locked)
385 lock_page(dn->inode_page);
386 return 0;
387
388truncate_out:
389 if (datablock_addr(tdn.node_page, tdn.ofs_in_node) == blkaddr)
390 truncate_data_blocks_range(&tdn, 1);
391 if (dn->inode->i_ino == nid && !dn->inode_page_locked)
392 unlock_page(dn->inode_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900393 return 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900394}
395
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900396static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900397 struct page *page, block_t blkaddr)
398{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900399 struct dnode_of_data dn;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900400 struct node_info ni;
Chao Yu81ca7352016-01-26 15:39:35 +0800401 unsigned int start, end;
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900402 int err = 0, recovered = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900403
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700404 /* step 1: recover xattr */
405 if (IS_INODE(page)) {
406 recover_inline_xattr(inode, page);
407 } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
Jaegeuk Kimbc4a1f82015-01-22 14:48:28 -0800408 /*
409 * Deprecated; xattr blocks should be found from cold log.
410 * But, we should remain this for backward compatibility.
411 */
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700412 recover_xattr_data(inode, page, blkaddr);
413 goto out;
414 }
Chao Yu70cfed82014-08-02 15:26:04 +0800415
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700416 /* step 2: recover inline data */
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900417 if (recover_inline_data(inode, page))
418 goto out;
419
Jaegeuk Kim1c35a902014-08-07 23:49:17 -0700420 /* step 3: recover data indices */
Chao Yu81ca7352016-01-26 15:39:35 +0800421 start = start_bidx_of_node(ofs_of_node(page), inode);
422 end = start + ADDRS_PER_PAGE(page, inode);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900423
424 set_new_dnode(&dn, inode, NULL, NULL, 0);
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700425retry_dn:
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900426 err = get_dnode_of_data(&dn, start, ALLOC_NODE);
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700427 if (err) {
428 if (err == -ENOMEM) {
429 congestion_wait(BLK_RW_ASYNC, HZ/50);
430 goto retry_dn;
431 }
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900432 goto out;
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700433 }
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
Jaegeuk Kim26de9b12016-05-20 20:42:37 -0700457 if ((start + 1) << PAGE_SHIFT > i_size_read(inode))
458 f2fs_i_size_write(inode, (start + 1) << PAGE_SHIFT);
459
Chao Yu12a83432015-08-05 17:23:54 +0800460 /*
461 * dest is reserved block, invalidate src block
462 * and then reserve one new block in dnode page.
463 */
464 if (dest == NEW_ADDR) {
465 truncate_data_blocks_range(&dn, 1);
Jaegeuk Kim3b9b10f2016-05-11 09:13:13 -0700466 reserve_new_block(&dn);
Chao Yu12a83432015-08-05 17:23:54 +0800467 continue;
468 }
469
470 /* dest is valid block, try to recover from src to dest */
471 if (is_valid_blkaddr(sbi, dest, META_POR)) {
Jaegeuk Kime03b07d2015-04-01 19:38:20 -0700472
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900473 if (src == NULL_ADDR) {
Jaegeuk Kim5d56b672013-10-29 15:14:54 +0900474 err = reserve_new_block(&dn);
Jaegeuk Kim975756c2016-05-19 11:57:21 -0700475#ifdef CONFIG_F2FS_FAULT_INJECTION
476 while (err)
477 err = reserve_new_block(&dn);
478#endif
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900479 /* We should not get -ENOSPC */
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700480 f2fs_bug_on(sbi, err);
Jaegeuk Kim6f3ec992016-07-19 19:30:06 -0700481 if (err)
482 goto err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900483 }
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700484retry_prev:
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900485 /* Check the previous node page having this index */
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900486 err = check_index_in_prev_nodes(sbi, dest, &dn);
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700487 if (err) {
488 if (err == -ENOMEM) {
489 congestion_wait(BLK_RW_ASYNC, HZ/50);
490 goto retry_prev;
491 }
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900492 goto err;
Jaegeuk Kime8ea9b32016-09-09 16:59:39 -0700493 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900494
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900495 /* write dummy data page */
Chao Yu528e3452015-05-28 19:15:35 +0800496 f2fs_replace_block(sbi, &dn, src, dest,
Chao Yu28bc1062016-02-06 14:40:34 +0800497 ni.version, false, false);
Jaegeuk Kimf356fe02013-05-16 15:04:49 +0900498 recovered++;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900499 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900500 }
501
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900502 copy_node_footer(dn.node_page, page);
503 fill_node_footer(dn.node_page, dn.nid, ni.ino,
504 ofs_of_node(page), false);
505 set_page_dirty(dn.node_page);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900506err:
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900507 f2fs_put_dnode(&dn);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900508out:
Chris Fries6c311ec2014-01-17 14:44:39 -0600509 f2fs_msg(sbi->sb, KERN_NOTICE,
510 "recover_data: ino = %lx, recovered = %d blocks, err = %d",
511 inode->i_ino, recovered, err);
Jaegeuk Kim39cf72c2013-05-22 08:20:01 +0900512 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900513}
514
Chao Yuf61cce52016-05-07 16:15:05 +0800515static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
516 struct list_head *dir_list)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900517{
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900518 struct curseg_info *curseg;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700519 struct page *page = NULL;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900520 int err = 0;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900521 block_t blkaddr;
522
523 /* get node pages in the current segment */
Chao Yub7973f22015-12-01 11:43:59 +0800524 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900525 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
526
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900527 while (1) {
528 struct fsync_inode_entry *entry;
529
Chao Yuf0c9cad2015-04-18 18:05:36 +0800530 if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900531 break;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900532
Chao Yu635aee12014-12-08 15:02:52 +0800533 ra_meta_pages_cond(sbi, blkaddr);
534
Chao Yu2b947002015-10-12 17:04:21 +0800535 page = get_tmp_page(sbi, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700536
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700537 if (!is_recoverable_dnode(page)) {
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700538 f2fs_put_page(page, 1);
539 break;
540 }
541
Chao Yuf61cce52016-05-07 16:15:05 +0800542 entry = get_fsync_inode(inode_list, ino_of_node(page));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900543 if (!entry)
544 goto next;
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700545 /*
546 * inode(x) | CP | inode(x) | dnode(F)
547 * In this case, we can lose the latest inode(x).
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700548 * So, call recover_inode for the inode update.
Jaegeuk Kim441ac5c2014-09-15 16:46:08 -0700549 */
Jaegeuk Kim608514d2016-04-15 09:43:17 -0700550 if (IS_INODE(page))
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700551 recover_inode(entry->inode, page);
552 if (entry->last_dentry == blkaddr) {
Chao Yuf61cce52016-05-07 16:15:05 +0800553 err = recover_dentry(entry->inode, page, dir_list);
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700554 if (err) {
555 f2fs_put_page(page, 1);
556 break;
557 }
558 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900559 err = do_recover_data(sbi, entry->inode, page, blkaddr);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700560 if (err) {
561 f2fs_put_page(page, 1);
Jaegeuk Kim45856af2013-05-20 10:26:09 +0900562 break;
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700563 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900564
Chao Yu3f8ab272016-04-29 20:13:37 +0800565 if (entry->blkaddr == blkaddr)
566 del_fsync_inode(entry);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900567next:
568 /* check next segment */
569 blkaddr = next_blkaddr_of_node(page);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700570 f2fs_put_page(page, 1);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900571 }
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900572 if (!err)
573 allocate_new_segments(sbi);
574 return err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900575}
576
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700577int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900578{
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700579 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900580 struct list_head inode_list;
Chao Yuf61cce52016-05-07 16:15:05 +0800581 struct list_head dir_list;
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700582 block_t blkaddr;
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900583 int err;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700584 int ret = 0;
Haicheng Liaabe5132013-10-23 12:39:32 +0800585 bool need_writecp = false;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900586
587 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
Gu Zhenge8512d22014-03-07 18:43:28 +0800588 sizeof(struct fsync_inode_entry));
Jaegeuk Kim6bacf522013-12-06 15:00:58 +0900589 if (!fsync_entry_slab)
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900590 return -ENOMEM;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900591
592 INIT_LIST_HEAD(&inode_list);
Chao Yuf61cce52016-05-07 16:15:05 +0800593 INIT_LIST_HEAD(&dir_list);
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900594
Jaegeuk Kim14f4e692014-08-13 16:30:46 -0700595 /* prevent checkpoint */
596 mutex_lock(&sbi->cp_mutex);
597
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700598 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
599
Jaegeuk Kim315df832015-08-11 12:45:39 -0700600 /* step #1: find fsynced inode numbers */
Jaegeuk Kim6ead1142013-03-20 19:01:06 +0900601 err = find_fsync_dnodes(sbi, &inode_list);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700602 if (err || list_empty(&inode_list))
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900603 goto out;
604
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700605 if (check_only) {
606 ret = 1;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900607 goto out;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700608 }
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900609
Haicheng Liaabe5132013-10-23 12:39:32 +0800610 need_writecp = true;
Chao Yu691c6fd2013-09-24 09:26:24 +0800611
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900612 /* step #2: recover data */
Chao Yuf61cce52016-05-07 16:15:05 +0800613 err = recover_data(sbi, &inode_list, &dir_list);
Jaegeuk Kimb3073842014-08-08 10:18:43 -0700614 if (!err)
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700615 f2fs_bug_on(sbi, !list_empty(&inode_list));
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900616out:
Gu Zheng5ebefc52013-06-27 09:28:54 +0800617 destroy_fsync_dnodes(&inode_list);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700618
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700619 /* truncate meta pages to be used by the recovery */
620 truncate_inode_pages_range(META_MAPPING(sbi),
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300621 (loff_t)MAIN_BLKADDR(sbi) << PAGE_SHIFT, -1);
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700622
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700623 if (err) {
624 truncate_inode_pages_final(NODE_MAPPING(sbi));
625 truncate_inode_pages_final(META_MAPPING(sbi));
626 }
627
Chao Yucaf00472015-01-28 17:48:42 +0800628 clear_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700629 if (err)
Chao Yuaaec2b12016-09-20 11:04:18 +0800630 set_ckpt_flags(sbi, CP_ERROR_FLAG);
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700631 mutex_unlock(&sbi->cp_mutex);
632
Jaegeuk Kim9e1e6df2016-09-19 18:13:54 -0700633 /* let's drop all the directory inodes for clean checkpoint */
634 destroy_fsync_dnodes(&dir_list);
635
Jaegeuk Kima468f0e2016-09-19 17:55:10 -0700636 if (!err && need_writecp) {
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700637 struct cp_control cpc = {
Jaegeuk Kim10027552015-04-09 17:03:53 -0700638 .reason = CP_RECOVERY,
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700639 };
Chao Yuc34f42e2015-12-23 17:50:30 +0800640 err = write_checkpoint(sbi, &cpc);
Jaegeuk Kimcf2271e2014-07-25 15:47:25 -0700641 }
Chao Yuf61cce52016-05-07 16:15:05 +0800642
Chao Yuf61cce52016-05-07 16:15:05 +0800643 kmem_cache_destroy(fsync_entry_slab);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -0700644 return ret ? ret: err;
Jaegeuk Kimd624c962012-11-02 17:13:32 +0900645}