/** * Adds the buffer as a segment to the appropriate place in the log, then clears * the buffer. */ int main(int argc, char *argv[]) { int res = 0; //printf("%s\n", "lfs_main"); log_system = malloc(sizeof(struct file_system)); if (!log_system) { perror("main malloc"); } else { ////printf("%s\n", "lfs_main: 1"); log_system->log_file_name = "/tmp/semihugefile.file"; if (!log_system->log_file_name) { perror("Filename not allocated/set"); } else { ////printf("%s\n", "lfs_main: 2"); log_system->buffer = malloc(SEGMENT_SIZE); if (!log_system->buffer) { res = -ENOMEM; } else { memset(log_system->buffer_summary, 0, BLOCKS_PR_SEGMENT); memset(log_system->buffer, 0, SEGMENT_SIZE); log_system->next_segment = 0; log_system->used_segments = 0; res = init_inode_table(log_system); ////printf("%s\n", "lfs_main: 4"); } } } if (res) { //printf("main fail: %d\n", res); //TODO error handling } return fuse_main(argc, argv, &lfs_oper); }
static void init_fs(){ /* u8 fsbuf[SECTOR_SIZE]; */ MESSAGE message; message.type=INFO_FS_DEVICE; message.device=ROOT_DEVICE; assert(dd_map[DRIVER(ROOT_DEVICE)].driver_pid!=PID_INVALID,""); send_receive(BOTH,dd_map[DRIVER(ROOT_DEVICE)].driver_pid,&message); //如果系统已经是要求的系统,就不需要在格式化系统了 get_super_block(ROOT_DEVICE,&super_block); /* if(super_block.magic!=MAGIC_V1) */{ mkfs(); get_super_block(ROOT_DEVICE,&super_block); } init_inode_table(); init_file_descriptor_table(); #ifdef DEBUG_FS //write test /* memset(fsbuf,0x23,SECTOR_SIZE); */ /* WRITE_SECTOR(ROOT_DEVICE,fsbuf,1); */ //read test u8 fsbuf[SECTOR_SIZE]; READ_SECTOR(ROOT_DEVICE,fsbuf,1); printl("read test:\nfsbuf[0]=%x fsbuf[1]=%x fsbuf[2]=%x fsbuf[3]=%x\n",fsbuf[0],fsbuf[1],fsbuf[2],fsbuf[3]); #endif }
static int execute_update_commands(WIMStruct *wim, const struct wimlib_update_command *cmds, size_t num_cmds, int update_flags) { struct wim_inode_table *inode_table; struct wim_sd_set *sd_set; struct list_head unhashed_streams; struct update_command_journal *j; union wimlib_progress_info info; int ret; if (have_command_type(cmds, num_cmds, WIMLIB_UPDATE_OP_ADD)) { /* If we have at least one "add" command, create the inode and * security descriptor tables to index new inodes and new * security descriptors, respectively. */ inode_table = alloca(sizeof(struct wim_inode_table)); sd_set = alloca(sizeof(struct wim_sd_set)); ret = init_inode_table(inode_table, 9001); if (ret) goto out; ret = init_sd_set(sd_set, wim_get_current_security_data(wim)); if (ret) goto out_destroy_inode_table; INIT_LIST_HEAD(&unhashed_streams); } else { inode_table = NULL; sd_set = NULL; } /* Start an in-memory journal to allow rollback if something goes wrong */ j = new_update_command_journal(num_cmds, &wim_get_current_image_metadata(wim)->root_dentry, wim->lookup_table); if (!j) { ret = WIMLIB_ERR_NOMEM; goto out_destroy_sd_set; } info.update.completed_commands = 0; info.update.total_commands = num_cmds; ret = 0; for (size_t i = 0; i < num_cmds; i++) { DEBUG("Executing update command %zu of %zu (op=%"TS")", i + 1, num_cmds, update_op_to_str(cmds[i].op)); info.update.command = &cmds[i]; if (update_flags & WIMLIB_UPDATE_FLAG_SEND_PROGRESS) { ret = call_progress(wim->progfunc, WIMLIB_PROGRESS_MSG_UPDATE_BEGIN_COMMAND, &info, wim->progctx); if (ret) goto rollback; } switch (cmds[i].op) { case WIMLIB_UPDATE_OP_ADD: ret = execute_add_command(j, wim, &cmds[i], inode_table, sd_set, &unhashed_streams); break; case WIMLIB_UPDATE_OP_DELETE: ret = execute_delete_command(j, wim, &cmds[i]); break; case WIMLIB_UPDATE_OP_RENAME: ret = execute_rename_command(j, wim, &cmds[i]); break; } if (unlikely(ret)) goto rollback; info.update.completed_commands++; if (update_flags & WIMLIB_UPDATE_FLAG_SEND_PROGRESS) { ret = call_progress(wim->progfunc, WIMLIB_PROGRESS_MSG_UPDATE_END_COMMAND, &info, wim->progctx); if (ret) goto rollback; } next_command(j); } commit_update(j); if (inode_table) { struct wim_image_metadata *imd; imd = wim_get_current_image_metadata(wim); list_splice_tail(&unhashed_streams, &imd->unhashed_streams); inode_table_prepare_inode_list(inode_table, &imd->inode_list); } goto out_destroy_sd_set; rollback: if (sd_set) rollback_new_security_descriptors(sd_set); rollback_update(j); out_destroy_sd_set: if (sd_set) destroy_sd_set(sd_set); out_destroy_inode_table: if (inode_table) destroy_inode_table(inode_table); out: return ret; }
void mksfs(int fresh){ //Implement mksfs here if (fresh == 1){ //deletes fs if it already exists if(access(DISK_FILE, F_OK) != -1){ unlink(DISK_FILE); } //fs creation printf("Initalizing sfs\n"); init_fresh_disk(DISK_FILE, BLOCK_SIZE, MAX_BLOCKS); //zero_everything(); // writes superblock to the first block printf("Writing superblocks\n"); init_superblock(); write_blocks(0, 1, &sb); // write the inode table to the 2nd block printf("Writing inode table\n"); init_inode_table(); //add_root_dir_inode(); //add_dummy_file_inode(); //write_blocks(1, 1, &inode_table); // creates free list init_free_list(); // write root directory data to the 3rd block printf("Writing root dir\n"); init_root_dir(); //allocate memory for directory inode inode_t *inode = malloc(ADJUST((MAX_FILES+1)*sizeof(inode_t))); read_blocks(INODE_TABLE, INODE_TABLE_SIZE, inode); if(inode == NULL){ return; } //set first inode to point to directory inode[0].size = DIRECTORY_SIZE*BLOCK_SIZE; inode[0].link_cnt = DIRECTORY_SIZE; inode[0].exists = 1; //check to see if we need to use ref_ptr //if(DIRECTORY_SIZE > 12){ //inode[0].ref_ptr = search(); //setAlloc(inode[0].ref_ptr); //unsigned int *buffer = malloc(BLOCK_SIZE); //write_blocks(19 + inode[0].ref_ptr, 1, buffer); //free(buffer); //assign the pointers the location of directory files int i; for(i = 0; i < DIRECTORY_SIZE; i++){ if(i > 11){ unsigned int *buffer = malloc(BLOCK_SIZE); read_blocks(19+ inode[0].ref_ptr, 1, buffer); buffer[i - 12] = 2 + i; write_blocks(19+ inode[0].ref_ptr, 1, buffer); free(buffer); } else{ inode[0].data_ptrs[i] = 2 + i; } } //update inode and free memory write_blocks(INODE_TABLE, INODE_TABLE_SIZE, inode); free(inode); } else if (fresh == 0){ if(init_disk(DISK_FILE, BLOCK_SIZE, MAX_BLOCKS) != 0){ printf("Error initializing disk\n"); return; } } //allocate main memory for filesystem data structures int *superblock = malloc(BLOCK_SIZE*SUPERBLOCK_SIZE); if(superblock == NULL){ printf("Error allocating memory for superblock\n"); return; } read_blocks(0, SUPERBLOCK_SIZE, superblock); //allocate main memory for directory root_dir = malloc(ADJUST(sizeof(dir_entry_t)*MAX_FILES)); if(root_dir == NULL){ printf("Error allocating memory for root directory\n"); return; } read_blocks(2, DIRECTORY_SIZE, root_dir); //allocate memory for inode table inode_table = malloc(ADJUST(sizeof(inode_t)*(MAX_FILES+1))); if(inode_table == NULL){ printf("Error allocating memory for inode table"); return; } read_blocks(INODE_TABLE, INODE_TABLE_SIZE, inode_table); fileCount = 0; fd_table = NULL; return; }
int main (int argc, char **argv) { int rc, c, opt_ind; char *device_name; size_t devblock_size; struct mfs_sb_info sb; /* Default is MinixFS V3 */ sb.magic = MFS_MAGIC_V3; sb.fs_version = 3; /* Default block size is 4Kb */ sb.block_size = MFS_MAX_BLOCKSIZE; sb.dirsize = MFS3_DIRSIZE; sb.n_inodes = 0; sb.longnames = false; sb.ino_per_block = V3_INODES_PER_BLOCK(MFS_MAX_BLOCKSIZE); if (argc == 1) { help_cmd_mkmfs(HELP_SHORT); printf("Incorrect number of arguments, try `mkmfs --help'\n"); exit(0); } for (c = 0, optind = 0, opt_ind = 0; c != -1;) { c = getopt_long(argc, argv, "lh12b:i:", long_options, &opt_ind); switch (c) { case 'h': help_cmd_mkmfs(HELP_LONG); exit(0); case '1': sb.magic = MFS_MAGIC_V1; sb.block_size = MFS_BLOCKSIZE; sb.fs_version = 1; sb.ino_per_block = V1_INODES_PER_BLOCK; sb.dirsize = MFS_DIRSIZE; break; case '2': sb.magic = MFS_MAGIC_V2; sb.block_size = MFS_BLOCKSIZE; sb.fs_version = 2; sb.ino_per_block = V2_INODES_PER_BLOCK; sb.dirsize = MFS_DIRSIZE; break; case 'b': sb.block_size = (uint32_t) strtol(optarg, NULL, 10); break; case 'i': sb.n_inodes = (uint64_t) strtol(optarg, NULL, 10); break; case 'l': sb.longnames = true; sb.dirsize = MFSL_DIRSIZE; break; } } if (sb.block_size < MFS_MIN_BLOCKSIZE || sb.block_size > MFS_MAX_BLOCKSIZE) { printf(NAME ":Error! Invalid block size.\n"); exit(0); } else if (!is_power_of_two(sb.block_size)) { /* Block size must be a power of 2. */ printf(NAME ":Error! Invalid block size.\n"); exit(0); } else if (sb.block_size > MFS_BLOCKSIZE && sb.fs_version != 3) { printf(NAME ":Error! Block size > 1024 is " "supported by V3 filesystem only.\n"); exit(0); } else if (sb.fs_version == 3 && sb.longnames) { printf(NAME ":Error! Long filenames are supported " "by V1/V2 filesystem only.\n"); exit(0); } if (sb.block_size == MFS_MIN_BLOCKSIZE) shift = 1; else if (sb.block_size == MFS_MAX_BLOCKSIZE) shift = 3; else shift = 2; argv += optind; device_name = argv[0]; if (!device_name) { help_cmd_mkmfs(HELP_LONG); exit(0); } rc = loc_service_get_id(device_name, &service_id, 0); if (rc != EOK) { printf(NAME ": Error resolving device `%s'.\n", device_name); return 2; } rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048); if (rc != EOK) { printf(NAME ": Error initializing libblock.\n"); return 2; } rc = block_get_bsize(service_id, &devblock_size); if (rc != EOK) { printf(NAME ": Error determining device block size.\n"); return 2; } rc = block_get_nblocks(service_id, &sb.dev_nblocks); if (rc != EOK) { printf(NAME ": Warning, failed to obtain " "block device size.\n"); } else { printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n", sb.dev_nblocks); } if (devblock_size != 512) { printf(NAME ": Error. Device block size is not 512 bytes.\n"); return 2; } /* Minimum block size is 1 Kb */ sb.dev_nblocks /= 2; printf(NAME ": Creating Minix file system on device\n"); printf(NAME ": Writing superblock\n"); /* Initialize superblock */ if (init_superblock(&sb) != EOK) { printf(NAME ": Error. Superblock initialization failed\n"); return 2; } printf(NAME ": Initializing bitmaps\n"); /* Initialize bitmaps */ if (init_bitmaps(&sb) != EOK) { printf(NAME ": Error. Bitmaps initialization failed\n"); return 2; } printf(NAME ": Initializing the inode table\n"); /* Init inode table */ if (init_inode_table(&sb) != EOK) { printf(NAME ": Error. Inode table initialization failed\n"); return 2; } printf(NAME ": Creating the root directory inode\n"); /* Make the root inode */ if (sb.fs_version == 1) rc = make_root_ino(&sb); else rc = make_root_ino2(&sb); if (rc != EOK) { printf(NAME ": Error. Root inode initialization failed\n"); return 2; } /* Insert directory entries . and .. */ if (insert_dentries(&sb) != EOK) { printf(NAME ": Error. Root directory initialization failed\n"); return 2; } block_fini(service_id); return 0; }