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 "xattr.h"
13 #include <locale.h>
14 #ifdef HAVE_LINUX_POSIX_ACL_H
15 #include <linux/posix_acl.h>
16 #endif
17 #ifdef HAVE_SYS_ACL_H
18 #include <sys/acl.h>
19 #endif
20
21 #ifndef ACL_UNDEFINED_TAG
22 #define ACL_UNDEFINED_TAG (0x00)
23 #define ACL_USER_OBJ (0x01)
24 #define ACL_USER (0x02)
25 #define ACL_GROUP_OBJ (0x04)
26 #define ACL_GROUP (0x08)
27 #define ACL_MASK (0x10)
28 #define ACL_OTHER (0x20)
29 #endif
30
get_free_segments(struct f2fs_sb_info * sbi)31 u32 get_free_segments(struct f2fs_sb_info *sbi)
32 {
33 u32 i, free_segs = 0;
34
35 for (i = 0; i < TOTAL_SEGS(sbi); i++) {
36 struct seg_entry *se = get_seg_entry(sbi, i);
37
38 if (se->valid_blocks == 0x0 && !IS_CUR_SEGNO(sbi, i))
39 free_segs++;
40 }
41 return free_segs;
42 }
43
update_free_segments(struct f2fs_sb_info * sbi)44 void update_free_segments(struct f2fs_sb_info *sbi)
45 {
46 char *progress = "-*|*-";
47 static int i = 0;
48
49 if (c.dbg_lv)
50 return;
51
52 MSG(0, "\r [ %c ] Free segments: 0x%x", progress[i % 5], get_free_segments(sbi));
53 fflush(stdout);
54 i++;
55 }
56
57 #if defined(HAVE_LINUX_POSIX_ACL_H) || defined(HAVE_SYS_ACL_H)
print_acl(char * value,int size)58 void print_acl(char *value, int size)
59 {
60 struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value;
61 struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1);
62 const char *end = value + size;
63 int i, count;
64
65 if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION)) {
66 MSG(0, "Invalid ACL version [0x%x : 0x%x]\n",
67 le32_to_cpu(hdr->a_version), F2FS_ACL_VERSION);
68 return;
69 }
70
71 count = f2fs_acl_count(size);
72 if (count <= 0) {
73 MSG(0, "Invalid ACL value size %d\n", size);
74 return;
75 }
76
77 for (i = 0; i < count; i++) {
78 if ((char *)entry > end) {
79 MSG(0, "Invalid ACL entries count %d\n", count);
80 return;
81 }
82
83 switch (le16_to_cpu(entry->e_tag)) {
84 case ACL_USER_OBJ:
85 case ACL_GROUP_OBJ:
86 case ACL_MASK:
87 case ACL_OTHER:
88 MSG(0, "tag:0x%x perm:0x%x\n",
89 le16_to_cpu(entry->e_tag),
90 le16_to_cpu(entry->e_perm));
91 entry = (struct f2fs_acl_entry *)((char *)entry +
92 sizeof(struct f2fs_acl_entry_short));
93 break;
94 case ACL_USER:
95 MSG(0, "tag:0x%x perm:0x%x uid:%u\n",
96 le16_to_cpu(entry->e_tag),
97 le16_to_cpu(entry->e_perm),
98 le32_to_cpu(entry->e_id));
99 entry = (struct f2fs_acl_entry *)((char *)entry +
100 sizeof(struct f2fs_acl_entry));
101 break;
102 case ACL_GROUP:
103 MSG(0, "tag:0x%x perm:0x%x gid:%u\n",
104 le16_to_cpu(entry->e_tag),
105 le16_to_cpu(entry->e_perm),
106 le32_to_cpu(entry->e_id));
107 entry = (struct f2fs_acl_entry *)((char *)entry +
108 sizeof(struct f2fs_acl_entry));
109 break;
110 default:
111 MSG(0, "Unknown ACL tag 0x%x\n",
112 le16_to_cpu(entry->e_tag));
113 return;
114 }
115 }
116 }
117 #else
118 #define print_acl(value, size) do { \
119 int i; \
120 for (i = 0; i < size; i++) \
121 MSG(0, "%02X", value[i]); \
122 MSG(0, "\n"); \
123 } while (0)
124 #endif
125
print_xattr_entry(struct f2fs_xattr_entry * ent)126 void print_xattr_entry(struct f2fs_xattr_entry *ent)
127 {
128 char *value = (char *)(ent->e_name + le16_to_cpu(ent->e_name_len));
129 struct fscrypt_context *ctx;
130 int i;
131
132 MSG(0, "\nxattr: e_name_index:%d e_name:", ent->e_name_index);
133 for (i = 0; i < le16_to_cpu(ent->e_name_len); i++)
134 MSG(0, "%c", ent->e_name[i]);
135 MSG(0, " e_name_len:%d e_value_size:%d e_value:\n",
136 ent->e_name_len, le16_to_cpu(ent->e_value_size));
137
138 switch (ent->e_name_index) {
139 case F2FS_XATTR_INDEX_POSIX_ACL_ACCESS:
140 case F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT:
141 print_acl(value, le16_to_cpu(ent->e_value_size));
142 break;
143 case F2FS_XATTR_INDEX_USER:
144 case F2FS_XATTR_INDEX_SECURITY:
145 case F2FS_XATTR_INDEX_TRUSTED:
146 case F2FS_XATTR_INDEX_LUSTRE:
147 for (i = 0; i < le16_to_cpu(ent->e_value_size); i++)
148 MSG(0, "%02X", value[i]);
149 MSG(0, "\n");
150 break;
151 case F2FS_XATTR_INDEX_ENCRYPTION:
152 ctx = (struct fscrypt_context *)value;
153 MSG(0, "format: %d\n", ctx->format);
154 MSG(0, "contents_encryption_mode: 0x%x\n", ctx->contents_encryption_mode);
155 MSG(0, "filenames_encryption_mode: 0x%x\n", ctx->filenames_encryption_mode);
156 MSG(0, "flags: 0x%x\n", ctx->flags);
157 MSG(0, "master_key_descriptor: ");
158 for (i = 0; i < FS_KEY_DESCRIPTOR_SIZE; i++)
159 MSG(0, "%02X", ctx->master_key_descriptor[i]);
160 MSG(0, "\nnonce: ");
161 for (i = 0; i < FS_KEY_DERIVATION_NONCE_SIZE; i++)
162 MSG(0, "%02X", ctx->nonce[i]);
163 MSG(0, "\n");
164 break;
165 default:
166 break;
167 }
168 }
169
print_inode_info(struct f2fs_sb_info * sbi,struct f2fs_node * node,int name)170 void print_inode_info(struct f2fs_sb_info *sbi,
171 struct f2fs_node *node, int name)
172 {
173 struct f2fs_inode *inode = &node->i;
174 void *xattr_addr;
175 struct f2fs_xattr_entry *ent;
176 unsigned char en[F2FS_NAME_LEN + 1];
177 unsigned int i = 0;
178 u32 namelen = le32_to_cpu(inode->i_namelen);
179 int enc_name = file_enc_name(inode);
180 int ofs = __get_extra_isize(inode);
181
182 namelen = convert_encrypted_name(inode->i_name, namelen, en, enc_name);
183 en[namelen] = '\0';
184 if (name && namelen) {
185 inode->i_name[namelen] = '\0';
186 MSG(0, " - File name : %s%s\n", en,
187 enc_name ? " <encrypted>" : "");
188 setlocale(LC_ALL, "");
189 MSG(0, " - File size : %'llu (bytes)\n",
190 le64_to_cpu(inode->i_size));
191 return;
192 }
193
194 DISP_u32(inode, i_mode);
195 DISP_u32(inode, i_advise);
196 DISP_u32(inode, i_uid);
197 DISP_u32(inode, i_gid);
198 DISP_u32(inode, i_links);
199 DISP_u64(inode, i_size);
200 DISP_u64(inode, i_blocks);
201
202 DISP_u64(inode, i_atime);
203 DISP_u32(inode, i_atime_nsec);
204 DISP_u64(inode, i_ctime);
205 DISP_u32(inode, i_ctime_nsec);
206 DISP_u64(inode, i_mtime);
207 DISP_u32(inode, i_mtime_nsec);
208
209 DISP_u32(inode, i_generation);
210 DISP_u32(inode, i_current_depth);
211 DISP_u32(inode, i_xattr_nid);
212 DISP_u32(inode, i_flags);
213 DISP_u32(inode, i_inline);
214 DISP_u32(inode, i_pino);
215 DISP_u32(inode, i_dir_level);
216
217 if (namelen) {
218 DISP_u32(inode, i_namelen);
219 printf("%-30s\t\t[%s]\n", "i_name", en);
220 }
221
222 printf("i_ext: fofs:%x blkaddr:%x len:%x\n",
223 le32_to_cpu(inode->i_ext.fofs),
224 le32_to_cpu(inode->i_ext.blk_addr),
225 le32_to_cpu(inode->i_ext.len));
226
227 if (c.feature & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR)) {
228 DISP_u16(inode, i_extra_isize);
229 if (c.feature & cpu_to_le32(F2FS_FEATURE_FLEXIBLE_INLINE_XATTR))
230 DISP_u16(inode, i_inline_xattr_size);
231 if (c.feature & cpu_to_le32(F2FS_FEATURE_PRJQUOTA))
232 DISP_u32(inode, i_projid);
233 if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM))
234 DISP_u32(inode, i_inode_checksum);
235 if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CRTIME)) {
236 DISP_u64(inode, i_crtime);
237 DISP_u32(inode, i_crtime_nsec);
238 }
239 }
240
241 DISP_u32(inode, i_addr[ofs]); /* Pointers to data blocks */
242 DISP_u32(inode, i_addr[ofs + 1]); /* Pointers to data blocks */
243 DISP_u32(inode, i_addr[ofs + 2]); /* Pointers to data blocks */
244 DISP_u32(inode, i_addr[ofs + 3]); /* Pointers to data blocks */
245
246 for (i = ofs + 3; i < ADDRS_PER_INODE(inode); i++) {
247 if (inode->i_addr[i] == 0x0)
248 break;
249 printf("i_addr[0x%x] points data block\t\t[0x%4x]\n",
250 i, le32_to_cpu(inode->i_addr[i]));
251 }
252
253 DISP_u32(inode, i_nid[0]); /* direct */
254 DISP_u32(inode, i_nid[1]); /* direct */
255 DISP_u32(inode, i_nid[2]); /* indirect */
256 DISP_u32(inode, i_nid[3]); /* indirect */
257 DISP_u32(inode, i_nid[4]); /* double indirect */
258
259 xattr_addr = read_all_xattrs(sbi, node);
260 list_for_each_xattr(ent, xattr_addr) {
261 print_xattr_entry(ent);
262 }
263 free(xattr_addr);
264
265 printf("\n");
266 }
267
print_node_info(struct f2fs_sb_info * sbi,struct f2fs_node * node_block,int verbose)268 void print_node_info(struct f2fs_sb_info *sbi,
269 struct f2fs_node *node_block, int verbose)
270 {
271 nid_t ino = le32_to_cpu(node_block->footer.ino);
272 nid_t nid = le32_to_cpu(node_block->footer.nid);
273 /* Is this inode? */
274 if (ino == nid) {
275 DBG(verbose, "Node ID [0x%x:%u] is inode\n", nid, nid);
276 print_inode_info(sbi, node_block, verbose);
277 } else {
278 int i;
279 u32 *dump_blk = (u32 *)node_block;
280 DBG(verbose,
281 "Node ID [0x%x:%u] is direct node or indirect node.\n",
282 nid, nid);
283 for (i = 0; i <= 10; i++)
284 MSG(verbose, "[%d]\t\t\t[0x%8x : %d]\n",
285 i, dump_blk[i], dump_blk[i]);
286 }
287 }
288
DISP_label(u_int16_t * name)289 static void DISP_label(u_int16_t *name)
290 {
291 char buffer[MAX_VOLUME_NAME];
292
293 utf16_to_utf8(buffer, name, MAX_VOLUME_NAME, MAX_VOLUME_NAME);
294 printf("%-30s" "\t\t[%s]\n", "volum_name", buffer);
295 }
296
print_raw_sb_info(struct f2fs_super_block * sb)297 void print_raw_sb_info(struct f2fs_super_block *sb)
298 {
299 if (!c.dbg_lv)
300 return;
301
302 printf("\n");
303 printf("+--------------------------------------------------------+\n");
304 printf("| Super block |\n");
305 printf("+--------------------------------------------------------+\n");
306
307 DISP_u32(sb, magic);
308 DISP_u32(sb, major_ver);
309
310 DISP_label(sb->volume_name);
311
312 DISP_u32(sb, minor_ver);
313 DISP_u32(sb, log_sectorsize);
314 DISP_u32(sb, log_sectors_per_block);
315
316 DISP_u32(sb, log_blocksize);
317 DISP_u32(sb, log_blocks_per_seg);
318 DISP_u32(sb, segs_per_sec);
319 DISP_u32(sb, secs_per_zone);
320 DISP_u32(sb, checksum_offset);
321 DISP_u64(sb, block_count);
322
323 DISP_u32(sb, section_count);
324 DISP_u32(sb, segment_count);
325 DISP_u32(sb, segment_count_ckpt);
326 DISP_u32(sb, segment_count_sit);
327 DISP_u32(sb, segment_count_nat);
328
329 DISP_u32(sb, segment_count_ssa);
330 DISP_u32(sb, segment_count_main);
331 DISP_u32(sb, segment0_blkaddr);
332
333 DISP_u32(sb, cp_blkaddr);
334 DISP_u32(sb, sit_blkaddr);
335 DISP_u32(sb, nat_blkaddr);
336 DISP_u32(sb, ssa_blkaddr);
337 DISP_u32(sb, main_blkaddr);
338
339 DISP_u32(sb, root_ino);
340 DISP_u32(sb, node_ino);
341 DISP_u32(sb, meta_ino);
342 DISP_u32(sb, cp_payload);
343 DISP_u32(sb, crc);
344 DISP("%-.256s", sb, version);
345 printf("\n");
346 }
347
print_ckpt_info(struct f2fs_sb_info * sbi)348 void print_ckpt_info(struct f2fs_sb_info *sbi)
349 {
350 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
351
352 if (!c.dbg_lv)
353 return;
354
355 printf("\n");
356 printf("+--------------------------------------------------------+\n");
357 printf("| Checkpoint |\n");
358 printf("+--------------------------------------------------------+\n");
359
360 DISP_u64(cp, checkpoint_ver);
361 DISP_u64(cp, user_block_count);
362 DISP_u64(cp, valid_block_count);
363 DISP_u32(cp, rsvd_segment_count);
364 DISP_u32(cp, overprov_segment_count);
365 DISP_u32(cp, free_segment_count);
366
367 DISP_u32(cp, alloc_type[CURSEG_HOT_NODE]);
368 DISP_u32(cp, alloc_type[CURSEG_WARM_NODE]);
369 DISP_u32(cp, alloc_type[CURSEG_COLD_NODE]);
370 DISP_u32(cp, cur_node_segno[0]);
371 DISP_u32(cp, cur_node_segno[1]);
372 DISP_u32(cp, cur_node_segno[2]);
373
374 DISP_u32(cp, cur_node_blkoff[0]);
375 DISP_u32(cp, cur_node_blkoff[1]);
376 DISP_u32(cp, cur_node_blkoff[2]);
377
378
379 DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]);
380 DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]);
381 DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]);
382 DISP_u32(cp, cur_data_segno[0]);
383 DISP_u32(cp, cur_data_segno[1]);
384 DISP_u32(cp, cur_data_segno[2]);
385
386 DISP_u32(cp, cur_data_blkoff[0]);
387 DISP_u32(cp, cur_data_blkoff[1]);
388 DISP_u32(cp, cur_data_blkoff[2]);
389
390 DISP_u32(cp, ckpt_flags);
391 DISP_u32(cp, cp_pack_total_block_count);
392 DISP_u32(cp, cp_pack_start_sum);
393 DISP_u32(cp, valid_node_count);
394 DISP_u32(cp, valid_inode_count);
395 DISP_u32(cp, next_free_nid);
396 DISP_u32(cp, sit_ver_bitmap_bytesize);
397 DISP_u32(cp, nat_ver_bitmap_bytesize);
398 DISP_u32(cp, checksum_offset);
399 DISP_u64(cp, elapsed_time);
400
401 DISP_u32(cp, sit_nat_version_bitmap[0]);
402 printf("\n\n");
403 }
404
print_cp_state(u32 flag)405 void print_cp_state(u32 flag)
406 {
407 MSG(0, "Info: checkpoint state = %x : ", flag);
408 if (flag & CP_QUOTA_NEED_FSCK_FLAG)
409 MSG(0, "%s", " quota_need_fsck");
410 if (flag & CP_LARGE_NAT_BITMAP_FLAG)
411 MSG(0, "%s", " large_nat_bitmap");
412 if (flag & CP_NOCRC_RECOVERY_FLAG)
413 MSG(0, "%s", " allow_nocrc");
414 if (flag & CP_TRIMMED_FLAG)
415 MSG(0, "%s", " trimmed");
416 if (flag & CP_NAT_BITS_FLAG)
417 MSG(0, "%s", " nat_bits");
418 if (flag & CP_CRC_RECOVERY_FLAG)
419 MSG(0, "%s", " crc");
420 if (flag & CP_FASTBOOT_FLAG)
421 MSG(0, "%s", " fastboot");
422 if (flag & CP_FSCK_FLAG)
423 MSG(0, "%s", " fsck");
424 if (flag & CP_ERROR_FLAG)
425 MSG(0, "%s", " error");
426 if (flag & CP_COMPACT_SUM_FLAG)
427 MSG(0, "%s", " compacted_summary");
428 if (flag & CP_ORPHAN_PRESENT_FLAG)
429 MSG(0, "%s", " orphan_inodes");
430 if (flag & CP_DISABLED_FLAG)
431 MSG(0, "%s", " disabled");
432 if (flag & CP_UMOUNT_FLAG)
433 MSG(0, "%s", " unmount");
434 else
435 MSG(0, "%s", " sudden-power-off");
436 MSG(0, "\n");
437 }
438
print_sb_state(struct f2fs_super_block * sb)439 void print_sb_state(struct f2fs_super_block *sb)
440 {
441 __le32 f = sb->feature;
442 int i;
443
444 MSG(0, "Info: superblock features = %x : ", f);
445 if (f & cpu_to_le32(F2FS_FEATURE_ENCRYPT)) {
446 MSG(0, "%s", " encrypt");
447 }
448 if (f & cpu_to_le32(F2FS_FEATURE_VERITY)) {
449 MSG(0, "%s", " verity");
450 }
451 if (f & cpu_to_le32(F2FS_FEATURE_BLKZONED)) {
452 MSG(0, "%s", " blkzoned");
453 }
454 if (f & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR)) {
455 MSG(0, "%s", " extra_attr");
456 }
457 if (f & cpu_to_le32(F2FS_FEATURE_PRJQUOTA)) {
458 MSG(0, "%s", " project_quota");
459 }
460 if (f & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM)) {
461 MSG(0, "%s", " inode_checksum");
462 }
463 if (f & cpu_to_le32(F2FS_FEATURE_FLEXIBLE_INLINE_XATTR)) {
464 MSG(0, "%s", " flexible_inline_xattr");
465 }
466 if (f & cpu_to_le32(F2FS_FEATURE_QUOTA_INO)) {
467 MSG(0, "%s", " quota_ino");
468 }
469 if (f & cpu_to_le32(F2FS_FEATURE_INODE_CRTIME)) {
470 MSG(0, "%s", " inode_crtime");
471 }
472 if (f & cpu_to_le32(F2FS_FEATURE_LOST_FOUND)) {
473 MSG(0, "%s", " lost_found");
474 }
475 if (f & cpu_to_le32(F2FS_FEATURE_SB_CHKSUM)) {
476 MSG(0, "%s", " sb_checksum");
477 }
478 MSG(0, "\n");
479 MSG(0, "Info: superblock encrypt level = %d, salt = ",
480 sb->encryption_level);
481 for (i = 0; i < 16; i++)
482 MSG(0, "%02x", sb->encrypt_pw_salt[i]);
483 MSG(0, "\n");
484 }
485
update_superblock(struct f2fs_super_block * sb,int sb_mask)486 void update_superblock(struct f2fs_super_block *sb, int sb_mask)
487 {
488 int addr, ret;
489 u_int8_t *buf;
490 u32 old_crc, new_crc;
491
492 buf = calloc(BLOCK_SZ, 1);
493 ASSERT(buf);
494
495 if (get_sb(feature) & F2FS_FEATURE_SB_CHKSUM) {
496 old_crc = get_sb(crc);
497 new_crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, sb,
498 SB_CHKSUM_OFFSET);
499 set_sb(crc, new_crc);
500 MSG(1, "Info: SB CRC is updated (0x%x -> 0x%x)\n",
501 old_crc, new_crc);
502 }
503
504 memcpy(buf + F2FS_SUPER_OFFSET, sb, sizeof(*sb));
505 for (addr = SB0_ADDR; addr < SB_MAX_ADDR; addr++) {
506 if (SB_MASK(addr) & sb_mask) {
507 ret = dev_write_block(buf, addr);
508 ASSERT(ret >= 0);
509 }
510 }
511
512 free(buf);
513 DBG(0, "Info: Done to update superblock\n");
514 }
515
sanity_check_area_boundary(struct f2fs_super_block * sb,enum SB_ADDR sb_addr)516 static inline int sanity_check_area_boundary(struct f2fs_super_block *sb,
517 enum SB_ADDR sb_addr)
518 {
519 u32 segment0_blkaddr = get_sb(segment0_blkaddr);
520 u32 cp_blkaddr = get_sb(cp_blkaddr);
521 u32 sit_blkaddr = get_sb(sit_blkaddr);
522 u32 nat_blkaddr = get_sb(nat_blkaddr);
523 u32 ssa_blkaddr = get_sb(ssa_blkaddr);
524 u32 main_blkaddr = get_sb(main_blkaddr);
525 u32 segment_count_ckpt = get_sb(segment_count_ckpt);
526 u32 segment_count_sit = get_sb(segment_count_sit);
527 u32 segment_count_nat = get_sb(segment_count_nat);
528 u32 segment_count_ssa = get_sb(segment_count_ssa);
529 u32 segment_count_main = get_sb(segment_count_main);
530 u32 segment_count = get_sb(segment_count);
531 u32 log_blocks_per_seg = get_sb(log_blocks_per_seg);
532 u64 main_end_blkaddr = main_blkaddr +
533 (segment_count_main << log_blocks_per_seg);
534 u64 seg_end_blkaddr = segment0_blkaddr +
535 (segment_count << log_blocks_per_seg);
536
537 if (segment0_blkaddr != cp_blkaddr) {
538 MSG(0, "\tMismatch segment0(%u) cp_blkaddr(%u)\n",
539 segment0_blkaddr, cp_blkaddr);
540 return -1;
541 }
542
543 if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
544 sit_blkaddr) {
545 MSG(0, "\tWrong CP boundary, start(%u) end(%u) blocks(%u)\n",
546 cp_blkaddr, sit_blkaddr,
547 segment_count_ckpt << log_blocks_per_seg);
548 return -1;
549 }
550
551 if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
552 nat_blkaddr) {
553 MSG(0, "\tWrong SIT boundary, start(%u) end(%u) blocks(%u)\n",
554 sit_blkaddr, nat_blkaddr,
555 segment_count_sit << log_blocks_per_seg);
556 return -1;
557 }
558
559 if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
560 ssa_blkaddr) {
561 MSG(0, "\tWrong NAT boundary, start(%u) end(%u) blocks(%u)\n",
562 nat_blkaddr, ssa_blkaddr,
563 segment_count_nat << log_blocks_per_seg);
564 return -1;
565 }
566
567 if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
568 main_blkaddr) {
569 MSG(0, "\tWrong SSA boundary, start(%u) end(%u) blocks(%u)\n",
570 ssa_blkaddr, main_blkaddr,
571 segment_count_ssa << log_blocks_per_seg);
572 return -1;
573 }
574
575 if (main_end_blkaddr > seg_end_blkaddr) {
576 MSG(0, "\tWrong MAIN_AREA, start(%u) end(%u) block(%u)\n",
577 main_blkaddr,
578 segment0_blkaddr +
579 (segment_count << log_blocks_per_seg),
580 segment_count_main << log_blocks_per_seg);
581 return -1;
582 } else if (main_end_blkaddr < seg_end_blkaddr) {
583 set_sb(segment_count, (main_end_blkaddr -
584 segment0_blkaddr) >> log_blocks_per_seg);
585
586 update_superblock(sb, SB_MASK(sb_addr));
587 MSG(0, "Info: Fix alignment: start(%u) end(%u) block(%u)\n",
588 main_blkaddr,
589 segment0_blkaddr +
590 (segment_count << log_blocks_per_seg),
591 segment_count_main << log_blocks_per_seg);
592 }
593 return 0;
594 }
595
verify_sb_chksum(struct f2fs_super_block * sb)596 static int verify_sb_chksum(struct f2fs_super_block *sb)
597 {
598 if (SB_CHKSUM_OFFSET != get_sb(checksum_offset)) {
599 MSG(0, "\tInvalid SB CRC offset: %u\n",
600 get_sb(checksum_offset));
601 return -1;
602 }
603 if (f2fs_crc_valid(get_sb(crc), sb,
604 get_sb(checksum_offset))) {
605 MSG(0, "\tInvalid SB CRC: 0x%x\n", get_sb(crc));
606 return -1;
607 }
608 return 0;
609 }
610
sanity_check_raw_super(struct f2fs_super_block * sb,enum SB_ADDR sb_addr)611 int sanity_check_raw_super(struct f2fs_super_block *sb, enum SB_ADDR sb_addr)
612 {
613 unsigned int blocksize;
614
615 if ((get_sb(feature) & F2FS_FEATURE_SB_CHKSUM) &&
616 verify_sb_chksum(sb))
617 return -1;
618
619 if (F2FS_SUPER_MAGIC != get_sb(magic))
620 return -1;
621
622 if (F2FS_BLKSIZE != PAGE_CACHE_SIZE)
623 return -1;
624
625 blocksize = 1 << get_sb(log_blocksize);
626 if (F2FS_BLKSIZE != blocksize)
627 return -1;
628
629 /* check log blocks per segment */
630 if (get_sb(log_blocks_per_seg) != 9)
631 return -1;
632
633 /* Currently, support 512/1024/2048/4096 bytes sector size */
634 if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE ||
635 get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE)
636 return -1;
637
638 if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) !=
639 F2FS_MAX_LOG_SECTOR_SIZE)
640 return -1;
641
642 /* check reserved ino info */
643 if (get_sb(node_ino) != 1 || get_sb(meta_ino) != 2 ||
644 get_sb(root_ino) != 3)
645 return -1;
646
647 /* Check zoned block device feature */
648 if (c.devices[0].zoned_model == F2FS_ZONED_HM &&
649 !(sb->feature & cpu_to_le32(F2FS_FEATURE_BLKZONED))) {
650 MSG(0, "\tMissing zoned block device feature\n");
651 return -1;
652 }
653
654 if (get_sb(segment_count) > F2FS_MAX_SEGMENT)
655 return -1;
656
657 if (sanity_check_area_boundary(sb, sb_addr))
658 return -1;
659 return 0;
660 }
661
validate_super_block(struct f2fs_sb_info * sbi,enum SB_ADDR sb_addr)662 int validate_super_block(struct f2fs_sb_info *sbi, enum SB_ADDR sb_addr)
663 {
664 char buf[F2FS_BLKSIZE];
665
666 sbi->raw_super = malloc(sizeof(struct f2fs_super_block));
667 if (!sbi->raw_super)
668 return -ENOMEM;
669
670 if (dev_read_block(buf, sb_addr))
671 return -1;
672
673 memcpy(sbi->raw_super, buf + F2FS_SUPER_OFFSET,
674 sizeof(struct f2fs_super_block));
675
676 if (!sanity_check_raw_super(sbi->raw_super, sb_addr)) {
677 /* get kernel version */
678 if (c.kd >= 0) {
679 dev_read_version(c.version, 0, VERSION_LEN);
680 get_kernel_version(c.version);
681 } else {
682 get_kernel_uname_version(c.version);
683 }
684
685 /* build sb version */
686 memcpy(c.sb_version, sbi->raw_super->version, VERSION_LEN);
687 get_kernel_version(c.sb_version);
688 memcpy(c.init_version, sbi->raw_super->init_version, VERSION_LEN);
689 get_kernel_version(c.init_version);
690
691 MSG(0, "Info: MKFS version\n \"%s\"\n", c.init_version);
692 MSG(0, "Info: FSCK version\n from \"%s\"\n to \"%s\"\n",
693 c.sb_version, c.version);
694 if (memcmp(c.sb_version, c.version, VERSION_LEN)) {
695 memcpy(sbi->raw_super->version,
696 c.version, VERSION_LEN);
697 update_superblock(sbi->raw_super, SB_MASK(sb_addr));
698
699 c.auto_fix = 0;
700 c.fix_on = 1;
701 }
702 print_sb_state(sbi->raw_super);
703 return 0;
704 }
705
706 free(sbi->raw_super);
707 sbi->raw_super = NULL;
708 MSG(0, "\tCan't find a valid F2FS superblock at 0x%x\n", sb_addr);
709
710 return -EINVAL;
711 }
712
init_sb_info(struct f2fs_sb_info * sbi)713 int init_sb_info(struct f2fs_sb_info *sbi)
714 {
715 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
716 u64 total_sectors;
717 int i;
718
719 sbi->log_sectors_per_block = get_sb(log_sectors_per_block);
720 sbi->log_blocksize = get_sb(log_blocksize);
721 sbi->blocksize = 1 << sbi->log_blocksize;
722 sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg);
723 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
724 sbi->segs_per_sec = get_sb(segs_per_sec);
725 sbi->secs_per_zone = get_sb(secs_per_zone);
726 sbi->total_sections = get_sb(section_count);
727 sbi->total_node_count = (get_sb(segment_count_nat) / 2) *
728 sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
729 sbi->root_ino_num = get_sb(root_ino);
730 sbi->node_ino_num = get_sb(node_ino);
731 sbi->meta_ino_num = get_sb(meta_ino);
732 sbi->cur_victim_sec = NULL_SEGNO;
733
734 for (i = 0; i < MAX_DEVICES; i++) {
735 if (!sb->devs[i].path[0])
736 break;
737
738 if (i) {
739 c.devices[i].path = strdup((char *)sb->devs[i].path);
740 if (get_device_info(i))
741 ASSERT(0);
742 } else {
743 ASSERT(!strcmp((char *)sb->devs[i].path,
744 (char *)c.devices[i].path));
745 }
746
747 c.devices[i].total_segments =
748 le32_to_cpu(sb->devs[i].total_segments);
749 if (i)
750 c.devices[i].start_blkaddr =
751 c.devices[i - 1].end_blkaddr + 1;
752 c.devices[i].end_blkaddr = c.devices[i].start_blkaddr +
753 c.devices[i].total_segments *
754 c.blks_per_seg - 1;
755 if (i == 0)
756 c.devices[i].end_blkaddr += get_sb(segment0_blkaddr);
757
758 c.ndevs = i + 1;
759 MSG(0, "Info: Device[%d] : %s blkaddr = %"PRIx64"--%"PRIx64"\n",
760 i, c.devices[i].path,
761 c.devices[i].start_blkaddr,
762 c.devices[i].end_blkaddr);
763 }
764
765 total_sectors = get_sb(block_count) << sbi->log_sectors_per_block;
766 MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n",
767 total_sectors, total_sectors >>
768 (20 - get_sb(log_sectorsize)));
769 return 0;
770 }
771
validate_checkpoint(struct f2fs_sb_info * sbi,block_t cp_addr,unsigned long long * version)772 void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr,
773 unsigned long long *version)
774 {
775 void *cp_page_1, *cp_page_2;
776 struct f2fs_checkpoint *cp;
777 unsigned long blk_size = sbi->blocksize;
778 unsigned long long cur_version = 0, pre_version = 0;
779 unsigned int crc = 0;
780 size_t crc_offset;
781
782 /* Read the 1st cp block in this CP pack */
783 cp_page_1 = malloc(PAGE_SIZE);
784 ASSERT(cp_page_1);
785
786 if (dev_read_block(cp_page_1, cp_addr) < 0)
787 goto invalid_cp1;
788
789 cp = (struct f2fs_checkpoint *)cp_page_1;
790 crc_offset = get_cp(checksum_offset);
791 if (crc_offset > (blk_size - sizeof(__le32)))
792 goto invalid_cp1;
793
794 crc = le32_to_cpu(*(__le32 *)((unsigned char *)cp + crc_offset));
795 if (f2fs_crc_valid(crc, cp, crc_offset))
796 goto invalid_cp1;
797
798 if (get_cp(cp_pack_total_block_count) > sbi->blocks_per_seg)
799 goto invalid_cp1;
800
801 pre_version = get_cp(checkpoint_ver);
802
803 /* Read the 2nd cp block in this CP pack */
804 cp_page_2 = malloc(PAGE_SIZE);
805 ASSERT(cp_page_2);
806
807 cp_addr += get_cp(cp_pack_total_block_count) - 1;
808
809 if (dev_read_block(cp_page_2, cp_addr) < 0)
810 goto invalid_cp2;
811
812 cp = (struct f2fs_checkpoint *)cp_page_2;
813 crc_offset = get_cp(checksum_offset);
814 if (crc_offset > (blk_size - sizeof(__le32)))
815 goto invalid_cp2;
816
817 crc = le32_to_cpu(*(__le32 *)((unsigned char *)cp + crc_offset));
818 if (f2fs_crc_valid(crc, cp, crc_offset))
819 goto invalid_cp2;
820
821 cur_version = get_cp(checkpoint_ver);
822
823 if (cur_version == pre_version) {
824 *version = cur_version;
825 free(cp_page_2);
826 return cp_page_1;
827 }
828
829 invalid_cp2:
830 free(cp_page_2);
831 invalid_cp1:
832 free(cp_page_1);
833 return NULL;
834 }
835
get_valid_checkpoint(struct f2fs_sb_info * sbi)836 int get_valid_checkpoint(struct f2fs_sb_info *sbi)
837 {
838 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
839 void *cp1, *cp2, *cur_page;
840 unsigned long blk_size = sbi->blocksize;
841 unsigned long long cp1_version = 0, cp2_version = 0, version;
842 unsigned long long cp_start_blk_no;
843 unsigned int cp_payload, cp_blks;
844 int ret;
845
846 cp_payload = get_sb(cp_payload);
847 if (cp_payload > F2FS_BLK_ALIGN(MAX_SIT_BITMAP_SIZE))
848 return -EINVAL;
849
850 cp_blks = 1 + cp_payload;
851 sbi->ckpt = malloc(cp_blks * blk_size);
852 if (!sbi->ckpt)
853 return -ENOMEM;
854 /*
855 * Finding out valid cp block involves read both
856 * sets( cp pack1 and cp pack 2)
857 */
858 cp_start_blk_no = get_sb(cp_blkaddr);
859 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
860
861 /* The second checkpoint pack should start at the next segment */
862 cp_start_blk_no += 1 << get_sb(log_blocks_per_seg);
863 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
864
865 if (cp1 && cp2) {
866 if (ver_after(cp2_version, cp1_version)) {
867 cur_page = cp2;
868 sbi->cur_cp = 2;
869 version = cp2_version;
870 } else {
871 cur_page = cp1;
872 sbi->cur_cp = 1;
873 version = cp1_version;
874 }
875 } else if (cp1) {
876 cur_page = cp1;
877 sbi->cur_cp = 1;
878 version = cp1_version;
879 } else if (cp2) {
880 cur_page = cp2;
881 sbi->cur_cp = 2;
882 version = cp2_version;
883 } else
884 goto fail_no_cp;
885
886 MSG(0, "Info: CKPT version = %llx\n", version);
887
888 memcpy(sbi->ckpt, cur_page, blk_size);
889
890 if (cp_blks > 1) {
891 unsigned int i;
892 unsigned long long cp_blk_no;
893
894 cp_blk_no = get_sb(cp_blkaddr);
895 if (cur_page == cp2)
896 cp_blk_no += 1 << get_sb(log_blocks_per_seg);
897
898 /* copy sit bitmap */
899 for (i = 1; i < cp_blks; i++) {
900 unsigned char *ckpt = (unsigned char *)sbi->ckpt;
901 ret = dev_read_block(cur_page, cp_blk_no + i);
902 ASSERT(ret >= 0);
903 memcpy(ckpt + i * blk_size, cur_page, blk_size);
904 }
905 }
906 if (cp1)
907 free(cp1);
908 if (cp2)
909 free(cp2);
910 return 0;
911
912 fail_no_cp:
913 free(sbi->ckpt);
914 sbi->ckpt = NULL;
915 return -EINVAL;
916 }
917
sanity_check_ckpt(struct f2fs_sb_info * sbi)918 int sanity_check_ckpt(struct f2fs_sb_info *sbi)
919 {
920 unsigned int total, fsmeta;
921 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
922 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
923 unsigned int ovp_segments, reserved_segments;
924 unsigned int main_segs, blocks_per_seg;
925 unsigned int sit_segs, nat_segs;
926 unsigned int sit_bitmap_size, nat_bitmap_size;
927 unsigned int log_blocks_per_seg;
928 unsigned int segment_count_main;
929 unsigned int cp_pack_start_sum, cp_payload;
930 block_t user_block_count;
931 int i;
932
933 total = get_sb(segment_count);
934 fsmeta = get_sb(segment_count_ckpt);
935 sit_segs = get_sb(segment_count_sit);
936 fsmeta += sit_segs;
937 nat_segs = get_sb(segment_count_nat);
938 fsmeta += nat_segs;
939 fsmeta += get_cp(rsvd_segment_count);
940 fsmeta += get_sb(segment_count_ssa);
941
942 if (fsmeta >= total)
943 return 1;
944
945 ovp_segments = get_cp(overprov_segment_count);
946 reserved_segments = get_cp(rsvd_segment_count);
947
948 if (fsmeta < F2FS_MIN_SEGMENT || ovp_segments == 0 ||
949 reserved_segments == 0) {
950 MSG(0, "\tWrong layout: check mkfs.f2fs version\n");
951 return 1;
952 }
953
954 user_block_count = get_cp(user_block_count);
955 segment_count_main = get_sb(segment_count_main);
956 log_blocks_per_seg = get_sb(log_blocks_per_seg);
957 if (!user_block_count || user_block_count >=
958 segment_count_main << log_blocks_per_seg) {
959 MSG(0, "\tWrong user_block_count(%u)\n", user_block_count);
960 return 1;
961 }
962
963 main_segs = get_sb(segment_count_main);
964 blocks_per_seg = sbi->blocks_per_seg;
965
966 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
967 if (get_cp(cur_node_segno[i]) >= main_segs ||
968 get_cp(cur_node_blkoff[i]) >= blocks_per_seg)
969 return 1;
970 }
971 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
972 if (get_cp(cur_data_segno[i]) >= main_segs ||
973 get_cp(cur_data_blkoff[i]) >= blocks_per_seg)
974 return 1;
975 }
976
977 sit_bitmap_size = get_cp(sit_ver_bitmap_bytesize);
978 nat_bitmap_size = get_cp(nat_ver_bitmap_bytesize);
979
980 if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 ||
981 nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) {
982 MSG(0, "\tWrong bitmap size: sit(%u), nat(%u)\n",
983 sit_bitmap_size, nat_bitmap_size);
984 return 1;
985 }
986
987 cp_pack_start_sum = __start_sum_addr(sbi);
988 cp_payload = __cp_payload(sbi);
989 if (cp_pack_start_sum < cp_payload + 1 ||
990 cp_pack_start_sum > blocks_per_seg - 1 -
991 NR_CURSEG_TYPE) {
992 MSG(0, "\tWrong cp_pack_start_sum(%u) or cp_payload(%u)\n",
993 cp_pack_start_sum, cp_payload);
994 if ((get_sb(feature) & F2FS_FEATURE_SB_CHKSUM))
995 return 1;
996 set_sb(cp_payload, cp_pack_start_sum - 1);
997 update_superblock(sb, SB_MASK_ALL);
998 }
999
1000 return 0;
1001 }
1002
current_nat_addr(struct f2fs_sb_info * sbi,nid_t start,int * pack)1003 pgoff_t current_nat_addr(struct f2fs_sb_info *sbi, nid_t start, int *pack)
1004 {
1005 struct f2fs_nm_info *nm_i = NM_I(sbi);
1006 pgoff_t block_off;
1007 pgoff_t block_addr;
1008 int seg_off;
1009
1010 block_off = NAT_BLOCK_OFFSET(start);
1011 seg_off = block_off >> sbi->log_blocks_per_seg;
1012
1013 block_addr = (pgoff_t)(nm_i->nat_blkaddr +
1014 (seg_off << sbi->log_blocks_per_seg << 1) +
1015 (block_off & ((1 << sbi->log_blocks_per_seg) -1)));
1016 if (pack)
1017 *pack = 1;
1018
1019 if (f2fs_test_bit(block_off, nm_i->nat_bitmap)) {
1020 block_addr += sbi->blocks_per_seg;
1021 if (pack)
1022 *pack = 2;
1023 }
1024
1025 return block_addr;
1026 }
1027
f2fs_init_nid_bitmap(struct f2fs_sb_info * sbi)1028 static int f2fs_init_nid_bitmap(struct f2fs_sb_info *sbi)
1029 {
1030 struct f2fs_nm_info *nm_i = NM_I(sbi);
1031 int nid_bitmap_size = (nm_i->max_nid + BITS_PER_BYTE - 1) / BITS_PER_BYTE;
1032 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1033 struct f2fs_summary_block *sum = curseg->sum_blk;
1034 struct f2fs_journal *journal = &sum->journal;
1035 struct f2fs_nat_block *nat_block;
1036 block_t start_blk;
1037 nid_t nid;
1038 int i;
1039
1040 if (!(c.func == SLOAD || c.func == FSCK))
1041 return 0;
1042
1043 nm_i->nid_bitmap = (char *)calloc(nid_bitmap_size, 1);
1044 if (!nm_i->nid_bitmap)
1045 return -ENOMEM;
1046
1047 /* arbitrarily set 0 bit */
1048 f2fs_set_bit(0, nm_i->nid_bitmap);
1049
1050 nat_block = malloc(F2FS_BLKSIZE);
1051 if (!nat_block) {
1052 free(nm_i->nid_bitmap);
1053 return -ENOMEM;
1054 }
1055
1056 for (nid = 0; nid < nm_i->max_nid; nid++) {
1057 if (!(nid % NAT_ENTRY_PER_BLOCK)) {
1058 int ret;
1059
1060 start_blk = current_nat_addr(sbi, nid, NULL);
1061 ret = dev_read_block(nat_block, start_blk);
1062 ASSERT(ret >= 0);
1063 }
1064
1065 if (nat_block->entries[nid % NAT_ENTRY_PER_BLOCK].block_addr)
1066 f2fs_set_bit(nid, nm_i->nid_bitmap);
1067 }
1068
1069 if (nats_in_cursum(journal) > NAT_JOURNAL_ENTRIES) {
1070 MSG(0, "\tError: f2fs_init_nid_bitmap truncate n_nats(%u) to "
1071 "NAT_JOURNAL_ENTRIES(%lu)\n",
1072 nats_in_cursum(journal), NAT_JOURNAL_ENTRIES);
1073 journal->n_nats = cpu_to_le16(NAT_JOURNAL_ENTRIES);
1074 }
1075
1076 for (i = 0; i < nats_in_cursum(journal); i++) {
1077 block_t addr;
1078
1079 addr = le32_to_cpu(nat_in_journal(journal, i).block_addr);
1080 if (!IS_VALID_BLK_ADDR(sbi, addr)) {
1081 MSG(0, "\tError: f2fs_init_nid_bitmap: addr(%u) is invalid!!!\n", addr);
1082 journal->n_nats = cpu_to_le16(i);
1083 continue;
1084 }
1085
1086 nid = le32_to_cpu(nid_in_journal(journal, i));
1087 if (!IS_VALID_NID(sbi, nid)) {
1088 MSG(0, "\tError: f2fs_init_nid_bitmap: nid(%u) is invalid!!!\n", nid);
1089 journal->n_nats = cpu_to_le16(i);
1090 continue;
1091 }
1092 if (addr != NULL_ADDR)
1093 f2fs_set_bit(nid, nm_i->nid_bitmap);
1094 }
1095 free(nat_block);
1096 return 0;
1097 }
1098
update_nat_bits_flags(struct f2fs_super_block * sb,struct f2fs_checkpoint * cp,u32 flags)1099 u32 update_nat_bits_flags(struct f2fs_super_block *sb,
1100 struct f2fs_checkpoint *cp, u32 flags)
1101 {
1102 u_int32_t nat_bits_bytes, nat_bits_blocks;
1103
1104 nat_bits_bytes = get_sb(segment_count_nat) << 5;
1105 nat_bits_blocks = F2FS_BYTES_TO_BLK((nat_bits_bytes << 1) + 8 +
1106 F2FS_BLKSIZE - 1);
1107 if (get_cp(cp_pack_total_block_count) <=
1108 (1 << get_sb(log_blocks_per_seg)) - nat_bits_blocks)
1109 flags |= CP_NAT_BITS_FLAG;
1110 else
1111 flags &= (~CP_NAT_BITS_FLAG);
1112
1113 return flags;
1114 }
1115
1116 /* should call flush_journal_entries() bfore this */
write_nat_bits(struct f2fs_sb_info * sbi,struct f2fs_super_block * sb,struct f2fs_checkpoint * cp,int set)1117 void write_nat_bits(struct f2fs_sb_info *sbi,
1118 struct f2fs_super_block *sb, struct f2fs_checkpoint *cp, int set)
1119 {
1120 struct f2fs_nm_info *nm_i = NM_I(sbi);
1121 u_int32_t nat_blocks = get_sb(segment_count_nat) <<
1122 (get_sb(log_blocks_per_seg) - 1);
1123 u_int32_t nat_bits_bytes = nat_blocks >> 3;
1124 u_int32_t nat_bits_blocks = F2FS_BYTES_TO_BLK((nat_bits_bytes << 1) +
1125 8 + F2FS_BLKSIZE - 1);
1126 unsigned char *nat_bits, *full_nat_bits, *empty_nat_bits;
1127 struct f2fs_nat_block *nat_block;
1128 u_int32_t i, j;
1129 block_t blkaddr;
1130 int ret;
1131
1132 nat_bits = calloc(F2FS_BLKSIZE, nat_bits_blocks);
1133 ASSERT(nat_bits);
1134
1135 nat_block = malloc(F2FS_BLKSIZE);
1136 ASSERT(nat_block);
1137
1138 full_nat_bits = nat_bits + 8;
1139 empty_nat_bits = full_nat_bits + nat_bits_bytes;
1140
1141 memset(full_nat_bits, 0, nat_bits_bytes);
1142 memset(empty_nat_bits, 0, nat_bits_bytes);
1143
1144 for (i = 0; i < nat_blocks; i++) {
1145 int seg_off = i >> get_sb(log_blocks_per_seg);
1146 int valid = 0;
1147
1148 blkaddr = (pgoff_t)(get_sb(nat_blkaddr) +
1149 (seg_off << get_sb(log_blocks_per_seg) << 1) +
1150 (i & ((1 << get_sb(log_blocks_per_seg)) - 1)));
1151
1152 /*
1153 * Should consider new nat_blocks is larger than old
1154 * nm_i->nat_blocks, since nm_i->nat_bitmap is based on
1155 * old one.
1156 */
1157 if (i < nm_i->nat_blocks && f2fs_test_bit(i, nm_i->nat_bitmap))
1158 blkaddr += (1 << get_sb(log_blocks_per_seg));
1159
1160 ret = dev_read_block(nat_block, blkaddr);
1161 ASSERT(ret >= 0);
1162
1163 for (j = 0; j < NAT_ENTRY_PER_BLOCK; j++) {
1164 if ((i == 0 && j == 0) ||
1165 nat_block->entries[j].block_addr != NULL_ADDR)
1166 valid++;
1167 }
1168 if (valid == 0)
1169 test_and_set_bit_le(i, empty_nat_bits);
1170 else if (valid == NAT_ENTRY_PER_BLOCK)
1171 test_and_set_bit_le(i, full_nat_bits);
1172 }
1173 *(__le64 *)nat_bits = get_cp_crc(cp);
1174 free(nat_block);
1175
1176 blkaddr = get_sb(segment0_blkaddr) + (set <<
1177 get_sb(log_blocks_per_seg)) - nat_bits_blocks;
1178
1179 DBG(1, "\tWriting NAT bits pages, at offset 0x%08x\n", blkaddr);
1180
1181 for (i = 0; i < nat_bits_blocks; i++) {
1182 if (dev_write_block(nat_bits + i * F2FS_BLKSIZE, blkaddr + i))
1183 ASSERT_MSG("\tError: write NAT bits to disk!!!\n");
1184 }
1185 MSG(0, "Info: Write valid nat_bits in checkpoint\n");
1186
1187 free(nat_bits);
1188 }
1189
check_nat_bits(struct f2fs_sb_info * sbi,struct f2fs_super_block * sb,struct f2fs_checkpoint * cp)1190 static int check_nat_bits(struct f2fs_sb_info *sbi,
1191 struct f2fs_super_block *sb, struct f2fs_checkpoint *cp)
1192 {
1193 struct f2fs_nm_info *nm_i = NM_I(sbi);
1194 u_int32_t nat_blocks = get_sb(segment_count_nat) <<
1195 (get_sb(log_blocks_per_seg) - 1);
1196 u_int32_t nat_bits_bytes = nat_blocks >> 3;
1197 u_int32_t nat_bits_blocks = F2FS_BYTES_TO_BLK((nat_bits_bytes << 1) +
1198 8 + F2FS_BLKSIZE - 1);
1199 unsigned char *nat_bits, *full_nat_bits, *empty_nat_bits;
1200 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1201 struct f2fs_journal *journal = &curseg->sum_blk->journal;
1202 u_int32_t i, j;
1203 block_t blkaddr;
1204 int err = 0;
1205
1206 nat_bits = calloc(F2FS_BLKSIZE, nat_bits_blocks);
1207 ASSERT(nat_bits);
1208
1209 full_nat_bits = nat_bits + 8;
1210 empty_nat_bits = full_nat_bits + nat_bits_bytes;
1211
1212 blkaddr = get_sb(segment0_blkaddr) + (sbi->cur_cp <<
1213 get_sb(log_blocks_per_seg)) - nat_bits_blocks;
1214
1215 for (i = 0; i < nat_bits_blocks; i++) {
1216 if (dev_read_block(nat_bits + i * F2FS_BLKSIZE, blkaddr + i))
1217 ASSERT_MSG("\tError: read NAT bits to disk!!!\n");
1218 }
1219
1220 if (*(__le64 *)nat_bits != get_cp_crc(cp) || nats_in_cursum(journal)) {
1221 /*
1222 * if there is a journal, f2fs was not shutdown cleanly. Let's
1223 * flush them with nat_bits.
1224 */
1225 if (c.fix_on)
1226 err = -1;
1227 /* Otherwise, kernel will disable nat_bits */
1228 goto out;
1229 }
1230
1231 for (i = 0; i < nat_blocks; i++) {
1232 u_int32_t start_nid = i * NAT_ENTRY_PER_BLOCK;
1233 u_int32_t valid = 0;
1234 int empty = test_bit_le(i, empty_nat_bits);
1235 int full = test_bit_le(i, full_nat_bits);
1236
1237 for (j = 0; j < NAT_ENTRY_PER_BLOCK; j++) {
1238 if (f2fs_test_bit(start_nid + j, nm_i->nid_bitmap))
1239 valid++;
1240 }
1241 if (valid == 0) {
1242 if (!empty || full) {
1243 err = -1;
1244 goto out;
1245 }
1246 } else if (valid == NAT_ENTRY_PER_BLOCK) {
1247 if (empty || !full) {
1248 err = -1;
1249 goto out;
1250 }
1251 } else {
1252 if (empty || full) {
1253 err = -1;
1254 goto out;
1255 }
1256 }
1257 }
1258 out:
1259 free(nat_bits);
1260 if (!err) {
1261 MSG(0, "Info: Checked valid nat_bits in checkpoint\n");
1262 } else {
1263 c.bug_nat_bits = 1;
1264 MSG(0, "Info: Corrupted valid nat_bits in checkpoint\n");
1265 }
1266 return err;
1267 }
1268
init_node_manager(struct f2fs_sb_info * sbi)1269 int init_node_manager(struct f2fs_sb_info *sbi)
1270 {
1271 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1272 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1273 struct f2fs_nm_info *nm_i = NM_I(sbi);
1274 unsigned char *version_bitmap;
1275 unsigned int nat_segs;
1276
1277 nm_i->nat_blkaddr = get_sb(nat_blkaddr);
1278
1279 /* segment_count_nat includes pair segment so divide to 2. */
1280 nat_segs = get_sb(segment_count_nat) >> 1;
1281 nm_i->nat_blocks = nat_segs << get_sb(log_blocks_per_seg);
1282 nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nm_i->nat_blocks;
1283 nm_i->fcnt = 0;
1284 nm_i->nat_cnt = 0;
1285 nm_i->init_scan_nid = get_cp(next_free_nid);
1286 nm_i->next_scan_nid = get_cp(next_free_nid);
1287
1288 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
1289
1290 nm_i->nat_bitmap = malloc(nm_i->bitmap_size);
1291 if (!nm_i->nat_bitmap)
1292 return -ENOMEM;
1293 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
1294 if (!version_bitmap)
1295 return -EFAULT;
1296
1297 /* copy version bitmap */
1298 memcpy(nm_i->nat_bitmap, version_bitmap, nm_i->bitmap_size);
1299 return f2fs_init_nid_bitmap(sbi);
1300 }
1301
build_node_manager(struct f2fs_sb_info * sbi)1302 int build_node_manager(struct f2fs_sb_info *sbi)
1303 {
1304 int err;
1305 sbi->nm_info = malloc(sizeof(struct f2fs_nm_info));
1306 if (!sbi->nm_info)
1307 return -ENOMEM;
1308
1309 err = init_node_manager(sbi);
1310 if (err)
1311 return err;
1312
1313 return 0;
1314 }
1315
build_sit_info(struct f2fs_sb_info * sbi)1316 int build_sit_info(struct f2fs_sb_info *sbi)
1317 {
1318 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1319 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1320 struct sit_info *sit_i;
1321 unsigned int sit_segs, start;
1322 char *src_bitmap, *dst_bitmap;
1323 unsigned int bitmap_size;
1324
1325 sit_i = malloc(sizeof(struct sit_info));
1326 if (!sit_i) {
1327 MSG(1, "\tError: Malloc failed for build_sit_info!\n");
1328 return -ENOMEM;
1329 }
1330
1331 SM_I(sbi)->sit_info = sit_i;
1332
1333 sit_i->sentries = calloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry), 1);
1334 if (!sit_i->sentries) {
1335 MSG(1, "\tError: Calloc failed for build_sit_info!\n");
1336 goto free_sit_info;
1337 }
1338
1339 for (start = 0; start < TOTAL_SEGS(sbi); start++) {
1340 sit_i->sentries[start].cur_valid_map
1341 = calloc(SIT_VBLOCK_MAP_SIZE, 1);
1342 if (!sit_i->sentries[start].cur_valid_map) {
1343 MSG(1, "\tError: Calloc failed for build_sit_info!!\n");
1344 goto free_validity_maps;
1345 }
1346 }
1347
1348 sit_segs = get_sb(segment_count_sit) >> 1;
1349 bitmap_size = __bitmap_size(sbi, SIT_BITMAP);
1350 src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);
1351
1352 dst_bitmap = malloc(bitmap_size);
1353 if (!dst_bitmap) {
1354 MSG(1, "\tError: Malloc failed for build_sit_info!!\n");
1355 goto free_validity_maps;
1356 }
1357
1358 memcpy(dst_bitmap, src_bitmap, bitmap_size);
1359
1360 sit_i->sit_base_addr = get_sb(sit_blkaddr);
1361 sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;
1362 sit_i->written_valid_blocks = get_cp(valid_block_count);
1363 sit_i->sit_bitmap = dst_bitmap;
1364 sit_i->bitmap_size = bitmap_size;
1365 sit_i->dirty_sentries = 0;
1366 sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK;
1367 sit_i->elapsed_time = get_cp(elapsed_time);
1368 return 0;
1369
1370 free_validity_maps:
1371 for (--start ; start >= 0; --start)
1372 free(sit_i->sentries[start].cur_valid_map);
1373 free(sit_i->sentries);
1374
1375 free_sit_info:
1376 free(sit_i);
1377
1378 return -ENOMEM;
1379 }
1380
reset_curseg(struct f2fs_sb_info * sbi,int type)1381 void reset_curseg(struct f2fs_sb_info *sbi, int type)
1382 {
1383 struct curseg_info *curseg = CURSEG_I(sbi, type);
1384 struct summary_footer *sum_footer;
1385 struct seg_entry *se;
1386
1387 sum_footer = &(curseg->sum_blk->footer);
1388 memset(sum_footer, 0, sizeof(struct summary_footer));
1389 if (IS_DATASEG(type))
1390 SET_SUM_TYPE(sum_footer, SUM_TYPE_DATA);
1391 if (IS_NODESEG(type))
1392 SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE);
1393 se = get_seg_entry(sbi, curseg->segno);
1394 se->type = type;
1395 se->dirty = 1;
1396 }
1397
read_compacted_summaries(struct f2fs_sb_info * sbi)1398 static void read_compacted_summaries(struct f2fs_sb_info *sbi)
1399 {
1400 struct curseg_info *curseg;
1401 unsigned int i, j, offset;
1402 block_t start;
1403 char *kaddr;
1404 int ret;
1405
1406 start = start_sum_block(sbi);
1407
1408 kaddr = (char *)malloc(PAGE_SIZE);
1409 ASSERT(kaddr);
1410
1411 ret = dev_read_block(kaddr, start++);
1412 ASSERT(ret >= 0);
1413
1414 curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1415 memcpy(&curseg->sum_blk->journal.n_nats, kaddr, SUM_JOURNAL_SIZE);
1416
1417 curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1418 memcpy(&curseg->sum_blk->journal.n_sits, kaddr + SUM_JOURNAL_SIZE,
1419 SUM_JOURNAL_SIZE);
1420
1421 offset = 2 * SUM_JOURNAL_SIZE;
1422 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
1423 unsigned short blk_off;
1424 struct curseg_info *curseg = CURSEG_I(sbi, i);
1425
1426 reset_curseg(sbi, i);
1427
1428 if (curseg->alloc_type == SSR)
1429 blk_off = sbi->blocks_per_seg;
1430 else
1431 blk_off = curseg->next_blkoff;
1432
1433 ASSERT(blk_off <= ENTRIES_IN_SUM);
1434
1435 for (j = 0; j < blk_off; j++) {
1436 struct f2fs_summary *s;
1437 s = (struct f2fs_summary *)(kaddr + offset);
1438 curseg->sum_blk->entries[j] = *s;
1439 offset += SUMMARY_SIZE;
1440 if (offset + SUMMARY_SIZE <=
1441 PAGE_CACHE_SIZE - SUM_FOOTER_SIZE)
1442 continue;
1443 memset(kaddr, 0, PAGE_SIZE);
1444 ret = dev_read_block(kaddr, start++);
1445 ASSERT(ret >= 0);
1446 offset = 0;
1447 }
1448 }
1449 free(kaddr);
1450 }
1451
restore_node_summary(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_summary_block * sum_blk)1452 static void restore_node_summary(struct f2fs_sb_info *sbi,
1453 unsigned int segno, struct f2fs_summary_block *sum_blk)
1454 {
1455 struct f2fs_node *node_blk;
1456 struct f2fs_summary *sum_entry;
1457 block_t addr;
1458 unsigned int i;
1459 int ret;
1460
1461 node_blk = malloc(F2FS_BLKSIZE);
1462 ASSERT(node_blk);
1463
1464 /* scan the node segment */
1465 addr = START_BLOCK(sbi, segno);
1466 sum_entry = &sum_blk->entries[0];
1467
1468 for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) {
1469 ret = dev_read_block(node_blk, addr);
1470 ASSERT(ret >= 0);
1471 sum_entry->nid = node_blk->footer.nid;
1472 addr++;
1473 }
1474 free(node_blk);
1475 }
1476
read_normal_summaries(struct f2fs_sb_info * sbi,int type)1477 static void read_normal_summaries(struct f2fs_sb_info *sbi, int type)
1478 {
1479 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1480 struct f2fs_summary_block *sum_blk;
1481 struct curseg_info *curseg;
1482 unsigned int segno = 0;
1483 block_t blk_addr = 0;
1484 int ret;
1485
1486 if (IS_DATASEG(type)) {
1487 segno = get_cp(cur_data_segno[type]);
1488 if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG))
1489 blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type);
1490 else
1491 blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type);
1492 } else {
1493 segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]);
1494 if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG))
1495 blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE,
1496 type - CURSEG_HOT_NODE);
1497 else
1498 blk_addr = GET_SUM_BLKADDR(sbi, segno);
1499 }
1500
1501 sum_blk = (struct f2fs_summary_block *)malloc(PAGE_SIZE);
1502 ASSERT(sum_blk);
1503
1504 ret = dev_read_block(sum_blk, blk_addr);
1505 ASSERT(ret >= 0);
1506
1507 if (IS_NODESEG(type) && !is_set_ckpt_flags(cp, CP_UMOUNT_FLAG))
1508 restore_node_summary(sbi, segno, sum_blk);
1509
1510 curseg = CURSEG_I(sbi, type);
1511 memcpy(curseg->sum_blk, sum_blk, PAGE_CACHE_SIZE);
1512 reset_curseg(sbi, type);
1513 free(sum_blk);
1514 }
1515
update_sum_entry(struct f2fs_sb_info * sbi,block_t blk_addr,struct f2fs_summary * sum)1516 void update_sum_entry(struct f2fs_sb_info *sbi, block_t blk_addr,
1517 struct f2fs_summary *sum)
1518 {
1519 struct f2fs_summary_block *sum_blk;
1520 u32 segno, offset;
1521 int type, ret;
1522 struct seg_entry *se;
1523
1524 segno = GET_SEGNO(sbi, blk_addr);
1525 offset = OFFSET_IN_SEG(sbi, blk_addr);
1526
1527 se = get_seg_entry(sbi, segno);
1528
1529 sum_blk = get_sum_block(sbi, segno, &type);
1530 memcpy(&sum_blk->entries[offset], sum, sizeof(*sum));
1531 sum_blk->footer.entry_type = IS_NODESEG(se->type) ? SUM_TYPE_NODE :
1532 SUM_TYPE_DATA;
1533
1534 /* write SSA all the time */
1535 ret = dev_write_block(sum_blk, GET_SUM_BLKADDR(sbi, segno));
1536 ASSERT(ret >= 0);
1537
1538 if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA ||
1539 type == SEG_TYPE_MAX)
1540 free(sum_blk);
1541 }
1542
restore_curseg_summaries(struct f2fs_sb_info * sbi)1543 static void restore_curseg_summaries(struct f2fs_sb_info *sbi)
1544 {
1545 int type = CURSEG_HOT_DATA;
1546
1547 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) {
1548 read_compacted_summaries(sbi);
1549 type = CURSEG_HOT_NODE;
1550 }
1551
1552 for (; type <= CURSEG_COLD_NODE; type++)
1553 read_normal_summaries(sbi, type);
1554 }
1555
build_curseg(struct f2fs_sb_info * sbi)1556 static int build_curseg(struct f2fs_sb_info *sbi)
1557 {
1558 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1559 struct curseg_info *array;
1560 unsigned short blk_off;
1561 unsigned int segno;
1562 int i;
1563
1564 array = malloc(sizeof(*array) * NR_CURSEG_TYPE);
1565 if (!array) {
1566 MSG(1, "\tError: Malloc failed for build_curseg!\n");
1567 return -ENOMEM;
1568 }
1569
1570 SM_I(sbi)->curseg_array = array;
1571
1572 for (i = 0; i < NR_CURSEG_TYPE; i++) {
1573 array[i].sum_blk = malloc(PAGE_CACHE_SIZE);
1574 if (!array[i].sum_blk) {
1575 MSG(1, "\tError: Malloc failed for build_curseg!!\n");
1576 goto seg_cleanup;
1577 }
1578
1579 if (i <= CURSEG_COLD_DATA) {
1580 blk_off = get_cp(cur_data_blkoff[i]);
1581 segno = get_cp(cur_data_segno[i]);
1582 }
1583 if (i > CURSEG_COLD_DATA) {
1584 blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]);
1585 segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]);
1586 }
1587 ASSERT(segno < TOTAL_SEGS(sbi));
1588 ASSERT(blk_off < DEFAULT_BLOCKS_PER_SEGMENT);
1589
1590 array[i].segno = segno;
1591 array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno);
1592 array[i].next_segno = NULL_SEGNO;
1593 array[i].next_blkoff = blk_off;
1594 array[i].alloc_type = cp->alloc_type[i];
1595 }
1596 restore_curseg_summaries(sbi);
1597 return 0;
1598
1599 seg_cleanup:
1600 for(--i ; i >=0; --i)
1601 free(array[i].sum_blk);
1602 free(array);
1603
1604 return -ENOMEM;
1605 }
1606
check_seg_range(struct f2fs_sb_info * sbi,unsigned int segno)1607 static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
1608 {
1609 unsigned int end_segno = SM_I(sbi)->segment_count - 1;
1610 ASSERT(segno <= end_segno);
1611 }
1612
get_current_sit_page(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_sit_block * sit_blk)1613 void get_current_sit_page(struct f2fs_sb_info *sbi,
1614 unsigned int segno, struct f2fs_sit_block *sit_blk)
1615 {
1616 struct sit_info *sit_i = SIT_I(sbi);
1617 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno);
1618 block_t blk_addr = sit_i->sit_base_addr + offset;
1619 int ret;
1620
1621 check_seg_range(sbi, segno);
1622
1623 /* calculate sit block address */
1624 if (f2fs_test_bit(offset, sit_i->sit_bitmap))
1625 blk_addr += sit_i->sit_blocks;
1626
1627 ret = dev_read_block(sit_blk, blk_addr);
1628 ASSERT(ret >= 0);
1629 }
1630
rewrite_current_sit_page(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_sit_block * sit_blk)1631 void rewrite_current_sit_page(struct f2fs_sb_info *sbi,
1632 unsigned int segno, struct f2fs_sit_block *sit_blk)
1633 {
1634 struct sit_info *sit_i = SIT_I(sbi);
1635 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno);
1636 block_t blk_addr = sit_i->sit_base_addr + offset;
1637 int ret;
1638
1639 /* calculate sit block address */
1640 if (f2fs_test_bit(offset, sit_i->sit_bitmap))
1641 blk_addr += sit_i->sit_blocks;
1642
1643 ret = dev_write_block(sit_blk, blk_addr);
1644 ASSERT(ret >= 0);
1645 }
1646
check_block_count(struct f2fs_sb_info * sbi,unsigned int segno,struct f2fs_sit_entry * raw_sit)1647 void check_block_count(struct f2fs_sb_info *sbi,
1648 unsigned int segno, struct f2fs_sit_entry *raw_sit)
1649 {
1650 struct f2fs_sm_info *sm_info = SM_I(sbi);
1651 unsigned int end_segno = sm_info->segment_count - 1;
1652 int valid_blocks = 0;
1653 unsigned int i;
1654
1655 /* check segment usage */
1656 if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg)
1657 ASSERT_MSG("Invalid SIT vblocks: segno=0x%x, %u",
1658 segno, GET_SIT_VBLOCKS(raw_sit));
1659
1660 /* check boundary of a given segment number */
1661 if (segno > end_segno)
1662 ASSERT_MSG("Invalid SEGNO: 0x%x", segno);
1663
1664 /* check bitmap with valid block count */
1665 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++)
1666 valid_blocks += get_bits_in_byte(raw_sit->valid_map[i]);
1667
1668 if (GET_SIT_VBLOCKS(raw_sit) != valid_blocks)
1669 ASSERT_MSG("Wrong SIT valid blocks: segno=0x%x, %u vs. %u",
1670 segno, GET_SIT_VBLOCKS(raw_sit), valid_blocks);
1671
1672 if (GET_SIT_TYPE(raw_sit) >= NO_CHECK_TYPE)
1673 ASSERT_MSG("Wrong SIT type: segno=0x%x, %u",
1674 segno, GET_SIT_TYPE(raw_sit));
1675 }
1676
seg_info_from_raw_sit(struct seg_entry * se,struct f2fs_sit_entry * raw_sit)1677 void seg_info_from_raw_sit(struct seg_entry *se,
1678 struct f2fs_sit_entry *raw_sit)
1679 {
1680 se->valid_blocks = GET_SIT_VBLOCKS(raw_sit);
1681 memcpy(se->cur_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE);
1682 se->type = GET_SIT_TYPE(raw_sit);
1683 se->orig_type = GET_SIT_TYPE(raw_sit);
1684 se->mtime = le64_to_cpu(raw_sit->mtime);
1685 }
1686
get_seg_entry(struct f2fs_sb_info * sbi,unsigned int segno)1687 struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
1688 unsigned int segno)
1689 {
1690 struct sit_info *sit_i = SIT_I(sbi);
1691 return &sit_i->sentries[segno];
1692 }
1693
get_sum_block(struct f2fs_sb_info * sbi,unsigned int segno,int * ret_type)1694 struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi,
1695 unsigned int segno, int *ret_type)
1696 {
1697 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1698 struct f2fs_summary_block *sum_blk;
1699 struct curseg_info *curseg;
1700 int type, ret;
1701 u64 ssa_blk;
1702
1703 *ret_type= SEG_TYPE_MAX;
1704
1705 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
1706 for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) {
1707 if (segno == get_cp(cur_node_segno[type])) {
1708 curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type);
1709 if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) {
1710 ASSERT_MSG("segno [0x%x] indicates a data "
1711 "segment, but should be node",
1712 segno);
1713 *ret_type = -SEG_TYPE_CUR_NODE;
1714 } else {
1715 *ret_type = SEG_TYPE_CUR_NODE;
1716 }
1717 return curseg->sum_blk;
1718 }
1719 }
1720
1721 for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) {
1722 if (segno == get_cp(cur_data_segno[type])) {
1723 curseg = CURSEG_I(sbi, type);
1724 if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) {
1725 ASSERT_MSG("segno [0x%x] indicates a node "
1726 "segment, but should be data",
1727 segno);
1728 *ret_type = -SEG_TYPE_CUR_DATA;
1729 } else {
1730 *ret_type = SEG_TYPE_CUR_DATA;
1731 }
1732 return curseg->sum_blk;
1733 }
1734 }
1735
1736 sum_blk = calloc(BLOCK_SZ, 1);
1737 ASSERT(sum_blk);
1738
1739 ret = dev_read_block(sum_blk, ssa_blk);
1740 ASSERT(ret >= 0);
1741
1742 if (IS_SUM_NODE_SEG(sum_blk->footer))
1743 *ret_type = SEG_TYPE_NODE;
1744 else if (IS_SUM_DATA_SEG(sum_blk->footer))
1745 *ret_type = SEG_TYPE_DATA;
1746
1747 return sum_blk;
1748 }
1749
get_sum_entry(struct f2fs_sb_info * sbi,u32 blk_addr,struct f2fs_summary * sum_entry)1750 int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr,
1751 struct f2fs_summary *sum_entry)
1752 {
1753 struct f2fs_summary_block *sum_blk;
1754 u32 segno, offset;
1755 int type;
1756
1757 segno = GET_SEGNO(sbi, blk_addr);
1758 offset = OFFSET_IN_SEG(sbi, blk_addr);
1759
1760 sum_blk = get_sum_block(sbi, segno, &type);
1761 memcpy(sum_entry, &(sum_blk->entries[offset]),
1762 sizeof(struct f2fs_summary));
1763 if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA ||
1764 type == SEG_TYPE_MAX)
1765 free(sum_blk);
1766 return type;
1767 }
1768
get_nat_entry(struct f2fs_sb_info * sbi,nid_t nid,struct f2fs_nat_entry * raw_nat)1769 static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid,
1770 struct f2fs_nat_entry *raw_nat)
1771 {
1772 struct f2fs_nat_block *nat_block;
1773 pgoff_t block_addr;
1774 int entry_off;
1775 int ret;
1776
1777 if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0)
1778 return;
1779
1780 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
1781 ASSERT(nat_block);
1782
1783 entry_off = nid % NAT_ENTRY_PER_BLOCK;
1784 block_addr = current_nat_addr(sbi, nid, NULL);
1785
1786 ret = dev_read_block(nat_block, block_addr);
1787 ASSERT(ret >= 0);
1788
1789 memcpy(raw_nat, &nat_block->entries[entry_off],
1790 sizeof(struct f2fs_nat_entry));
1791 free(nat_block);
1792 }
1793
update_data_blkaddr(struct f2fs_sb_info * sbi,nid_t nid,u16 ofs_in_node,block_t newaddr)1794 void update_data_blkaddr(struct f2fs_sb_info *sbi, nid_t nid,
1795 u16 ofs_in_node, block_t newaddr)
1796 {
1797 struct f2fs_node *node_blk = NULL;
1798 struct node_info ni;
1799 block_t oldaddr, startaddr, endaddr;
1800 int ret;
1801
1802 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
1803 ASSERT(node_blk);
1804
1805 get_node_info(sbi, nid, &ni);
1806
1807 /* read node_block */
1808 ret = dev_read_block(node_blk, ni.blk_addr);
1809 ASSERT(ret >= 0);
1810
1811 /* check its block address */
1812 if (node_blk->footer.nid == node_blk->footer.ino) {
1813 int ofs = get_extra_isize(node_blk);
1814
1815 oldaddr = le32_to_cpu(node_blk->i.i_addr[ofs + ofs_in_node]);
1816 node_blk->i.i_addr[ofs + ofs_in_node] = cpu_to_le32(newaddr);
1817 } else {
1818 oldaddr = le32_to_cpu(node_blk->dn.addr[ofs_in_node]);
1819 node_blk->dn.addr[ofs_in_node] = cpu_to_le32(newaddr);
1820 }
1821
1822 ret = dev_write_block(node_blk, ni.blk_addr);
1823 ASSERT(ret >= 0);
1824
1825 /* check extent cache entry */
1826 if (node_blk->footer.nid != node_blk->footer.ino) {
1827 get_node_info(sbi, le32_to_cpu(node_blk->footer.ino), &ni);
1828
1829 /* read inode block */
1830 ret = dev_read_block(node_blk, ni.blk_addr);
1831 ASSERT(ret >= 0);
1832 }
1833
1834 startaddr = le32_to_cpu(node_blk->i.i_ext.blk_addr);
1835 endaddr = startaddr + le32_to_cpu(node_blk->i.i_ext.len);
1836 if (oldaddr >= startaddr && oldaddr < endaddr) {
1837 node_blk->i.i_ext.len = 0;
1838
1839 /* update inode block */
1840 ret = dev_write_block(node_blk, ni.blk_addr);
1841 ASSERT(ret >= 0);
1842 }
1843 free(node_blk);
1844 }
1845
update_nat_blkaddr(struct f2fs_sb_info * sbi,nid_t ino,nid_t nid,block_t newaddr)1846 void update_nat_blkaddr(struct f2fs_sb_info *sbi, nid_t ino,
1847 nid_t nid, block_t newaddr)
1848 {
1849 struct f2fs_nat_block *nat_block;
1850 pgoff_t block_addr;
1851 int entry_off;
1852 int ret;
1853
1854 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
1855 ASSERT(nat_block);
1856
1857 entry_off = nid % NAT_ENTRY_PER_BLOCK;
1858 block_addr = current_nat_addr(sbi, nid, NULL);
1859
1860 ret = dev_read_block(nat_block, block_addr);
1861 ASSERT(ret >= 0);
1862
1863 if (ino)
1864 nat_block->entries[entry_off].ino = cpu_to_le32(ino);
1865 nat_block->entries[entry_off].block_addr = cpu_to_le32(newaddr);
1866 if (c.func == FSCK)
1867 F2FS_FSCK(sbi)->entries[nid] = nat_block->entries[entry_off];
1868
1869 ret = dev_write_block(nat_block, block_addr);
1870 ASSERT(ret >= 0);
1871 free(nat_block);
1872 }
1873
get_node_info(struct f2fs_sb_info * sbi,nid_t nid,struct node_info * ni)1874 void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
1875 {
1876 struct f2fs_nat_entry raw_nat;
1877
1878 ni->nid = nid;
1879 if (c.func == FSCK) {
1880 node_info_from_raw_nat(ni, &(F2FS_FSCK(sbi)->entries[nid]));
1881 if (ni->blk_addr)
1882 return;
1883 /* nat entry is not cached, read it */
1884 }
1885
1886 get_nat_entry(sbi, nid, &raw_nat);
1887 node_info_from_raw_nat(ni, &raw_nat);
1888 }
1889
build_sit_entries(struct f2fs_sb_info * sbi)1890 static int build_sit_entries(struct f2fs_sb_info *sbi)
1891 {
1892 struct sit_info *sit_i = SIT_I(sbi);
1893 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1894 struct f2fs_journal *journal = &curseg->sum_blk->journal;
1895 struct f2fs_sit_block *sit_blk;
1896 struct seg_entry *se;
1897 struct f2fs_sit_entry sit;
1898 unsigned int i, segno;
1899
1900 sit_blk = calloc(BLOCK_SZ, 1);
1901 if (!sit_blk) {
1902 MSG(1, "\tError: Calloc failed for build_sit_entries!\n");
1903 return -ENOMEM;
1904 }
1905
1906 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1907 se = &sit_i->sentries[segno];
1908
1909 get_current_sit_page(sbi, segno, sit_blk);
1910 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
1911
1912 check_block_count(sbi, segno, &sit);
1913 seg_info_from_raw_sit(se, &sit);
1914 }
1915
1916 free(sit_blk);
1917 for (i = 0; i < sits_in_cursum(journal); i++) {
1918 segno = le32_to_cpu(segno_in_journal(journal, i));
1919 se = &sit_i->sentries[segno];
1920 sit = sit_in_journal(journal, i);
1921
1922 check_block_count(sbi, segno, &sit);
1923 seg_info_from_raw_sit(se, &sit);
1924 }
1925 return 0;
1926 }
1927
build_segment_manager(struct f2fs_sb_info * sbi)1928 static int build_segment_manager(struct f2fs_sb_info *sbi)
1929 {
1930 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1931 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1932 struct f2fs_sm_info *sm_info;
1933
1934 sm_info = malloc(sizeof(struct f2fs_sm_info));
1935 if (!sm_info) {
1936 MSG(1, "\tError: Malloc failed for build_segment_manager!\n");
1937 return -ENOMEM;
1938 }
1939
1940 /* init sm info */
1941 sbi->sm_info = sm_info;
1942 sm_info->seg0_blkaddr = get_sb(segment0_blkaddr);
1943 sm_info->main_blkaddr = get_sb(main_blkaddr);
1944 sm_info->segment_count = get_sb(segment_count);
1945 sm_info->reserved_segments = get_cp(rsvd_segment_count);
1946 sm_info->ovp_segments = get_cp(overprov_segment_count);
1947 sm_info->main_segments = get_sb(segment_count_main);
1948 sm_info->ssa_blkaddr = get_sb(ssa_blkaddr);
1949
1950 if (build_sit_info(sbi) || build_curseg(sbi) || build_sit_entries(sbi)) {
1951 free(sm_info);
1952 return -ENOMEM;
1953 }
1954
1955 return 0;
1956 }
1957
build_sit_area_bitmap(struct f2fs_sb_info * sbi)1958 void build_sit_area_bitmap(struct f2fs_sb_info *sbi)
1959 {
1960 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1961 struct f2fs_sm_info *sm_i = SM_I(sbi);
1962 unsigned int segno = 0;
1963 char *ptr = NULL;
1964 u32 sum_vblocks = 0;
1965 u32 free_segs = 0;
1966 struct seg_entry *se;
1967
1968 fsck->sit_area_bitmap_sz = sm_i->main_segments * SIT_VBLOCK_MAP_SIZE;
1969 fsck->sit_area_bitmap = calloc(1, fsck->sit_area_bitmap_sz);
1970 ASSERT(fsck->sit_area_bitmap);
1971 ptr = fsck->sit_area_bitmap;
1972
1973 ASSERT(fsck->sit_area_bitmap_sz == fsck->main_area_bitmap_sz);
1974
1975 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1976 se = get_seg_entry(sbi, segno);
1977
1978 memcpy(ptr, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE);
1979 ptr += SIT_VBLOCK_MAP_SIZE;
1980
1981 if (se->valid_blocks == 0x0) {
1982 if (le32_to_cpu(sbi->ckpt->cur_node_segno[0]) == segno ||
1983 le32_to_cpu(sbi->ckpt->cur_data_segno[0]) == segno ||
1984 le32_to_cpu(sbi->ckpt->cur_node_segno[1]) == segno ||
1985 le32_to_cpu(sbi->ckpt->cur_data_segno[1]) == segno ||
1986 le32_to_cpu(sbi->ckpt->cur_node_segno[2]) == segno ||
1987 le32_to_cpu(sbi->ckpt->cur_data_segno[2]) == segno) {
1988 continue;
1989 } else {
1990 free_segs++;
1991 }
1992 } else {
1993 sum_vblocks += se->valid_blocks;
1994 }
1995 }
1996 fsck->chk.sit_valid_blocks = sum_vblocks;
1997 fsck->chk.sit_free_segs = free_segs;
1998
1999 DBG(1, "Blocks [0x%x : %d] Free Segs [0x%x : %d]\n\n",
2000 sum_vblocks, sum_vblocks,
2001 free_segs, free_segs);
2002 }
2003
rewrite_sit_area_bitmap(struct f2fs_sb_info * sbi)2004 void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi)
2005 {
2006 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2007 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2008 struct sit_info *sit_i = SIT_I(sbi);
2009 struct f2fs_sit_block *sit_blk;
2010 unsigned int segno = 0;
2011 struct f2fs_summary_block *sum = curseg->sum_blk;
2012 char *ptr = NULL;
2013
2014 sit_blk = calloc(BLOCK_SZ, 1);
2015 ASSERT(sit_blk);
2016 /* remove sit journal */
2017 sum->journal.n_sits = 0;
2018
2019 ptr = fsck->main_area_bitmap;
2020
2021 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
2022 struct f2fs_sit_entry *sit;
2023 struct seg_entry *se;
2024 u16 valid_blocks = 0;
2025 u16 type;
2026 int i;
2027
2028 get_current_sit_page(sbi, segno, sit_blk);
2029 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
2030 memcpy(sit->valid_map, ptr, SIT_VBLOCK_MAP_SIZE);
2031
2032 /* update valid block count */
2033 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++)
2034 valid_blocks += get_bits_in_byte(sit->valid_map[i]);
2035
2036 se = get_seg_entry(sbi, segno);
2037 memcpy(se->cur_valid_map, ptr, SIT_VBLOCK_MAP_SIZE);
2038 se->valid_blocks = valid_blocks;
2039 type = se->type;
2040 if (type >= NO_CHECK_TYPE) {
2041 ASSERT_MSG("Invalide type and valid blocks=%x,%x",
2042 segno, valid_blocks);
2043 type = 0;
2044 }
2045 sit->vblocks = cpu_to_le16((type << SIT_VBLOCKS_SHIFT) |
2046 valid_blocks);
2047 rewrite_current_sit_page(sbi, segno, sit_blk);
2048
2049 ptr += SIT_VBLOCK_MAP_SIZE;
2050 }
2051
2052 free(sit_blk);
2053 }
2054
flush_sit_journal_entries(struct f2fs_sb_info * sbi)2055 static int flush_sit_journal_entries(struct f2fs_sb_info *sbi)
2056 {
2057 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2058 struct f2fs_journal *journal = &curseg->sum_blk->journal;
2059 struct sit_info *sit_i = SIT_I(sbi);
2060 struct f2fs_sit_block *sit_blk;
2061 unsigned int segno;
2062 int i;
2063
2064 sit_blk = calloc(BLOCK_SZ, 1);
2065 ASSERT(sit_blk);
2066 for (i = 0; i < sits_in_cursum(journal); i++) {
2067 struct f2fs_sit_entry *sit;
2068 struct seg_entry *se;
2069
2070 segno = segno_in_journal(journal, i);
2071 se = get_seg_entry(sbi, segno);
2072
2073 get_current_sit_page(sbi, segno, sit_blk);
2074 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
2075
2076 memcpy(sit->valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE);
2077 sit->vblocks = cpu_to_le16((se->type << SIT_VBLOCKS_SHIFT) |
2078 se->valid_blocks);
2079 sit->mtime = cpu_to_le64(se->mtime);
2080
2081 rewrite_current_sit_page(sbi, segno, sit_blk);
2082 }
2083
2084 free(sit_blk);
2085 journal->n_sits = 0;
2086 return i;
2087 }
2088
flush_nat_journal_entries(struct f2fs_sb_info * sbi)2089 static int flush_nat_journal_entries(struct f2fs_sb_info *sbi)
2090 {
2091 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
2092 struct f2fs_journal *journal = &curseg->sum_blk->journal;
2093 struct f2fs_nat_block *nat_block;
2094 pgoff_t block_addr;
2095 int entry_off;
2096 nid_t nid;
2097 int ret;
2098 int i = 0;
2099
2100 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
2101 ASSERT(nat_block);
2102 next:
2103 if (i >= nats_in_cursum(journal)) {
2104 free(nat_block);
2105 journal->n_nats = 0;
2106 return i;
2107 }
2108
2109 nid = le32_to_cpu(nid_in_journal(journal, i));
2110
2111 entry_off = nid % NAT_ENTRY_PER_BLOCK;
2112 block_addr = current_nat_addr(sbi, nid, NULL);
2113
2114 ret = dev_read_block(nat_block, block_addr);
2115 ASSERT(ret >= 0);
2116
2117 memcpy(&nat_block->entries[entry_off], &nat_in_journal(journal, i),
2118 sizeof(struct f2fs_nat_entry));
2119
2120 ret = dev_write_block(nat_block, block_addr);
2121 ASSERT(ret >= 0);
2122 i++;
2123 goto next;
2124 }
2125
flush_journal_entries(struct f2fs_sb_info * sbi)2126 void flush_journal_entries(struct f2fs_sb_info *sbi)
2127 {
2128 int n_nats = flush_nat_journal_entries(sbi);
2129 int n_sits = flush_sit_journal_entries(sbi);
2130
2131 if (n_nats || n_sits)
2132 write_checkpoint(sbi);
2133 }
2134
flush_sit_entries(struct f2fs_sb_info * sbi)2135 void flush_sit_entries(struct f2fs_sb_info *sbi)
2136 {
2137 struct sit_info *sit_i = SIT_I(sbi);
2138 struct f2fs_sit_block *sit_blk;
2139 unsigned int segno = 0;
2140
2141 sit_blk = calloc(BLOCK_SZ, 1);
2142 ASSERT(sit_blk);
2143 /* update free segments */
2144 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
2145 struct f2fs_sit_entry *sit;
2146 struct seg_entry *se;
2147
2148 se = get_seg_entry(sbi, segno);
2149
2150 if (!se->dirty)
2151 continue;
2152
2153 get_current_sit_page(sbi, segno, sit_blk);
2154 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
2155 memcpy(sit->valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE);
2156 sit->vblocks = cpu_to_le16((se->type << SIT_VBLOCKS_SHIFT) |
2157 se->valid_blocks);
2158 rewrite_current_sit_page(sbi, segno, sit_blk);
2159 }
2160
2161 free(sit_blk);
2162 }
2163
find_next_free_block(struct f2fs_sb_info * sbi,u64 * to,int left,int type)2164 int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type)
2165 {
2166 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2167 struct seg_entry *se;
2168 u32 segno;
2169 u32 offset;
2170 int not_enough = 0;
2171 u64 end_blkaddr = (get_sb(segment_count_main) <<
2172 get_sb(log_blocks_per_seg)) + get_sb(main_blkaddr);
2173
2174 if (*to > 0)
2175 *to -= left;
2176 if (get_free_segments(sbi) <= SM_I(sbi)->reserved_segments + 1)
2177 not_enough = 1;
2178
2179 while (*to >= SM_I(sbi)->main_blkaddr && *to < end_blkaddr) {
2180 segno = GET_SEGNO(sbi, *to);
2181 offset = OFFSET_IN_SEG(sbi, *to);
2182
2183 se = get_seg_entry(sbi, segno);
2184
2185 if (se->valid_blocks == sbi->blocks_per_seg ||
2186 IS_CUR_SEGNO(sbi, segno)) {
2187 *to = left ? START_BLOCK(sbi, segno) - 1:
2188 START_BLOCK(sbi, segno + 1);
2189 continue;
2190 }
2191
2192 if (se->valid_blocks == 0 && not_enough) {
2193 *to = left ? START_BLOCK(sbi, segno) - 1:
2194 START_BLOCK(sbi, segno + 1);
2195 continue;
2196 }
2197
2198 if (se->valid_blocks == 0 && !(segno % sbi->segs_per_sec)) {
2199 struct seg_entry *se2;
2200 unsigned int i;
2201
2202 for (i = 1; i < sbi->segs_per_sec; i++) {
2203 se2 = get_seg_entry(sbi, segno + i);
2204 if (se2->valid_blocks)
2205 break;
2206 }
2207 if (i == sbi->segs_per_sec)
2208 return 0;
2209 }
2210
2211 if (se->type == type &&
2212 !f2fs_test_bit(offset, (const char *)se->cur_valid_map))
2213 return 0;
2214
2215 *to = left ? *to - 1: *to + 1;
2216 }
2217 return -1;
2218 }
2219
move_curseg_info(struct f2fs_sb_info * sbi,u64 from,int left)2220 void move_curseg_info(struct f2fs_sb_info *sbi, u64 from, int left)
2221 {
2222 int i, ret;
2223
2224 /* update summary blocks having nullified journal entries */
2225 for (i = 0; i < NO_CHECK_TYPE; i++) {
2226 struct curseg_info *curseg = CURSEG_I(sbi, i);
2227 struct f2fs_summary_block buf;
2228 u32 old_segno;
2229 u64 ssa_blk, to;
2230
2231 /* update original SSA too */
2232 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
2233 ret = dev_write_block(curseg->sum_blk, ssa_blk);
2234 ASSERT(ret >= 0);
2235
2236 to = from;
2237 ret = find_next_free_block(sbi, &to, left, i);
2238 ASSERT(ret == 0);
2239
2240 old_segno = curseg->segno;
2241 curseg->segno = GET_SEGNO(sbi, to);
2242 curseg->next_blkoff = OFFSET_IN_SEG(sbi, to);
2243 curseg->alloc_type = SSR;
2244
2245 /* update new segno */
2246 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
2247 ret = dev_read_block(&buf, ssa_blk);
2248 ASSERT(ret >= 0);
2249
2250 memcpy(curseg->sum_blk, &buf, SUM_ENTRIES_SIZE);
2251
2252 /* update se->types */
2253 reset_curseg(sbi, i);
2254
2255 DBG(1, "Move curseg[%d] %x -> %x after %"PRIx64"\n",
2256 i, old_segno, curseg->segno, from);
2257 }
2258 }
2259
zero_journal_entries(struct f2fs_sb_info * sbi)2260 void zero_journal_entries(struct f2fs_sb_info *sbi)
2261 {
2262 int i;
2263
2264 for (i = 0; i < NO_CHECK_TYPE; i++)
2265 CURSEG_I(sbi, i)->sum_blk->journal.n_nats = 0;
2266 }
2267
write_curseg_info(struct f2fs_sb_info * sbi)2268 void write_curseg_info(struct f2fs_sb_info *sbi)
2269 {
2270 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2271 int i;
2272
2273 for (i = 0; i < NO_CHECK_TYPE; i++) {
2274 cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type;
2275 if (i < CURSEG_HOT_NODE) {
2276 set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno);
2277 set_cp(cur_data_blkoff[i],
2278 CURSEG_I(sbi, i)->next_blkoff);
2279 } else {
2280 int n = i - CURSEG_HOT_NODE;
2281
2282 set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno);
2283 set_cp(cur_node_blkoff[n],
2284 CURSEG_I(sbi, i)->next_blkoff);
2285 }
2286 }
2287 }
2288
lookup_nat_in_journal(struct f2fs_sb_info * sbi,u32 nid,struct f2fs_nat_entry * raw_nat)2289 int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid,
2290 struct f2fs_nat_entry *raw_nat)
2291 {
2292 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
2293 struct f2fs_journal *journal = &curseg->sum_blk->journal;
2294 int i = 0;
2295
2296 for (i = 0; i < nats_in_cursum(journal); i++) {
2297 if (le32_to_cpu(nid_in_journal(journal, i)) == nid) {
2298 memcpy(raw_nat, &nat_in_journal(journal, i),
2299 sizeof(struct f2fs_nat_entry));
2300 DBG(3, "==> Found nid [0x%x] in nat cache\n", nid);
2301 return i;
2302 }
2303 }
2304 return -1;
2305 }
2306
nullify_nat_entry(struct f2fs_sb_info * sbi,u32 nid)2307 void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
2308 {
2309 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
2310 struct f2fs_journal *journal = &curseg->sum_blk->journal;
2311 struct f2fs_nat_block *nat_block;
2312 pgoff_t block_addr;
2313 int entry_off;
2314 int ret;
2315 int i = 0;
2316
2317 /* check in journal */
2318 for (i = 0; i < nats_in_cursum(journal); i++) {
2319 if (le32_to_cpu(nid_in_journal(journal, i)) == nid) {
2320 memset(&nat_in_journal(journal, i), 0,
2321 sizeof(struct f2fs_nat_entry));
2322 FIX_MSG("Remove nid [0x%x] in nat journal", nid);
2323 return;
2324 }
2325 }
2326 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
2327 ASSERT(nat_block);
2328
2329 entry_off = nid % NAT_ENTRY_PER_BLOCK;
2330 block_addr = current_nat_addr(sbi, nid, NULL);
2331
2332 ret = dev_read_block(nat_block, block_addr);
2333 ASSERT(ret >= 0);
2334
2335 if (nid == F2FS_NODE_INO(sbi) || nid == F2FS_META_INO(sbi)) {
2336 FIX_MSG("nid [0x%x] block_addr= 0x%x -> 0x1", nid,
2337 le32_to_cpu(nat_block->entries[entry_off].block_addr));
2338 nat_block->entries[entry_off].block_addr = cpu_to_le32(0x1);
2339 } else {
2340 memset(&nat_block->entries[entry_off], 0,
2341 sizeof(struct f2fs_nat_entry));
2342 FIX_MSG("Remove nid [0x%x] in NAT", nid);
2343 }
2344
2345 ret = dev_write_block(nat_block, block_addr);
2346 ASSERT(ret >= 0);
2347 free(nat_block);
2348 }
2349
write_checkpoint(struct f2fs_sb_info * sbi)2350 void write_checkpoint(struct f2fs_sb_info *sbi)
2351 {
2352 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2353 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2354 block_t orphan_blks = 0;
2355 unsigned long long cp_blk_no;
2356 u32 flags = CP_UMOUNT_FLAG;
2357 int i, ret;
2358 u_int32_t crc = 0;
2359
2360 if (is_set_ckpt_flags(cp, CP_ORPHAN_PRESENT_FLAG)) {
2361 orphan_blks = __start_sum_addr(sbi) - 1;
2362 flags |= CP_ORPHAN_PRESENT_FLAG;
2363 }
2364 if (is_set_ckpt_flags(cp, CP_TRIMMED_FLAG))
2365 flags |= CP_TRIMMED_FLAG;
2366 if (is_set_ckpt_flags(cp, CP_DISABLED_FLAG))
2367 flags |= CP_DISABLED_FLAG;
2368
2369 set_cp(free_segment_count, get_free_segments(sbi));
2370 set_cp(valid_block_count, sbi->total_valid_block_count);
2371 set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload));
2372
2373 flags = update_nat_bits_flags(sb, cp, flags);
2374 set_cp(ckpt_flags, flags);
2375
2376 crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CP_CHKSUM_OFFSET);
2377 *((__le32 *)((unsigned char *)cp + CP_CHKSUM_OFFSET)) = cpu_to_le32(crc);
2378
2379 cp_blk_no = get_sb(cp_blkaddr);
2380 if (sbi->cur_cp == 2)
2381 cp_blk_no += 1 << get_sb(log_blocks_per_seg);
2382
2383 /* write the first cp */
2384 ret = dev_write_block(cp, cp_blk_no++);
2385 ASSERT(ret >= 0);
2386
2387 /* skip payload */
2388 cp_blk_no += get_sb(cp_payload);
2389 /* skip orphan blocks */
2390 cp_blk_no += orphan_blks;
2391
2392 /* update summary blocks having nullified journal entries */
2393 for (i = 0; i < NO_CHECK_TYPE; i++) {
2394 struct curseg_info *curseg = CURSEG_I(sbi, i);
2395 u64 ssa_blk;
2396
2397 ret = dev_write_block(curseg->sum_blk, cp_blk_no++);
2398 ASSERT(ret >= 0);
2399
2400 /* update original SSA too */
2401 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
2402 ret = dev_write_block(curseg->sum_blk, ssa_blk);
2403 ASSERT(ret >= 0);
2404 }
2405
2406 /* Write nat bits */
2407 if (flags & CP_NAT_BITS_FLAG)
2408 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
2409
2410 /* in case of sudden power off */
2411 ret = f2fs_fsync_device();
2412 ASSERT(ret >= 0);
2413
2414 /* write the last cp */
2415 ret = dev_write_block(cp, cp_blk_no++);
2416 ASSERT(ret >= 0);
2417 }
2418
build_nat_area_bitmap(struct f2fs_sb_info * sbi)2419 void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
2420 {
2421 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
2422 struct f2fs_journal *journal = &curseg->sum_blk->journal;
2423 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2424 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2425 struct f2fs_nm_info *nm_i = NM_I(sbi);
2426 struct f2fs_nat_block *nat_block;
2427 struct node_info ni;
2428 u32 nid, nr_nat_blks;
2429 pgoff_t block_off;
2430 pgoff_t block_addr;
2431 int seg_off;
2432 int ret;
2433 unsigned int i;
2434
2435 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
2436 ASSERT(nat_block);
2437
2438 /* Alloc & build nat entry bitmap */
2439 nr_nat_blks = (get_sb(segment_count_nat) / 2) <<
2440 sbi->log_blocks_per_seg;
2441
2442 fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK;
2443 fsck->nat_area_bitmap_sz = (fsck->nr_nat_entries + 7) / 8;
2444 fsck->nat_area_bitmap = calloc(fsck->nat_area_bitmap_sz, 1);
2445 ASSERT(fsck->nat_area_bitmap);
2446
2447 fsck->entries = calloc(sizeof(struct f2fs_nat_entry),
2448 fsck->nr_nat_entries);
2449 ASSERT(fsck->entries);
2450
2451 for (block_off = 0; block_off < nr_nat_blks; block_off++) {
2452
2453 seg_off = block_off >> sbi->log_blocks_per_seg;
2454 block_addr = (pgoff_t)(nm_i->nat_blkaddr +
2455 (seg_off << sbi->log_blocks_per_seg << 1) +
2456 (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
2457
2458 if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
2459 block_addr += sbi->blocks_per_seg;
2460
2461 ret = dev_read_block(nat_block, block_addr);
2462 ASSERT(ret >= 0);
2463
2464 nid = block_off * NAT_ENTRY_PER_BLOCK;
2465 for (i = 0; i < NAT_ENTRY_PER_BLOCK; i++) {
2466 ni.nid = nid + i;
2467
2468 if ((nid + i) == F2FS_NODE_INO(sbi) ||
2469 (nid + i) == F2FS_META_INO(sbi)) {
2470 /*
2471 * block_addr of node/meta inode should be 0x1.
2472 * Set this bit, and fsck_verify will fix it.
2473 */
2474 if (le32_to_cpu(nat_block->entries[i].block_addr) != 0x1) {
2475 ASSERT_MSG("\tError: ino[0x%x] block_addr[0x%x] is invalid\n",
2476 nid + i, le32_to_cpu(nat_block->entries[i].block_addr));
2477 f2fs_set_bit(nid + i, fsck->nat_area_bitmap);
2478 }
2479 continue;
2480 }
2481
2482 node_info_from_raw_nat(&ni, &nat_block->entries[i]);
2483 if (ni.blk_addr == 0x0)
2484 continue;
2485 if (ni.ino == 0x0) {
2486 ASSERT_MSG("\tError: ino[0x%8x] or blk_addr[0x%16x]"
2487 " is invalid\n", ni.ino, ni.blk_addr);
2488 }
2489 if (ni.ino == (nid + i)) {
2490 fsck->nat_valid_inode_cnt++;
2491 DBG(3, "ino[0x%8x] maybe is inode\n", ni.ino);
2492 }
2493 if (nid + i == 0) {
2494 /*
2495 * nat entry [0] must be null. If
2496 * it is corrupted, set its bit in
2497 * nat_area_bitmap, fsck_verify will
2498 * nullify it
2499 */
2500 ASSERT_MSG("Invalid nat entry[0]: "
2501 "blk_addr[0x%x]\n", ni.blk_addr);
2502 fsck->chk.valid_nat_entry_cnt--;
2503 }
2504
2505 DBG(3, "nid[0x%8x] addr[0x%16x] ino[0x%8x]\n",
2506 nid + i, ni.blk_addr, ni.ino);
2507 f2fs_set_bit(nid + i, fsck->nat_area_bitmap);
2508 fsck->chk.valid_nat_entry_cnt++;
2509
2510 fsck->entries[nid + i] = nat_block->entries[i];
2511 }
2512 }
2513
2514 /* Traverse nat journal, update the corresponding entries */
2515 for (i = 0; i < nats_in_cursum(journal); i++) {
2516 struct f2fs_nat_entry raw_nat;
2517 nid = le32_to_cpu(nid_in_journal(journal, i));
2518 ni.nid = nid;
2519
2520 DBG(3, "==> Found nid [0x%x] in nat cache, update it\n", nid);
2521
2522 /* Clear the original bit and count */
2523 if (fsck->entries[nid].block_addr != 0x0) {
2524 fsck->chk.valid_nat_entry_cnt--;
2525 f2fs_clear_bit(nid, fsck->nat_area_bitmap);
2526 if (fsck->entries[nid].ino == nid)
2527 fsck->nat_valid_inode_cnt--;
2528 }
2529
2530 /* Use nat entries in journal */
2531 memcpy(&raw_nat, &nat_in_journal(journal, i),
2532 sizeof(struct f2fs_nat_entry));
2533 node_info_from_raw_nat(&ni, &raw_nat);
2534 if (ni.blk_addr != 0x0) {
2535 if (ni.ino == 0x0)
2536 ASSERT_MSG("\tError: ino[0x%8x] or blk_addr[0x%16x]"
2537 " is invalid\n", ni.ino, ni.blk_addr);
2538 if (ni.ino == nid) {
2539 fsck->nat_valid_inode_cnt++;
2540 DBG(3, "ino[0x%8x] maybe is inode\n", ni.ino);
2541 }
2542 f2fs_set_bit(nid, fsck->nat_area_bitmap);
2543 fsck->chk.valid_nat_entry_cnt++;
2544 DBG(3, "nid[0x%x] in nat cache\n", nid);
2545 }
2546 fsck->entries[nid] = raw_nat;
2547 }
2548 free(nat_block);
2549
2550 DBG(1, "valid nat entries (block_addr != 0x0) [0x%8x : %u]\n",
2551 fsck->chk.valid_nat_entry_cnt,
2552 fsck->chk.valid_nat_entry_cnt);
2553 }
2554
check_sector_size(struct f2fs_super_block * sb)2555 static int check_sector_size(struct f2fs_super_block *sb)
2556 {
2557 u_int32_t log_sectorsize, log_sectors_per_block;
2558
2559 log_sectorsize = log_base_2(c.sector_size);
2560 log_sectors_per_block = log_base_2(c.sectors_per_blk);
2561
2562 if (log_sectorsize == get_sb(log_sectorsize) &&
2563 log_sectors_per_block == get_sb(log_sectors_per_block))
2564 return 0;
2565
2566 set_sb(log_sectorsize, log_sectorsize);
2567 set_sb(log_sectors_per_block, log_sectors_per_block);
2568
2569 update_superblock(sb, SB_MASK_ALL);
2570 return 0;
2571 }
2572
tune_sb_features(struct f2fs_sb_info * sbi)2573 static void tune_sb_features(struct f2fs_sb_info *sbi)
2574 {
2575 int sb_changed = 0;
2576 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2577
2578 if (!(sb->feature & cpu_to_le32(F2FS_FEATURE_ENCRYPT)) &&
2579 c.feature & cpu_to_le32(F2FS_FEATURE_ENCRYPT)) {
2580 sb->feature |= cpu_to_le32(F2FS_FEATURE_ENCRYPT);
2581 MSG(0, "Info: Set Encryption feature\n");
2582 sb_changed = 1;
2583 }
2584 /* TODO: quota needs to allocate inode numbers */
2585
2586 c.feature = sb->feature;
2587 if (!sb_changed)
2588 return;
2589
2590 update_superblock(sb, SB_MASK_ALL);
2591 }
2592
f2fs_do_mount(struct f2fs_sb_info * sbi)2593 int f2fs_do_mount(struct f2fs_sb_info *sbi)
2594 {
2595 struct f2fs_checkpoint *cp = NULL;
2596 struct f2fs_super_block *sb = NULL;
2597 int ret;
2598
2599 sbi->active_logs = NR_CURSEG_TYPE;
2600 ret = validate_super_block(sbi, SB0_ADDR);
2601 if (ret) {
2602 ret = validate_super_block(sbi, SB1_ADDR);
2603 if (ret)
2604 return -1;
2605 }
2606 sb = F2FS_RAW_SUPER(sbi);
2607
2608 ret = check_sector_size(sb);
2609 if (ret)
2610 return -1;
2611
2612 print_raw_sb_info(sb);
2613
2614 init_sb_info(sbi);
2615
2616 ret = get_valid_checkpoint(sbi);
2617 if (ret) {
2618 ERR_MSG("Can't find valid checkpoint\n");
2619 return -1;
2620 }
2621
2622 if (sanity_check_ckpt(sbi)) {
2623 ERR_MSG("Checkpoint is polluted\n");
2624 return -1;
2625 }
2626 cp = F2FS_CKPT(sbi);
2627
2628 print_ckpt_info(sbi);
2629
2630 if (c.quota_fix) {
2631 if (get_cp(ckpt_flags) & CP_QUOTA_NEED_FSCK_FLAG)
2632 c.fix_on = 1;
2633 }
2634
2635 if (c.auto_fix || c.preen_mode) {
2636 u32 flag = get_cp(ckpt_flags);
2637
2638 if (flag & CP_FSCK_FLAG ||
2639 flag & CP_QUOTA_NEED_FSCK_FLAG ||
2640 (exist_qf_ino(sb) && (flag & CP_ERROR_FLAG))) {
2641 c.fix_on = 1;
2642 } else if (!c.preen_mode) {
2643 print_cp_state(flag);
2644 return 1;
2645 }
2646 }
2647
2648 c.bug_on = 0;
2649
2650 tune_sb_features(sbi);
2651
2652 /* precompute checksum seed for metadata */
2653 if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM))
2654 c.chksum_seed = f2fs_cal_crc32(~0, sb->uuid, sizeof(sb->uuid));
2655
2656 sbi->total_valid_node_count = get_cp(valid_node_count);
2657 sbi->total_valid_inode_count = get_cp(valid_inode_count);
2658 sbi->user_block_count = get_cp(user_block_count);
2659 sbi->total_valid_block_count = get_cp(valid_block_count);
2660 sbi->last_valid_block_count = sbi->total_valid_block_count;
2661 sbi->alloc_valid_block_count = 0;
2662
2663 if (build_segment_manager(sbi)) {
2664 ERR_MSG("build_segment_manager failed\n");
2665 return -1;
2666 }
2667
2668 if (build_node_manager(sbi)) {
2669 ERR_MSG("build_node_manager failed\n");
2670 return -1;
2671 }
2672
2673 /* Check nat_bits */
2674 if (c.func == FSCK && is_set_ckpt_flags(cp, CP_NAT_BITS_FLAG)) {
2675 if (check_nat_bits(sbi, sb, cp) && c.fix_on)
2676 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
2677 }
2678 return 0;
2679 }
2680
f2fs_do_umount(struct f2fs_sb_info * sbi)2681 void f2fs_do_umount(struct f2fs_sb_info *sbi)
2682 {
2683 struct sit_info *sit_i = SIT_I(sbi);
2684 struct f2fs_sm_info *sm_i = SM_I(sbi);
2685 struct f2fs_nm_info *nm_i = NM_I(sbi);
2686 unsigned int i;
2687
2688 /* free nm_info */
2689 if (c.func == SLOAD || c.func == FSCK)
2690 free(nm_i->nid_bitmap);
2691 free(nm_i->nat_bitmap);
2692 free(sbi->nm_info);
2693
2694 /* free sit_info */
2695 for (i = 0; i < TOTAL_SEGS(sbi); i++)
2696 free(sit_i->sentries[i].cur_valid_map);
2697
2698 free(sit_i->sit_bitmap);
2699 free(sm_i->sit_info);
2700
2701 /* free sm_info */
2702 for (i = 0; i < NR_CURSEG_TYPE; i++)
2703 free(sm_i->curseg_array[i].sum_blk);
2704
2705 free(sm_i->curseg_array);
2706 free(sbi->sm_info);
2707
2708 free(sbi->ckpt);
2709 free(sbi->raw_super);
2710 }
2711