// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
int i;
uint32_t diskbno;
for (i = 0; i < (f->f_size + BLKSIZE - 1) / BLKSIZE; i++) {
if (file_map_block(f, i, &diskbno, 0) < 0)
continue;
if (block_is_dirty(diskbno))
write_block(diskbno);
}
}
// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
// LAB 5: Your code here.
int blkno = ROUNDUP(f->f_size,BLKSIZE) / BLKSIZE;
int i,disk_blk_no;
for(i=0;i<blkno;i++){
if(file_map_block(f,i,(unsigned int *)(&disk_blk_no),0) < 0)
panic("file_flush: file_map_block fail!\n");
if(block_is_dirty(disk_blk_no) != 0)
write_block(disk_blk_no);
}
}
// Make sure this block is unmapped.
void
unmap_block(uint32_t blockno)
{
int r;
if (!block_is_mapped(blockno))
return;
assert(block_is_free(blockno) || !block_is_dirty(blockno));
if ((r = sys_page_unmap(0, diskaddr(blockno))) < 0)
panic("unmap_block: sys_mem_unmap: %e", r);
assert(!block_is_mapped(blockno));
}
// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
// LAB 5: Your code here.
int i, n, r;
uint32_t diskbno;
for (i = 0; i < f->f_size; i += BLKSIZE) {
if ((r = file_map_block(f, i/BLKSIZE, &diskbno, 0)) < 0)
panic("file map block error: %e", r);
if (block_is_dirty(diskbno))
write_block(diskbno);
//if (f->f_indirect && block_is_dirty(f->f_indirect))
//write_block(f->f_indirect);
}
}
// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
int r;
uint32_t diskbno, i;
// LAB 5: Your code here.
for (i = 0; i < NINDIRECT; i++) {
r = file_map_block(f, i, &diskbno, 0);
if (r == -E_NOT_FOUND || r == -E_INVAL)
break;
if (r < 0)
continue;
if (block_is_dirty(diskbno))
write_block(diskbno);
}
}
// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
// LAB 5: Your code here.
// panic("file_flush not implemented");
int error;
int filebno;
uint32_t diskbno;
int filebnum = DIV_ROUNDUP(f->f_size, BLKSIZE);
for(filebno=0; filebno<filebnum; filebno++)
{
error = file_map_block(f, filebno, &diskbno, 0);
if(error< 0) panic("file_map_block fail");
if(block_is_dirty(diskbno)) write_block(diskbno);
}
}
// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
// LAB 5: Your code here.
int r;
off_t i;
uint32_t diskbno;
if (f->f_size == 0)
return;
for (i = 0; i < (f->f_size - 1) / BLKSIZE + 1; i++) {
// Blocks not even allocated cannot be dirty.
if ((r = file_map_block(f, i, &diskbno, 0)) == -E_NOT_FOUND)
continue;
if (r)
panic("file_flush: file_map_block error: %e\n", r);
if (block_is_dirty(diskbno))
write_block(diskbno);
}
}
// Flush the contents of file f out to disk.
// Loop over all the blocks in file.
// Translate the file block number into a disk block number
// and then check whether that disk block is dirty. If so, write it out.
//
// Hint: use file_map_block, block_is_dirty, and write_block.
void
file_flush(struct File *f)
{
// LAB 5: Your code here.
int r, i, how_many;
uint32_t diskbno;
how_many = f->f_size/BLKSIZE;
if (f->f_size % BLKSIZE)
how_many++;
for(i=0; i<how_many; i++){
if ((r = file_map_block(f, i, &diskbno, 0)) < 0)
panic("file_flush - file_map_block failed!");
if (block_is_dirty(diskbno))
write_block(diskbno);
}
return;
}
// Copy the current contents of the block out to disk.
// Then clear the PTE_D bit using sys_page_map.
// Hint: Use ide_write.
// Hint: Use the PTE_USER constant when calling sys_page_map.
int
write_block(uint32_t blockno)
{
char *addr;
int r;
if (!block_is_mapped(blockno))
panic("write unmapped block %08x", blockno);
// Write the disk block and clear PTE_D.
// LAB 5: Your code here.
addr = diskaddr(blockno);
if((r = ide_write(blockno*(BLKSIZE/SECTSIZE), (const void *)addr, (size_t) BLKSIZE/SECTSIZE)) < 0)
return r;
if(block_is_dirty(blockno))
if ((r = sys_page_map(sys_getenvid(), addr, sys_getenvid(),
addr, (PTE_U|PTE_P|PTE_W) & ~PTE_D)) < 0)
return r;
return 0;
}
