void init_inode_store (dev_s *dev) { FN; init_tree( &Inode_tree, &Inode_species, dev); init_super_block(); }
int fs_format() { if(mb.magic == FS_MAGIC) { printf("Refusing to format a mounted disk\n"); return -1; } disk_read(0, (char *)&mb); if(mb.magic == FS_MAGIC){ printf("Refusing to format a formatted disk!\n"); mb.magic = 0; return -1; } //Format disk init_super_block(); init_empty_dir(); //Flush disk_write(0, (char*)&mb); disk_write(1, (char*)dir); mb.magic = 0; // mark disk as unmounted return 0; }
void init_string (tree_s *tree, log_s *log) { bind_tree_log(log, TREE_SLOT); init_tree(tree, &String_species, log->lg_sys, log, TREE_SLOT); add_slot_log(log, STRING_SLOT, String_redo); init_super_block(tree); }
static void mkfs(){ MESSAGE message; HD_PART_INFO part_info; message.type=INFO_FS_IOCTL; message.subtype=DIOCTL_GET_PART_INFO; message.device=ROOT_DEVICE;//-------------需要指定到具体分区-------------------- message.arg_pointer=(void*)&part_info; message.source_pid=TASK_FS; assert(dd_map[DRIVER(message.device)].driver_pid!=PID_INVALID,"driver not exist!"); send_receive(BOTH,dd_map[DRIVER(message.device)].driver_pid,&message); #ifdef DEBUG_FS printl("device=%d base=%d size=%d (in sector)\n",DEVICE(message.device),part_info.base,part_info.size); #endif SUPER_BLOCK sb; //super block int super_block_first_index=get_super_block_first_index(); init_super_block(&sb,super_block_first_index,part_info.size); #ifdef DEBUG_FS printl("init_super_block ok(start_sector=%d)\n",super_block_first_index); #endif //imap /* int imap_first_index=super_block_first_index+SUPER_SECTORS_LENGTH; */ int imap_first_index=get_imap_first_index(sb); int imap_sectors_length=get_imap_length(sb)/* sb.imap_sectors_length */; init_imap(imap_first_index,imap_sectors_length); #ifdef DEBUG_FS printl("init_imap ok(start_sector=%d)\n",imap_first_index); #endif //smap /* int smap_first_index=imap_first_index+imap_sectors_length; */ int smap_first_index=get_smap_first_index(sb); int smap_sectors_length=get_smap_length(sb)/* sb.smap_sectors_length */; init_smap(smap_first_index,smap_sectors_length); #ifdef DEBUG_FS printl("init_smap ok(start_sector=%d)\n",smap_first_index); #endif //inode /* int inode_first_index=smap_first_index+smap_sectors_length; */ int inode_first_index=get_inode_first_index(sb); /* int inode_sectors_length=get_inode_length(sb)/\* sb.inodes_sectors_length *\/; */ int root_dir_start_index=get_data_block_first_index(sb)/* sb.data_first_sector_index */; init_inode(inode_first_index,root_dir_start_index); #ifdef DEBUG_FS printl("init_inode ok(start_sector=%d)\n",inode_first_index); #endif //data /* int data_block_first_index=inode_first_index+inode_sectors_length; */ int data_block_first_index=get_data_block_first_index(sb); init_data_block(data_block_first_index); #ifdef DEBUG_FS printl("init_data_block ok(start_sector=%d)\n",data_block_first_index); #endif }
void set_defaults(void) { char param_value[LINE_MAX + 1]; get_param("INSTR_SLICE", param_value); instr_slice = atoi(param_value); int heads, tracks, sectors; char command[1000]; get_param("NUM_HEADS", param_value); heads = atoi(param_value); get_param("NUM_TRACKS", param_value); tracks = atoi(param_value); get_param("NUM_SECTORS", param_value); sectors = atoi(param_value); FILE* check = fopen("Sim_disk", "r"); if(check != NULL) { disk_file_pointer = fopen("Sim_disk", "rb+"); read_super_block(); init_cache(); fclose(check); } else { total_blocks_virtual_mem = (heads * tracks * sectors) / 8; blocks_in_track = total_blocks_virtual_mem / tracks; prev_track = 0; disk_block_data = (int *) malloc(total_blocks_virtual_mem * sizeof(int)); int i = 0; for (i = 0; i < total_blocks_virtual_mem; i++) disk_block_data[i] = -1; sprintf(command, "(dd if=/dev/zero of=Sim_disk bs=%dx%dx%db count=1) 2> /dev/zero", heads, tracks, sectors); system(command); disk_file_pointer = fopen("Sim_disk", "rb+"); init_super_block(); init_cache(); } }
static void format_disk(char *disk, struct lmfs_address *addr, int files) { u32 ib_size = 0; u32 db_size = 0; u32 inode_size = 0; u32 sb_size = 0; u32 block_cnt = (MAX_SIZE / BLOCK_SIZE); u32 data_start_block; u32 free_block; sb_size = BLOCK_SIZE; ib_size = baligin((sizeof(u32) * files), BLOCK_SIZE); inode_size = baligin(512 *files, BLOCK_SIZE); db_size = block_cnt - ((ib_size + inode_size + sb_size) / BLOCK_SIZE); db_size = baligin(sizeof(u32) *files, BLOCK_SIZE); addr->p_sb = (struct lmfs_super_block *)disk; addr->p_ib = (u32 *)(disk + sb_size); addr->p_db = (u32 *)(disk + sb_size + ib_size); addr->p_inode = disk + sb_size + ib_size + db_size; addr->p_data = disk + sb_size + ib_size + db_size + inode_size; addr->sb_size = sb_size; addr->ib_size = ib_size; addr->db_size = db_size; addr->inode_size = inode_size; data_start_block = (addr->p_data - disk) / BLOCK_SIZE; free_block = block_cnt - data_start_block; printf("p_sb:0x%x p_ib:0x%x p_db:0x%x p_inode:0x%x p_data:0x%x\n", addr->p_sb, addr->p_ib, addr->p_db, addr->p_inode, addr->p_data); printf("block_cnt:%d, free_block:%d data_start_block:%d\n", block_cnt, free_block, data_start_block); (void)init_super_block(addr, data_start_block, free_block, block_cnt); }
void init_string (tree_s *tree, log_s *log) { init_tree(tree, &String_species, log->lg_sys, log); init_super_block(tree); }
int32_t ofs_create_container_nolock(const char *ct_name, uint64_t total_sectors, container_handle_t **ct) { container_handle_t *tmp_ct = NULL; int32_t ret = 0; avl_index_t where = 0; if ((ct == NULL) || (total_sectors == 0) || (ct_name == NULL)) { LOG_ERROR("Invalid parameter. ct(%p) total_sectors(%lld) ct_name(%p)\n", ct, total_sectors, ct_name); return -INDEX_ERR_PARAMETER; } if (strlen(ct_name) >= OFS_NAME_SIZE) { LOG_ERROR("file name size must < %d bytes.\n", OFS_NAME_SIZE); return -INDEX_ERR_PARAMETER; } LOG_INFO("Create the ct. ct_name(%s) total_sectors(%lld)\n", ct_name, total_sectors); /* already opened */ tmp_ct = avl_find(g_container_list, (avl_find_fn_t)compare_container2, ct_name, &where); if (tmp_ct) { *ct = tmp_ct; LOG_WARN("The ct is opened already. ct_name(%s) start_lba(%lld)\n", ct_name); return -INDEX_ERR_IS_OPENED; } /* allocate resource */ ret = init_container_resource(&tmp_ct, ct_name); if (ret < 0) { LOG_ERROR("Init ct resource failed. ct_name(%s) ret(%d)", ct_name, ret); return ret; } /* init super block */ ret = init_super_block(&tmp_ct->sb, total_sectors, BYTES_PER_BLOCK_SHIFT); if (ret < 0) { LOG_ERROR("init super block failed. name(%s)\n", ct_name); close_container(tmp_ct); return ret; } ret = os_disk_create(&tmp_ct->disk_hnd, ct_name); if (ret < 0) { LOG_ERROR("init disk failed. ret(%d)\n", ret); close_container(tmp_ct); return ret; } ret = ofs_init_super_block(tmp_ct); if (ret < 0) { LOG_ERROR("Update super block failed. ct_name(%s) vbn(%lld) ret(%d)\n", ct_name, SUPER_BLOCK_VBN, ret); close_container(tmp_ct); return ret; } ret = create_system_objects(tmp_ct); if (ret < 0) { LOG_ERROR("create system objects failed. ct_name(%s) ret(%d)\n", ct_name, ret); close_container(tmp_ct); return ret; } ret = ofs_update_super_block(tmp_ct); if (ret < 0) { LOG_ERROR("Update super block failed. hnd(%p) ret(%d)\n", tmp_ct, ret); close_container(tmp_ct); return ret; } *ct = tmp_ct; LOG_INFO("Create the ct success. ct_name(%s) total_sectors(%lld) ct(%p)\n", ct_name, total_sectors, tmp_ct); return 0; }