Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * fs/f2fs/recovery.c
4 : : *
5 : : * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 : : * http://www.samsung.com/
7 : : */
8 : : #include <linux/fs.h>
9 : : #include <linux/f2fs_fs.h>
10 : : #include "f2fs.h"
11 : : #include "node.h"
12 : : #include "segment.h"
13 : :
14 : : /*
15 : : * Roll forward recovery scenarios.
16 : : *
17 : : * [Term] F: fsync_mark, D: dentry_mark
18 : : *
19 : : * 1. inode(x) | CP | inode(x) | dnode(F)
20 : : * -> Update the latest inode(x).
21 : : *
22 : : * 2. inode(x) | CP | inode(F) | dnode(F)
23 : : * -> No problem.
24 : : *
25 : : * 3. inode(x) | CP | dnode(F) | inode(x)
26 : : * -> Recover to the latest dnode(F), and drop the last inode(x)
27 : : *
28 : : * 4. inode(x) | CP | dnode(F) | inode(F)
29 : : * -> No problem.
30 : : *
31 : : * 5. CP | inode(x) | dnode(F)
32 : : * -> The inode(DF) was missing. Should drop this dnode(F).
33 : : *
34 : : * 6. CP | inode(DF) | dnode(F)
35 : : * -> No problem.
36 : : *
37 : : * 7. CP | dnode(F) | inode(DF)
38 : : * -> If f2fs_iget fails, then goto next to find inode(DF).
39 : : *
40 : : * 8. CP | dnode(F) | inode(x)
41 : : * -> If f2fs_iget fails, then goto next to find inode(DF).
42 : : * But it will fail due to no inode(DF).
43 : : */
44 : :
45 : : static struct kmem_cache *fsync_entry_slab;
46 : :
47 : 0 : bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi)
48 : : {
49 : 0 : s64 nalloc = percpu_counter_sum_positive(&sbi->alloc_valid_block_count);
50 : :
51 : 0 : if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)
52 : : return false;
53 : 0 : return true;
54 : : }
55 : :
56 : : static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
57 : : nid_t ino)
58 : : {
59 : : struct fsync_inode_entry *entry;
60 : :
61 : 0 : list_for_each_entry(entry, head, list)
62 : 0 : if (entry->inode->i_ino == ino)
63 : 0 : return entry;
64 : :
65 : : return NULL;
66 : : }
67 : :
68 : 0 : static struct fsync_inode_entry *add_fsync_inode(struct f2fs_sb_info *sbi,
69 : : struct list_head *head, nid_t ino, bool quota_inode)
70 : : {
71 : : struct inode *inode;
72 : : struct fsync_inode_entry *entry;
73 : : int err;
74 : :
75 : 0 : inode = f2fs_iget_retry(sbi->sb, ino);
76 : 0 : if (IS_ERR(inode))
77 : : return ERR_CAST(inode);
78 : :
79 : 0 : err = dquot_initialize(inode);
80 : 0 : if (err)
81 : : goto err_out;
82 : :
83 : 0 : if (quota_inode) {
84 : 0 : err = dquot_alloc_inode(inode);
85 : 0 : if (err)
86 : : goto err_out;
87 : : }
88 : :
89 : 0 : entry = f2fs_kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
90 : 0 : entry->inode = inode;
91 : 0 : list_add_tail(&entry->list, head);
92 : :
93 : 0 : return entry;
94 : : err_out:
95 : 0 : iput(inode);
96 : 0 : return ERR_PTR(err);
97 : : }
98 : :
99 : 0 : static void del_fsync_inode(struct fsync_inode_entry *entry, int drop)
100 : : {
101 : 0 : if (drop) {
102 : : /* inode should not be recovered, drop it */
103 : 0 : f2fs_inode_synced(entry->inode);
104 : : }
105 : 0 : iput(entry->inode);
106 : : list_del(&entry->list);
107 : 0 : kmem_cache_free(fsync_entry_slab, entry);
108 : 0 : }
109 : :
110 : 0 : static int recover_dentry(struct inode *inode, struct page *ipage,
111 : : struct list_head *dir_list)
112 : : {
113 : 0 : struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
114 : 0 : nid_t pino = le32_to_cpu(raw_inode->i_pino);
115 : : struct f2fs_dir_entry *de;
116 : : struct fscrypt_name fname;
117 : : struct page *page;
118 : : struct inode *dir, *einode;
119 : : struct fsync_inode_entry *entry;
120 : : int err = 0;
121 : : char *name;
122 : :
123 : : entry = get_fsync_inode(dir_list, pino);
124 : 0 : if (!entry) {
125 : 0 : entry = add_fsync_inode(F2FS_I_SB(inode), dir_list,
126 : : pino, false);
127 : 0 : if (IS_ERR(entry)) {
128 : : dir = ERR_CAST(entry);
129 : : err = PTR_ERR(entry);
130 : 0 : goto out;
131 : : }
132 : : }
133 : :
134 : 0 : dir = entry->inode;
135 : :
136 : 0 : memset(&fname, 0, sizeof(struct fscrypt_name));
137 : 0 : fname.disk_name.len = le32_to_cpu(raw_inode->i_namelen);
138 : 0 : fname.disk_name.name = raw_inode->i_name;
139 : :
140 : 0 : if (unlikely(fname.disk_name.len > F2FS_NAME_LEN)) {
141 : 0 : WARN_ON(1);
142 : : err = -ENAMETOOLONG;
143 : 0 : goto out;
144 : : }
145 : : retry:
146 : 0 : de = __f2fs_find_entry(dir, &fname, &page);
147 : 0 : if (de && inode->i_ino == le32_to_cpu(de->ino))
148 : : goto out_put;
149 : :
150 : 0 : if (de) {
151 : 0 : einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));
152 : 0 : if (IS_ERR(einode)) {
153 : 0 : WARN_ON(1);
154 : : err = PTR_ERR(einode);
155 : 0 : if (err == -ENOENT)
156 : : err = -EEXIST;
157 : : goto out_put;
158 : : }
159 : :
160 : 0 : err = dquot_initialize(einode);
161 : 0 : if (err) {
162 : 0 : iput(einode);
163 : 0 : goto out_put;
164 : : }
165 : :
166 : 0 : err = f2fs_acquire_orphan_inode(F2FS_I_SB(inode));
167 : 0 : if (err) {
168 : 0 : iput(einode);
169 : 0 : goto out_put;
170 : : }
171 : 0 : f2fs_delete_entry(de, page, dir, einode);
172 : 0 : iput(einode);
173 : 0 : goto retry;
174 : 0 : } else if (IS_ERR(page)) {
175 : : err = PTR_ERR(page);
176 : : } else {
177 : 0 : err = f2fs_add_dentry(dir, &fname, inode,
178 : 0 : inode->i_ino, inode->i_mode);
179 : : }
180 : 0 : if (err == -ENOMEM)
181 : : goto retry;
182 : : goto out;
183 : :
184 : : out_put:
185 : 0 : f2fs_put_page(page, 0);
186 : : out:
187 : 0 : if (file_enc_name(inode))
188 : : name = "<encrypted>";
189 : : else
190 : 0 : name = raw_inode->i_name;
191 : 0 : f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %lx, err = %d",
192 : : __func__, ino_of_node(ipage), name,
193 : : IS_ERR(dir) ? 0 : dir->i_ino, err);
194 : 0 : return err;
195 : : }
196 : :
197 : 0 : static int recover_quota_data(struct inode *inode, struct page *page)
198 : : {
199 : 0 : struct f2fs_inode *raw = F2FS_INODE(page);
200 : : struct iattr attr;
201 : 0 : uid_t i_uid = le32_to_cpu(raw->i_uid);
202 : 0 : gid_t i_gid = le32_to_cpu(raw->i_gid);
203 : : int err;
204 : :
205 : 0 : memset(&attr, 0, sizeof(attr));
206 : :
207 : 0 : attr.ia_uid = make_kuid(inode->i_sb->s_user_ns, i_uid);
208 : 0 : attr.ia_gid = make_kgid(inode->i_sb->s_user_ns, i_gid);
209 : :
210 : 0 : if (!uid_eq(attr.ia_uid, inode->i_uid))
211 : 0 : attr.ia_valid |= ATTR_UID;
212 : 0 : if (!gid_eq(attr.ia_gid, inode->i_gid))
213 : 0 : attr.ia_valid |= ATTR_GID;
214 : :
215 : 0 : if (!attr.ia_valid)
216 : : return 0;
217 : :
218 : 0 : err = dquot_transfer(inode, &attr);
219 : 0 : if (err)
220 : : set_sbi_flag(F2FS_I_SB(inode), SBI_QUOTA_NEED_REPAIR);
221 : 0 : return err;
222 : : }
223 : :
224 : 0 : static void recover_inline_flags(struct inode *inode, struct f2fs_inode *ri)
225 : : {
226 : 0 : if (ri->i_inline & F2FS_PIN_FILE)
227 : 0 : set_inode_flag(inode, FI_PIN_FILE);
228 : : else
229 : 0 : clear_inode_flag(inode, FI_PIN_FILE);
230 : 0 : if (ri->i_inline & F2FS_DATA_EXIST)
231 : 0 : set_inode_flag(inode, FI_DATA_EXIST);
232 : : else
233 : 0 : clear_inode_flag(inode, FI_DATA_EXIST);
234 : 0 : }
235 : :
236 : 0 : static int recover_inode(struct inode *inode, struct page *page)
237 : : {
238 : 0 : struct f2fs_inode *raw = F2FS_INODE(page);
239 : : char *name;
240 : : int err;
241 : :
242 : 0 : inode->i_mode = le16_to_cpu(raw->i_mode);
243 : :
244 : 0 : err = recover_quota_data(inode, page);
245 : 0 : if (err)
246 : : return err;
247 : :
248 : 0 : i_uid_write(inode, le32_to_cpu(raw->i_uid));
249 : 0 : i_gid_write(inode, le32_to_cpu(raw->i_gid));
250 : :
251 : 0 : if (raw->i_inline & F2FS_EXTRA_ATTR) {
252 : 0 : if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&
253 : 0 : F2FS_FITS_IN_INODE(raw, le16_to_cpu(raw->i_extra_isize),
254 : : i_projid)) {
255 : : projid_t i_projid;
256 : : kprojid_t kprojid;
257 : :
258 : 0 : i_projid = (projid_t)le32_to_cpu(raw->i_projid);
259 : 0 : kprojid = make_kprojid(&init_user_ns, i_projid);
260 : :
261 : 0 : if (!projid_eq(kprojid, F2FS_I(inode)->i_projid)) {
262 : 0 : err = f2fs_transfer_project_quota(inode,
263 : : kprojid);
264 : 0 : if (err)
265 : 0 : return err;
266 : 0 : F2FS_I(inode)->i_projid = kprojid;
267 : : }
268 : : }
269 : : }
270 : :
271 : 0 : f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
272 : 0 : inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);
273 : 0 : inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
274 : 0 : inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
275 : 0 : inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);
276 : 0 : inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
277 : 0 : inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
278 : :
279 : 0 : F2FS_I(inode)->i_advise = raw->i_advise;
280 : 0 : F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags);
281 : 0 : f2fs_set_inode_flags(inode);
282 : 0 : F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] =
283 : 0 : le16_to_cpu(raw->i_gc_failures);
284 : :
285 : 0 : recover_inline_flags(inode, raw);
286 : :
287 : 0 : f2fs_mark_inode_dirty_sync(inode, true);
288 : :
289 : 0 : if (file_enc_name(inode))
290 : : name = "<encrypted>";
291 : : else
292 : 0 : name = F2FS_INODE(page)->i_name;
293 : :
294 : 0 : f2fs_notice(F2FS_I_SB(inode), "recover_inode: ino = %x, name = %s, inline = %x",
295 : : ino_of_node(page), name, raw->i_inline);
296 : 0 : return 0;
297 : : }
298 : :
299 : 0 : static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
300 : : bool check_only)
301 : : {
302 : : struct curseg_info *curseg;
303 : : struct page *page = NULL;
304 : : block_t blkaddr;
305 : : unsigned int loop_cnt = 0;
306 : 0 : unsigned int free_blocks = MAIN_SEGS(sbi) * sbi->blocks_per_seg -
307 : : valid_user_blocks(sbi);
308 : : int err = 0;
309 : :
310 : : /* get node pages in the current segment */
311 : : curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
312 : 0 : blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
313 : :
314 : : while (1) {
315 : : struct fsync_inode_entry *entry;
316 : :
317 : 0 : if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
318 : : return 0;
319 : :
320 : 0 : page = f2fs_get_tmp_page(sbi, blkaddr);
321 : 0 : if (IS_ERR(page)) {
322 : : err = PTR_ERR(page);
323 : 0 : break;
324 : : }
325 : :
326 : 0 : if (!is_recoverable_dnode(page)) {
327 : 0 : f2fs_put_page(page, 1);
328 : 0 : break;
329 : : }
330 : :
331 : 0 : if (!is_fsync_dnode(page))
332 : : goto next;
333 : :
334 : : entry = get_fsync_inode(head, ino_of_node(page));
335 : 0 : if (!entry) {
336 : : bool quota_inode = false;
337 : :
338 : 0 : if (!check_only &&
339 : 0 : IS_INODE(page) && is_dent_dnode(page)) {
340 : 0 : err = f2fs_recover_inode_page(sbi, page);
341 : 0 : if (err) {
342 : 0 : f2fs_put_page(page, 1);
343 : 0 : break;
344 : : }
345 : : quota_inode = true;
346 : : }
347 : :
348 : : /*
349 : : * CP | dnode(F) | inode(DF)
350 : : * For this case, we should not give up now.
351 : : */
352 : 0 : entry = add_fsync_inode(sbi, head, ino_of_node(page),
353 : : quota_inode);
354 : 0 : if (IS_ERR(entry)) {
355 : : err = PTR_ERR(entry);
356 : 0 : if (err == -ENOENT) {
357 : : err = 0;
358 : : goto next;
359 : : }
360 : 0 : f2fs_put_page(page, 1);
361 : 0 : break;
362 : : }
363 : : }
364 : 0 : entry->blkaddr = blkaddr;
365 : :
366 : 0 : if (IS_INODE(page) && is_dent_dnode(page))
367 : 0 : entry->last_dentry = blkaddr;
368 : : next:
369 : : /* sanity check in order to detect looped node chain */
370 : 0 : if (++loop_cnt >= free_blocks ||
371 : : blkaddr == next_blkaddr_of_node(page)) {
372 : 0 : f2fs_notice(sbi, "%s: detect looped node chain, blkaddr:%u, next:%u",
373 : : __func__, blkaddr,
374 : : next_blkaddr_of_node(page));
375 : 0 : f2fs_put_page(page, 1);
376 : : err = -EINVAL;
377 : 0 : break;
378 : : }
379 : :
380 : : /* check next segment */
381 : : blkaddr = next_blkaddr_of_node(page);
382 : 0 : f2fs_put_page(page, 1);
383 : :
384 : 0 : f2fs_ra_meta_pages_cond(sbi, blkaddr);
385 : 0 : }
386 : 0 : return err;
387 : : }
388 : :
389 : : static void destroy_fsync_dnodes(struct list_head *head, int drop)
390 : : {
391 : : struct fsync_inode_entry *entry, *tmp;
392 : :
393 : 0 : list_for_each_entry_safe(entry, tmp, head, list)
394 : 0 : del_fsync_inode(entry, drop);
395 : : }
396 : :
397 : 0 : static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
398 : : block_t blkaddr, struct dnode_of_data *dn)
399 : : {
400 : : struct seg_entry *sentry;
401 : 0 : unsigned int segno = GET_SEGNO(sbi, blkaddr);
402 : 0 : unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
403 : : struct f2fs_summary_block *sum_node;
404 : : struct f2fs_summary sum;
405 : : struct page *sum_page, *node_page;
406 : 0 : struct dnode_of_data tdn = *dn;
407 : : nid_t ino, nid;
408 : : struct inode *inode;
409 : : unsigned int offset;
410 : : block_t bidx;
411 : : int i;
412 : :
413 : : sentry = get_seg_entry(sbi, segno);
414 : 0 : if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
415 : : return 0;
416 : :
417 : : /* Get the previous summary */
418 : 0 : for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
419 : : struct curseg_info *curseg = CURSEG_I(sbi, i);
420 : 0 : if (curseg->segno == segno) {
421 : 0 : sum = curseg->sum_blk->entries[blkoff];
422 : 0 : goto got_it;
423 : : }
424 : : }
425 : :
426 : 0 : sum_page = f2fs_get_sum_page(sbi, segno);
427 : 0 : if (IS_ERR(sum_page))
428 : 0 : return PTR_ERR(sum_page);
429 : : sum_node = (struct f2fs_summary_block *)page_address(sum_page);
430 : 0 : sum = sum_node->entries[blkoff];
431 : 0 : f2fs_put_page(sum_page, 1);
432 : : got_it:
433 : : /* Use the locked dnode page and inode */
434 : : nid = le32_to_cpu(sum.nid);
435 : 0 : if (dn->inode->i_ino == nid) {
436 : 0 : tdn.nid = nid;
437 : 0 : if (!dn->inode_page_locked)
438 : 0 : lock_page(dn->inode_page);
439 : 0 : tdn.node_page = dn->inode_page;
440 : 0 : tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
441 : 0 : goto truncate_out;
442 : 0 : } else if (dn->nid == nid) {
443 : 0 : tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
444 : 0 : goto truncate_out;
445 : : }
446 : :
447 : : /* Get the node page */
448 : 0 : node_page = f2fs_get_node_page(sbi, nid);
449 : 0 : if (IS_ERR(node_page))
450 : 0 : return PTR_ERR(node_page);
451 : :
452 : : offset = ofs_of_node(node_page);
453 : : ino = ino_of_node(node_page);
454 : 0 : f2fs_put_page(node_page, 1);
455 : :
456 : 0 : if (ino != dn->inode->i_ino) {
457 : : int ret;
458 : :
459 : : /* Deallocate previous index in the node page */
460 : 0 : inode = f2fs_iget_retry(sbi->sb, ino);
461 : 0 : if (IS_ERR(inode))
462 : 0 : return PTR_ERR(inode);
463 : :
464 : 0 : ret = dquot_initialize(inode);
465 : 0 : if (ret) {
466 : 0 : iput(inode);
467 : 0 : return ret;
468 : : }
469 : : } else {
470 : : inode = dn->inode;
471 : : }
472 : :
473 : 0 : bidx = f2fs_start_bidx_of_node(offset, inode) +
474 : : le16_to_cpu(sum.ofs_in_node);
475 : :
476 : : /*
477 : : * if inode page is locked, unlock temporarily, but its reference
478 : : * count keeps alive.
479 : : */
480 : 0 : if (ino == dn->inode->i_ino && dn->inode_page_locked)
481 : 0 : unlock_page(dn->inode_page);
482 : :
483 : : set_new_dnode(&tdn, inode, NULL, NULL, 0);
484 : 0 : if (f2fs_get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
485 : : goto out;
486 : :
487 : 0 : if (tdn.data_blkaddr == blkaddr)
488 : 0 : f2fs_truncate_data_blocks_range(&tdn, 1);
489 : :
490 : 0 : f2fs_put_dnode(&tdn);
491 : : out:
492 : 0 : if (ino != dn->inode->i_ino)
493 : 0 : iput(inode);
494 : 0 : else if (dn->inode_page_locked)
495 : 0 : lock_page(dn->inode_page);
496 : : return 0;
497 : :
498 : : truncate_out:
499 : 0 : if (datablock_addr(tdn.inode, tdn.node_page,
500 : : tdn.ofs_in_node) == blkaddr)
501 : 0 : f2fs_truncate_data_blocks_range(&tdn, 1);
502 : 0 : if (dn->inode->i_ino == nid && !dn->inode_page_locked)
503 : 0 : unlock_page(dn->inode_page);
504 : : return 0;
505 : : }
506 : :
507 : 0 : static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
508 : : struct page *page)
509 : : {
510 : : struct dnode_of_data dn;
511 : : struct node_info ni;
512 : : unsigned int start, end;
513 : : int err = 0, recovered = 0;
514 : :
515 : : /* step 1: recover xattr */
516 : 0 : if (IS_INODE(page)) {
517 : 0 : f2fs_recover_inline_xattr(inode, page);
518 : 0 : } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
519 : 0 : err = f2fs_recover_xattr_data(inode, page);
520 : 0 : if (!err)
521 : : recovered++;
522 : : goto out;
523 : : }
524 : :
525 : : /* step 2: recover inline data */
526 : 0 : if (f2fs_recover_inline_data(inode, page))
527 : : goto out;
528 : :
529 : : /* step 3: recover data indices */
530 : 0 : start = f2fs_start_bidx_of_node(ofs_of_node(page), inode);
531 : 0 : end = start + ADDRS_PER_PAGE(page, inode);
532 : :
533 : : set_new_dnode(&dn, inode, NULL, NULL, 0);
534 : : retry_dn:
535 : 0 : err = f2fs_get_dnode_of_data(&dn, start, ALLOC_NODE);
536 : 0 : if (err) {
537 : 0 : if (err == -ENOMEM) {
538 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/50);
539 : 0 : goto retry_dn;
540 : : }
541 : : goto out;
542 : : }
543 : :
544 : 0 : f2fs_wait_on_page_writeback(dn.node_page, NODE, true, true);
545 : :
546 : 0 : err = f2fs_get_node_info(sbi, dn.nid, &ni);
547 : 0 : if (err)
548 : : goto err;
549 : :
550 : 0 : f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
551 : :
552 : 0 : if (ofs_of_node(dn.node_page) != ofs_of_node(page)) {
553 : 0 : f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%lu, ofs:%u, %u",
554 : : inode->i_ino, ofs_of_node(dn.node_page),
555 : : ofs_of_node(page));
556 : : err = -EFSCORRUPTED;
557 : 0 : goto err;
558 : : }
559 : :
560 : 0 : for (; start < end; start++, dn.ofs_in_node++) {
561 : : block_t src, dest;
562 : :
563 : 0 : src = datablock_addr(dn.inode, dn.node_page, dn.ofs_in_node);
564 : 0 : dest = datablock_addr(dn.inode, page, dn.ofs_in_node);
565 : :
566 : 0 : if (__is_valid_data_blkaddr(src) &&
567 : 0 : !f2fs_is_valid_blkaddr(sbi, src, META_POR)) {
568 : : err = -EFSCORRUPTED;
569 : : goto err;
570 : : }
571 : :
572 : 0 : if (__is_valid_data_blkaddr(dest) &&
573 : 0 : !f2fs_is_valid_blkaddr(sbi, dest, META_POR)) {
574 : : err = -EFSCORRUPTED;
575 : : goto err;
576 : : }
577 : :
578 : : /* skip recovering if dest is the same as src */
579 : 0 : if (src == dest)
580 : 0 : continue;
581 : :
582 : : /* dest is invalid, just invalidate src block */
583 : 0 : if (dest == NULL_ADDR) {
584 : 0 : f2fs_truncate_data_blocks_range(&dn, 1);
585 : 0 : continue;
586 : : }
587 : :
588 : 0 : if (!file_keep_isize(inode) &&
589 : 0 : (i_size_read(inode) <= ((loff_t)start << PAGE_SHIFT)))
590 : 0 : f2fs_i_size_write(inode,
591 : 0 : (loff_t)(start + 1) << PAGE_SHIFT);
592 : :
593 : : /*
594 : : * dest is reserved block, invalidate src block
595 : : * and then reserve one new block in dnode page.
596 : : */
597 : 0 : if (dest == NEW_ADDR) {
598 : 0 : f2fs_truncate_data_blocks_range(&dn, 1);
599 : 0 : f2fs_reserve_new_block(&dn);
600 : 0 : continue;
601 : : }
602 : :
603 : : /* dest is valid block, try to recover from src to dest */
604 : 0 : if (f2fs_is_valid_blkaddr(sbi, dest, META_POR)) {
605 : :
606 : 0 : if (src == NULL_ADDR) {
607 : 0 : err = f2fs_reserve_new_block(&dn);
608 : : while (err &&
609 : : IS_ENABLED(CONFIG_F2FS_FAULT_INJECTION))
610 : : err = f2fs_reserve_new_block(&dn);
611 : : /* We should not get -ENOSPC */
612 : 0 : f2fs_bug_on(sbi, err);
613 : 0 : if (err)
614 : : goto err;
615 : : }
616 : : retry_prev:
617 : : /* Check the previous node page having this index */
618 : 0 : err = check_index_in_prev_nodes(sbi, dest, &dn);
619 : 0 : if (err) {
620 : 0 : if (err == -ENOMEM) {
621 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/50);
622 : 0 : goto retry_prev;
623 : : }
624 : : goto err;
625 : : }
626 : :
627 : : /* write dummy data page */
628 : 0 : f2fs_replace_block(sbi, &dn, src, dest,
629 : : ni.version, false, false);
630 : 0 : recovered++;
631 : : }
632 : : }
633 : :
634 : 0 : copy_node_footer(dn.node_page, page);
635 : 0 : fill_node_footer(dn.node_page, dn.nid, ni.ino,
636 : : ofs_of_node(page), false);
637 : 0 : set_page_dirty(dn.node_page);
638 : : err:
639 : 0 : f2fs_put_dnode(&dn);
640 : : out:
641 : 0 : f2fs_notice(sbi, "recover_data: ino = %lx (i_size: %s) recovered = %d, err = %d",
642 : : inode->i_ino, file_keep_isize(inode) ? "keep" : "recover",
643 : : recovered, err);
644 : 0 : return err;
645 : : }
646 : :
647 : 0 : static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
648 : : struct list_head *tmp_inode_list, struct list_head *dir_list)
649 : : {
650 : : struct curseg_info *curseg;
651 : : struct page *page = NULL;
652 : : int err = 0;
653 : : block_t blkaddr;
654 : :
655 : : /* get node pages in the current segment */
656 : : curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
657 : 0 : blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
658 : :
659 : : while (1) {
660 : : struct fsync_inode_entry *entry;
661 : :
662 : 0 : if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
663 : : break;
664 : :
665 : 0 : f2fs_ra_meta_pages_cond(sbi, blkaddr);
666 : :
667 : 0 : page = f2fs_get_tmp_page(sbi, blkaddr);
668 : 0 : if (IS_ERR(page)) {
669 : : err = PTR_ERR(page);
670 : 0 : break;
671 : : }
672 : :
673 : 0 : if (!is_recoverable_dnode(page)) {
674 : 0 : f2fs_put_page(page, 1);
675 : 0 : break;
676 : : }
677 : :
678 : : entry = get_fsync_inode(inode_list, ino_of_node(page));
679 : 0 : if (!entry)
680 : : goto next;
681 : : /*
682 : : * inode(x) | CP | inode(x) | dnode(F)
683 : : * In this case, we can lose the latest inode(x).
684 : : * So, call recover_inode for the inode update.
685 : : */
686 : 0 : if (IS_INODE(page)) {
687 : 0 : err = recover_inode(entry->inode, page);
688 : 0 : if (err) {
689 : 0 : f2fs_put_page(page, 1);
690 : 0 : break;
691 : : }
692 : : }
693 : 0 : if (entry->last_dentry == blkaddr) {
694 : 0 : err = recover_dentry(entry->inode, page, dir_list);
695 : 0 : if (err) {
696 : 0 : f2fs_put_page(page, 1);
697 : 0 : break;
698 : : }
699 : : }
700 : 0 : err = do_recover_data(sbi, entry->inode, page);
701 : 0 : if (err) {
702 : 0 : f2fs_put_page(page, 1);
703 : 0 : break;
704 : : }
705 : :
706 : 0 : if (entry->blkaddr == blkaddr)
707 : 0 : list_move_tail(&entry->list, tmp_inode_list);
708 : : next:
709 : : /* check next segment */
710 : : blkaddr = next_blkaddr_of_node(page);
711 : 0 : f2fs_put_page(page, 1);
712 : 0 : }
713 : 0 : if (!err)
714 : 0 : f2fs_allocate_new_segments(sbi);
715 : 0 : return err;
716 : : }
717 : :
718 : 0 : int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
719 : : {
720 : : struct list_head inode_list, tmp_inode_list;
721 : : struct list_head dir_list;
722 : : int err;
723 : : int ret = 0;
724 : 0 : unsigned long s_flags = sbi->sb->s_flags;
725 : : bool need_writecp = false;
726 : : #ifdef CONFIG_QUOTA
727 : : int quota_enabled;
728 : : #endif
729 : :
730 : 0 : if (s_flags & SB_RDONLY) {
731 : 0 : f2fs_info(sbi, "recover fsync data on readonly fs");
732 : 0 : sbi->sb->s_flags &= ~SB_RDONLY;
733 : : }
734 : :
735 : : #ifdef CONFIG_QUOTA
736 : : /* Needed for iput() to work correctly and not trash data */
737 : 0 : sbi->sb->s_flags |= SB_ACTIVE;
738 : : /* Turn on quotas so that they are updated correctly */
739 : 0 : quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
740 : : #endif
741 : :
742 : 0 : fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
743 : : sizeof(struct fsync_inode_entry));
744 : 0 : if (!fsync_entry_slab) {
745 : : err = -ENOMEM;
746 : : goto out;
747 : : }
748 : :
749 : : INIT_LIST_HEAD(&inode_list);
750 : : INIT_LIST_HEAD(&tmp_inode_list);
751 : : INIT_LIST_HEAD(&dir_list);
752 : :
753 : : /* prevent checkpoint */
754 : 0 : mutex_lock(&sbi->cp_mutex);
755 : :
756 : : /* step #1: find fsynced inode numbers */
757 : 0 : err = find_fsync_dnodes(sbi, &inode_list, check_only);
758 : 0 : if (err || list_empty(&inode_list))
759 : : goto skip;
760 : :
761 : 0 : if (check_only) {
762 : : ret = 1;
763 : : goto skip;
764 : : }
765 : :
766 : : need_writecp = true;
767 : :
768 : : /* step #2: recover data */
769 : 0 : err = recover_data(sbi, &inode_list, &tmp_inode_list, &dir_list);
770 : 0 : if (!err)
771 : 0 : f2fs_bug_on(sbi, !list_empty(&inode_list));
772 : : else {
773 : : /* restore s_flags to let iput() trash data */
774 : 0 : sbi->sb->s_flags = s_flags;
775 : : }
776 : : skip:
777 : : destroy_fsync_dnodes(&inode_list, err);
778 : : destroy_fsync_dnodes(&tmp_inode_list, err);
779 : :
780 : : /* truncate meta pages to be used by the recovery */
781 : 0 : truncate_inode_pages_range(META_MAPPING(sbi),
782 : 0 : (loff_t)MAIN_BLKADDR(sbi) << PAGE_SHIFT, -1);
783 : :
784 : 0 : if (err) {
785 : 0 : truncate_inode_pages_final(NODE_MAPPING(sbi));
786 : 0 : truncate_inode_pages_final(META_MAPPING(sbi));
787 : : } else {
788 : : clear_sbi_flag(sbi, SBI_POR_DOING);
789 : : }
790 : 0 : mutex_unlock(&sbi->cp_mutex);
791 : :
792 : : /* let's drop all the directory inodes for clean checkpoint */
793 : : destroy_fsync_dnodes(&dir_list, err);
794 : :
795 : 0 : if (need_writecp) {
796 : : set_sbi_flag(sbi, SBI_IS_RECOVERED);
797 : :
798 : 0 : if (!err) {
799 : 0 : struct cp_control cpc = {
800 : : .reason = CP_RECOVERY,
801 : : };
802 : 0 : err = f2fs_write_checkpoint(sbi, &cpc);
803 : : }
804 : : }
805 : :
806 : 0 : kmem_cache_destroy(fsync_entry_slab);
807 : : out:
808 : : #ifdef CONFIG_QUOTA
809 : : /* Turn quotas off */
810 : 0 : if (quota_enabled)
811 : 0 : f2fs_quota_off_umount(sbi->sb);
812 : : #endif
813 : 0 : sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
814 : :
815 : 0 : return ret ? ret: err;
816 : : }
|
