/* chage byte offset to disk sector */
block_sector_t byte_to_sector(const struct inode_disk *inode_disk, off_t pos)
{
block_sector_t result_sec;
if(pos < inode_disk->length)
{
struct inode_indirect_block *ind_block;
struct inode_indirect_block *second_ind_block;
struct sector_location sec_loc;
/* get index1,index2 and directness */
locate_byte(pos,&sec_loc);
switch(sec_loc.directness)
{
/* direct */
case NORMAL_DIRECT:
result_sec = inode_disk->direct_map_table[sec_loc.index1];
break;
/* indirect */
case INDIRECT:
ind_block = (struct inode_indirect_block *)malloc(SECTOR_SIZE);
/* read index1 block from disk */
if(ind_block != NULL)
{
/* read index block1 */
bc_read(inode_disk->indirect_block_sec, (void *)ind_block, 0, SECTOR_SIZE, 0);
/* get the disk sector_number, which located index1 */
result_sec = ind_block->map_table[sec_loc.index1];
free(ind_block);
}
else
result_sec = 0;
break;
case DOUBLE_INDIRECT:
ind_block = (struct inode_indirect_block *)malloc(SECTOR_SIZE);
second_ind_block = (struct inode_indirect_block *)malloc(SECTOR_SIZE);
/* read index block1 and index block2 from disk. and get disk block number */
if(ind_block != NULL && second_ind_block != NULL)
{
/* read index block1 */
bc_read(inode_disk->double_indirect_block_sec, (void *)ind_block, 0, SECTOR_SIZE, 0);
/* read_index block2 */
bc_read(ind_block->map_table[sec_loc.index1] ,(void *)second_ind_block, 0, SECTOR_SIZE, 0);
result_sec = second_ind_block->map_table[sec_loc.index2];
free(ind_block);
free(second_ind_block);
}
else
result_sec = 0;
break;
case OUT_LIMIT:
printf("OUT LIMIT!\n");
result_sec = 0;
break;
}
}
else
result_sec = 0;
return result_sec;
}
int main(int argc, char *argv[])
{
list_entry_t *pos;
int byteStart, byteEnd, globalEnd;
struct ProcStruct *next;
schedInit(); //init schedule
printf("SchedInit finished!\n");
cpu_init(); //init cpu
printf("Cpu init finished!\n");
initProcList(); //runnbale process
printf("Init process list finished!\n");
procInit(); //init process table
printf("The first proc init finished!\n");
initWaitQueue(); //init wait queue
printf("Init wait queue finished!\n");
bc_read(&byteStart, &byteEnd, &globalEnd); //读取字节码
/*
for (int i = 0; i < 7; i++) {
printf("%d %d %d\n", byte_code[i].code, byte_code[i].arg1, byte_code[i].arg2);
}
*/
createProcess(byteStart, byteEnd, globalEnd); //根据字节码的初始下标和终止下标创建第一个进程
// createProcess(0, 9, 3); //根据字节码的初始下标和终止下标创建第一个进程
printCurrent();
addRunEqueue(); //将创建的进程加入到就绪队列
printf("The proc addRunEqueu finished!\n");
while (cpu_state != 0 && rq->proc_num)
{
printf("schedul start...\n");
cpuSchedProc();
}
while (rq->proc_num == 0 && wq->wait_num != 0)
{
next = waitQueuePickNext(wq);
delWaitQueue(wq, next);
schedClassEnqueue(next);
schedule();
}
return 0;
}
/* update new disk block number to inode_disk */
static bool register_sector(struct inode_disk *inode_disk, block_sector_t new_sector, struct sector_location sec_loc)
{
switch(sec_loc.directness)
{
case NORMAL_DIRECT:
/* update new disk block */
inode_disk->direct_map_table[sec_loc.index1] = new_sector;
break;
case INDIRECT:
/* if use indirect first, allocate disk for indirect index block */
if(sec_loc.index1 == 0)
{
block_sector_t sector_idx;
if(free_map_allocate(1, §or_idx))
inode_disk->indirect_block_sec = sector_idx;
}
/* allocate new_block and write new_sector to new_block */
block_sector_t *new_block = (block_sector_t *)malloc(SECTOR_SIZE);
if(new_block == NULL)
return false;
new_block[sec_loc.index1] = new_sector;
/* write new_block to index block */
bc_write(inode_disk->indirect_block_sec, (void *)new_block,map_table_offset(sec_loc.index1) ,4 ,map_table_offset(sec_loc.index1));
free(new_block);
break;
case DOUBLE_INDIRECT:
/* if index1 and index2 is 0, allocate disk for index block 1 */
if(sec_loc.index1 == 0 && sec_loc.index2 ==0)
{
block_sector_t sector_idx;
if(free_map_allocate(1, §or_idx))
inode_disk->double_indirect_block_sec = sector_idx;
}
/* if index2 is 0, allocate disk for index block 2 and update index block 1 */
if(sec_loc.index2 == 0 )
{
/* allocate disk for index block 2 */
block_sector_t sector_idx;
if(free_map_allocate(1, §or_idx) == false)
return false;
/* update index block 1*/
block_sector_t *new_block = (block_sector_t *)malloc(SECTOR_SIZE);
if(new_block == NULL)
return false;
new_block[sec_loc.index1] = sector_idx;
bc_write(inode_disk->double_indirect_block_sec, (void *)new_block, sec_loc.index1 * 4, 4, sec_loc.index1 * 4);
free(new_block);
}
/* update index block 2 */
/* Value for read index_block 1 */
block_sector_t *index_block1 = (block_sector_t *)malloc(SECTOR_SIZE);
if(index_block1 == NULL)
return false;
/* Value for update index_block 2 */
block_sector_t *new_block2 = (block_sector_t *)malloc(SECTOR_SIZE);
if(new_block2 == NULL)
return false;
/* read index block 1 */
bc_read(inode_disk->double_indirect_block_sec, (void *)index_block1, 0, SECTOR_SIZE, 0);
block_sector_t block_sector = index_block1[sec_loc.index1];
/* update index block 2*/
new_block2[sec_loc.index2] = new_sector;
bc_write(block_sector, (void *)new_block2, sec_loc.index2 * 4, 4, sec_loc.index2 * 4);
free(new_block2);
free(index_block1);
break;
default:
return false;
}
return true;
}
void free_inode_sectors(struct inode_disk *inode_disk)
{
/* double indirect block release */
if(inode_disk->double_indirect_block_sec > 0)
{
/* read index block 1*/
int i = 0;
struct inode_indirect_block *index_block1;
index_block1 = (struct inode_indirect_block *)malloc(SECTOR_SIZE);
if(index_block1 == NULL)
return;
bc_read(inode_disk->double_indirect_block_sec, (void *)index_block1, 0, SECTOR_SIZE, 0);
/* approach index block 2(index i) by index block 1 */
while(index_block1->map_table[i] > 0)
{
int j = 0;
struct inode_indirect_block *index_block2;
/* read index block 2 */
index_block2 = (struct inode_indirect_block *)malloc(SECTOR_SIZE);
if(index_block2 == NULL)
return;
bc_read(index_block1->map_table[i], (void *)index_block2, 0, SECTOR_SIZE, 0);
/* free disk block which stored in index block 2*/
while(index_block2->map_table[j] > 0)
{
free_map_release(index_block2->map_table[j], 1);
j++;
}
/* free index block 2*/
free_map_release(index_block1->map_table[i], 1);
i++;
}
/* free index block 1 */
free_map_release(inode_disk->double_indirect_block_sec, 1);
}
/* indirect block release */
if(inode_disk->indirect_block_sec > 0 )
{
int i = 0;
struct inode_indirect_block *index_block1;
index_block1 = (struct inode_indirect_block *)malloc(SECTOR_SIZE);
if(index_block1 == NULL)
return;
bc_read(inode_disk->indirect_block_sec, (void *)index_block1, 0, SECTOR_SIZE, 0);
/* free disk block which stored in index block 1 */
while(index_block1->map_table[i] > 0)
{
free_map_release(index_block1->map_table[i], 1);
i++;
}
/* free index block 1 */
free_map_release(inode_disk->indirect_block_sec, 1);
}
int i = 0;
/* free direct block release */
while(inode_disk->direct_map_table[i] > 0 )
{
free_map_release(inode_disk->direct_map_table[i], 1);
i++;
}
}
/* get disk from inode */
bool get_disk_inode(const struct inode *inode, struct inode_disk *inode_disk)
{
bc_read(inode->sector,(void *)inode_disk, 0, SECTOR_SIZE, 0);
return true;
}
