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