1 /**
2 * mount.c
3 *
4 * Copyright (c) 2013 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 "fsck.h"
12 #include <locale.h>
13
print_inode_info(struct f2fs_inode * inode,int name)14 void print_inode_info(struct f2fs_inode *inode, int name)
15 {
16 unsigned int i = 0;
17 int namelen = le32_to_cpu(inode->i_namelen);
18
19 if (name && namelen) {
20 inode->i_name[namelen] = '\0';
21 MSG(0, " - File name : %s\n", inode->i_name);
22 setlocale(LC_ALL, "");
23 MSG(0, " - File size : %'llu (bytes)\n",
24 le64_to_cpu(inode->i_size));
25 return;
26 }
27
28 DISP_u32(inode, i_mode);
29 DISP_u32(inode, i_uid);
30 DISP_u32(inode, i_gid);
31 DISP_u32(inode, i_links);
32 DISP_u64(inode, i_size);
33 DISP_u64(inode, i_blocks);
34
35 DISP_u64(inode, i_atime);
36 DISP_u32(inode, i_atime_nsec);
37 DISP_u64(inode, i_ctime);
38 DISP_u32(inode, i_ctime_nsec);
39 DISP_u64(inode, i_mtime);
40 DISP_u32(inode, i_mtime_nsec);
41
42 DISP_u32(inode, i_generation);
43 DISP_u32(inode, i_current_depth);
44 DISP_u32(inode, i_xattr_nid);
45 DISP_u32(inode, i_flags);
46 DISP_u32(inode, i_inline);
47 DISP_u32(inode, i_pino);
48
49 if (namelen) {
50 DISP_u32(inode, i_namelen);
51 inode->i_name[namelen] = '\0';
52 DISP_utf(inode, i_name);
53 }
54
55 printf("i_ext: fofs:%x blkaddr:%x len:%x\n",
56 inode->i_ext.fofs,
57 inode->i_ext.blk_addr,
58 inode->i_ext.len);
59
60 DISP_u32(inode, i_addr[0]); /* Pointers to data blocks */
61 DISP_u32(inode, i_addr[1]); /* Pointers to data blocks */
62 DISP_u32(inode, i_addr[2]); /* Pointers to data blocks */
63 DISP_u32(inode, i_addr[3]); /* Pointers to data blocks */
64
65 for (i = 4; i < ADDRS_PER_INODE(inode); i++) {
66 if (inode->i_addr[i] != 0x0) {
67 printf("i_addr[0x%x] points data block\r\t\t[0x%4x]\n",
68 i, inode->i_addr[i]);
69 break;
70 }
71 }
72
73 DISP_u32(inode, i_nid[0]); /* direct */
74 DISP_u32(inode, i_nid[1]); /* direct */
75 DISP_u32(inode, i_nid[2]); /* indirect */
76 DISP_u32(inode, i_nid[3]); /* indirect */
77 DISP_u32(inode, i_nid[4]); /* double indirect */
78
79 printf("\n");
80 }
81
print_node_info(struct f2fs_node * node_block)82 void print_node_info(struct f2fs_node *node_block)
83 {
84 nid_t ino = le32_to_cpu(node_block->footer.ino);
85 nid_t nid = le32_to_cpu(node_block->footer.nid);
86 /* Is this inode? */
87 if (ino == nid) {
88 DBG(0, "Node ID [0x%x:%u] is inode\n", nid, nid);
89 print_inode_info(&node_block->i, 0);
90 } else {
91 int i;
92 u32 *dump_blk = (u32 *)node_block;
93 DBG(0, "Node ID [0x%x:%u] is direct node or indirect node.\n",
94 nid, nid);
95 for (i = 0; i <= 10; i++)
96 MSG(0, "[%d]\t\t\t[0x%8x : %d]\n",
97 i, dump_blk[i], dump_blk[i]);
98 }
99 }
100
print_raw_sb_info(struct f2fs_sb_info * sbi)101 void print_raw_sb_info(struct f2fs_sb_info *sbi)
102 {
103 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
104
105 if (!config.dbg_lv)
106 return;
107
108 printf("\n");
109 printf("+--------------------------------------------------------+\n");
110 printf("| Super block |\n");
111 printf("+--------------------------------------------------------+\n");
112
113 DISP_u32(sb, magic);
114 DISP_u32(sb, major_ver);
115 DISP_u32(sb, minor_ver);
116 DISP_u32(sb, log_sectorsize);
117 DISP_u32(sb, log_sectors_per_block);
118
119 DISP_u32(sb, log_blocksize);
120 DISP_u32(sb, log_blocks_per_seg);
121 DISP_u32(sb, segs_per_sec);
122 DISP_u32(sb, secs_per_zone);
123 DISP_u32(sb, checksum_offset);
124 DISP_u64(sb, block_count);
125
126 DISP_u32(sb, section_count);
127 DISP_u32(sb, segment_count);
128 DISP_u32(sb, segment_count_ckpt);
129 DISP_u32(sb, segment_count_sit);
130 DISP_u32(sb, segment_count_nat);
131
132 DISP_u32(sb, segment_count_ssa);
133 DISP_u32(sb, segment_count_main);
134 DISP_u32(sb, segment0_blkaddr);
135
136 DISP_u32(sb, cp_blkaddr);
137 DISP_u32(sb, sit_blkaddr);
138 DISP_u32(sb, nat_blkaddr);
139 DISP_u32(sb, ssa_blkaddr);
140 DISP_u32(sb, main_blkaddr);
141
142 DISP_u32(sb, root_ino);
143 DISP_u32(sb, node_ino);
144 DISP_u32(sb, meta_ino);
145 DISP_u32(sb, cp_payload);
146 DISP("%s", sb, version);
147 printf("\n");
148 }
149
print_ckpt_info(struct f2fs_sb_info * sbi)150 void print_ckpt_info(struct f2fs_sb_info *sbi)
151 {
152 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
153
154 if (!config.dbg_lv)
155 return;
156
157 printf("\n");
158 printf("+--------------------------------------------------------+\n");
159 printf("| Checkpoint |\n");
160 printf("+--------------------------------------------------------+\n");
161
162 DISP_u64(cp, checkpoint_ver);
163 DISP_u64(cp, user_block_count);
164 DISP_u64(cp, valid_block_count);
165 DISP_u32(cp, rsvd_segment_count);
166 DISP_u32(cp, overprov_segment_count);
167 DISP_u32(cp, free_segment_count);
168
169 DISP_u32(cp, alloc_type[CURSEG_HOT_NODE]);
170 DISP_u32(cp, alloc_type[CURSEG_WARM_NODE]);
171 DISP_u32(cp, alloc_type[CURSEG_COLD_NODE]);
172 DISP_u32(cp, cur_node_segno[0]);
173 DISP_u32(cp, cur_node_segno[1]);
174 DISP_u32(cp, cur_node_segno[2]);
175
176 DISP_u32(cp, cur_node_blkoff[0]);
177 DISP_u32(cp, cur_node_blkoff[1]);
178 DISP_u32(cp, cur_node_blkoff[2]);
179
180
181 DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]);
182 DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]);
183 DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]);
184 DISP_u32(cp, cur_data_segno[0]);
185 DISP_u32(cp, cur_data_segno[1]);
186 DISP_u32(cp, cur_data_segno[2]);
187
188 DISP_u32(cp, cur_data_blkoff[0]);
189 DISP_u32(cp, cur_data_blkoff[1]);
190 DISP_u32(cp, cur_data_blkoff[2]);
191
192 DISP_u32(cp, ckpt_flags);
193 DISP_u32(cp, cp_pack_total_block_count);
194 DISP_u32(cp, cp_pack_start_sum);
195 DISP_u32(cp, valid_node_count);
196 DISP_u32(cp, valid_inode_count);
197 DISP_u32(cp, next_free_nid);
198 DISP_u32(cp, sit_ver_bitmap_bytesize);
199 DISP_u32(cp, nat_ver_bitmap_bytesize);
200 DISP_u32(cp, checksum_offset);
201 DISP_u64(cp, elapsed_time);
202
203 DISP_u32(cp, sit_nat_version_bitmap[0]);
204 printf("\n\n");
205 }
206
sanity_check_raw_super(struct f2fs_super_block * raw_super)207 int sanity_check_raw_super(struct f2fs_super_block *raw_super)
208 {
209 unsigned int blocksize;
210
211 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {
212 return -1;
213 }
214
215 if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
216 return -1;
217 }
218
219 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
220 if (F2FS_BLKSIZE != blocksize) {
221 return -1;
222 }
223
224 if (le32_to_cpu(raw_super->log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE ||
225 le32_to_cpu(raw_super->log_sectorsize) <
226 F2FS_MIN_LOG_SECTOR_SIZE) {
227 return -1;
228 }
229
230 if (le32_to_cpu(raw_super->log_sectors_per_block) +
231 le32_to_cpu(raw_super->log_sectorsize) !=
232 F2FS_MAX_LOG_SECTOR_SIZE) {
233 return -1;
234 }
235
236 return 0;
237 }
238
validate_super_block(struct f2fs_sb_info * sbi,int block)239 int validate_super_block(struct f2fs_sb_info *sbi, int block)
240 {
241 u64 offset;
242
243 sbi->raw_super = malloc(sizeof(struct f2fs_super_block));
244
245 if (block == 0)
246 offset = F2FS_SUPER_OFFSET;
247 else
248 offset = F2FS_BLKSIZE + F2FS_SUPER_OFFSET;
249
250 if (dev_read(sbi->raw_super, offset, sizeof(struct f2fs_super_block)))
251 return -1;
252
253 if (!sanity_check_raw_super(sbi->raw_super)) {
254 /* get kernel version */
255 if (config.kd >= 0) {
256 dev_read_version(config.version, 0, VERSION_LEN);
257 get_kernel_version(config.version);
258 } else {
259 memset(config.version, 0, VERSION_LEN);
260 }
261
262 /* build sb version */
263 memcpy(config.sb_version, sbi->raw_super->version, VERSION_LEN);
264 get_kernel_version(config.sb_version);
265 memcpy(config.init_version, sbi->raw_super->init_version, VERSION_LEN);
266 get_kernel_version(config.init_version);
267
268 MSG(0, "Info: MKFS version\n \"%s\"\n", config.init_version);
269 MSG(0, "Info: FSCK version\n from \"%s\"\n to \"%s\"\n",
270 config.sb_version, config.version);
271 if (memcmp(config.sb_version, config.version, VERSION_LEN)) {
272 int ret;
273
274 memcpy(sbi->raw_super->version,
275 config.version, VERSION_LEN);
276 ret = dev_write(sbi->raw_super, offset,
277 sizeof(struct f2fs_super_block));
278 ASSERT(ret >= 0);
279
280 config.auto_fix = 0;
281 config.fix_on = 1;
282 }
283 return 0;
284 }
285
286 free(sbi->raw_super);
287 MSG(0, "\tCan't find a valid F2FS superblock at 0x%x\n", block);
288
289 return -EINVAL;
290 }
291
init_sb_info(struct f2fs_sb_info * sbi)292 int init_sb_info(struct f2fs_sb_info *sbi)
293 {
294 struct f2fs_super_block *raw_super = sbi->raw_super;
295
296 sbi->log_sectors_per_block =
297 le32_to_cpu(raw_super->log_sectors_per_block);
298 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
299 sbi->blocksize = 1 << sbi->log_blocksize;
300 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
301 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
302 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
303 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
304 sbi->total_sections = le32_to_cpu(raw_super->section_count);
305 sbi->total_node_count =
306 (le32_to_cpu(raw_super->segment_count_nat) / 2)
307 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
308 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
309 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
310 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
311 sbi->cur_victim_sec = NULL_SEGNO;
312 return 0;
313 }
314
validate_checkpoint(struct f2fs_sb_info * sbi,block_t cp_addr,unsigned long long * version)315 void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr,
316 unsigned long long *version)
317 {
318 void *cp_page_1, *cp_page_2;
319 struct f2fs_checkpoint *cp_block;
320 unsigned long blk_size = sbi->blocksize;
321 unsigned long long cur_version = 0, pre_version = 0;
322 unsigned int crc = 0;
323 size_t crc_offset;
324
325 /* Read the 1st cp block in this CP pack */
326 cp_page_1 = malloc(PAGE_SIZE);
327 if (dev_read_block(cp_page_1, cp_addr) < 0)
328 return NULL;
329
330 cp_block = (struct f2fs_checkpoint *)cp_page_1;
331 crc_offset = le32_to_cpu(cp_block->checksum_offset);
332 if (crc_offset >= blk_size)
333 goto invalid_cp1;
334
335 crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset);
336 if (f2fs_crc_valid(crc, cp_block, crc_offset))
337 goto invalid_cp1;
338
339 pre_version = le64_to_cpu(cp_block->checkpoint_ver);
340
341 /* Read the 2nd cp block in this CP pack */
342 cp_page_2 = malloc(PAGE_SIZE);
343 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
344
345 if (dev_read_block(cp_page_2, cp_addr) < 0)
346 goto invalid_cp2;
347
348 cp_block = (struct f2fs_checkpoint *)cp_page_2;
349 crc_offset = le32_to_cpu(cp_block->checksum_offset);
350 if (crc_offset >= blk_size)
351 goto invalid_cp2;
352
353 crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset);
354 if (f2fs_crc_valid(crc, cp_block, crc_offset))
355 goto invalid_cp2;
356
357 cur_version = le64_to_cpu(cp_block->checkpoint_ver);
358
359 if (cur_version == pre_version) {
360 *version = cur_version;
361 free(cp_page_2);
362 return cp_page_1;
363 }
364
365 invalid_cp2:
366 free(cp_page_2);
367 invalid_cp1:
368 free(cp_page_1);
369 return NULL;
370 }
371
get_valid_checkpoint(struct f2fs_sb_info * sbi)372 int get_valid_checkpoint(struct f2fs_sb_info *sbi)
373 {
374 struct f2fs_super_block *raw_sb = sbi->raw_super;
375 void *cp1, *cp2, *cur_page;
376 unsigned long blk_size = sbi->blocksize;
377 unsigned long long cp1_version = 0, cp2_version = 0;
378 unsigned long long cp_start_blk_no;
379 unsigned int cp_blks = 1 + le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
380 int ret;
381
382 sbi->ckpt = malloc(cp_blks * blk_size);
383 if (!sbi->ckpt)
384 return -ENOMEM;
385 /*
386 * Finding out valid cp block involves read both
387 * sets( cp pack1 and cp pack 2)
388 */
389 cp_start_blk_no = le32_to_cpu(raw_sb->cp_blkaddr);
390 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
391
392 /* The second checkpoint pack should start at the next segment */
393 cp_start_blk_no += 1 << le32_to_cpu(raw_sb->log_blocks_per_seg);
394 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
395
396 if (cp1 && cp2) {
397 if (ver_after(cp2_version, cp1_version)) {
398 cur_page = cp2;
399 sbi->cur_cp = 2;
400 } else {
401 cur_page = cp1;
402 sbi->cur_cp = 1;
403 }
404 } else if (cp1) {
405 cur_page = cp1;
406 sbi->cur_cp = 1;
407 } else if (cp2) {
408 cur_page = cp2;
409 sbi->cur_cp = 2;
410 } else {
411 free(cp1);
412 free(cp2);
413 goto fail_no_cp;
414 }
415
416 memcpy(sbi->ckpt, cur_page, blk_size);
417
418 if (cp_blks > 1) {
419 unsigned int i;
420 unsigned long long cp_blk_no;
421
422 cp_blk_no = le32_to_cpu(raw_sb->cp_blkaddr);
423 if (cur_page == cp2)
424 cp_blk_no += 1 <<
425 le32_to_cpu(raw_sb->log_blocks_per_seg);
426 /* copy sit bitmap */
427 for (i = 1; i < cp_blks; i++) {
428 unsigned char *ckpt = (unsigned char *)sbi->ckpt;
429 ret = dev_read_block(cur_page, cp_blk_no + i);
430 ASSERT(ret >= 0);
431 memcpy(ckpt + i * blk_size, cur_page, blk_size);
432 }
433 }
434 free(cp1);
435 free(cp2);
436 return 0;
437
438 fail_no_cp:
439 free(sbi->ckpt);
440 return -EINVAL;
441 }
442
sanity_check_ckpt(struct f2fs_sb_info * sbi)443 int sanity_check_ckpt(struct f2fs_sb_info *sbi)
444 {
445 unsigned int total, fsmeta;
446 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
447 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
448
449 total = le32_to_cpu(raw_super->segment_count);
450 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
451 fsmeta += le32_to_cpu(raw_super->segment_count_sit);
452 fsmeta += le32_to_cpu(raw_super->segment_count_nat);
453 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
454 fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
455
456 if (fsmeta >= total)
457 return 1;
458
459 return 0;
460 }
461
init_node_manager(struct f2fs_sb_info * sbi)462 int init_node_manager(struct f2fs_sb_info *sbi)
463 {
464 struct f2fs_super_block *sb_raw = F2FS_RAW_SUPER(sbi);
465 struct f2fs_nm_info *nm_i = NM_I(sbi);
466 unsigned char *version_bitmap;
467 unsigned int nat_segs, nat_blocks;
468
469 nm_i->nat_blkaddr = le32_to_cpu(sb_raw->nat_blkaddr);
470
471 /* segment_count_nat includes pair segment so divide to 2. */
472 nat_segs = le32_to_cpu(sb_raw->segment_count_nat) >> 1;
473 nat_blocks = nat_segs << le32_to_cpu(sb_raw->log_blocks_per_seg);
474 nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks;
475 nm_i->fcnt = 0;
476 nm_i->nat_cnt = 0;
477 nm_i->init_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
478 nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
479
480 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
481
482 nm_i->nat_bitmap = malloc(nm_i->bitmap_size);
483 if (!nm_i->nat_bitmap)
484 return -ENOMEM;
485 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
486 if (!version_bitmap)
487 return -EFAULT;
488
489 /* copy version bitmap */
490 memcpy(nm_i->nat_bitmap, version_bitmap, nm_i->bitmap_size);
491 return 0;
492 }
493
build_node_manager(struct f2fs_sb_info * sbi)494 int build_node_manager(struct f2fs_sb_info *sbi)
495 {
496 int err;
497 sbi->nm_info = malloc(sizeof(struct f2fs_nm_info));
498 if (!sbi->nm_info)
499 return -ENOMEM;
500
501 err = init_node_manager(sbi);
502 if (err)
503 return err;
504
505 return 0;
506 }
507
build_sit_info(struct f2fs_sb_info * sbi)508 int build_sit_info(struct f2fs_sb_info *sbi)
509 {
510 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
511 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
512 struct sit_info *sit_i;
513 unsigned int sit_segs, start;
514 char *src_bitmap, *dst_bitmap;
515 unsigned int bitmap_size;
516
517 sit_i = malloc(sizeof(struct sit_info));
518 if (!sit_i)
519 return -ENOMEM;
520
521 SM_I(sbi)->sit_info = sit_i;
522
523 sit_i->sentries = calloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry), 1);
524
525 for (start = 0; start < TOTAL_SEGS(sbi); start++) {
526 sit_i->sentries[start].cur_valid_map
527 = calloc(SIT_VBLOCK_MAP_SIZE, 1);
528 sit_i->sentries[start].ckpt_valid_map
529 = calloc(SIT_VBLOCK_MAP_SIZE, 1);
530 if (!sit_i->sentries[start].cur_valid_map
531 || !sit_i->sentries[start].ckpt_valid_map)
532 return -ENOMEM;
533 }
534
535 sit_segs = le32_to_cpu(raw_sb->segment_count_sit) >> 1;
536 bitmap_size = __bitmap_size(sbi, SIT_BITMAP);
537 src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);
538
539 dst_bitmap = malloc(bitmap_size);
540 memcpy(dst_bitmap, src_bitmap, bitmap_size);
541
542 sit_i->sit_base_addr = le32_to_cpu(raw_sb->sit_blkaddr);
543 sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;
544 sit_i->written_valid_blocks = le64_to_cpu(ckpt->valid_block_count);
545 sit_i->sit_bitmap = dst_bitmap;
546 sit_i->bitmap_size = bitmap_size;
547 sit_i->dirty_sentries = 0;
548 sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK;
549 sit_i->elapsed_time = le64_to_cpu(ckpt->elapsed_time);
550 return 0;
551 }
552
reset_curseg(struct f2fs_sb_info * sbi,int type)553 void reset_curseg(struct f2fs_sb_info *sbi, int type)
554 {
555 struct curseg_info *curseg = CURSEG_I(sbi, type);
556 struct summary_footer *sum_footer;
557 struct seg_entry *se;
558
559 sum_footer = &(curseg->sum_blk->footer);
560 memset(sum_footer, 0, sizeof(struct summary_footer));
561 if (IS_DATASEG(type))
562 SET_SUM_TYPE(sum_footer, SUM_TYPE_DATA);
563 if (IS_NODESEG(type))
564 SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE);
565 se = get_seg_entry(sbi, curseg->segno);
566 se->type = type;
567 }
568
read_compacted_summaries(struct f2fs_sb_info * sbi)569 static void read_compacted_summaries(struct f2fs_sb_info *sbi)
570 {
571 struct curseg_info *curseg;
572 unsigned int i, j, offset;
573 block_t start;
574 char *kaddr;
575 int ret;
576
577 start = start_sum_block(sbi);
578
579 kaddr = (char *)malloc(PAGE_SIZE);
580 ret = dev_read_block(kaddr, start++);
581 ASSERT(ret >= 0);
582
583 curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
584 memcpy(&curseg->sum_blk->n_nats, kaddr, SUM_JOURNAL_SIZE);
585
586 curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
587 memcpy(&curseg->sum_blk->n_sits, kaddr + SUM_JOURNAL_SIZE,
588 SUM_JOURNAL_SIZE);
589
590 offset = 2 * SUM_JOURNAL_SIZE;
591 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
592 unsigned short blk_off;
593 struct curseg_info *curseg = CURSEG_I(sbi, i);
594
595 reset_curseg(sbi, i);
596
597 if (curseg->alloc_type == SSR)
598 blk_off = sbi->blocks_per_seg;
599 else
600 blk_off = curseg->next_blkoff;
601
602 for (j = 0; j < blk_off; j++) {
603 struct f2fs_summary *s;
604 s = (struct f2fs_summary *)(kaddr + offset);
605 curseg->sum_blk->entries[j] = *s;
606 offset += SUMMARY_SIZE;
607 if (offset + SUMMARY_SIZE <=
608 PAGE_CACHE_SIZE - SUM_FOOTER_SIZE)
609 continue;
610 memset(kaddr, 0, PAGE_SIZE);
611 ret = dev_read_block(kaddr, start++);
612 ASSERT(ret >= 0);
613 offset = 0;
614 }
615 }
616 free(kaddr);
617 }
618
restore_node_summary(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_summary_block * sum_blk)619 static void restore_node_summary(struct f2fs_sb_info *sbi,
620 unsigned int segno, struct f2fs_summary_block *sum_blk)
621 {
622 struct f2fs_node *node_blk;
623 struct f2fs_summary *sum_entry;
624 block_t addr;
625 unsigned int i;
626 int ret;
627
628 node_blk = malloc(F2FS_BLKSIZE);
629 ASSERT(node_blk);
630
631 /* scan the node segment */
632 addr = START_BLOCK(sbi, segno);
633 sum_entry = &sum_blk->entries[0];
634
635 for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) {
636 ret = dev_read_block(node_blk, addr);
637 ASSERT(ret >= 0);
638 sum_entry->nid = node_blk->footer.nid;
639 addr++;
640 }
641 free(node_blk);
642 }
643
read_normal_summaries(struct f2fs_sb_info * sbi,int type)644 static void read_normal_summaries(struct f2fs_sb_info *sbi, int type)
645 {
646 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
647 struct f2fs_summary_block *sum_blk;
648 struct curseg_info *curseg;
649 unsigned int segno = 0;
650 block_t blk_addr = 0;
651 int ret;
652
653 if (IS_DATASEG(type)) {
654 segno = le32_to_cpu(ckpt->cur_data_segno[type]);
655 if (is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG))
656 blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type);
657 else
658 blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type);
659 } else {
660 segno = le32_to_cpu(ckpt->cur_node_segno[type -
661 CURSEG_HOT_NODE]);
662 if (is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG))
663 blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE,
664 type - CURSEG_HOT_NODE);
665 else
666 blk_addr = GET_SUM_BLKADDR(sbi, segno);
667 }
668
669 sum_blk = (struct f2fs_summary_block *)malloc(PAGE_SIZE);
670 ret = dev_read_block(sum_blk, blk_addr);
671 ASSERT(ret >= 0);
672
673 if (IS_NODESEG(type) && !is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG))
674 restore_node_summary(sbi, segno, sum_blk);
675
676 curseg = CURSEG_I(sbi, type);
677 memcpy(curseg->sum_blk, sum_blk, PAGE_CACHE_SIZE);
678 reset_curseg(sbi, type);
679 free(sum_blk);
680 }
681
restore_curseg_summaries(struct f2fs_sb_info * sbi)682 static void restore_curseg_summaries(struct f2fs_sb_info *sbi)
683 {
684 int type = CURSEG_HOT_DATA;
685
686 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) {
687 read_compacted_summaries(sbi);
688 type = CURSEG_HOT_NODE;
689 }
690
691 for (; type <= CURSEG_COLD_NODE; type++)
692 read_normal_summaries(sbi, type);
693 }
694
build_curseg(struct f2fs_sb_info * sbi)695 static void build_curseg(struct f2fs_sb_info *sbi)
696 {
697 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
698 struct curseg_info *array;
699 unsigned short blk_off;
700 unsigned int segno;
701 int i;
702
703 array = malloc(sizeof(*array) * NR_CURSEG_TYPE);
704 ASSERT(array);
705
706 SM_I(sbi)->curseg_array = array;
707
708 for (i = 0; i < NR_CURSEG_TYPE; i++) {
709 array[i].sum_blk = malloc(PAGE_CACHE_SIZE);
710 ASSERT(array[i].sum_blk);
711 if (i <= CURSEG_COLD_DATA) {
712 blk_off = le16_to_cpu(ckpt->cur_data_blkoff[i]);
713 segno = le32_to_cpu(ckpt->cur_data_segno[i]);
714 }
715 if (i > CURSEG_COLD_DATA) {
716 blk_off = le16_to_cpu(ckpt->cur_node_blkoff[i -
717 CURSEG_HOT_NODE]);
718 segno = le32_to_cpu(ckpt->cur_node_segno[i -
719 CURSEG_HOT_NODE]);
720 }
721 array[i].segno = segno;
722 array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno);
723 array[i].next_segno = NULL_SEGNO;
724 array[i].next_blkoff = blk_off;
725 array[i].alloc_type = ckpt->alloc_type[i];
726 }
727 restore_curseg_summaries(sbi);
728 }
729
check_seg_range(struct f2fs_sb_info * sbi,unsigned int segno)730 inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
731 {
732 unsigned int end_segno = SM_I(sbi)->segment_count - 1;
733 ASSERT(segno <= end_segno);
734 }
735
get_current_sit_page(struct f2fs_sb_info * sbi,unsigned int segno)736 static struct f2fs_sit_block *get_current_sit_page(struct f2fs_sb_info *sbi,
737 unsigned int segno)
738 {
739 struct sit_info *sit_i = SIT_I(sbi);
740 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno);
741 block_t blk_addr = sit_i->sit_base_addr + offset;
742 struct f2fs_sit_block *sit_blk = calloc(BLOCK_SZ, 1);
743 int ret;
744
745 check_seg_range(sbi, segno);
746
747 /* calculate sit block address */
748 if (f2fs_test_bit(offset, sit_i->sit_bitmap))
749 blk_addr += sit_i->sit_blocks;
750
751 ret = dev_read_block(sit_blk, blk_addr);
752 ASSERT(ret >= 0);
753
754 return sit_blk;
755 }
756
rewrite_current_sit_page(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_sit_block * sit_blk)757 void rewrite_current_sit_page(struct f2fs_sb_info *sbi,
758 unsigned int segno, struct f2fs_sit_block *sit_blk)
759 {
760 struct sit_info *sit_i = SIT_I(sbi);
761 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno);
762 block_t blk_addr = sit_i->sit_base_addr + offset;
763 int ret;
764
765 /* calculate sit block address */
766 if (f2fs_test_bit(offset, sit_i->sit_bitmap))
767 blk_addr += sit_i->sit_blocks;
768
769 ret = dev_write_block(sit_blk, blk_addr);
770 ASSERT(ret >= 0);
771 }
772
check_block_count(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_sit_entry * raw_sit)773 void check_block_count(struct f2fs_sb_info *sbi,
774 unsigned int segno, struct f2fs_sit_entry *raw_sit)
775 {
776 struct f2fs_sm_info *sm_info = SM_I(sbi);
777 unsigned int end_segno = sm_info->segment_count - 1;
778 int valid_blocks = 0;
779 unsigned int i;
780
781 /* check segment usage */
782 if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg)
783 ASSERT_MSG("Invalid SIT vblocks: segno=0x%x, %u",
784 segno, GET_SIT_VBLOCKS(raw_sit));
785
786 /* check boundary of a given segment number */
787 if (segno > end_segno)
788 ASSERT_MSG("Invalid SEGNO: 0x%x", segno);
789
790 /* check bitmap with valid block count */
791 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++)
792 valid_blocks += get_bits_in_byte(raw_sit->valid_map[i]);
793
794 if (GET_SIT_VBLOCKS(raw_sit) != valid_blocks)
795 ASSERT_MSG("Wrong SIT valid blocks: segno=0x%x, %u vs. %u",
796 segno, GET_SIT_VBLOCKS(raw_sit), valid_blocks);
797
798 if (GET_SIT_TYPE(raw_sit) >= NO_CHECK_TYPE)
799 ASSERT_MSG("Wrong SIT type: segno=0x%x, %u",
800 segno, GET_SIT_TYPE(raw_sit));
801 }
802
seg_info_from_raw_sit(struct seg_entry * se,struct f2fs_sit_entry * raw_sit)803 void seg_info_from_raw_sit(struct seg_entry *se,
804 struct f2fs_sit_entry *raw_sit)
805 {
806 se->valid_blocks = GET_SIT_VBLOCKS(raw_sit);
807 se->ckpt_valid_blocks = GET_SIT_VBLOCKS(raw_sit);
808 memcpy(se->cur_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE);
809 memcpy(se->ckpt_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE);
810 se->type = GET_SIT_TYPE(raw_sit);
811 se->orig_type = GET_SIT_TYPE(raw_sit);
812 se->mtime = le64_to_cpu(raw_sit->mtime);
813 }
814
get_seg_entry(struct f2fs_sb_info * sbi,unsigned int segno)815 struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
816 unsigned int segno)
817 {
818 struct sit_info *sit_i = SIT_I(sbi);
819 return &sit_i->sentries[segno];
820 }
821
get_sum_block(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_summary_block * sum_blk)822 int get_sum_block(struct f2fs_sb_info *sbi, unsigned int segno,
823 struct f2fs_summary_block *sum_blk)
824 {
825 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
826 struct curseg_info *curseg;
827 int type, ret;
828 u64 ssa_blk;
829
830 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
831 for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) {
832 if (segno == ckpt->cur_node_segno[type]) {
833 curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type);
834 if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) {
835 ASSERT_MSG("segno [0x%x] indicates a data "
836 "segment, but should be node",
837 segno);
838 return -EINVAL;
839 }
840 memcpy(sum_blk, curseg->sum_blk, BLOCK_SZ);
841 return SEG_TYPE_CUR_NODE;
842 }
843 }
844
845 for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) {
846 if (segno == ckpt->cur_data_segno[type]) {
847 curseg = CURSEG_I(sbi, type);
848 if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) {
849 ASSERT_MSG("segno [0x%x] indicates a node "
850 "segment, but should be data",
851 segno);
852 return -EINVAL;
853 }
854 DBG(2, "segno [0x%x] is current data seg[0x%x]\n",
855 segno, type);
856 memcpy(sum_blk, curseg->sum_blk, BLOCK_SZ);
857 return SEG_TYPE_CUR_DATA;
858 }
859 }
860
861 ret = dev_read_block(sum_blk, ssa_blk);
862 ASSERT(ret >= 0);
863
864 if (IS_SUM_NODE_SEG(sum_blk->footer))
865 return SEG_TYPE_NODE;
866 else
867 return SEG_TYPE_DATA;
868
869 }
870
get_sum_entry(struct f2fs_sb_info * sbi,u32 blk_addr,struct f2fs_summary * sum_entry)871 int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr,
872 struct f2fs_summary *sum_entry)
873 {
874 struct f2fs_summary_block *sum_blk;
875 u32 segno, offset;
876 int ret;
877
878 segno = GET_SEGNO(sbi, blk_addr);
879 offset = OFFSET_IN_SEG(sbi, blk_addr);
880
881 sum_blk = calloc(BLOCK_SZ, 1);
882
883 ret = get_sum_block(sbi, segno, sum_blk);
884 memcpy(sum_entry, &(sum_blk->entries[offset]),
885 sizeof(struct f2fs_summary));
886 free(sum_blk);
887 return ret;
888 }
889
get_nat_entry(struct f2fs_sb_info * sbi,nid_t nid,struct f2fs_nat_entry * raw_nat)890 static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid,
891 struct f2fs_nat_entry *raw_nat)
892 {
893 struct f2fs_nm_info *nm_i = NM_I(sbi);
894 struct f2fs_nat_block *nat_block;
895 pgoff_t block_off;
896 pgoff_t block_addr;
897 int seg_off, entry_off;
898 int ret;
899
900 if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0)
901 return;
902
903 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
904
905 block_off = nid / NAT_ENTRY_PER_BLOCK;
906 entry_off = nid % NAT_ENTRY_PER_BLOCK;
907
908 seg_off = block_off >> sbi->log_blocks_per_seg;
909 block_addr = (pgoff_t)(nm_i->nat_blkaddr +
910 (seg_off << sbi->log_blocks_per_seg << 1) +
911 (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
912
913 if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
914 block_addr += sbi->blocks_per_seg;
915
916 ret = dev_read_block(nat_block, block_addr);
917 ASSERT(ret >= 0);
918
919 memcpy(raw_nat, &nat_block->entries[entry_off],
920 sizeof(struct f2fs_nat_entry));
921 free(nat_block);
922 }
923
get_node_info(struct f2fs_sb_info * sbi,nid_t nid,struct node_info * ni)924 void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
925 {
926 struct f2fs_nat_entry raw_nat;
927 get_nat_entry(sbi, nid, &raw_nat);
928 ni->nid = nid;
929 node_info_from_raw_nat(ni, &raw_nat);
930 }
931
build_sit_entries(struct f2fs_sb_info * sbi)932 void build_sit_entries(struct f2fs_sb_info *sbi)
933 {
934 struct sit_info *sit_i = SIT_I(sbi);
935 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
936 struct f2fs_summary_block *sum = curseg->sum_blk;
937 unsigned int segno;
938
939 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
940 struct seg_entry *se = &sit_i->sentries[segno];
941 struct f2fs_sit_block *sit_blk;
942 struct f2fs_sit_entry sit;
943 int i;
944
945 for (i = 0; i < sits_in_cursum(sum); i++) {
946 if (le32_to_cpu(segno_in_journal(sum, i)) == segno) {
947 sit = sit_in_journal(sum, i);
948 goto got_it;
949 }
950 }
951 sit_blk = get_current_sit_page(sbi, segno);
952 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
953 free(sit_blk);
954 got_it:
955 check_block_count(sbi, segno, &sit);
956 seg_info_from_raw_sit(se, &sit);
957 }
958
959 }
960
build_segment_manager(struct f2fs_sb_info * sbi)961 int build_segment_manager(struct f2fs_sb_info *sbi)
962 {
963 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
964 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
965 struct f2fs_sm_info *sm_info;
966
967 sm_info = malloc(sizeof(struct f2fs_sm_info));
968 if (!sm_info)
969 return -ENOMEM;
970
971 /* init sm info */
972 sbi->sm_info = sm_info;
973 sm_info->seg0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
974 sm_info->main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
975 sm_info->segment_count = le32_to_cpu(raw_super->segment_count);
976 sm_info->reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
977 sm_info->ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
978 sm_info->main_segments = le32_to_cpu(raw_super->segment_count_main);
979 sm_info->ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
980
981 build_sit_info(sbi);
982
983 build_curseg(sbi);
984
985 build_sit_entries(sbi);
986
987 return 0;
988 }
989
build_sit_area_bitmap(struct f2fs_sb_info * sbi)990 void build_sit_area_bitmap(struct f2fs_sb_info *sbi)
991 {
992 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
993 struct f2fs_sm_info *sm_i = SM_I(sbi);
994 unsigned int segno = 0;
995 char *ptr = NULL;
996 u32 sum_vblocks = 0;
997 u32 free_segs = 0;
998 struct seg_entry *se;
999
1000 fsck->sit_area_bitmap_sz = sm_i->main_segments * SIT_VBLOCK_MAP_SIZE;
1001 fsck->sit_area_bitmap = calloc(1, fsck->sit_area_bitmap_sz);
1002 ptr = fsck->sit_area_bitmap;
1003
1004 ASSERT(fsck->sit_area_bitmap_sz == fsck->main_area_bitmap_sz);
1005
1006 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1007 se = get_seg_entry(sbi, segno);
1008
1009 memcpy(ptr, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE);
1010 ptr += SIT_VBLOCK_MAP_SIZE;
1011
1012 if (se->valid_blocks == 0x0) {
1013 if (sbi->ckpt->cur_node_segno[0] == segno ||
1014 sbi->ckpt->cur_data_segno[0] == segno ||
1015 sbi->ckpt->cur_node_segno[1] == segno ||
1016 sbi->ckpt->cur_data_segno[1] == segno ||
1017 sbi->ckpt->cur_node_segno[2] == segno ||
1018 sbi->ckpt->cur_data_segno[2] == segno) {
1019 continue;
1020 } else {
1021 free_segs++;
1022 }
1023 } else {
1024 sum_vblocks += se->valid_blocks;
1025 }
1026 }
1027 fsck->chk.sit_valid_blocks = sum_vblocks;
1028 fsck->chk.sit_free_segs = free_segs;
1029
1030 DBG(1, "Blocks [0x%x : %d] Free Segs [0x%x : %d]\n\n",
1031 sum_vblocks, sum_vblocks,
1032 free_segs, free_segs);
1033 }
1034
rewrite_sit_area_bitmap(struct f2fs_sb_info * sbi)1035 void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi)
1036 {
1037 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1038 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1039 struct sit_info *sit_i = SIT_I(sbi);
1040 unsigned int segno = 0;
1041 struct f2fs_summary_block *sum = curseg->sum_blk;
1042 char *ptr = NULL;
1043
1044 /* remove sit journal */
1045 sum->n_sits = 0;
1046
1047 fsck->chk.free_segs = 0;
1048
1049 ptr = fsck->main_area_bitmap;
1050
1051 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1052 struct f2fs_sit_block *sit_blk;
1053 struct f2fs_sit_entry *sit;
1054 struct seg_entry *se;
1055 u16 valid_blocks = 0;
1056 u16 type;
1057 int i;
1058
1059 sit_blk = get_current_sit_page(sbi, segno);
1060 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
1061 memcpy(sit->valid_map, ptr, SIT_VBLOCK_MAP_SIZE);
1062
1063 /* update valid block count */
1064 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++)
1065 valid_blocks += get_bits_in_byte(sit->valid_map[i]);
1066
1067 se = get_seg_entry(sbi, segno);
1068 type = se->type;
1069 if (type >= NO_CHECK_TYPE) {
1070 ASSERT_MSG("Invalide type and valid blocks=%x,%x",
1071 segno, valid_blocks);
1072 type = 0;
1073 }
1074 sit->vblocks = cpu_to_le16((type << SIT_VBLOCKS_SHIFT) |
1075 valid_blocks);
1076 rewrite_current_sit_page(sbi, segno, sit_blk);
1077 free(sit_blk);
1078
1079 if (valid_blocks == 0 &&
1080 sbi->ckpt->cur_node_segno[0] != segno &&
1081 sbi->ckpt->cur_data_segno[0] != segno &&
1082 sbi->ckpt->cur_node_segno[1] != segno &&
1083 sbi->ckpt->cur_data_segno[1] != segno &&
1084 sbi->ckpt->cur_node_segno[2] != segno &&
1085 sbi->ckpt->cur_data_segno[2] != segno)
1086 fsck->chk.free_segs++;
1087
1088 ptr += SIT_VBLOCK_MAP_SIZE;
1089 }
1090 }
1091
lookup_nat_in_journal(struct f2fs_sb_info * sbi,u32 nid,struct f2fs_nat_entry * raw_nat)1092 int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid,
1093 struct f2fs_nat_entry *raw_nat)
1094 {
1095 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1096 struct f2fs_summary_block *sum = curseg->sum_blk;
1097 int i = 0;
1098
1099 for (i = 0; i < nats_in_cursum(sum); i++) {
1100 if (le32_to_cpu(nid_in_journal(sum, i)) == nid) {
1101 memcpy(raw_nat, &nat_in_journal(sum, i),
1102 sizeof(struct f2fs_nat_entry));
1103 DBG(3, "==> Found nid [0x%x] in nat cache\n", nid);
1104 return i;
1105 }
1106 }
1107 return -1;
1108 }
1109
nullify_nat_entry(struct f2fs_sb_info * sbi,u32 nid)1110 void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
1111 {
1112 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1113 struct f2fs_summary_block *sum = curseg->sum_blk;
1114 struct f2fs_nm_info *nm_i = NM_I(sbi);
1115 struct f2fs_nat_block *nat_block;
1116 pgoff_t block_off;
1117 pgoff_t block_addr;
1118 int seg_off, entry_off;
1119 int ret;
1120 int i = 0;
1121
1122 /* check in journal */
1123 for (i = 0; i < nats_in_cursum(sum); i++) {
1124 if (le32_to_cpu(nid_in_journal(sum, i)) == nid) {
1125 memset(&nat_in_journal(sum, i), 0,
1126 sizeof(struct f2fs_nat_entry));
1127 FIX_MSG("Remove nid [0x%x] in nat journal\n", nid);
1128 return;
1129 }
1130 }
1131 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
1132
1133 block_off = nid / NAT_ENTRY_PER_BLOCK;
1134 entry_off = nid % NAT_ENTRY_PER_BLOCK;
1135
1136 seg_off = block_off >> sbi->log_blocks_per_seg;
1137 block_addr = (pgoff_t)(nm_i->nat_blkaddr +
1138 (seg_off << sbi->log_blocks_per_seg << 1) +
1139 (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
1140
1141 if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
1142 block_addr += sbi->blocks_per_seg;
1143
1144 ret = dev_read_block(nat_block, block_addr);
1145 ASSERT(ret >= 0);
1146
1147 memset(&nat_block->entries[entry_off], 0,
1148 sizeof(struct f2fs_nat_entry));
1149
1150 ret = dev_write_block(nat_block, block_addr);
1151 ASSERT(ret >= 0);
1152 free(nat_block);
1153 }
1154
build_nat_area_bitmap(struct f2fs_sb_info * sbi)1155 void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
1156 {
1157 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1158 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
1159 struct f2fs_nm_info *nm_i = NM_I(sbi);
1160 struct f2fs_nat_block *nat_block;
1161 u32 nid, nr_nat_blks;
1162 pgoff_t block_off;
1163 pgoff_t block_addr;
1164 int seg_off;
1165 int ret;
1166 unsigned int i;
1167
1168 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
1169 ASSERT(nat_block);
1170
1171 /* Alloc & build nat entry bitmap */
1172 nr_nat_blks = (le32_to_cpu(raw_sb->segment_count_nat) / 2) <<
1173 sbi->log_blocks_per_seg;
1174
1175 fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK;
1176 fsck->nat_area_bitmap_sz = (fsck->nr_nat_entries + 7) / 8;
1177 fsck->nat_area_bitmap = calloc(fsck->nat_area_bitmap_sz, 1);
1178 ASSERT(fsck->nat_area_bitmap != NULL);
1179
1180 for (block_off = 0; block_off < nr_nat_blks; block_off++) {
1181
1182 seg_off = block_off >> sbi->log_blocks_per_seg;
1183 block_addr = (pgoff_t)(nm_i->nat_blkaddr +
1184 (seg_off << sbi->log_blocks_per_seg << 1) +
1185 (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
1186
1187 if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
1188 block_addr += sbi->blocks_per_seg;
1189
1190 ret = dev_read_block(nat_block, block_addr);
1191 ASSERT(ret >= 0);
1192
1193 nid = block_off * NAT_ENTRY_PER_BLOCK;
1194 for (i = 0; i < NAT_ENTRY_PER_BLOCK; i++) {
1195 struct f2fs_nat_entry raw_nat;
1196 struct node_info ni;
1197 ni.nid = nid + i;
1198
1199 if ((nid + i) == F2FS_NODE_INO(sbi) ||
1200 (nid + i) == F2FS_META_INO(sbi)) {
1201 ASSERT(nat_block->entries[i].block_addr != 0x0);
1202 continue;
1203 }
1204
1205 if (lookup_nat_in_journal(sbi, nid + i,
1206 &raw_nat) >= 0) {
1207 node_info_from_raw_nat(&ni, &raw_nat);
1208 if (ni.blk_addr != 0x0) {
1209 f2fs_set_bit(nid + i,
1210 fsck->nat_area_bitmap);
1211 fsck->chk.valid_nat_entry_cnt++;
1212 DBG(3, "nid[0x%x] in nat cache\n",
1213 nid + i);
1214 }
1215 } else {
1216 node_info_from_raw_nat(&ni,
1217 &nat_block->entries[i]);
1218 if (ni.blk_addr == 0)
1219 continue;
1220 ASSERT(nid + i != 0x0);
1221
1222 DBG(3, "nid[0x%8x] addr[0x%16x] ino[0x%8x]\n",
1223 nid + i, ni.blk_addr, ni.ino);
1224 f2fs_set_bit(nid + i, fsck->nat_area_bitmap);
1225 fsck->chk.valid_nat_entry_cnt++;
1226 }
1227 }
1228 }
1229 free(nat_block);
1230
1231 DBG(1, "valid nat entries (block_addr != 0x0) [0x%8x : %u]\n",
1232 fsck->chk.valid_nat_entry_cnt,
1233 fsck->chk.valid_nat_entry_cnt);
1234 }
1235
f2fs_do_mount(struct f2fs_sb_info * sbi)1236 int f2fs_do_mount(struct f2fs_sb_info *sbi)
1237 {
1238 int ret;
1239
1240 sbi->active_logs = NR_CURSEG_TYPE;
1241 ret = validate_super_block(sbi, 0);
1242 if (ret) {
1243 ret = validate_super_block(sbi, 1);
1244 if (ret)
1245 return -1;
1246 }
1247
1248 print_raw_sb_info(sbi);
1249
1250 init_sb_info(sbi);
1251
1252 ret = get_valid_checkpoint(sbi);
1253 if (ret) {
1254 ERR_MSG("Can't find valid checkpoint\n");
1255 return -1;
1256 }
1257
1258 if (sanity_check_ckpt(sbi)) {
1259 ERR_MSG("Checkpoint is polluted\n");
1260 return -1;
1261 }
1262
1263 print_ckpt_info(sbi);
1264
1265 if (config.auto_fix) {
1266 u32 flag = le32_to_cpu(sbi->ckpt->ckpt_flags);
1267
1268 if (flag & CP_FSCK_FLAG)
1269 config.fix_on = 1;
1270 else
1271 return 1;
1272 }
1273
1274 config.bug_on = 0;
1275
1276 sbi->total_valid_node_count = le32_to_cpu(sbi->ckpt->valid_node_count);
1277 sbi->total_valid_inode_count =
1278 le32_to_cpu(sbi->ckpt->valid_inode_count);
1279 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
1280 sbi->total_valid_block_count =
1281 le64_to_cpu(sbi->ckpt->valid_block_count);
1282 sbi->last_valid_block_count = sbi->total_valid_block_count;
1283 sbi->alloc_valid_block_count = 0;
1284
1285 if (build_segment_manager(sbi)) {
1286 ERR_MSG("build_segment_manager failed\n");
1287 return -1;
1288 }
1289
1290 if (build_node_manager(sbi)) {
1291 ERR_MSG("build_segment_manager failed\n");
1292 return -1;
1293 }
1294
1295 return 0;
1296 }
1297
f2fs_do_umount(struct f2fs_sb_info * sbi)1298 void f2fs_do_umount(struct f2fs_sb_info *sbi)
1299 {
1300 struct sit_info *sit_i = SIT_I(sbi);
1301 struct f2fs_sm_info *sm_i = SM_I(sbi);
1302 struct f2fs_nm_info *nm_i = NM_I(sbi);
1303 unsigned int i;
1304
1305 /* free nm_info */
1306 free(nm_i->nat_bitmap);
1307 free(sbi->nm_info);
1308
1309 /* free sit_info */
1310 for (i = 0; i < TOTAL_SEGS(sbi); i++) {
1311 free(sit_i->sentries[i].cur_valid_map);
1312 free(sit_i->sentries[i].ckpt_valid_map);
1313 }
1314 free(sit_i->sit_bitmap);
1315 free(sm_i->sit_info);
1316
1317 /* free sm_info */
1318 for (i = 0; i < NR_CURSEG_TYPE; i++)
1319 free(sm_i->curseg_array[i].sum_blk);
1320
1321 free(sm_i->curseg_array);
1322 free(sbi->sm_info);
1323
1324 free(sbi->ckpt);
1325 free(sbi->raw_super);
1326 }
1327