/* * Given a filesystem and a block number, frees the given block in the * filesystem. * * This function may potentially block. * * The caller is responsible for ensuring that the block being placed on * the free list is actually free and is not resident. */ static void s5_free_block(s5fs_t *fs, int blockno) { s5_super_t *s = fs->s5f_super; lock_s5(fs); KASSERT(S5_NBLKS_PER_FNODE > s->s5s_nfree); if ((S5_NBLKS_PER_FNODE - 1) == s->s5s_nfree) { /* get the pframe where we will store the free block nums */ pframe_t *prev_free_blocks = NULL; KASSERT(fs->s5f_bdev); pframe_get(&fs->s5f_bdev->bd_mmobj, blockno, &prev_free_blocks); KASSERT(prev_free_blocks->pf_addr); /* copy from the superblock to the new block on disk */ memcpy(prev_free_blocks->pf_addr, (void *)(s->s5s_free_blocks), S5_NBLKS_PER_FNODE * sizeof(int)); pframe_dirty(prev_free_blocks); /* reset s->s5s_nfree and s->s5s_free_blocks */ s->s5s_nfree = 0; s->s5s_free_blocks[S5_NBLKS_PER_FNODE - 1] = blockno; } else { s->s5s_free_blocks[s->s5s_nfree++] = blockno; } s5_dirty_super(fs); unlock_s5(fs); }
/* * s5_alloc_block: * Allocate a new disk-block off the block free list and return it. * param *fs: the pointer to the file system object * return: the block number, or negative number if no space */ static int s5_alloc_block(s5fs_t *fs) { dbg(DBG_S5FS, "{\n"); KASSERT(fs != NULL); lock_s5(fs); s5_super_t* super = fs->s5f_super; pframe_t* next_free_block = NULL; int ret = 0; int block_number = 0; if (super->s5s_nfree == 0) /* no free pages */ { int ret = pframe_get( S5FS_TO_VMOBJ(fs), super->s5s_free_blocks[S5_NBLKS_PER_FNODE - 1], &next_free_block); if (ret < 0 || next_free_block == NULL) { /* No more free blocks */ unlock_s5(fs); dbg(DBG_S5FS, "}(error code returned)\n"); return -ENOSPC; } else { block_number = super->s5s_free_blocks[S5_NBLKS_PER_FNODE - 1]; /* copy the next free block into the super block */ memcpy((void*)(super->s5s_free_blocks), next_free_block->pf_addr, S5_NBLKS_PER_FNODE * sizeof(uint32_t)); memset(next_free_block->pf_addr, 0, S5_BLOCK_SIZE); pframe_dirty(next_free_block); pframe_clean(next_free_block); pframe_free(next_free_block); /* now full */ super->s5s_nfree = S5_NBLKS_PER_FNODE-1; s5_dirty_super(fs); unlock_s5(fs); dbg(DBG_S5FS, "}\n"); return block_number; } } else /* there is some free pages */ { block_number = super->s5s_free_blocks[super->s5s_nfree - 1]; super->s5s_nfree--; s5_dirty_super(fs); unlock_s5(fs); dbg(DBG_S5FS, "}\n"); return block_number; } }
/* allocated an indirect block for a vnode who's indirect block is currently sparse */ static int alloc_indirect_block(vnode_t *v){ /* an array of 0's that we'll use to quickly create blocks of zeros */ static int zero_array[BLOCK_SIZE] = {}; s5_inode_t *inode = VNODE_TO_S5INODE(v); KASSERT(inode->s5_indirect_block == 0); /* first, get an indirect block */ int indirect_block = s5_alloc_block(VNODE_TO_S5FS(v)); if (indirect_block == -ENOSPC){ dbg(DBG_S5FS, "couldn't alloc a new block\n"); return -ENOSPC; } KASSERT(indirect_block > 0 && "forgot to handle an error case"); /* then, zero it */ pframe_t *ind_page; mmobj_t *mmo = S5FS_TO_VMOBJ(VNODE_TO_S5FS(v)); int get_res = pframe_get(mmo, indirect_block, &ind_page); if (get_res < 0){ return get_res; } memcpy(ind_page->pf_addr, zero_array, BLOCK_SIZE); int dirty_res = pframe_dirty(ind_page); if (dirty_res < 0){ return dirty_res; } /* finally, set this block to be the indirect block of the inode */ inode->s5_indirect_block = indirect_block; s5_dirty_inode(VNODE_TO_S5FS(v), inode); return 0; }
/* * This gets called by _pt_fault_handler in mm/pagetable.c The * calling function has already done a lot of error checking for * us. In particular it has checked that we are not page faulting * while in kernel mode. Make sure you understand why an * unexpected page fault in kernel mode is bad in Weenix. You * should probably read the _pt_fault_handler function to get a * sense of what it is doing. * * Before you can do anything you need to find the vmarea that * contains the address that was faulted on. Make sure to check * the permissions on the area to see if the process has * permission to do [cause]. If either of these checks does not * pass kill the offending process, setting its exit status to * EFAULT (normally we would send the SIGSEGV signal, however * Weenix does not support signals). * * Now it is time to find the correct page (don't forget * about shadow objects, especially copy-on-write magic!). Make * sure that if the user writes to the page it will be handled * correctly. * * Finally call pt_map to have the new mapping placed into the * appropriate page table. * * @param vaddr the address that was accessed to cause the fault * * @param cause this is the type of operation on the memory * address which caused the fault, possible values * can be found in pagefault.h */ void handle_pagefault(uintptr_t vaddr, uint32_t cause) { int forwrite = 0; if( vaddr<(USER_MEM_LOW) ||vaddr >= (USER_MEM_HIGH)){ dbg(DBG_PRINT, "(GRADING3D) ADDRESS NOT VALID \n"); do_exit(EFAULT); return; } vmarea_t *container = vmmap_lookup(curproc->p_vmmap, ADDR_TO_PN(vaddr)); if(container == NULL){ dbg(DBG_PRINT, "(GRADING3D) VMAREA NOT VALID \n"); do_exit(EFAULT); return; } if(container->vma_prot == PROT_NONE){ dbg(DBG_PRINT, "(GRADING3D) PROT NOT VALID \n"); do_exit(EFAULT); return; } if((cause & FAULT_WRITE) && !(container->vma_prot & PROT_WRITE)){ dbg(DBG_PRINT, "(GRADING3D) CONTAINER PROT NOT VALID \n"); do_exit(EFAULT); return; } if(!(container->vma_prot & PROT_READ)){ dbg(DBG_PRINT, "(GRADING3D) PROT IS NOT PROT READ \n"); do_exit(EFAULT); return; } int pagenum = ADDR_TO_PN(vaddr)-container->vma_start+container->vma_off; pframe_t *pf; if((container->vma_prot & PROT_WRITE) && (cause & FAULT_WRITE)){ dbg(DBG_PRINT, "(GRADING3D) prot write fault write \n"); int pf_res = pframe_lookup(container->vma_obj, pagenum, 1, &pf); if(pf_res<0){ dbg(DBG_PRINT, "(GRADING3D) pframe lookup failed\n"); do_exit(EFAULT); } pframe_dirty(pf); }else{ dbg(DBG_PRINT, "(GRADING3D) prot write fault write else \n"); int pf_res = pframe_lookup(container->vma_obj, pagenum, forwrite, &pf); if(pf_res<0){ dbg(DBG_PRINT, "(GRADING3D) pframe lookup failed \n"); do_exit(EFAULT); } } KASSERT(pf); dbg(DBG_PRINT, "(GRADING3A 5.a) pf is not NULL\n"); KASSERT(pf->pf_addr); dbg(DBG_PRINT, "(GRADING3A 5.a) pf->addr is not NULL\n"); uint32_t pdflags = PD_PRESENT | PD_USER; uint32_t ptflags = PT_PRESENT | PT_USER; if(cause & FAULT_WRITE){ dbg(DBG_PRINT, "(GRADING3D) cause is fault write \n"); pdflags = pdflags | PD_WRITE; ptflags = ptflags | PT_WRITE; } int ptmap_res = pt_map(curproc->p_pagedir, (uintptr_t)PAGE_ALIGN_DOWN(vaddr), pt_virt_to_phys((uintptr_t)pf->pf_addr), pdflags, ptflags); }
/* * s5_seek_to_block: * Return the disk-block number for the given seek pointer (aka file * position). * param vnode: pointer to vnode * param seekptr: seek offset * alloc: allocate new page or not * return: the block number, or negative number on failure */ int s5_seek_to_block(vnode_t *vnode, off_t seekptr, int alloc) { KASSERT(vnode != 0); KASSERT(alloc == 1 || alloc == 0); KASSERT(seekptr >= 0); s5_inode_t* inode = VNODE_TO_S5INODE(vnode); uint32_t block_number = S5_DATA_BLOCK(seekptr); /* check if the block_number is valid */ if (block_number >= S5_NIDIRECT_BLOCKS + S5_NDIRECT_BLOCKS) { return -1; } if (block_number < S5_NDIRECT_BLOCKS) { /* sparse block */ if (inode->s5_direct_blocks[block_number] == 0) { /* alloc is zero, simply return */ if (alloc == 0) { return 0; } else { /* alloc a new disk block */ int block_num = s5_alloc_block(VNODE_TO_S5FS(vnode)); if (block_num < 0) { /* error */ return block_num; } else { /* add the new block to inode */ inode->s5_direct_blocks[block_number] = block_num; /* dirty the inode */ s5_dirty_inode((VNODE_TO_S5FS(vnode)), inode); return block_num; } } } else /* already there*/ { return inode->s5_direct_blocks[block_number]; } } else { /* indirect blocks */ /* if the indirect block is zero, alloc it firstly */ pframe_t* page = NULL; if (inode->s5_indirect_block == 0) { int block_num = 0; if ((block_num = s5_alloc_block(FS_TO_S5FS(vnode->vn_fs))) < 0) { return block_num; } else { int ret = pframe_get(S5FS_TO_VMOBJ(FS_TO_S5FS(vnode->vn_fs)), block_num, &page); if (ret < 0 || page == NULL) { return ret; } else { pframe_pin(page); memset(page->pf_addr, 0, S5_BLOCK_SIZE); pframe_dirty(page); pframe_unpin(page); inode->s5_indirect_block = block_num; s5_dirty_inode(FS_TO_S5FS(vnode->vn_fs), inode); } } } else { int ret = pframe_get(S5FS_TO_VMOBJ(FS_TO_S5FS(vnode->vn_fs)), inode->s5_indirect_block, &page); if (ret < 0 || page == NULL) return ret; } KASSERT(page != NULL); pframe_pin(page); int off = block_number - S5_NDIRECT_BLOCKS; int32_t* addr = ((int32_t*)page->pf_addr) + off; pframe_unpin(page); if (*addr == 0) { if (alloc == 0) { return 0; } else { int block_num = s5_alloc_block(VNODE_TO_S5FS(vnode)); if (block_num < 0) { return block_num; } else { pframe_pin(page); *addr = block_num; pframe_dirty(page); pframe_unpin(page); return block_num; } } } else { /* already there, return */ return *addr; } } }
/* * s5_write_file: * write len bytes to the given inode, starting at seek bytes from the * beginning of the inode. On success, * param *vnode: the pointer to the vnode object * param seek: the seek position * param *bytes: the source buffer * param len: the length of the source buffer in bytes * return: the number of bytes actually written; on failure, return -errno. */ int s5_write_file(vnode_t *vnode, off_t seek, const char *bytes, size_t len) { dbg(DBG_S5FS, "{\n"); KASSERT(vnode != NULL); KASSERT(bytes != NULL); KASSERT(PAGE_SIZE == S5_BLOCK_SIZE); KASSERT((uint32_t)vnode->vn_len == VNODE_TO_S5INODE(vnode)->s5_size); off_t start_pos = seek; off_t start_block_offset = S5_DATA_OFFSET(start_pos); off_t end_pos = MIN(seek + len, S5_MAX_FILE_BLOCKS*PAGE_SIZE); off_t end_block_offset = S5_DATA_OFFSET(end_pos); int start_block = S5_DATA_BLOCK(start_pos); int end_block = S5_DATA_BLOCK(end_pos); int ret = 0; pframe_t* start = NULL; ret = pframe_get(&vnode->vn_mmobj, start_block, &start); if (ret < 0) { dbg(DBG_S5FS, "}(error code returend)\n"); return ret; } pframe_t* end = NULL; ret = pframe_get(&vnode->vn_mmobj, end_block, &end); if (ret < 0) { dbg(DBG_S5FS, "}(error code returend)\n"); return ret; } uint32_t num_bytes = 0; if (start == end) { pframe_pin(start); memcpy((char*)start->pf_addr + start_block_offset, bytes, len); KASSERT((char*)start->pf_addr + start_block_offset + len == (char*)start->pf_addr + end_block_offset); /* dirty the page */ pframe_dirty(start); pframe_unpin(start); num_bytes = len; s5_inode_t* inode = VNODE_TO_S5INODE(vnode ); inode->s5_size = MAX(end_pos, vnode->vn_len); vnode->vn_len = inode->s5_size; s5_dirty_inode(VNODE_TO_S5FS(vnode),inode); } else { /* copy the start block */ pframe_pin(start); memcpy((char*)start->pf_addr + start_block_offset, bytes, S5_BLOCK_SIZE - start_block_offset); bytes += S5_BLOCK_SIZE - start_block_offset; num_bytes += S5_BLOCK_SIZE - start_block_offset; pframe_dirty(start); pframe_unpin(start); s5_inode_t* inode = VNODE_TO_S5INODE(vnode ); inode->s5_size = MAX(start_pos + num_bytes, (uint32_t)vnode->vn_len); vnode->vn_len = inode->s5_size; while (1) { pframe_t* tmp; int block_number = S5_DATA_BLOCK(start_pos + num_bytes ); ret = pframe_get(&vnode->vn_mmobj, block_number, &tmp); if (tmp == NULL) { VNODE_TO_S5INODE(vnode)->s5_size = MAX(start_pos + num_bytes, (uint32_t)vnode->vn_len); vnode->vn_len = VNODE_TO_S5INODE(vnode)->s5_size; s5_dirty_inode(VNODE_TO_S5FS(vnode),inode); return ret; } if (tmp == end) { break; } pframe_pin(tmp); memcpy(tmp->pf_addr, bytes, S5_BLOCK_SIZE); pframe_dirty(tmp); pframe_unpin(tmp); bytes += S5_BLOCK_SIZE; num_bytes += S5_BLOCK_SIZE; } /* copy the last one */ pframe_pin(end); memcpy(end->pf_addr, bytes, len - num_bytes); num_bytes += len - num_bytes; /* len */ pframe_dirty(end); pframe_unpin(end); /* add the size */ inode->s5_size = MAX(end_pos, vnode->vn_len); s5_dirty_inode(VNODE_TO_S5FS(vnode),inode); vnode->vn_len = inode->s5_size; } KASSERT((uint32_t)vnode->vn_len == VNODE_TO_S5INODE(vnode)->s5_size); dbg(DBG_S5FS, "}\n"); return num_bytes; }
/* * This gets called by _pt_fault_handler in mm/pagetable.c The * calling function has already done a lot of error checking for * us. In particular it has checked that we are not page faulting * while in kernel mode. Make sure you understand why an * unexpected page fault in kernel mode is bad in Weenix. You * should probably read the _pt_fault_handler function to get a * sense of what it is doing. * * Before you can do anything you need to find the vmarea that * contains the address that was faulted on. Make sure to check * the permissions on the area to see if the process has * permission to do [cause]. If either of these checks does not * pass kill the offending process, setting its exit status to * EFAULT (normally we would send the SIGSEGV signal, however * Weenix does not support signals). * * Now it is time to find the correct page (don't forget * about shadow objects, especially copy-on-write magic!). Make * sure that if the user writes to the page it will be handled * correctly. * * Finally call pt_map to have the new mapping placed into the * appropriate page table. * * @param vaddr the address that was accessed to cause the fault * * @param cause this is the type of operation on the memory * address which caused the fault, possible values * can be found in pagefault.h */ void handle_pagefault(uintptr_t vaddr, uint32_t cause) { /*NOT_YET_IMPLEMENTED("VM: handle_pagefault");*/ vmarea_t *vma; pframe_t *pf; int pflags = PD_PRESENT | PD_USER; int writeflag = 0; dbg(DBG_PRINT, "(GRADING3F)\n"); if ((vma = vmmap_lookup(curproc->p_vmmap, ADDR_TO_PN(vaddr))) == NULL) { dbg(DBG_PRINT, "(GRADING3C 1)\n"); proc_kill(curproc, EFAULT); return; } /* if (vma->vma_prot & PROT_NONE) { dbg(DBG_ERROR, "(GRADING3 3)\n"); proc_kill(curproc, EFAULT); return; }*/ if (!((cause & FAULT_WRITE) || (cause & FAULT_EXEC)) && !(vma->vma_prot & PROT_READ)) { dbg(DBG_PRINT, "(GRADING3D 3)\n"); proc_kill(curproc, EFAULT); return; } if ((cause & FAULT_WRITE) && !(vma->vma_prot & PROT_WRITE)) { dbg(DBG_PRINT, "(GRADING3D 3)\n"); proc_kill(curproc, EFAULT); return; }/* if ((cause & FAULT_EXEC) && !(vma->vma_prot & PROT_EXEC)) { dbg(DBG_ERROR, "(GRADING3 6)\n"); proc_kill(curproc, EFAULT); return;; }*/ if (cause & FAULT_WRITE) { dbg(DBG_PRINT, "(GRADING3F)\n"); writeflag = 1; } if (pframe_lookup(vma->vma_obj, ADDR_TO_PN(vaddr) - vma->vma_start + vma->vma_off, writeflag, &pf) < 0) { dbg(DBG_PRINT, "(GRADING3D 4)\n"); proc_kill(curproc, EFAULT); return; } if (cause & FAULT_WRITE) { pframe_pin(pf); dbg(DBG_PRINT, "(GRADING3F)\n"); pframe_dirty(pf); /* if ( < 0) { dbg(DBG_ERROR, "(GRADING3 10)\n"); pframe_unpin(pf); proc_kill(curproc, EFAULT); return; }*/ pframe_unpin(pf); pflags |= PD_WRITE; } pt_map(curproc->p_pagedir, (uintptr_t) PAGE_ALIGN_DOWN(vaddr), pt_virt_to_phys((uintptr_t) pf->pf_addr), pflags, pflags); }
/* * Write len bytes to the given inode, starting at seek bytes from the * beginning of the inode. On success, return the number of bytes * actually written (which should be 'len', unless there's only enough * room for a partial write); on failure, return -errno. * * This function should allow writing to files or directories, treating * them identically. * * Writing to a sparse block of the file should cause that block to be * allocated. Writing past the end of the file should increase the size * of the file. Blocks between the end and where you start writing will * be sparse. * * Do not call s5_seek_to_block() directly from this function. You will * use the vnode's pframe functions, which will eventually result in a * call to s5_seek_to_block(). * * You will need pframe_dirty(), pframe_get(), memcpy(). */ int s5_write_file(vnode_t *vnode, off_t seek, const char *bytes, size_t len) { if (seek < 0){ dbg(DBG_S5FS, "invalid seek value\n"); return -EINVAL; } if (seek + len >= S5_MAX_FILE_SIZE){ len = S5_MAX_FILE_SIZE - seek - 1; } /* extend file size, if necessary */ uint32_t newlength = max(seek + len, vnode->vn_len); /* if (seek + len > (unsigned) vnode->vn_len){*/ /*vnode->vn_len = seek + len;*/ /*VNODE_TO_S5INODE(vnode)->s5_size = vnode->vn_len;*/ /*s5_dirty_inode(VNODE_TO_S5FS(vnode), VNODE_TO_S5INODE(vnode));*/ /*}*/ off_t start_pos = seek; /*off_t end_pos = min(seek + len, vnode->vn_len);*/ off_t end_pos = min(seek + len, newlength); unsigned int srcpos = 0; int get_res; int write_size; pframe_t *p; uint32_t err = 0; while (srcpos < len){ int data_offset = S5_DATA_OFFSET(seek); get_res = pframe_get(&vnode->vn_mmobj, S5_DATA_BLOCK(seek), &p); if (get_res < 0){ dbg(DBG_S5FS, "error getting page\n"); err = get_res; break; } write_size = min(PAGE_SIZE - data_offset, end_pos - seek); KASSERT(write_size >= 0 && "write size is negative"); memcpy((char *) p->pf_addr + data_offset, (void *) bytes, write_size); int dirty_res = pframe_dirty(p); if (dirty_res < 0){ err = dirty_res; break; } srcpos += write_size; seek += write_size; } if (seek > vnode->vn_len){ vnode->vn_len = seek; VNODE_TO_S5INODE(vnode)->s5_size = vnode->vn_len; s5_dirty_inode(VNODE_TO_S5FS(vnode), VNODE_TO_S5INODE(vnode)); } return err ? err : srcpos; }
/* * Return the disk-block number for the given seek pointer (aka file * position). * * If the seek pointer refers to a sparse block, and alloc is false, * then return 0. If the seek pointer refers to a sparse block, and * alloc is true, then allocate a new disk block (and make the inode * point to it) and return it. * * Be sure to handle indirect blocks! * * If there is an error, return -errno. * * You probably want to use pframe_get, pframe_pin, pframe_unpin, pframe_dirty. */ int s5_seek_to_block(vnode_t *vnode, off_t seekptr, int alloc) { int block_index = S5_DATA_BLOCK(seekptr); if ((unsigned) block_index >= S5_MAX_FILE_BLOCKS){ dbg(DBG_S5FS, "file too large"); return -EFBIG; } if (seekptr > vnode->vn_len && !alloc){ return 0; } s5_inode_t *inode = VNODE_TO_S5INODE(vnode); uint32_t block_num; if (block_index >= S5_NDIRECT_BLOCKS){ pframe_t *ind_page; mmobj_t *mmo = S5FS_TO_VMOBJ(VNODE_TO_S5FS(vnode)); if (inode->s5_indirect_block == 0){ if (!alloc){ return 0; } int alloc_res = alloc_indirect_block(vnode); if (alloc_res < 0){ dbg(DBG_S5FS, "error allocating indirect block\n"); return alloc_res; } } if (pframe_get(mmo, inode->s5_indirect_block, &ind_page) < 0){ panic("an indirect block is messed up\n"); } block_num = ((uint32_t *) ind_page->pf_addr)[block_index - S5_NDIRECT_BLOCKS]; /* case where we've found a sparse block and need to allocate*/ if (block_num == 0 && alloc){ pframe_pin(ind_page); int block_num = s5_alloc_block(VNODE_TO_S5FS(vnode)); pframe_unpin(ind_page); if (block_num == -ENOSPC){ dbg(DBG_S5FS, "couldn't alloc a new block\n"); return -ENOSPC; } KASSERT(block_num > 0 && "forgot to handle an error case"); ((uint32_t *) ind_page->pf_addr)[block_index - S5_NDIRECT_BLOCKS] = block_num; int dirty_res = pframe_dirty(ind_page); if (dirty_res < 0){ return dirty_res; } } } else { block_num = inode->s5_direct_blocks[block_index]; /* case where we've found a sparse block and need to allocate*/ if (block_num == 0 && alloc){ int block_num = s5_alloc_block(VNODE_TO_S5FS(vnode)); if (block_num == -ENOSPC){ dbg(DBG_S5FS, "couldn't alloc a new block\n"); return -ENOSPC; } KASSERT(block_num > 0 && "forgot to handle an error case"); inode->s5_direct_blocks[block_index] = block_num; s5_dirty_inode(VNODE_TO_S5FS(vnode), inode); } } return block_num; }
/* * Return the disk-block number for the given seek pointer (aka file * position). * * If the seek pointer refers to a sparse block, and alloc is false, * then return 0. If the seek pointer refers to a sparse block, and * alloc is true, then allocate a new disk block (and make the inode * point to it) and return it. * * Be sure to handle indirect blocks! * * If there is an error, return -errno. * * You probably want to use pframe_get, pframe_pin, pframe_unpin, pframe_dirty. */ int s5_seek_to_block(vnode_t *vnode, off_t seekptr, int alloc) { /* CASE BLOCK TYPE ALLOC Direct Sparse Indirect Sparse WAT DO? * 1 (BLOCK > Total Blocks) Return Error * 2 DIRECT FALSE TRUE N/A return block from s5_direct_blocks * 3 DIRECT TRUE TRUE N/A allocate new block and point inode (also memcpy) * 4 DIRECT TRUE FALSE N/A return block from s5_direct_blocks * 5 INDIRECT FALSE TRUE TRUE return 0 * 7 INDIRECT FALSE FALSE FALSE Find block we want * 8 INDIRECT TRUE FALSE FALSE Find block we want * 9 INDIRECT TRUE TRUE FALSE allocate new block, memcpy to 0, set data address in indirect * * INDIRECT TRUE N/A TRUE allocate new block, pframe_get on inode->indirect_block */ dbg_print("s5_seek_to_block: Entering Function, seekptr: %i, alloc: %i\n",seekptr,alloc); s5fs_t* vnode_s5fs = VNODE_TO_S5FS(vnode); s5_inode_t* vnode_inode = VNODE_TO_S5INODE(vnode); struct mmobj* vnode_vmobj = S5FS_TO_VMOBJ(vnode_s5fs); uint32_t data_block = S5_DATA_BLOCK(seekptr); pframe_t* pf; dbg_print("s5_seek_to_block: a\n"); if(data_block > S5_MAX_FILE_BLOCKS) { /* Case 1 */ dbg_print("s5_seek_to_block: Case 1\n"); return 0; } if(data_block < S5_NDIRECT_BLOCKS) { dbg_print("s5_seek_to_block: b\n"); /* Direct Block */ if(!alloc) { /* ALLOC FALSE */ /* CASE 2 */ dbg_print("s5_seek_to_block: c\n"); dbg_print("s5_seek_to_block: Case 2\n"); return vnode_inode->s5_direct_blocks[data_block]; } else { /* ALLOC TRUE */ dbg_print("s5_seek_to_block: d\n"); if(vnode_inode->s5_direct_blocks[data_block] == 0) { /* Sparse Block */ /* CASE 3 */ dbg_print("s5_seek_to_block: e\n"); pframe_get(vnode_vmobj,data_block,&pf); pframe_pin(pf); int block_alloc = s5_alloc_block(vnode_s5fs); dbg_print("s5_seek_to_block: f\n"); if(block_alloc == -ENOSPC) { /* Allocation Failure */ dbg_print("s5_seek_to_block: g\n"); pframe_unpin(pf); dbg_print("s5_seek_to_block: Allocation Failure #1\n"); return -ENOSPC; } else { /* Success in Allocation, Connect Inode and Dirty */ dbg_print("s5_seek_to_block: h\n"); vnode_inode->s5_direct_blocks[data_block] = block_alloc; /* memset(pf->pf_addr, 0, PAGE_SIZE); */ pframe_dirty(pf); s5_dirty_inode(vnode_s5fs,vnode_inode); pframe_unpin(pf); dbg_print("s5_seek_to_block: Case 3\n"); return block_alloc; } } else { /* Not Sparse Block */ /* CASE 4 */ dbg_print("s5_seek_to_block: Case 4\n"); return vnode_inode->s5_direct_blocks[data_block]; } } } else { /* Indirect Block */ dbg_print("s5_seek_to_block: i\n"); if(!alloc) { /* ALLOC FALSE */ dbg_print("s5_seek_to_block: j\n"); if(vnode_inode->s5_indirect_block == 0) { /* Sparse Block */ /* CASE 5 */ dbg_print("s5_seek_to_block: Case 5\n"); return 0; } else { /* Not Sparse Block */ /* CASE 7 */ dbg_print("s5_seek_to_block: Case 7\n"); return vnode_inode->s5_direct_blocks[data_block - S5_NDIRECT_BLOCKS]; } } else { /* ALLOC TRUE */ dbg_print("s5_seek_to_block: k\n"); if(vnode_inode->s5_indirect_block == 0) { /* Sparse Block */ /* CASE 5 */ dbg_print("s5_seek_to_block: l\n"); int indirect_alloc = s5_alloc_block(vnode_s5fs); if(indirect_alloc == -ENOSPC) { /* Allocation Failure */ dbg_print("s5_seek_to_block: Allocation Failure #2\n"); return -ENOSPC; } /* Success in Allocation, Connect Inode and Dirty */ dbg_print("s5_seek_to_block: m\n"); pframe_get(vnode_vmobj,vnode_inode->s5_indirect_block,&pf); pframe_pin(pf); /* memset(pf->pf_addr, 0, PAGE_SIZE); */ vnode_inode->s5_indirect_block = indirect_alloc; pframe_dirty(pf); s5_dirty_inode(vnode_s5fs,vnode_inode); dbg_print("s5_seek_to_block: n\n"); } else { /* Not Sparse Block */ dbg_print("s5_seek_to_block: o\n"); pframe_get(vnode_vmobj,vnode_inode->s5_indirect_block,&pf); pframe_pin(pf); } dbg_print("s5_seek_to_block: p\n"); uint32_t indirect_map = data_block - S5_NDIRECT_BLOCKS; uint32_t* block_array = (uint32_t*)pf->pf_addr; int direct_index = block_array[indirect_map]; if(direct_index == 0) { dbg_print("s5_seek_to_block: q\n"); direct_index = s5_alloc_block(vnode_s5fs); if(direct_index == -ENOSPC) { /* Allocation Failure */ dbg_print("s5_seek_to_block: Allocation Failure #3\n"); return -ENOSPC; } } dbg_print("s5_seek_to_block: rn"); block_array[indirect_map] = direct_index; pframe_dirty(pf); pframe_unpin(pf); dbg_print("s5_seek_to_block: Case 6\n"); return direct_index; } } /* NOT_YET_IMPLEMENTED("S5FS: s5_seek_to_block"); * return -1; */ }
/* * Write len bytes to the given inode, starting at seek bytes from the * beginning of the inode. On success, return the number of bytes * actually written (which should be 'len', unless there's only enough * room for a partial write); on failure, return -errno. * * This function should allow writing to files or directories, treating * them identically. * * Writing to a sparse block of the file should cause that block to be * allocated. Writing past the end of the file should increase the size * of the file. Blocks between the end and where you start writing will * be sparse. * * Do not call s5_seek_to_block() directly from this function. You will * use the vnode's pframe functions, which will eventually result in a * call to s5_seek_to_block(). * * You will need pframe_dirty(), pframe_get(), memcpy(). */ int s5_write_file(vnode_t *vnode, off_t seek, const char *bytes, size_t len) { dbg_print("s5_write_file: Writing to File, Length: %i\n",len); uint32_t to_write = len; /* Block Number */ uint32_t block_index = S5_DATA_BLOCK(seek); if(block_index >= S5_MAX_FILE_BLOCKS) { dbg_print("s5_write_file: Exiting with Value: 0\n"); return 0; } /* Offset within block */ uint32_t block_offset = S5_DATA_OFFSET(seek); uint32_t remaining = S5_BLOCK_SIZE - block_offset; int total_written = 0; s5_inode_t* inode = VNODE_TO_S5INODE(vnode); s5fs_t* dir_fs = VNODE_TO_S5FS(vnode); if(seek >= vnode->vn_len) { /* End to Start of Writing should be written as sparse */ } while(to_write > 0) { pframe_t* pf; pframe_get(&(vnode->vn_mmobj),block_index,&pf); pframe_pin(pf); if(to_write <= remaining) { memcpy((char*)pf->pf_addr + block_offset,bytes + total_written,to_write); total_written += to_write; block_offset = 0; to_write = 0; } else { /* to_write > remaining */ memcpy((char*)pf->pf_addr + block_offset,bytes + total_written,remaining); total_written += remaining; block_offset = 0; to_write -= remaining; block_index++; remaining = S5_BLOCK_SIZE; if(block_index == S5_MAX_FILE_BLOCKS) { break; } } pframe_dirty(pf); pframe_unpin(pf); } if(seek + total_written > vnode->vn_len) { vnode->vn_len = seek + total_written; inode->s5_size = seek + total_written; } s5_dirty_inode(dir_fs,inode); return total_written; }
void handle_pagefault(uintptr_t vaddr, uint32_t cause) { pframe_t *pf; int ret_val; vmarea_t *vma = vmmap_lookup(curproc->p_vmmap, ADDR_TO_PN(vaddr)); if(vma == NULL) { dbg(DBG_PRINT,"(GRADING3D 1): No vmarea found\n"); proc_kill(curproc,EFAULT); return; } if(cause & FAULT_WRITE) { dbg(DBG_VM,"grade14\n"); dbg(DBG_PRINT,"(GRADING3D 1),checking permission for writing\n"); if(vma->vma_prot & PROT_WRITE) { dbg(DBG_VM,"grade15\n"); dbg(DBG_PRINT,"(GRADING3D 1),Vmarea has write permission\n"); ret_val = pframe_lookup(vma->vma_obj, ADDR_TO_PN(vaddr) - vma->vma_start + vma->vma_off, (cause & FAULT_WRITE),&pf); if(ret_val<0) { dbg(DBG_VM,"grade16\n"); dbg(DBG_PRINT,"(GRADING3D 1),pframe could not be found\n"); proc_kill(curproc,EFAULT); return; } pframe_dirty(pf); KASSERT(pf); dbg(DBG_PRINT,"(GRADING3A 5.a),pframe is not NULL\n"); KASSERT(pf->pf_addr); dbg(DBG_PRINT,"(GRADING3A 5.a),pf->pf_addr is not NULL\n"); } else { dbg(DBG_VM,"grade17\n"); dbg(DBG_PRINT,"(GRADING3D 1),Vmarea does not have write permission\n"); proc_kill(curproc,EFAULT); return; } dbg(DBG_VM,"grade18\n"); dbg(DBG_PRINT,"(GRADING3D 1),Calling pt_map after write\n"); pt_map(curproc->p_pagedir,(uintptr_t)PAGE_ALIGN_DOWN(vaddr),pt_virt_to_phys((uintptr_t)pf->pf_addr), (PD_WRITE|PD_PRESENT|PD_USER), (PT_WRITE|PT_PRESENT|PT_USER)); } else { dbg(DBG_VM,"grade19\n"); dbg(DBG_PRINT,"(GRADING3D 1),checking permission for reading\n"); if(vma->vma_prot & PROT_READ) { dbg(DBG_VM,"grade20\n"); dbg(DBG_PRINT,"(GRADING3D 1),Vmarea has read permission\n"); ret_val = pframe_lookup(vma->vma_obj, ADDR_TO_PN(vaddr) - vma->vma_start + vma->vma_off, (cause & FAULT_WRITE),&pf); if(ret_val<0) { dbg(DBG_VM,"grade21\n"); dbg(DBG_PRINT,"(GRADING3D 1),pframe could not be found\n"); proc_kill(curproc,EFAULT); return; } dbg(DBG_VM,"grade22\n"); KASSERT(pf); dbg(DBG_PRINT,"(GRADING3A 5.a),pframe is not NULL\n"); KASSERT(pf->pf_addr); dbg(DBG_PRINT,"(GRADING3A 5.a),pf->pf_addr is not NULL\n"); } else { dbg(DBG_VM,"grade23\n"); dbg(DBG_PRINT,"(GRADING3D 1),Vmarea does not have read permission\n"); proc_kill(curproc,EFAULT); return; } dbg(DBG_VM,"grade24\n"); dbg(DBG_PRINT,"(GRADING3D 1),Calling pt_map after read\n"); pt_map(curproc->p_pagedir,(uintptr_t)PAGE_ALIGN_DOWN(vaddr),pt_virt_to_phys((uintptr_t)pf->pf_addr), (PD_PRESENT|PD_USER), (PT_PRESENT|PT_USER)); } }