| // Copyright 2021 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "f2fs.h" |
| |
| #include <fcntl.h> |
| #include <inttypes.h> |
| #include <lib/syslog/cpp/macros.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| |
| #include "src/lib/uuid/uuid.h" |
| #include "zircon/errors.h" |
| #include "zircon/types.h" |
| |
| #include <memory> |
| |
| #include <lib/zx/event.h> |
| #include <zircon/assert.h> |
| |
| #include <lib/trace-provider/provider.h> |
| |
| |
| namespace f2fs { |
| |
| const char *media_ext_lists[] = {"jpg", "gif", "png", "avi", "divx", "mp4", "mp3", "3gp", |
| "wmv", "wma", "mpeg", "mkv", "mov", "asx", "asf", "wmx", |
| "svi", "wvx", "wm", "mpg", "mpe", "rm", "ogg", nullptr}; |
| |
| F2fsMkfs::F2fsMkfs(std::unique_ptr<f2fs::Bcache> bc, const MkfsOptions &mkfs_options) |
| : bc_(std::move(bc)), mkfs_options_(mkfs_options) {} |
| |
| zx_status_t F2fsMkfs::Mkfs() { |
| char extension_list[] = ""; |
| |
| #ifdef F2FS_BU_DEBUG |
| // TODO: lable, extention list |
| std::cout << "f2fs mkfs heap-based allocation = " << mkfs_options_.heap_based_allocation |
| << std::endl; |
| std::cout << "f2fs mkfs overprovision ratio = " << mkfs_options_.overprovision_ratio << std::endl; |
| std::cout << "f2fs mkfs # of segments per section = " << mkfs_options_.num_of_seg_per_sec |
| << std::endl; |
| std::cout << "f2fs mkfs overprovision ratio = " << mkfs_options_.num_of_sec_per_zone << std::endl; |
| #endif |
| |
| // TODO: parse mkfs options |
| f2fs_params.extension_list = extension_list; |
| |
| F2fsInitGlobalParameters(); |
| |
| if (F2fsGetDeviceInfo() < 0) |
| return -1; |
| |
| if (F2fsFormatDevice() < 0) |
| return -1; |
| |
| printf("Info: format successful\n"); |
| |
| return ZX_OK; |
| } |
| |
| void F2fsMkfs::ASCIIToUNICODE(uint16_t *out_buf, uint8_t *in_buf) { |
| uint8_t *pchTempPtr = in_buf; |
| uint16_t *pwTempPtr = out_buf; |
| |
| while (*pchTempPtr != '\0') { |
| /* Copy the string elements character by character |
| * to the output string with typecasting the source. |
| */ |
| *pwTempPtr = static_cast<uint16_t>(*pchTempPtr); |
| pchTempPtr++; |
| pwTempPtr++; |
| } |
| *pwTempPtr = '\0'; |
| } |
| |
| void F2fsMkfs::F2fsInitGlobalParameters() { |
| static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__); |
| |
| f2fs_params.sector_size = DEFAULT_SECTOR_SIZE; |
| f2fs_params.sectors_per_blk = DEFAULT_SECTORS_PER_BLOCK; |
| f2fs_params.blks_per_seg = DEFAULT_BLOCKS_PER_SEGMENT; |
| f2fs_params.reserved_segments = 20; /* calculated by overprovision ratio */ |
| f2fs_params.overprovision = 5; |
| f2fs_params.segs_per_sec = 1; |
| f2fs_params.secs_per_zone = 1; |
| f2fs_params.heap = 1; |
| memset(f2fs_params.vol_label, 0, sizeof(f2fs_params.vol_label)); |
| |
| f2fs_params.vol_label[0] = 'F'; |
| f2fs_params.vol_label[1] = '2'; |
| f2fs_params.vol_label[2] = 'F'; |
| f2fs_params.vol_label[3] = 'S'; |
| f2fs_params.vol_label[4] = '\0'; |
| f2fs_params.device_name = nullptr; |
| } |
| |
| inline int F2fsMkfs::F2fsSetBit(unsigned int nr, unsigned char *addr) { |
| int mask; |
| int ret; |
| |
| addr += (nr >> 3); |
| mask = 1 << (7 - (nr & 0x07)); |
| ret = mask & *addr; |
| *addr |= mask; |
| return ret; |
| } |
| |
| int8_t F2fsMkfs::LogBase2(uint32_t num) { |
| int8_t ret = 0; |
| |
| if (num <= 0 || (num & (num - 1)) != 0) { |
| return -1; |
| } |
| |
| while (num >>= 1) { |
| ret++; |
| } |
| |
| return ret; |
| } |
| |
| #if 0 // porting needed |
| void F2fsMkfs::f2fs_usage(void) |
| { |
| fprintf(stderr, "Usage: f2fs_format [options] device\n"); |
| fprintf(stderr, "[options]\n"); |
| fprintf(stderr, "-l label\n"); |
| fprintf(stderr, "-a heap-based allocation [default:1]\n"); |
| fprintf(stderr, "-o overprovision ratio [default:5]\n"); |
| fprintf(stderr, "-s # of segments per section [default:1]\n"); |
| fprintf(stderr, "-z # of sections per zone [default:1]\n"); |
| fprintf(stderr, "-e [extension list] e.g. \"mp3,gif,mov\"\n"); |
| exit(1); |
| } |
| #endif |
| |
| zx_status_t F2fsMkfs::F2fsGetDeviceInfo() { |
| fuchsia_hardware_block_BlockInfo info; |
| |
| bc_->device()->BlockGetInfo(&info); |
| |
| ZX_ASSERT(info.block_size == DEFAULT_SECTOR_SIZE); |
| |
| f2fs_params.sector_size = DEFAULT_SECTOR_SIZE; |
| f2fs_params.sectors_per_blk = kF2fsBlockSize / DEFAULT_SECTOR_SIZE; |
| f2fs_params.total_sectors = info.block_count; |
| f2fs_params.start_sector = kSuperblockStart; |
| |
| if (f2fs_params.total_sectors < (F2FS_MIN_VOLUME_SIZE / DEFAULT_SECTOR_SIZE)) { |
| printf("Error: Min volume size supported is %d\n", F2FS_MIN_VOLUME_SIZE); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| return ZX_OK; |
| } |
| |
| void F2fsMkfs::ConfigureExtensionList() { |
| const char **extlist = media_ext_lists; |
| char *ext_str = f2fs_params.extension_list; |
| char *ue; |
| int name_len; |
| int i = 0; |
| |
| super_block.extension_count = 0; |
| memset(super_block.extension_list, 0, sizeof(super_block.extension_list)); |
| |
| while (*extlist) { |
| name_len = static_cast<int>(strlen(*extlist)); |
| memcpy(super_block.extension_list[i++], *extlist, name_len); |
| extlist++; |
| } |
| super_block.extension_count = i - 1; |
| |
| if (!ext_str) |
| return; |
| |
| /* add user ext list */ |
| ue = strtok(ext_str, ","); |
| while (ue != nullptr) { |
| name_len = static_cast<int>(strlen(ue)); |
| memcpy(super_block.extension_list[i++], ue, name_len); |
| ue = strtok(nullptr, ","); |
| if (i > F2FS_MAX_EXTENSION) |
| break; |
| } |
| |
| super_block.extension_count = i - 1; |
| #if 0 // porting needed |
| // TODO: strdup in f2fs_parse_options |
| // free(f2fs_params.extension_list); |
| #endif |
| } |
| |
| zx_status_t F2fsMkfs::WriteToDisk(void *buf, uint64_t offset, size_t length) { |
| zx_status_t status = 0; |
| uint64_t curr_offset = offset; |
| |
| #ifdef F2FS_BU_DEBUG |
| std::cout << std::hex << "writetodeisk: offset= 0x" << offset << " length= 0x" << length |
| << std::endl; |
| #endif |
| |
| if (offset % kF2fsBlockSize) { |
| std::cout << std::hex << "block is not aligned: offset = " << offset << " length = " << length |
| << std::endl; |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| if (length % kF2fsBlockSize) { |
| std::cout << std::hex << "block size is not aligned: offset = " << offset |
| << " length = " << length << std::endl; |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| for (uint64_t i = 0; i < length / kF2fsBlockSize; i++) { |
| if ((status = bc_->Writeblk((offset / kF2fsBlockSize) + i, buf)) != ZX_OK) { |
| std::cout << "mkfs: Failed to write root directory: " << status << std::endl; |
| } |
| |
| curr_offset += kF2fsBlockSize; |
| } |
| |
| ZX_ASSERT(curr_offset == offset + length); |
| |
| return status; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsPrepareSuperBlock() { |
| uint32_t blk_size_bytes; |
| uint32_t log_sectorsize, log_sectors_per_block; |
| uint32_t log_blocksize, log_blks_per_seg; |
| uint32_t segment_size_bytes, zone_size_bytes; |
| uint32_t sit_segments; |
| uint32_t blocks_for_sit, blocks_for_nat, blocks_for_ssa; |
| uint32_t total_valid_blks_available; |
| uint64_t zone_align_start_offset, diff, total_meta_segments; |
| uint32_t sit_bitmap_size, max_nat_bitmap_size, max_nat_segments; |
| uint32_t total_zones; |
| |
| super_block.magic = CpuToLe(uint32_t{kF2fsSuperMagic}); |
| super_block.major_ver = CpuToLe(uint16_t{F2FS_MAJOR_VERSION}); |
| super_block.minor_ver = CpuToLe(uint16_t{F2FS_MINOR_VERSION}); |
| |
| log_sectorsize = LogBase2(f2fs_params.sector_size); |
| log_sectors_per_block = LogBase2(f2fs_params.sectors_per_blk); |
| log_blocksize = log_sectorsize + log_sectors_per_block; |
| log_blks_per_seg = LogBase2(f2fs_params.blks_per_seg); |
| |
| super_block.log_sectorsize = CpuToLe(log_sectorsize); |
| |
| if (log_sectorsize < 0) { |
| printf("\n\tError: Failed to get the sector size: %u!\n", f2fs_params.sector_size); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| super_block.log_sectors_per_block = CpuToLe(log_sectors_per_block); |
| |
| if (log_sectors_per_block < 0) { |
| printf("\n\tError: Failed to get sectors per block: %u!\n", f2fs_params.sectors_per_blk); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| super_block.log_blocksize = CpuToLe(log_blocksize); |
| super_block.log_blocks_per_seg = CpuToLe(log_blks_per_seg); |
| |
| if (log_blks_per_seg < 0) { |
| printf("\n\tError: Failed to get block per segment: %u!\n", f2fs_params.blks_per_seg); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| super_block.segs_per_sec = CpuToLe(f2fs_params.segs_per_sec); |
| super_block.secs_per_zone = CpuToLe(f2fs_params.secs_per_zone); |
| blk_size_bytes = 1 << log_blocksize; |
| segment_size_bytes = blk_size_bytes * f2fs_params.blks_per_seg; |
| zone_size_bytes = blk_size_bytes * f2fs_params.secs_per_zone * f2fs_params.segs_per_sec * |
| f2fs_params.blks_per_seg; |
| |
| super_block.checksum_offset = 0; |
| |
| super_block.block_count = |
| CpuToLe((f2fs_params.total_sectors * DEFAULT_SECTOR_SIZE) / blk_size_bytes); |
| |
| zone_align_start_offset = |
| (f2fs_params.start_sector * DEFAULT_SECTOR_SIZE + 2 * F2FS_BLKSIZE + zone_size_bytes - 1) / |
| zone_size_bytes * zone_size_bytes - |
| f2fs_params.start_sector * DEFAULT_SECTOR_SIZE; |
| |
| if (f2fs_params.start_sector % DEFAULT_SECTORS_PER_BLOCK) { |
| printf("WARN: Align start sector number in a unit of pages\n"); |
| printf("\ti.e., start sector: %d, ofs:%d (sectors per page: %d)\n", f2fs_params.start_sector, |
| f2fs_params.start_sector % DEFAULT_SECTORS_PER_BLOCK, DEFAULT_SECTORS_PER_BLOCK); |
| } |
| |
| super_block.segment_count = |
| CpuToLe(((f2fs_params.total_sectors * DEFAULT_SECTOR_SIZE) - zone_align_start_offset) / |
| segment_size_bytes); |
| |
| super_block.segment0_blkaddr = CpuToLe(zone_align_start_offset / blk_size_bytes); |
| super_block.cp_blkaddr = super_block.segment0_blkaddr; |
| |
| super_block.segment_count_ckpt = CpuToLe(uint32_t{F2FS_NUMBER_OF_CHECKPOINT_PACK}); |
| |
| super_block.sit_blkaddr = |
| CpuToLe(LeToCpu(super_block.segment0_blkaddr) + |
| (LeToCpu(super_block.segment_count_ckpt) * (1 << log_blks_per_seg))); |
| |
| blocks_for_sit = |
| (LeToCpu(super_block.segment_count) + SIT_ENTRY_PER_BLOCK - 1) / SIT_ENTRY_PER_BLOCK; |
| |
| sit_segments = (blocks_for_sit + f2fs_params.blks_per_seg - 1) / f2fs_params.blks_per_seg; |
| |
| super_block.segment_count_sit = CpuToLe(sit_segments * 2); |
| |
| super_block.nat_blkaddr = |
| CpuToLe(LeToCpu(super_block.sit_blkaddr) + |
| (LeToCpu(super_block.segment_count_sit) * f2fs_params.blks_per_seg)); |
| |
| total_valid_blks_available = |
| (LeToCpu(super_block.segment_count) - |
| (LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit))) * |
| f2fs_params.blks_per_seg; |
| |
| blocks_for_nat = (total_valid_blks_available + NAT_ENTRY_PER_BLOCK - 1) / NAT_ENTRY_PER_BLOCK; |
| |
| super_block.segment_count_nat = |
| CpuToLe((blocks_for_nat + f2fs_params.blks_per_seg - 1) / f2fs_params.blks_per_seg); |
| /* |
| * The number of node segments should not be exceeded a "Threshold". |
| * This number resizes NAT bitmap area in a CP page. |
| * So the threshold is determined not to overflow one CP page |
| */ |
| sit_bitmap_size = ((LeToCpu(super_block.segment_count_sit) / 2) << log_blks_per_seg) / 8; |
| max_nat_bitmap_size = 4096 - sizeof(struct f2fs_checkpoint) + 1 - sit_bitmap_size; |
| max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg; |
| |
| if (LeToCpu(super_block.segment_count_nat) > max_nat_segments) |
| super_block.segment_count_nat = CpuToLe(max_nat_segments); |
| |
| super_block.segment_count_nat = CpuToLe(LeToCpu(super_block.segment_count_nat) * 2); |
| |
| super_block.ssa_blkaddr = |
| CpuToLe(LeToCpu(super_block.nat_blkaddr) + |
| LeToCpu(super_block.segment_count_nat) * f2fs_params.blks_per_seg); |
| |
| total_valid_blks_available = |
| (LeToCpu(super_block.segment_count) - |
| (LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit) + |
| LeToCpu(super_block.segment_count_nat))) * |
| f2fs_params.blks_per_seg; |
| |
| blocks_for_ssa = total_valid_blks_available / f2fs_params.blks_per_seg + 1; |
| |
| super_block.segment_count_ssa = |
| CpuToLe((blocks_for_ssa + f2fs_params.blks_per_seg - 1) / f2fs_params.blks_per_seg); |
| |
| total_meta_segments = |
| LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit) + |
| LeToCpu(super_block.segment_count_nat) + LeToCpu(super_block.segment_count_ssa); |
| diff = total_meta_segments % (f2fs_params.segs_per_sec * f2fs_params.secs_per_zone); |
| if (diff) |
| super_block.segment_count_ssa = |
| CpuToLe(LeToCpu(super_block.segment_count_ssa) + |
| (f2fs_params.segs_per_sec * f2fs_params.secs_per_zone - diff)); |
| |
| super_block.main_blkaddr = |
| CpuToLe(LeToCpu(super_block.ssa_blkaddr) + |
| (LeToCpu(super_block.segment_count_ssa) * f2fs_params.blks_per_seg)); |
| |
| super_block.segment_count_main = CpuToLe( |
| LeToCpu(super_block.segment_count) - |
| (LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit) + |
| LeToCpu(super_block.segment_count_nat) + LeToCpu(super_block.segment_count_ssa))); |
| |
| super_block.section_count = |
| CpuToLe(LeToCpu(super_block.segment_count_main) / f2fs_params.segs_per_sec); |
| |
| super_block.segment_count_main = |
| CpuToLe(LeToCpu(super_block.section_count) * f2fs_params.segs_per_sec); |
| |
| if ((LeToCpu(super_block.segment_count_main) - 2) < f2fs_params.reserved_segments) { |
| printf( |
| "Error: Device size is not sufficient for F2FS volume, \ |
| more segment needed =%u", |
| f2fs_params.reserved_segments - (LeToCpu(super_block.segment_count_main) - 2)); |
| return ZX_ERR_NO_SPACE; |
| } |
| |
| memcpy(super_block.uuid, uuid::Uuid::Generate().bytes(), 16); |
| |
| ASCIIToUNICODE(super_block.volume_name, f2fs_params.vol_label); |
| |
| super_block.node_ino = CpuToLe(uint32_t{1}); |
| super_block.meta_ino = CpuToLe(uint32_t{2}); |
| super_block.root_ino = CpuToLe(uint32_t{3}); |
| |
| total_zones = ((LeToCpu(super_block.segment_count_main) - 1) / f2fs_params.segs_per_sec) / |
| f2fs_params.secs_per_zone; |
| if (total_zones <= 6) { |
| printf( |
| "\n\tError: %d zones: Need more zones \ |
| by shrinking zone size\n", |
| total_zones); |
| return ZX_ERR_NO_SPACE; |
| } |
| |
| if (f2fs_params.heap) { |
| f2fs_params.cur_seg[CURSEG_HOT_NODE] = |
| (total_zones - 1) * f2fs_params.segs_per_sec * f2fs_params.secs_per_zone + |
| ((f2fs_params.secs_per_zone - 1) * f2fs_params.segs_per_sec); |
| f2fs_params.cur_seg[CURSEG_WARM_NODE] = |
| f2fs_params.cur_seg[CURSEG_HOT_NODE] - f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_COLD_NODE] = f2fs_params.cur_seg[CURSEG_WARM_NODE] - |
| f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_HOT_DATA] = f2fs_params.cur_seg[CURSEG_COLD_NODE] - |
| f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_COLD_DATA] = 0; |
| f2fs_params.cur_seg[CURSEG_WARM_DATA] = f2fs_params.cur_seg[CURSEG_COLD_DATA] + |
| f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| } else { |
| f2fs_params.cur_seg[CURSEG_HOT_NODE] = 0; |
| f2fs_params.cur_seg[CURSEG_WARM_NODE] = |
| f2fs_params.cur_seg[CURSEG_HOT_NODE] + f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_COLD_NODE] = f2fs_params.cur_seg[CURSEG_WARM_NODE] + |
| f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_HOT_DATA] = f2fs_params.cur_seg[CURSEG_COLD_NODE] + |
| f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_COLD_DATA] = |
| f2fs_params.cur_seg[CURSEG_HOT_DATA] + f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| f2fs_params.cur_seg[CURSEG_WARM_DATA] = f2fs_params.cur_seg[CURSEG_COLD_DATA] + |
| f2fs_params.segs_per_sec * f2fs_params.secs_per_zone; |
| } |
| |
| ConfigureExtensionList(); |
| |
| return 0; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsInitSitArea() { |
| uint32_t blk_size_bytes; |
| uint32_t seg_size_bytes; |
| uint32_t index = 0; |
| uint64_t sit_seg_blk_offset = 0; |
| uint8_t *zero_buf = nullptr; |
| zx_status_t ret; |
| |
| blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize); |
| seg_size_bytes = (1 << LeToCpu(super_block.log_blocks_per_seg)) * blk_size_bytes; |
| |
| zero_buf = static_cast<uint8_t *>(calloc(sizeof(uint8_t), seg_size_bytes)); |
| if (zero_buf == nullptr) { |
| printf("\n\tError: Calloc Failed for sit_zero_buf!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| sit_seg_blk_offset = LeToCpu(super_block.sit_blkaddr) * blk_size_bytes; |
| |
| for (index = 0; index < (LeToCpu(super_block.segment_count_sit) / 2); index++) { |
| ret = WriteToDisk(zero_buf, sit_seg_blk_offset, seg_size_bytes); |
| if (ret < 0) { |
| printf( |
| "\n\tError: While zeroing out the sit area \ |
| on disk!!!\n"); |
| return ret; |
| } |
| sit_seg_blk_offset = sit_seg_blk_offset + seg_size_bytes; |
| } |
| |
| free(zero_buf); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsInitNatArea() { |
| uint32_t blk_size_bytes; |
| uint32_t seg_size_bytes; |
| uint32_t index = 0; |
| uint64_t nat_seg_blk_offset = 0; |
| uint8_t *nat_buf = nullptr; |
| zx_status_t ret; |
| |
| blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize); |
| seg_size_bytes = (1 << LeToCpu(super_block.log_blocks_per_seg)) * blk_size_bytes; |
| |
| nat_buf = static_cast<uint8_t *>(calloc(sizeof(uint8_t), seg_size_bytes)); |
| if (nat_buf == nullptr) { |
| printf("\n\tError: Calloc Failed for nat_zero_blk!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| nat_seg_blk_offset = LeToCpu(super_block.nat_blkaddr) * blk_size_bytes; |
| |
| for (index = 0; index < (LeToCpu(super_block.segment_count_nat) / 2); index++) { |
| ret = WriteToDisk(nat_buf, nat_seg_blk_offset, seg_size_bytes); |
| if (ret < 0) { |
| printf( |
| "\n\tError: While zeroing out the nat area \ |
| on disk!!!\n"); |
| return ret; |
| } |
| nat_seg_blk_offset = nat_seg_blk_offset + (2 * seg_size_bytes); |
| } |
| |
| free(nat_buf); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsWriteCheckPointPack() { |
| struct f2fs_checkpoint *ckp = nullptr; |
| struct f2fs_summary_block *sum = nullptr; |
| uint32_t blk_size_bytes; |
| uint64_t cp_seg_blk_offset = 0; |
| uint32_t crc = 0; |
| zx_status_t ret; |
| int i; |
| |
| ckp = static_cast<struct f2fs_checkpoint *>(calloc(F2FS_BLKSIZE, 1)); |
| if (ckp == nullptr) { |
| printf("\n\tError: Calloc Failed for f2fs_checkpoint!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| sum = static_cast<struct f2fs_summary_block *>(calloc(F2FS_BLKSIZE, 1)); |
| if (sum == nullptr) { |
| printf("\n\tError: Calloc Failed for summay_node!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| /* 1. cp page 1 of checkpoint pack 1 */ |
| ckp->checkpoint_ver = 1; |
| ckp->cur_node_segno[0] = CpuToLe(f2fs_params.cur_seg[CURSEG_HOT_NODE]); |
| ckp->cur_node_segno[1] = CpuToLe(f2fs_params.cur_seg[CURSEG_WARM_NODE]); |
| ckp->cur_node_segno[2] = CpuToLe(f2fs_params.cur_seg[CURSEG_COLD_NODE]); |
| ckp->cur_data_segno[0] = CpuToLe(f2fs_params.cur_seg[CURSEG_HOT_DATA]); |
| ckp->cur_data_segno[1] = CpuToLe(f2fs_params.cur_seg[CURSEG_WARM_DATA]); |
| ckp->cur_data_segno[2] = CpuToLe(f2fs_params.cur_seg[CURSEG_COLD_DATA]); |
| for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) { |
| ckp->cur_node_segno[i] = 0xffffffff; |
| ckp->cur_data_segno[i] = 0xffffffff; |
| } |
| |
| ckp->cur_node_blkoff[0] = CpuToLe(uint16_t{1}); |
| ckp->cur_data_blkoff[0] = CpuToLe(uint16_t{1}); |
| ckp->valid_block_count = CpuToLe(uint64_t{2}); |
| ckp->rsvd_segment_count = CpuToLe(f2fs_params.reserved_segments); |
| ckp->overprov_segment_count = CpuToLe( |
| (LeToCpu(super_block.segment_count_main) - LeToCpu(ckp->rsvd_segment_count)) * |
| f2fs_params.overprovision / 100); |
| ckp->overprov_segment_count = |
| CpuToLe(LeToCpu(ckp->overprov_segment_count) + LeToCpu(ckp->rsvd_segment_count)); |
| |
| /* main segments - reserved segments - (node + data segments) */ |
| ckp->free_segment_count = CpuToLe(LeToCpu(super_block.segment_count_main) - 6); |
| |
| ckp->user_block_count = CpuToLe( |
| ((LeToCpu(ckp->free_segment_count) + 6 - LeToCpu(ckp->overprov_segment_count)) * |
| f2fs_params.blks_per_seg)); |
| |
| ckp->cp_pack_total_block_count = CpuToLe(uint32_t{8}); |
| ckp->ckpt_flags |= CP_UMOUNT_FLAG; |
| ckp->cp_pack_start_sum = CpuToLe(uint32_t{1}); |
| ckp->valid_node_count = CpuToLe(uint32_t{1}); |
| ckp->valid_inode_count = CpuToLe(uint32_t{1}); |
| ckp->next_free_nid = CpuToLe(LeToCpu(super_block.root_ino) + 1); |
| |
| ckp->sit_ver_bitmap_bytesize = CpuToLe(((LeToCpu(super_block.segment_count_sit) / 2) |
| << LeToCpu(super_block.log_blocks_per_seg)) / |
| 8); |
| |
| ckp->nat_ver_bitmap_bytesize = CpuToLe(((LeToCpu(super_block.segment_count_nat) / 2) |
| << LeToCpu(super_block.log_blocks_per_seg)) / |
| 8); |
| |
| ckp->checksum_offset = CpuToLe(uint32_t{4092}); //TODO use constexpr |
| |
| crc = F2fsCalCrc32(kF2fsSuperMagic, ckp, LeToCpu(ckp->checksum_offset)); |
| *(reinterpret_cast<uint32_t *>(reinterpret_cast<unsigned char *>(ckp) + |
| LeToCpu(ckp->checksum_offset))) = crc; |
| |
| blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize); |
| cp_seg_blk_offset = LeToCpu(super_block.segment0_blkaddr) * blk_size_bytes; |
| |
| ret = WriteToDisk(ckp, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the ckp to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 2. Prepare and write Segment summary for data blocks */ |
| memset(sum, 0, sizeof(struct f2fs_summary_block)); |
| SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA); |
| |
| sum->entries[0].nid = super_block.root_ino; |
| sum->entries[0].ofs_in_node = 0; |
| |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the sum_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 3. Fill segment summary for data block to zero. */ |
| memset(sum, 0, sizeof(struct f2fs_summary_block)); |
| SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA); |
| |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the sum_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 4. Fill segment summary for data block to zero. */ |
| memset(sum, 0, sizeof(struct f2fs_summary_block)); |
| SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA); |
| |
| /* inode sit for root */ |
| sum->n_sits = CpuToLe(uint16_t{6}); |
| sum->sit_j.entries[0].segno = ckp->cur_node_segno[0]; |
| sum->sit_j.entries[0].se.vblocks = CpuToLe(uint16_t{(CURSEG_HOT_NODE << 10) | 1}); |
| F2fsSetBit(0, sum->sit_j.entries[0].se.valid_map); |
| sum->sit_j.entries[1].segno = ckp->cur_node_segno[1]; |
| sum->sit_j.entries[1].se.vblocks = CpuToLe(uint16_t{(CURSEG_WARM_NODE << 10)}); |
| sum->sit_j.entries[2].segno = ckp->cur_node_segno[2]; |
| sum->sit_j.entries[2].se.vblocks = CpuToLe(uint16_t{(CURSEG_COLD_NODE << 10)}); |
| |
| /* data sit for root */ |
| sum->sit_j.entries[3].segno = ckp->cur_data_segno[0]; |
| sum->sit_j.entries[3].se.vblocks = CpuToLe(uint16_t{(CURSEG_HOT_DATA << 10) | 1}); |
| F2fsSetBit(0, sum->sit_j.entries[3].se.valid_map); |
| sum->sit_j.entries[4].segno = ckp->cur_data_segno[1]; |
| sum->sit_j.entries[4].se.vblocks = CpuToLe(uint16_t{(CURSEG_WARM_DATA << 10)}); |
| sum->sit_j.entries[5].segno = ckp->cur_data_segno[2]; |
| sum->sit_j.entries[5].se.vblocks = CpuToLe(uint16_t{(CURSEG_COLD_DATA << 10)}); |
| |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the sum_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 5. Prepare and write Segment summary for node blocks */ |
| memset(sum, 0, sizeof(struct f2fs_summary_block)); |
| SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE); |
| |
| sum->entries[0].nid = super_block.root_ino; |
| sum->entries[0].ofs_in_node = 0; |
| |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the sum_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 6. Fill segment summary for data block to zero. */ |
| memset(sum, 0, sizeof(struct f2fs_summary_block)); |
| SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE); |
| |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the sum_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 7. Fill segment summary for data block to zero. */ |
| memset(sum, 0, sizeof(struct f2fs_summary_block)); |
| SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE); |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the sum_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 8. cp page2 */ |
| cp_seg_blk_offset += blk_size_bytes; |
| ret = WriteToDisk(ckp, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the ckp to disk!!!\n"); |
| return ret; |
| } |
| |
| /* 9. cp page 1 of check point pack 2 |
| * Initiatialize other checkpoint pack with version zero |
| */ |
| ckp->checkpoint_ver = 0; |
| |
| crc = F2fsCalCrc32(kF2fsSuperMagic, ckp, LeToCpu(ckp->checksum_offset)); |
| *(reinterpret_cast<uint32_t *>(reinterpret_cast<unsigned char *>(ckp) + |
| LeToCpu(ckp->checksum_offset))) = crc; |
| |
| cp_seg_blk_offset = |
| (LeToCpu(super_block.segment0_blkaddr) + f2fs_params.blks_per_seg) * blk_size_bytes; |
| ret = WriteToDisk(ckp, cp_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the ckp to disk!!!\n"); |
| return ret; |
| } |
| |
| free(sum); |
| free(ckp); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsWriteSuperBlock() { |
| uint32_t index = 0; |
| uint8_t *zero_buff; |
| zx_status_t ret; |
| |
| zero_buff = static_cast<uint8_t *>(calloc(F2FS_BLKSIZE, 1)); |
| |
| memcpy(zero_buff + F2FS_SUPER_OFFSET, &super_block, sizeof(super_block)); |
| |
| for (index = 0; index < 2; index++) { |
| ret = WriteToDisk(zero_buff, index * F2FS_BLKSIZE, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf( |
| "\n\tError: While while writing supe_blk \ |
| on disk!!! index : %d\n", |
| index); |
| return ret; |
| } |
| } |
| |
| free(zero_buff); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsWriteRootInode() { |
| struct f2fs_node *raw_node = nullptr; |
| uint32_t blk_size_bytes; |
| uint64_t data_blk_nor; |
| uint64_t main_area_node_seg_blk_offset = 0; |
| zx_status_t ret; |
| |
| raw_node = static_cast<struct f2fs_node *>(calloc(F2FS_BLKSIZE, 1)); |
| if (raw_node == nullptr) { |
| printf("\n\tError: Calloc Failed for raw_node!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| raw_node->footer.nid = super_block.root_ino; |
| raw_node->footer.ino = super_block.root_ino; |
| raw_node->footer.cp_ver = CpuToLe(uint64_t{1}); |
| raw_node->footer.next_blkaddr = |
| CpuToLe(LeToCpu(super_block.main_blkaddr) + |
| f2fs_params.cur_seg[CURSEG_HOT_NODE] * f2fs_params.blks_per_seg + 1); |
| |
| raw_node->i.i_mode = CpuToLe(uint16_t{0x41ed}); |
| raw_node->i.i_links = CpuToLe(uint32_t{2}); |
| raw_node->i.i_uid = CpuToLe(getuid()); |
| raw_node->i.i_gid = CpuToLe(getgid()); |
| |
| blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize); |
| raw_node->i.i_size = CpuToLe(1 * blk_size_bytes); /* dentry */ |
| raw_node->i.i_blocks = CpuToLe(uint64_t{2}); |
| |
| raw_node->i.i_atime = CpuToLe(static_cast<uint64_t>(time(nullptr))); |
| raw_node->i.i_atime_nsec = 0; |
| raw_node->i.i_ctime = CpuToLe(static_cast<uint64_t>(time(nullptr))); |
| raw_node->i.i_ctime_nsec = 0; |
| raw_node->i.i_mtime = CpuToLe(static_cast<uint64_t>(time(nullptr))); |
| raw_node->i.i_mtime_nsec = 0; |
| raw_node->i.i_generation = 0; |
| raw_node->i.i_xattr_nid = 0; |
| raw_node->i.i_flags = 0; |
| raw_node->i.i_current_depth = CpuToLe(uint32_t{1}); |
| |
| data_blk_nor = LeToCpu(super_block.main_blkaddr) + |
| f2fs_params.cur_seg[CURSEG_HOT_DATA] * f2fs_params.blks_per_seg; |
| raw_node->i.i_addr[0] = CpuToLe(data_blk_nor); |
| |
| raw_node->i.i_ext.fofs = 0; |
| raw_node->i.i_ext.blk_addr = CpuToLe(data_blk_nor); |
| raw_node->i.i_ext.len = CpuToLe(uint32_t{1}); |
| |
| main_area_node_seg_blk_offset = LeToCpu(super_block.main_blkaddr); |
| main_area_node_seg_blk_offset += f2fs_params.cur_seg[CURSEG_HOT_NODE] * f2fs_params.blks_per_seg; |
| main_area_node_seg_blk_offset *= blk_size_bytes; |
| |
| ret = WriteToDisk(raw_node, main_area_node_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the raw_node to disk!!!, size = %lu\n", |
| sizeof(struct f2fs_node)); |
| return ret; |
| } |
| |
| memset(raw_node, 0xff, sizeof(struct f2fs_node)); |
| |
| ret = WriteToDisk(raw_node, main_area_node_seg_blk_offset + 4096, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the raw_node to disk!!!\n"); |
| return ret; |
| } |
| free(raw_node); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsUpdateNatRoot() { |
| struct f2fs_nat_block *nat_blk = nullptr; |
| uint32_t blk_size_bytes; |
| uint64_t nat_seg_blk_offset = 0; |
| zx_status_t ret; |
| |
| nat_blk = static_cast<struct f2fs_nat_block *>(calloc(F2FS_BLKSIZE, 1)); |
| if (nat_blk == nullptr) { |
| printf("\n\tError: Calloc Failed for nat_blk!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| /* update root */ |
| nat_blk->entries[super_block.root_ino].block_addr = |
| CpuToLe(LeToCpu(super_block.main_blkaddr) + |
| f2fs_params.cur_seg[CURSEG_HOT_NODE] * f2fs_params.blks_per_seg); |
| nat_blk->entries[super_block.root_ino].ino = super_block.root_ino; |
| |
| /* update node nat */ |
| nat_blk->entries[super_block.node_ino].block_addr = CpuToLe(uint32_t{1}); |
| nat_blk->entries[super_block.node_ino].ino = super_block.node_ino; |
| |
| /* update meta nat */ |
| nat_blk->entries[super_block.meta_ino].block_addr = CpuToLe(uint32_t{1}); |
| nat_blk->entries[super_block.meta_ino].ino = super_block.meta_ino; |
| |
| blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize); |
| |
| nat_seg_blk_offset = LeToCpu(super_block.nat_blkaddr) * blk_size_bytes; |
| |
| ret = WriteToDisk(nat_blk, nat_seg_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the nat_blk set0 to disk!!!\n"); |
| return ret; |
| } |
| |
| free(nat_blk); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsAddDefaultDentryRoot() { |
| struct f2fs_dentry_block *dent_blk = nullptr; |
| uint32_t blk_size_bytes; |
| uint64_t data_blk_offset = 0; |
| zx_status_t ret; |
| |
| dent_blk = static_cast<struct f2fs_dentry_block *>(calloc(F2FS_BLKSIZE, 1)); |
| if (dent_blk == nullptr) { |
| printf("\n\tError: Calloc Failed for dent_blk!!!\n"); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| dent_blk->dentry[0].hash_code = 0; |
| dent_blk->dentry[0].ino = super_block.root_ino; |
| dent_blk->dentry[0].name_len = CpuToLe(uint16_t{1}); |
| dent_blk->dentry[0].file_type = F2FS_FT_DIR; |
| memcpy(dent_blk->filename[0], ".", 1); |
| |
| dent_blk->dentry[1].hash_code = 0; |
| dent_blk->dentry[1].ino = super_block.root_ino; |
| dent_blk->dentry[1].name_len = CpuToLe(uint16_t{2}); |
| dent_blk->dentry[1].file_type = F2FS_FT_DIR; |
| memcpy(dent_blk->filename[1], "..", 2); |
| |
| /* bitmap for . and .. */ |
| dent_blk->dentry_bitmap[0] = (1 << 1) | (1 << 0); |
| blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize); |
| data_blk_offset = (LeToCpu(super_block.main_blkaddr) + |
| f2fs_params.cur_seg[CURSEG_HOT_DATA] * f2fs_params.blks_per_seg) * |
| blk_size_bytes; |
| |
| ret = WriteToDisk(dent_blk, data_blk_offset, F2FS_BLKSIZE); |
| if (ret < 0) { |
| printf("\n\tError: While writing the dentry_blk to disk!!!\n"); |
| return ret; |
| } |
| |
| free(dent_blk); |
| return ZX_OK; |
| } |
| |
| zx_status_t F2fsMkfs::F2fsCreateRootDir() { |
| int8_t err = 0; |
| |
| err = F2fsWriteRootInode(); |
| if (err < 0) { |
| printf("\n\tError: Failed to write root inode!!!\n"); |
| goto exit; |
| } |
| |
| err = F2fsUpdateNatRoot(); |
| if (err < 0) { |
| printf("\n\tError: Failed to update NAT for root!!!\n"); |
| goto exit; |
| } |
| |
| err = F2fsAddDefaultDentryRoot(); |
| if (err < 0) { |
| printf("\n\tError: Failed to add default dentries for root!!!\n"); |
| goto exit; |
| } |
| exit: |
| if (err) |
| printf("\n\tError: Could not create the root directory!!!\n"); |
| |
| return err; |
| } |
| |
| #if 0 // porting needed |
| // int F2fsMkfs::F2fsTrimDevice() |
| // { |
| // unsigned long long range[2]; |
| // struct stat stat_buf; |
| |
| // range[0] = 0; |
| // range[1] = f2fs_params.total_sectors * DEFAULT_SECTOR_SIZE; |
| |
| // if (fstat(f2fs_params.fd, &stat_buf) < 0 ) { |
| // printf("\n\tError: Failed to get the device stat!!!\n"); |
| // return -1; |
| // } |
| |
| // if (S_ISREG(stat_buf.st_mode)) |
| // return 0; |
| // else if (S_ISBLK(stat_buf.st_mode)) { |
| // // if (ioctl(f2fs_params.fd, BLKDISCARD, &range) < 0) |
| // printf("Info: This device doesn't support TRIM\n"); |
| // } else |
| // return -1; |
| // return 0; |
| // } |
| #endif |
| |
| int8_t F2fsMkfs::F2fsFormatDevice() { |
| int8_t err = 0; |
| |
| err = static_cast<int8_t>(F2fsPrepareSuperBlock()); |
| if (err < 0) |
| goto exit; |
| |
| #if 0 // porting needed |
| // TRIM is not supported |
| // err = f2fs_trim_device(); |
| // if (err < 0) { |
| // printf("\n\tError: Failed to trim whole device!!!\n"); |
| // goto exit; |
| // } |
| #endif |
| err = F2fsInitSitArea(); |
| if (err < 0) { |
| printf("\n\tError: Failed to Initialise the SIT AREA!!!\n"); |
| goto exit; |
| } |
| |
| err = F2fsInitNatArea(); |
| if (err < 0) { |
| printf("\n\tError: Failed to Initialise the NAT AREA!!!\n"); |
| goto exit; |
| } |
| |
| err = F2fsCreateRootDir(); |
| if (err < 0) { |
| printf("\n\tError: Failed to create the root directory!!!\n"); |
| goto exit; |
| } |
| |
| err = F2fsWriteCheckPointPack(); |
| if (err < 0) { |
| printf("\n\tError: Failed to write the check point pack!!!\n"); |
| goto exit; |
| } |
| |
| err = F2fsWriteSuperBlock(); |
| if (err < 0) { |
| printf("\n\tError: Failed to write the Super Block!!!\n"); |
| goto exit; |
| } |
| exit: |
| if (err) |
| printf("\n\tError: Could not format the device!!!\n"); |
| |
| /* |
| * We should call fsync() to flush out all the dirty pages |
| * in the block device page cache. |
| */ |
| bc_->Sync(); |
| |
| return err; |
| } |
| |
| } // namespace f2fs |