void mksfs(int fresh){
int i;
if (fresh){
init_fresh_disk(disk_name, BLOCK_SIZE, NUM_BLOCKS);
free_blocks = list_create(NULL);
for (i=2; i<NUM_BLOCKS-1; i++){
list_append_int(free_blocks, i);
}
for (i=0; i<NUM_BLOCKS; i++){
fat[i][block_index] = unused;
fat[i][next] = eof;
}
for (i=0; i<MAX_NUM_FILES; i++){
files[i].created = false;
files[i].fatIndex = eof;
}
}
else{
init_disk(disk_name, BLOCK_SIZE, NUM_BLOCKS);
read_blocks(0,1, &files);
read_blocks(1,1, &fat);
read_blocks(NUM_BLOCKS-1, 1, &free_blocks);
}
for(i=0; i<MAX_NUM_FILES; i++){
fdt[i][open] = false;
fdt[i][read_ptr] = false;
fdt[i][write_ptr] = files[i].size;
}
}
int main(int argc, char *argv[])
{
if (argc > 1) {
strncpy(config_file, argv[1], sizeof(config_file) - 1);
config_file[sizeof(config_file) - 1] = 0;
if (!strncmp(config_file, "(nd)", 4))
preset_menu = "dhcp";
} else if (start_info.mod_len)
preset_menu = (void*) start_info.mod_start;
else
preset_menu = "dhcp --with-configfile";
mbi.drives_addr = BOOTSEC_LOCATION + (60 * 1024);
mbi.drives_length = 0;
mbi.boot_loader_name = (unsigned long) "GNU GRUB " VERSION;
mbi.mem_lower = (start_info.nr_pages * PAGE_SIZE) / 1024;
mbi.mem_upper = 0;
saved_drive = boot_drive;
saved_partition = install_partition;
init_disk();
/* Try to make sure the client part got launched */
sleep(1);
cmain();
printk("cmain returned!\n");
}
int
main(int argc, char *argv[])
{
int ch;
cpu_t *cpu = init_cpu();
char *sys_file;
while ((ch = getopt(argc, argv, "df:")) != EOF) {
switch (ch) {
case 'd':
cpu->debug = true;
break;
case 'f':
sys_file = strdup(optarg);
break;
}
}
argc -= optind;
argv += optind;
init_disk(cpu->port0, "/tmp/disk0");
load_cpu(cpu, sys_file);
while (true)
run_cpu(cpu);
free_cpu(cpu);
return 0;
}
int mksfs(int fresh) {
int diskinit;
//Create a new filesystem if the fresh variable is set
if(fresh==1){
diskinit = init_fresh_disk(FILESYSTEMNAME, BLOCKSIZE, NUMBEROFBLOCKS);
if(diskinit != 0){
//perror("Error creating disk");
exit(-1);
}
else {
//To keep the root directory in memory
initDirectory();
//Initialize SuperBlock
mySuperBlock.magic = MAGIC;
mySuperBlock.blockSize = BLOCKSIZE;
mySuperBlock.fileSystemSize = NUMBEROFBLOCKS;
mySuperBlock.iNodeTableLength = NUMBEROFINODES;
mySuperBlock.rootINode = 0;
//Use a block sized buffer
unsigned char buffer[512];
memset(buffer,255,512);
memcpy(buffer,&mySuperBlock,512);
write_blocks(0,1,buffer);
initializeFreeBitMap();
initializeFDTable();
//Now for the Inodes: initialize the first one: (for root dir)
int numRootINode = createINode(RWE, 1, ROOT_UID, ROOT_GID, 1);
readDirectory();
return 0;
}
}
//if the free variable is not set, load
else if (fresh==0) {
diskinit = init_disk(FILESYSTEMNAME, BLOCKSIZE, NUMBEROFBLOCKS);
if(diskinit != 0){
//perror("Error reading disc");
exit(-1);
}
else {
return 0;
}
}
return -1;
}
//=======================================================================================
//==============================PRIMARY API FUNCTIONS====================================
//=======================================================================================
void mksfs(int fresh){
buffer = (void*) malloc(BLOCK_SIZE);
memset(buffer,0,BLOCK_SIZE);
if (fresh){ //FORMAT VIRTUAL DISK, CREATE NEW FROM SCRATCH
init_fresh_disk(FILESYSTEM, BLOCK_SIZE, FILESYSTEM_SIZE);
//=========Storing sb in-memory===========
sb = (superblock){0, BLOCK_SIZE, FILESYSTEM_SIZE, MAX_FD, 0};
memcpy(buffer, &sb, sizeof(superblock));
//========Storing sb on-disk==============
write_blocks(0, 1, buffer);
//========Initializing Bitmap block=======
unsigned int bit_row = 4294967295; //Row consisting of 32 '1' bits
for (int i = 0; i<256; i++){
bitmap[i] = bit_row; //Filling table with 1's (1 means block is free)
}
/*We use the first 3 blocks to store the Root Directory mapping table*/
bitmap[0] = bitmap[0] << 3;
write_blocks(1, 1, bitmap);
//========Storing inode table on-disk=====
//inode inode_table[MAX_FD+1];
for (int i = 0; i <= MAX_FD; i++){
inode_table[i] = (inode){0, 1, 1, 0, {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}, -1};
if (i == 0) { //First inode is root dir inode.
//It spans 3 blocks of data -> first three blocks in the datablock section
inode_table[i] = (inode){0,1,1,3,{FIRST_DB,FIRST_DB+1,FIRST_DB+2,-1,-1,-1,-1,-1,-1,-1,-1,-1},-1};
}
memcpy(buffer, &(inode_table[i]), sizeof(inode));
write_blocks(i+2, 1, buffer);
}
//====Initializing rootdir in-memory======
for (int i = 0; i < MAX_FD; i++){
root[i] = (dir){"", -1};
}
//====Initializing rootdir on-disk========
free(buffer);
buffer = (void*) malloc(BLOCK_SIZE*3);
memset(buffer,0,BLOCK_SIZE*3);
memcpy(buffer, &root, 3*BLOCK_SIZE);
write_blocks(MAX_FD+3, 3, buffer);
//====Initializing fd table in-memory=====
for (int i = 0; i < MAX_FD; i++)
fd_table[i] = (fd){1,-1,-1,-1}; //mark all entries in fd_table as empty (flag = 1 means empty)
} else {
init_disk(FILESYSTEM, BLOCK_SIZE, FILESYSTEM_SIZE);
}
free(buffer);
}
int mksfs(int fresh)
{
super_block spr_block;
char buff[BLKSIZ];
int i;
// Initialize fd_table
for(i = 0; i < MAXOPENFILES; i++)
fd_table[i].status = FREE;
if(fresh)
{
// Initialize and write super block to disk
init_fresh_disk(DISKIMG, BLKSIZ, BLOCKNUM);
spr_block.magic_number = MAGICNUM;
spr_block.block_size = BLKSIZ;
spr_block.fs_size = BLOCKNUM;
spr_block.inode_tbl_length = INODETBLSIZ;
spr_block.root_inode = ROOTINODENUM;
write_blocks(SUPERBLOCKADD, 1, (void*) &spr_block);
// Setup datablock bitmap
memset(buff, FREE, BLKSIZ);
write_blocks(DBBITMAPADD, 1, buff);
// Setup INODE Bitmap and allocate first i-node entry to root directory
buff[ROOTINODENUM] = USED;
write_blocks(INBITMAPADD, 1, buff);
// Allocate fd to root directory
fd_table[ROOTFD].status = USED;
fd_table[ROOTFD].inode_num = ROOTINODENUM;
fd_table[ROOTFD].rw_pointer = 0;
fd_table[ROOTFD].inode = (inode_struct*) calloc(1, sizeof(inode_struct));
fd_table[ROOTFD].inode->size = 0;
write_inode_by_index(fd_table[ROOTFD].inode_num, fd_table[ROOTFD].inode);
} else
{
init_disk(DISKIMG, BLKSIZ, BLOCKNUM);
fd_table[ROOTFD].status = USED;
fd_table[ROOTFD].inode_num = ROOTINODENUM;
fd_table[ROOTFD].inode = get_inode_by_index(ROOTINODENUM);
fd_table[ROOTFD].rw_pointer = fd_table[ROOTFD].inode->size;
}
return 0;
}
void mksfs(int fresh) {
if (fresh == 1){
//Makes a new disk if fresh flag is true
printf("Initializing disk\n");
init_fresh_disk(DISK,BLOCK_SIZE,MAX_BLOCKS);
fillWithZeroes();
//calloc for fdt
fileDescriptorTable = (FileDescriptorTable*)calloc(1,sizeof(FileDescriptorTable));
//Write superblock
printf("Writing superblock\n");
//setupSuperblock(superBlock);
printf("Setting up superblock\n");
write_blocks(0,1,&superBlock);
//Write root directory
bzero(&rootDirectory,sizeof(Directory));
printf("Writing root directory\n");
write_blocks(1,1, &rootDirectory);
//Write free blocks
printf("Writing free blocks\n");
freeBlocks.numberFree = MAX_BLOCKS;
freeBlocks.freeBlocks[0] = 1; //superblock
freeBlocks.numberFree--;
freeBlocks.freeBlocks[1] = 1; //root directory
freeBlocks.numberFree--;
freeBlocks.freeBlocks[MAX_BLOCKS-1] = 1; //free_blocks;
freeBlocks.numberFree--;
//Write free blocks to disk
printf("writing free blocks to disk \n");
write_blocks(MAX_BLOCKS - 1, 1, &freeBlocks);
}else{
printf("Loading disk\n");
//Pull disk data into memory
init_disk(DISK, BLOCK_SIZE, MAX_BLOCKS);
}
//Initializes variable for sfs_getnextfilename;
sfsGetNextIndex = 0;
//Initializes variable for fileDescriptor table
(*fileDescriptorTable).firstOpenIndex = 0;
(*fileDescriptorTable).size = 0;
//Initializes variable for rootDirectory
rootDirectory.firstOpenIndex = 2;
rootDirectory.size = 3;
return;
}
/**
* creates the file system
*/
void mksfs(int fresh) {
// Allocate the local file system
allocate_necessary_memory();
//Implement mksfs here
if (fresh) {
// We need to construct the file system from scratch
// Delete the disk file, if it exists
remove(FILE_SYSTEM_NAME);
// Initialize a new fresh disk
init_fresh_disk(FILE_SYSTEM_NAME, DISK_BLOCK_SIZE, DISK_BLOCK_COUNT);
// Write superblock to disk
SuperBlock sb = {};
sb.magic = SB_MAGIC;
sb.block_size = 512;
sb.file_system_size = DISK_BLOCK_COUNT;
sb.i_node_table_length = I_NODE_COUNT;
sb.root_directory_i_node = 0;
write_blocks(SUPER_BLOCK_INDEX, 1, &sb);
// Write the rest of the stuff to disk
save_local_file_system_to_disk(freeBitMap, iNodeTable, directoryCache);
} else {
// File system already exists on disk, so we need to load it from the disk.
// Initialize an existing disk
init_disk(FILE_SYSTEM_NAME, DISK_BLOCK_SIZE, DISK_BLOCK_COUNT);
// Copy iNodes into local memory
load_i_node_cache_from_disk(iNodeTable);
// Copy directory cache into memory
load_directory_cache_from_disk(directoryCache);
// Copy the free bit map into memory
load_free_bitmap_from_disk(freeBitMap);
}
return;
}
/************************************************
* get_block(blknum,buf)
* - retrieves one block from the simulated disk
* if disk file is not yet open, an attempt is
* made to open it.
*
* - blknum is the number of the desired block
* (zero-based count)
* - buf should point to a block-sized buffer
*
* - Returns 0 if successful, -1 otherwise
*************************************************/
int
get_block(int blknum,
char *buf)
{
if (blknum >= NUMBLKS || blknum < 0) {
fprintf(stderr,"get_block: invalid block number: %d\n",blknum);
return(-1);
}
if (diskfd < 0) {
/* disk data file is not yet open - attempt to open it */
if (init_disk() != 0) return(-1);
}
/* locate specified block */
if (lseek(diskfd,blknum*BLKSIZE,SEEK_SET) < 0) {
perror("get_block");
return(-1);
}
/* get the data */
if (read(diskfd,buf,BLKSIZE) < 0) {
perror("get_block");
return(-1);
}
return(0);
}
//Creates the file system
int mksfs(int fresh){
char buf[BLOCKSIZE];
memset(buf,0, BLOCKSIZE); //sets a block-size buffer and set it to zero
if(fresh){
init_fresh_disk(DISK_FILE, BLOCKSIZE, TOTAL_NUM_BLOCKS);
//initialize super block
super_block superblock;
superblock.magic=0xAABB0005;
superblock.block_size=BLOCKSIZE;
superblock.file_system_size=TOTAL_NUM_BLOCKS;
superblock.inode_table_length=NUMBER_INODES;
superblock.root_dir_inode_number=0; //set root directory at the first inode
//copy super block to buffer
memcpy((void *)buf,(const void *) &superblock, sizeof(super_block));
//write the superblock to the first block in the disk
write_blocks(0,1, buf);
//initialize inode table
memset(inodes, 0, sizeof(inodes));
//Set first inode to root directory inode
INODE root_dir_inode={
.mode=0777,
.link_cnt=1,
.uid=0,
.gid=0,
.size=0,
.pointers={14,15,16,17,18,0,0,0,0,0,0,0,0} //pointer to the first data block starting at 14
};
inodes[0]=root_dir_inode;
//write inode into disk
int inode_number = 0;
int block_of_inode=inode_number/8+1;
char inode_update_buf[BLOCKSIZE];
memset(inode_update_buf,0, BLOCKSIZE);
read_blocks(block_of_inode, 1, inode_update_buf);
memcpy((void *)inode_update_buf+(inode_number%8)*sizeof(INODE),(const void *) &inodes[inode_number], sizeof(INODE));
write_blocks(block_of_inode, 1, inode_update_buf);
//initialize the bitmap
memset(free_bitmap, 0, sizeof(free_bitmap));
free_bitmap[0]=255; //superblock and first part of inodes to occupied.
free_bitmap[1]=255; //inodes table to occupied.
free_bitmap[2]=224; //directory entry table to occupied.
free_bitmap[BLOCKSIZE-1]=1; //last block for the bitmap
write_blocks(TOTAL_NUM_BLOCKS-1,1,free_bitmap);//write the bitmap into disk
//initialize directory table into memory
memset(dir_table, 0, sizeof(dir_table));
//Initialize all file's RW pointers to 0 and open to 0
memset(file_des_t, 0, sizeof(file_des_t));
cur_pos=-1;
return 0;
}
else{
//file system already exists
init_disk(DISK_FILE, BLOCKSIZE, TOTAL_NUM_BLOCKS);
// set free_bitmap to zeros
memset(free_bitmap,0, sizeof(free_bitmap));
//load existing bitmap
read_blocks(TOTAL_NUM_BLOCKS-1,1,free_bitmap);
//load existing superblock
super_block superblock;
read_blocks(0,1,&superblock);
//load existing inode table
char inodes_buffer[BLOCKS_INODES_TABLE*BLOCKSIZE];
memset(inodes_buffer,0,sizeof(inodes_buffer));
read_blocks(1,BLOCKS_INODES_TABLE,inodes_buffer);
int n;
for(n=0;n<NUMBER_INODES;n++){
memcpy((void *)&(inodes[n]),(const void *)(inodes_buffer+n*(BLOCKSIZE/8)), BLOCKSIZE/8);
}
//load existing directory table
INODE root_directory=inodes[superblock.root_dir_inode_number];
int i;
char root_dir_buffer[BLOCKSIZE];
memset(root_dir_buffer,0,BLOCKSIZE);
for(i=0;i<INODE_POINTERS;i++){
if(root_directory.pointers[i]!=0){
read_blocks(root_directory.pointers[i],1, root_dir_buffer);
int j;
for(j=0;j<NUM_ENTRIES_PERBLOCK;j++){
if((j+NUM_ENTRIES_PERBLOCK*i) >= TOTAL_NUM_FILES){
break;
}
memcpy((void *)&(dir_table[j]), (const void *)(root_dir_buffer+j*(sizeof(dir_entry))), sizeof(dir_entry));
}
memset(root_dir_buffer,0,BLOCKSIZE);
}
}
//initialize all rw pointers to 0 and open to 0
memset(file_des_t, 0, sizeof(file_des_t));
cur_pos=-1;
return 0;
}
}
disk_t *fewf_init(const char *device, const int mode)
{
unsigned int num_files=0;
char **filenames= NULL;
disk_t *disk=NULL;
struct info_fewf_struct *data;
#if !defined( HAVE_LIBEWF_V2_API ) && defined( HAVE_GLOB_H )
glob_t globbuf;
#endif
data=(struct info_fewf_struct *)MALLOC(sizeof(struct info_fewf_struct));
memset(data, 0, sizeof(struct info_fewf_struct));
data->file_name = strdup(device);
data->handle=NULL;
data->mode = mode;
#ifdef DEBUG_EWF
#if defined( HAVE_LIBEWF_V2_API )
libewf_notify_set_stream( stderr, NULL );
libewf_notify_set_verbose( 1 );
#else
libewf_set_notify_values( stderr, 1 );
#endif
#endif
#if defined( HAVE_LIBEWF_V2_API )
if( libewf_glob(
data->file_name,
strlen(data->file_name),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
(int *)&num_files,
NULL ) != 1 )
{
log_error("libewf_glob failed\n");
free(data);
return NULL;
}
#elif defined( HAVE_GLOB_H )
{
globbuf.gl_offs = 0;
glob(data->file_name, GLOB_DOOFFS, NULL, &globbuf);
if(globbuf.gl_pathc>0)
{
filenames=(char **)MALLOC(globbuf.gl_pathc * sizeof(*filenames));
for (num_files=0; num_files<globbuf.gl_pathc; num_files++) {
filenames[num_files]=globbuf.gl_pathv[num_files];
}
}
}
if(filenames==NULL)
{
globfree(&globbuf);
free(data);
return NULL;
}
#else
{
filenames=(char **)MALLOC(1*sizeof(*filenames));
filenames[num_files] = data->file_name;
num_files++;
}
#endif
if((mode&TESTDISK_O_RDWR)==TESTDISK_O_RDWR)
{
#if defined( HAVE_LIBEWF_V2_API )
if( libewf_handle_initialize(
&( data->handle ),
NULL ) != 1 )
{
log_error("libewf_handle_initialize failed\n");
libewf_glob_free(
filenames,
num_files,
NULL );
free(data);
return NULL;
}
if( libewf_handle_open(
data->handle,
filenames,
num_files,
LIBEWF_OPEN_READ_WRITE,
NULL ) != 1 )
{
log_error("libewf_handle_open(%s) failed\n", device);
}
#else
data->handle=libewf_open(filenames, num_files, LIBEWF_OPEN_READ_WRITE);
if(data->handle==NULL)
{
log_error("libewf_open(%s) failed\n", device);
}
#endif /* defined( HAVE_LIBEWF_V2_API ) */
}
if(data->handle==NULL)
{
data->mode&=~TESTDISK_O_RDWR;
#if defined( HAVE_LIBEWF_V2_API )
if( libewf_handle_initialize(
&( data->handle ),
NULL ) != 1 )
{
log_error("libewf_handle_initialize failed\n");
libewf_glob_free(
filenames,
num_files,
NULL );
free(data);
return NULL;
}
if( libewf_handle_open(
data->handle,
filenames,
num_files,
LIBEWF_OPEN_READ,
NULL ) != 1 )
{
log_error("libewf_handle_open(%s) failed\n", device);
libewf_handle_free(
&( data->handle ),
NULL );
libewf_glob_free(
filenames,
num_files,
NULL );
free(data);
return NULL;
}
#else
data->handle=libewf_open(filenames, num_files, LIBEWF_OPEN_READ);
if(data->handle==NULL)
{
log_error("libewf_open(%s) failed\n", device);
#if defined( HAVE_GLOB_H )
globfree(&globbuf);
#endif
free(filenames);
free(data);
return NULL;
}
#endif /* defined( HAVE_LIBEWF_V2_API ) */
}
#if defined( HAVE_LIBEWF_V2_API )
if( libewf_handle_set_header_values_date_format(
data->handle,
LIBEWF_DATE_FORMAT_DAYMONTH,
NULL ) != 1 )
{
log_error("%s Unable to set header values date format\n", device);
}
#else
if( libewf_parse_header_values( data->handle, LIBEWF_DATE_FORMAT_DAYMONTH) != 1 )
{
log_error("%s Unable to parse EWF header values\n", device);
}
#endif
disk=(disk_t *)MALLOC(sizeof(*disk));
init_disk(disk);
disk->arch=&arch_none;
disk->device=strdup(device);
disk->data=data;
disk->description=fewf_description;
disk->description_short=fewf_description_short;
disk->pread_fast=fewf_pread_fast;
disk->pread=fewf_pread;
disk->pwrite=(data->mode&TESTDISK_O_RDWR?fewf_pwrite:fewf_nopwrite);
disk->sync=fewf_sync;
disk->access_mode=(data->mode&TESTDISK_O_RDWR);
disk->clean=fewf_clean;
#if defined( HAVE_LIBEWF_V2_API ) || defined( LIBEWF_GET_BYTES_PER_SECTOR_HAVE_TWO_ARGUMENTS )
{
uint32_t bytes_per_sector = 0;
#if defined( HAVE_LIBEWF_V2_API )
if( libewf_handle_get_bytes_per_sector(
data->handle,
&bytes_per_sector,
NULL ) != 1 )
#else
if( libewf_get_bytes_per_sector(data->handle, &bytes_per_sector)<0)
#endif
{
disk->sector_size=DEFAULT_SECTOR_SIZE;
}
else
{
disk->sector_size=bytes_per_sector;
}
}
#else
disk->sector_size=libewf_get_bytes_per_sector(data->handle);
#endif
// printf("libewf_get_bytes_per_sector %u\n",disk->sector_size);
if(disk->sector_size==0)
disk->sector_size=DEFAULT_SECTOR_SIZE;
/* Set geometry */
disk->geom.cylinders=0;
disk->geom.heads_per_cylinder=1;
disk->geom.sectors_per_head=1;
disk->geom.bytes_per_sector=disk->sector_size;
/* Get disk_real_size */
#if defined( HAVE_LIBEWF_V2_API ) || defined( LIBEWF_GET_MEDIA_SIZE_HAVE_TWO_ARGUMENTS )
{
size64_t media_size = 0;
#if defined( HAVE_LIBEWF_V2_API )
if( libewf_handle_get_media_size(
data->handle,
&media_size,
NULL ) != 1 )
#else
if(libewf_get_media_size(data->handle, &media_size)<0)
#endif
{
disk->disk_real_size=0;
}
else
{
disk->disk_real_size=media_size;
}
}
#else
disk->disk_real_size=libewf_get_media_size(data->handle);
#endif
update_disk_car_fields(disk);
#if defined( HAVE_LIBEWF_V2_API )
libewf_glob_free(
filenames,
num_files,
NULL );
#else
#if defined( HAVE_GLOB_H )
globfree(&globbuf);
#endif
free(filenames);
#endif
return disk;
}
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;
}
void sfs_init_storage()
{
CACHE_SWITCH = 0;
init_disk("storage", 1026, 0);
}
void mksfs(int fresh){
int freeSpace;
int FATSize;
int dirSize;
int i;
int j;
char *buffer1;
blockSize = BLOCK_SIZE;
numBlocks = NUM_BLOCKS;
maximummyfiles = MAX_myfileS;
buffer1 = (char *) malloc(1024);
if(fresh != 0){//create a new sfs
init_disk("s2.dsk", blockSize, numBlocks);
init_cache(0);
for(i=0; i<maximummyfiles; i++){
strcpy(directory[i].name, "empty_myfile");
directory[i].size = 0;
directory[i].date = 0;
directory[i].indFAT = -1;
}
for(i=0; i<numBlocks; i++){
for(j=0; j<2; j++) FAT[i][j] = -2;
}
for(i=0; i<numBlocks; i++){
free_list[i] = '0';
}
free_list[0] = '1';
free_list[1] = '1';
free_list[numBlocks - 1] = '1';
//set FDT settings
for(i=0; i<maximummyfiles; i++){
FDT[i].dirIndex = -1;
}
dirSize = sizeof(entry) * maximummyfiles;
FATSize = sizeof(int) * numBlocks * 2;
freeSpace = sizeof(char) * numBlocks;
while(dirSize>0){
if(dirSize>1024){
memcpy(buffer1, directory, 1024);
}
else {
memcpy(buffer1, directory, dirSize);
}
write_blocks(0, 1, buffer1);
dirSize -= 1024;
}
while(FATSize>0){
if(FATSize>1024){
memcpy(buffer1, FAT, 1024);
}
else {
memcpy(buffer1, FAT, FATSize);
}
write_blocks(1, 1, buffer1);
FATSize -= 1024;
}
while(freeSpace>0){
if(freeSpace>1024){
memcpy(buffer1, free_list, 1024);
}
else {
memcpy(buffer1, free_list, freeSpace);
}
write_blocks(1023, 1, buffer1);
freeSpace -= 1024;
}
printf("SFS created successfully\n");
}
else{ // load existing sfs
for(i=0; i<maximummyfiles; i++){
FDT[i].dirIndex = -1;
}
read_blocks(0, 1, buffer1);
memcpy(directory,buffer1, 1024);
read_blocks(1, 1, buffer1);
memcpy(FAT,buffer1, 1024);
read_blocks(1023, 1, buffer1);
memcpy(free_list,buffer1, 1024);
printf("SFS loading successfull\n");
}
read_blocks(0, 1, buffer1);
memcpy(directory,buffer1, 1024);
read_blocks(1, 1, buffer1);
memcpy(FAT,buffer1, 1024);
read_blocks(1023, 1, buffer1);
memcpy(free_list,buffer1, 1024);
}
