// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // code for lab 5- M.G // panic("file_get_block not implemented"); uint32_t *ppdiskbno; uint32_t new_block_no; int return_value; if ((return_value = file_block_walk(f, filebno, &ppdiskbno,true)) < 0) { return return_value; } if (!*ppdiskbno) { if ((new_block_no = alloc_block()) < 0) { return -E_NO_DISK; } *ppdiskbno = new_block_no; } *blk = diskaddr(*ppdiskbno); return 0; }
// Set *blk to point at the filebno'th block in file 'f'. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. int r; uint32_t *pblkno; if ((r = file_block_walk(f, filebno, &pblkno, 1)) < 0){ return r; } // if not exist if (*pblkno == 0){ if ((r = alloc_block()) < 0){ return -E_NO_DISK; } *pblkno = r; // Clear this block memset(diskaddr(r), 0, BLKSIZE); // flush this empty block into disk flush_block(diskaddr(r)); } *blk = diskaddr(*pblkno); return 0; }
// Set *blk to point at the filebno'th block in file 'f'. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. //panic("file_get_block not implemented"); uint32_t *pdiskbno; int result; if((result=file_block_walk(f, filebno, &pdiskbno, 1)) < 0) { return result; } if(*pdiskbno == 0) { if((result=alloc_block()) < 0) { return -E_NO_DISK; } else { *pdiskbno=result; memset(diskaddr(result), 0, BLKSIZE); flush_block(diskaddr (result)); } } *blk=diskaddr(*pdiskbno); return 0; }
// Remove a block from file f. If it's not there, just silently succeed. // Returns 0 on success, < 0 on error. static int file_free_block(struct File *f, uint32_t filebno) { int r; uint32_t *ptr; if ((r = file_block_walk(f, filebno, &ptr, 0)) < 0) return r; if (*ptr) { free_block(*ptr); *ptr = 0; } return 0; }
// Flush the contents and metadata 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. void file_flush(struct File *f) { int i; uint32_t *pdiskbno; for (i = 0; i < (f->f_size + BLKSIZE - 1) / BLKSIZE; i++) { if (file_block_walk(f, i, &pdiskbno, 0) < 0 || pdiskbno == NULL || *pdiskbno == 0) continue; flush_block(diskaddr(*pdiskbno)); } flush_block(f); if (f->f_indirect) flush_block(diskaddr(f->f_indirect)); }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // int file_get_block(struct File *f, uint32_t filebno, char **blk) { if (filebno >= NDIRECT + NINDIRECT) { return -E_INVAL; } uint32_t *ppdiskbno; int r = file_block_walk(f, filebno, &ppdiskbno, false); if (r < 0) return r; if (!*ppdiskbno) return -E_NO_DISK; *blk = (char*)diskaddr(*ppdiskbno); return 0; // LAB 5: Your code here. //panic("file_block_walk not implemented"); }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. int r; uint32_t *ppdiskbno; if ((r = file_block_walk(f, filebno, &ppdiskbno, 1)) < 0) return r; if (!*ppdiskbno) { if ((r = alloc_block()) < 0) return r; *ppdiskbno = r; } *blk = (char *) diskaddr(*ppdiskbno); return 0; }
// Set '*diskbno' to the disk block number for the 'filebno'th block // in file 'f'. // If 'alloc' is set and the block does not exist, allocate it. // // Returns 0 on success, < 0 on error. Errors are: // -E_NOT_FOUND if alloc was 0 but the block did not exist. // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_NO_MEM if we're out of memory. // -E_INVAL if filebno is out of range. int file_map_block(struct File *f, uint32_t filebno, uint32_t *diskbno, bool alloc) { int r; uint32_t *ptr; if ((r = file_block_walk(f, filebno, &ptr, alloc)) < 0) return r; if (*ptr == 0) { if (alloc == 0) return -E_NOT_FOUND; if ((r = alloc_block()) < 0) return r; *ptr = r; } *diskbno = *ptr; return 0; }
// Set *blk to point at the filebno'th block in file 'f'. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. int r; uint32_t *pdiskbno; if (0 != (r = file_block_walk(f, filebno, &pdiskbno, true))) return r; if (0 == *pdiskbno) { r = alloc_block(); if (0 > r) return -E_NO_DISK; *pdiskbno = r; } if (NULL != blk) *blk = (char *)(DISKMAP + BLKSIZE * (*pdiskbno)); return 0; }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. // panic("file_get_block not implemented"); int r; uint32_t *ptr; if ((r = file_block_walk(f, filebno, &ptr, 1)) < 0) return r; if (!*ptr) { *ptr = alloc_block(); } if (!*ptr) { return -E_NO_DISK; } *blk = (char *)diskaddr(*ptr); return 0; }
// Set *blk to point at the filebno'th block in file 'f'. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. if(filebno >= NDIRECT + NINDIRECT) return -E_INVAL; uint32_t* baddr; int status = 0; if((status = file_block_walk(f, filebno, &baddr, 1)) < 0) return status; if(*baddr == 0) { if((status = alloc_block()) < 0) return status; *baddr = status; } char* addr = (char*)diskaddr(*baddr); *blk = addr; return 0; }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. uint32_t *blkno; uint32_t err; if ((err = file_block_walk(f, filebno, &blkno, 1)) < 0) { return err; } if (!*blkno) { // no block allocated if ((err = alloc_block()) < 0) return -E_NO_DISK; *blkno = err; } *blk = (char *) diskaddr(*blkno); return 0; }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. // panic("file_get_block not implemented"); if (!f) panic("file not exist!\n"); if (filebno >= NDIRECT + NINDIRECT) return -E_INVAL; uint32_t *ppdiskbno = NULL; int r; if ((r = file_block_walk(f, filebno, &ppdiskbno, 1)) < 0) return r; if ((*ppdiskbno) == 0) { if ((r = alloc_block()) < 0) return r; *ppdiskbno = r; } *blk = diskaddr(*ppdiskbno); return 0; }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. //panic("file_get_block not implemented"); int r; uint32_t *pdiskbno; uint32_t blockno; if((r =file_block_walk(f,filebno, &pdiskbno, 1)) < 0) return r; if( *pdiskbno == 0){ if((*pdiskbno = alloc_block()) < 0) return -E_NO_DISK; zero_block(*pdiskbno); } *blk = (char *)diskaddr(*pdiskbno); return 0; }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // Allocate the block if it doesn't yet exist. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // // Hint: Use file_block_walk and alloc_block. int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. int new_block; uint32_t * blkno; if(!f || !blk) return -E_INVAL; int i; i = file_block_walk(f, filebno, &blkno, 1); if(i<0) return i; if(*blkno == 0) { new_block = alloc_block(); if(new_block == -E_NO_DISK) return -E_NO_DISK; *blkno = (uint32_t)new_block; } *blk = (char *)diskaddr(*blkno); return 0; // panic("file_get_block not implemented"); }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. // cprintf("entering file_get_block\n"); if(!f||!blk) { cprintf("invalid file or blk pointer\n"); return -E_INVAL; } int i; uint32_t * blkno; i=file_block_walk(f,filebno,&blkno,0); if(i<0) { cprintf("error during file_block_walk in file_get_block\n"); return i; } *blk=(char *)diskaddr(*blkno); // cprintf("exiting file_get_block\n"); return 0; panic("file_block_walk not implemented"); }
// Set *blk to the address in memory where the filebno'th // block of file 'f' would be mapped. // // Returns 0 on success, < 0 on error. Errors are: // -E_NO_DISK if a block needed to be allocated but the disk is full. // -E_INVAL if filebno is out of range. // int file_get_block(struct File *f, uint32_t filebno, char **blk) { // LAB 5: Your code here. // Find block's disk block number. uint32_t *pdiskbno; int r = file_block_walk(f, filebno, &pdiskbno, 1); if (r) return r; // Not exist yet. if (!*pdiskbno) *pdiskbno = alloc_block(); // Allocation failed. if (!*pdiskbno) return -E_NO_DISK; *blk = (char *)diskaddr(*pdiskbno); return 0; // panic("file_get_block not implemented"); }