xref: /openbmc/linux/fs/f2fs/recovery.c (revision c0e297dc) 
1 /*
2  * 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 
17 /*
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 
48 static struct kmem_cache *fsync_entry_slab;
49 
50 bool 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 
58 static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
59 								nid_t ino)
60 {
61 	struct fsync_inode_entry *entry;
62 
63 	list_for_each_entry(entry, head, list)
64 		if (entry->inode->i_ino == ino)
65 			return entry;
66 
67 	return NULL;
68 }
69 
70 static int recover_dentry(struct inode *inode, struct page *ipage)
71 {
72 	struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
73 	nid_t pino = le32_to_cpu(raw_inode->i_pino);
74 	struct f2fs_dir_entry *de;
75 	struct qstr name;
76 	struct page *page;
77 	struct inode *dir, *einode;
78 	int err = 0;
79 
80 	dir = f2fs_iget(inode->i_sb, pino);
81 	if (IS_ERR(dir)) {
82 		err = PTR_ERR(dir);
83 		goto out;
84 	}
85 
86 	if (file_enc_name(inode)) {
87 		iput(dir);
88 		return 0;
89 	}
90 
91 	name.len = le32_to_cpu(raw_inode->i_namelen);
92 	name.name = raw_inode->i_name;
93 
94 	if (unlikely(name.len > F2FS_NAME_LEN)) {
95 		WARN_ON(1);
96 		err = -ENAMETOOLONG;
97 		goto out_err;
98 	}
99 retry:
100 	de = f2fs_find_entry(dir, &name, &page);
101 	if (de && inode->i_ino == le32_to_cpu(de->ino))
102 		goto out_unmap_put;
103 
104 	if (de) {
105 		einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino));
106 		if (IS_ERR(einode)) {
107 			WARN_ON(1);
108 			err = PTR_ERR(einode);
109 			if (err == -ENOENT)
110 				err = -EEXIST;
111 			goto out_unmap_put;
112 		}
113 		err = acquire_orphan_inode(F2FS_I_SB(inode));
114 		if (err) {
115 			iput(einode);
116 			goto out_unmap_put;
117 		}
118 		f2fs_delete_entry(de, page, dir, einode);
119 		iput(einode);
120 		goto retry;
121 	}
122 	err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);
123 	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 
133 	goto out;
134 
135 out_unmap_put:
136 	f2fs_dentry_kunmap(dir, page);
137 	f2fs_put_page(page, 0);
138 out_err:
139 	iput(dir);
140 out:
141 	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,
144 			IS_ERR(dir) ? 0 : dir->i_ino, err);
145 	return err;
146 }
147 
148 static void recover_inode(struct inode *inode, struct page *page)
149 {
150 	struct f2fs_inode *raw = F2FS_INODE(page);
151 	char *name;
152 
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);
161 
162 	if (file_enc_name(inode))
163 		name = "<encrypted>";
164 	else
165 		name = F2FS_INODE(page)->i_name;
166 
167 	f2fs_msg(inode->i_sb, KERN_NOTICE, "recover_inode: ino = %x, name = %s",
168 			ino_of_node(page), name);
169 }
170 
171 static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
172 {
173 	unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
174 	struct curseg_info *curseg;
175 	struct page *page = NULL;
176 	block_t blkaddr;
177 	int err = 0;
178 
179 	/* get node pages in the current segment */
180 	curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
181 	blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
182 
183 	ra_meta_pages(sbi, blkaddr, 1, META_POR);
184 
185 	while (1) {
186 		struct fsync_inode_entry *entry;
187 
188 		if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
189 			return 0;
190 
191 		page = get_meta_page(sbi, blkaddr);
192 
193 		if (cp_ver != cpver_of_node(page))
194 			break;
195 
196 		if (!is_fsync_dnode(page))
197 			goto next;
198 
199 		entry = get_fsync_inode(head, ino_of_node(page));
200 		if (!entry) {
201 			if (IS_INODE(page) && is_dent_dnode(page)) {
202 				err = recover_inode_page(sbi, page);
203 				if (err)
204 					break;
205 			}
206 
207 			/* add this fsync inode to the list */
208 			entry = kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
209 			if (!entry) {
210 				err = -ENOMEM;
211 				break;
212 			}
213 			/*
214 			 * CP | dnode(F) | inode(DF)
215 			 * For this case, we should not give up now.
216 			 */
217 			entry->inode = f2fs_iget(sbi->sb, ino_of_node(page));
218 			if (IS_ERR(entry->inode)) {
219 				err = PTR_ERR(entry->inode);
220 				kmem_cache_free(fsync_entry_slab, entry);
221 				if (err == -ENOENT) {
222 					err = 0;
223 					goto next;
224 				}
225 				break;
226 			}
227 			list_add_tail(&entry->list, head);
228 		}
229 		entry->blkaddr = blkaddr;
230 
231 		if (IS_INODE(page)) {
232 			entry->last_inode = blkaddr;
233 			if (is_dent_dnode(page))
234 				entry->last_dentry = blkaddr;
235 		}
236 next:
237 		/* check next segment */
238 		blkaddr = next_blkaddr_of_node(page);
239 		f2fs_put_page(page, 1);
240 
241 		ra_meta_pages_cond(sbi, blkaddr);
242 	}
243 	f2fs_put_page(page, 1);
244 	return err;
245 }
246 
247 static void destroy_fsync_dnodes(struct list_head *head)
248 {
249 	struct fsync_inode_entry *entry, *tmp;
250 
251 	list_for_each_entry_safe(entry, tmp, head, list) {
252 		iput(entry->inode);
253 		list_del(&entry->list);
254 		kmem_cache_free(fsync_entry_slab, entry);
255 	}
256 }
257 
258 static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
259 			block_t blkaddr, struct dnode_of_data *dn)
260 {
261 	struct seg_entry *sentry;
262 	unsigned int segno = GET_SEGNO(sbi, blkaddr);
263 	unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
264 	struct f2fs_summary_block *sum_node;
265 	struct f2fs_summary sum;
266 	struct page *sum_page, *node_page;
267 	struct dnode_of_data tdn = *dn;
268 	nid_t ino, nid;
269 	struct inode *inode;
270 	unsigned int offset;
271 	block_t bidx;
272 	int i;
273 
274 	sentry = get_seg_entry(sbi, segno);
275 	if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
276 		return 0;
277 
278 	/* Get the previous summary */
279 	for (i = CURSEG_WARM_DATA; i <= CURSEG_COLD_DATA; i++) {
280 		struct curseg_info *curseg = CURSEG_I(sbi, i);
281 		if (curseg->segno == segno) {
282 			sum = curseg->sum_blk->entries[blkoff];
283 			goto got_it;
284 		}
285 	}
286 
287 	sum_page = get_sum_page(sbi, segno);
288 	sum_node = (struct f2fs_summary_block *)page_address(sum_page);
289 	sum = sum_node->entries[blkoff];
290 	f2fs_put_page(sum_page, 1);
291 got_it:
292 	/* Use the locked dnode page and inode */
293 	nid = le32_to_cpu(sum.nid);
294 	if (dn->inode->i_ino == nid) {
295 		tdn.nid = nid;
296 		if (!dn->inode_page_locked)
297 			lock_page(dn->inode_page);
298 		tdn.node_page = dn->inode_page;
299 		tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
300 		goto truncate_out;
301 	} else if (dn->nid == nid) {
302 		tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
303 		goto truncate_out;
304 	}
305 
306 	/* Get the node page */
307 	node_page = get_node_page(sbi, nid);
308 	if (IS_ERR(node_page))
309 		return PTR_ERR(node_page);
310 
311 	offset = ofs_of_node(node_page);
312 	ino = ino_of_node(node_page);
313 	f2fs_put_page(node_page, 1);
314 
315 	if (ino != dn->inode->i_ino) {
316 		/* Deallocate previous index in the node page */
317 		inode = f2fs_iget(sbi->sb, ino);
318 		if (IS_ERR(inode))
319 			return PTR_ERR(inode);
320 	} else {
321 		inode = dn->inode;
322 	}
323 
324 	bidx = start_bidx_of_node(offset, F2FS_I(inode)) +
325 			le16_to_cpu(sum.ofs_in_node);
326 
327 	/*
328 	 * if inode page is locked, unlock temporarily, but its reference
329 	 * count keeps alive.
330 	 */
331 	if (ino == dn->inode->i_ino && dn->inode_page_locked)
332 		unlock_page(dn->inode_page);
333 
334 	set_new_dnode(&tdn, inode, NULL, NULL, 0);
335 	if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
336 		goto out;
337 
338 	if (tdn.data_blkaddr == blkaddr)
339 		truncate_data_blocks_range(&tdn, 1);
340 
341 	f2fs_put_dnode(&tdn);
342 out:
343 	if (ino != dn->inode->i_ino)
344 		iput(inode);
345 	else if (dn->inode_page_locked)
346 		lock_page(dn->inode_page);
347 	return 0;
348 
349 truncate_out:
350 	if (datablock_addr(tdn.node_page, tdn.ofs_in_node) == blkaddr)
351 		truncate_data_blocks_range(&tdn, 1);
352 	if (dn->inode->i_ino == nid && !dn->inode_page_locked)
353 		unlock_page(dn->inode_page);
354 	return 0;
355 }
356 
357 static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
358 					struct page *page, block_t blkaddr)
359 {
360 	struct f2fs_inode_info *fi = F2FS_I(inode);
361 	unsigned int start, end;
362 	struct dnode_of_data dn;
363 	struct node_info ni;
364 	int err = 0, recovered = 0;
365 
366 	/* step 1: recover xattr */
367 	if (IS_INODE(page)) {
368 		recover_inline_xattr(inode, page);
369 	} else if (f2fs_has_xattr_block(ofs_of_node(page))) {
370 		/*
371 		 * Deprecated; xattr blocks should be found from cold log.
372 		 * But, we should remain this for backward compatibility.
373 		 */
374 		recover_xattr_data(inode, page, blkaddr);
375 		goto out;
376 	}
377 
378 	/* step 2: recover inline data */
379 	if (recover_inline_data(inode, page))
380 		goto out;
381 
382 	/* step 3: recover data indices */
383 	start = start_bidx_of_node(ofs_of_node(page), fi);
384 	end = start + ADDRS_PER_PAGE(page, fi);
385 
386 	f2fs_lock_op(sbi);
387 
388 	set_new_dnode(&dn, inode, NULL, NULL, 0);
389 
390 	err = get_dnode_of_data(&dn, start, ALLOC_NODE);
391 	if (err) {
392 		f2fs_unlock_op(sbi);
393 		goto out;
394 	}
395 
396 	f2fs_wait_on_page_writeback(dn.node_page, NODE);
397 
398 	get_node_info(sbi, dn.nid, &ni);
399 	f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
400 	f2fs_bug_on(sbi, ofs_of_node(dn.node_page) != ofs_of_node(page));
401 
402 	for (; start < end; start++) {
403 		block_t src, dest;
404 
405 		src = datablock_addr(dn.node_page, dn.ofs_in_node);
406 		dest = datablock_addr(page, dn.ofs_in_node);
407 
408 		if (src != dest && dest != NEW_ADDR && dest != NULL_ADDR &&
409 			is_valid_blkaddr(sbi, dest, META_POR)) {
410 
411 			if (src == NULL_ADDR) {
412 				err = reserve_new_block(&dn);
413 				/* We should not get -ENOSPC */
414 				f2fs_bug_on(sbi, err);
415 			}
416 
417 			/* Check the previous node page having this index */
418 			err = check_index_in_prev_nodes(sbi, dest, &dn);
419 			if (err)
420 				goto err;
421 
422 			/* write dummy data page */
423 			f2fs_replace_block(sbi, &dn, src, dest,
424 							ni.version, false);
425 			recovered++;
426 		}
427 		dn.ofs_in_node++;
428 	}
429 
430 	if (IS_INODE(dn.node_page))
431 		sync_inode_page(&dn);
432 
433 	copy_node_footer(dn.node_page, page);
434 	fill_node_footer(dn.node_page, dn.nid, ni.ino,
435 					ofs_of_node(page), false);
436 	set_page_dirty(dn.node_page);
437 err:
438 	f2fs_put_dnode(&dn);
439 	f2fs_unlock_op(sbi);
440 out:
441 	f2fs_msg(sbi->sb, KERN_NOTICE,
442 		"recover_data: ino = %lx, recovered = %d blocks, err = %d",
443 		inode->i_ino, recovered, err);
444 	return err;
445 }
446 
447 static int recover_data(struct f2fs_sb_info *sbi,
448 				struct list_head *head, int type)
449 {
450 	unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
451 	struct curseg_info *curseg;
452 	struct page *page = NULL;
453 	int err = 0;
454 	block_t blkaddr;
455 
456 	/* get node pages in the current segment */
457 	curseg = CURSEG_I(sbi, type);
458 	blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
459 
460 	while (1) {
461 		struct fsync_inode_entry *entry;
462 
463 		if (!is_valid_blkaddr(sbi, blkaddr, META_POR))
464 			break;
465 
466 		ra_meta_pages_cond(sbi, blkaddr);
467 
468 		page = get_meta_page(sbi, blkaddr);
469 
470 		if (cp_ver != cpver_of_node(page)) {
471 			f2fs_put_page(page, 1);
472 			break;
473 		}
474 
475 		entry = get_fsync_inode(head, ino_of_node(page));
476 		if (!entry)
477 			goto next;
478 		/*
479 		 * inode(x) | CP | inode(x) | dnode(F)
480 		 * In this case, we can lose the latest inode(x).
481 		 * So, call recover_inode for the inode update.
482 		 */
483 		if (entry->last_inode == blkaddr)
484 			recover_inode(entry->inode, page);
485 		if (entry->last_dentry == blkaddr) {
486 			err = recover_dentry(entry->inode, page);
487 			if (err) {
488 				f2fs_put_page(page, 1);
489 				break;
490 			}
491 		}
492 		err = do_recover_data(sbi, entry->inode, page, blkaddr);
493 		if (err) {
494 			f2fs_put_page(page, 1);
495 			break;
496 		}
497 
498 		if (entry->blkaddr == blkaddr) {
499 			iput(entry->inode);
500 			list_del(&entry->list);
501 			kmem_cache_free(fsync_entry_slab, entry);
502 		}
503 next:
504 		/* check next segment */
505 		blkaddr = next_blkaddr_of_node(page);
506 		f2fs_put_page(page, 1);
507 	}
508 	if (!err)
509 		allocate_new_segments(sbi);
510 	return err;
511 }
512 
513 int recover_fsync_data(struct f2fs_sb_info *sbi)
514 {
515 	struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
516 	struct list_head inode_list;
517 	block_t blkaddr;
518 	int err;
519 	bool need_writecp = false;
520 
521 	fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
522 			sizeof(struct fsync_inode_entry));
523 	if (!fsync_entry_slab)
524 		return -ENOMEM;
525 
526 	INIT_LIST_HEAD(&inode_list);
527 
528 	/* step #1: find fsynced inode numbers */
529 	set_sbi_flag(sbi, SBI_POR_DOING);
530 
531 	/* prevent checkpoint */
532 	mutex_lock(&sbi->cp_mutex);
533 
534 	blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
535 
536 	err = find_fsync_dnodes(sbi, &inode_list);
537 	if (err)
538 		goto out;
539 
540 	if (list_empty(&inode_list))
541 		goto out;
542 
543 	need_writecp = true;
544 
545 	/* step #2: recover data */
546 	err = recover_data(sbi, &inode_list, CURSEG_WARM_NODE);
547 	if (!err)
548 		f2fs_bug_on(sbi, !list_empty(&inode_list));
549 out:
550 	destroy_fsync_dnodes(&inode_list);
551 	kmem_cache_destroy(fsync_entry_slab);
552 
553 	/* truncate meta pages to be used by the recovery */
554 	truncate_inode_pages_range(META_MAPPING(sbi),
555 			MAIN_BLKADDR(sbi) << PAGE_CACHE_SHIFT, -1);
556 
557 	if (err) {
558 		truncate_inode_pages_final(NODE_MAPPING(sbi));
559 		truncate_inode_pages_final(META_MAPPING(sbi));
560 	}
561 
562 	clear_sbi_flag(sbi, SBI_POR_DOING);
563 	if (err) {
564 		discard_next_dnode(sbi, blkaddr);
565 
566 		/* Flush all the NAT/SIT pages */
567 		while (get_pages(sbi, F2FS_DIRTY_META))
568 			sync_meta_pages(sbi, META, LONG_MAX);
569 		set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
570 		mutex_unlock(&sbi->cp_mutex);
571 	} else if (need_writecp) {
572 		struct cp_control cpc = {
573 			.reason = CP_RECOVERY,
574 		};
575 		mutex_unlock(&sbi->cp_mutex);
576 		write_checkpoint(sbi, &cpc);
577 	} else {
578 		mutex_unlock(&sbi->cp_mutex);
579 	}
580 	return err;
581 }
582