int read(int fd, void *buf, unsigned int bytes) { if (!_valid_file(fd)) { klogf("read: Invalid file %x\n", fd); return -1; } FSFile *file = (FSFile*) fd; _lock_file(file); int reverse = (!!(file->mode & O_PIPE_MODE)) ^ (!!(file->mode & _O_REVERSE)); if (!(file->access & O_RDONLY) || !(file->fs->accessmode(file->fs, file->device) & O_RDONLY)) { klogf("Permission error: %d\n", file->access); _set_error(FILE_PERMISSIONS_ERROR, "Invalid permissions"); _unlock_file(file); return -1; } if (!file->fs->pread) { klogf("Read not supported by filesystem: %x\n", file->fs->pread); _set_error(FILE_TYPE_ERROR, "Read not supported by the filesystem driver"); _unlock_file(file); return -1; } int ret, *cursor = ((file->mode & O_PIPE_MODE) && reverse) ? &file->pipe_rcursor : &file->cursor; ret = file->fs->pread(file->fs, file->device, file->internalfd, buf, bytes, *cursor); if (ret < 0) { _unlock_file(file); file->fs->lasterror_message[sizeof(file->fs->lasterror_message)-1] = 0; strncpy(file->errmsg, file->fs->lasterror_message, sizeof(file->errmsg)-1); file->errno = file->fs->lasterror; klogf("Read error:%d: %s\n", file->fs->lasterror, file->fs->lasterror_message); return -1; } *cursor += ret; //klogf("cursorr: %d, ret: %d\n", *cursor, ret); if (file->mode & O_PIPE_MODE) { struct stat sdata; file->fs->stat(file->fs, file->device, (int)file, &sdata); unsigned int size = sdata.st_size; *cursor = *cursor % size; } _unlock_file(file); return ret; }
int pread(int fd, void *buf, unsigned int bytes, unsigned int off) { if (!_valid_file(fd)) { klogf("pread: Invalid file %x\n", fd); return -1; } FSFile *file = (FSFile*) fd; _lock_file(file); //int reverse = (!!(file->mode & O_PIPE_MODE)) ^ (!!(file->mode & _O_REVERSE)); if (!(file->access & O_RDONLY) || !(file->fs->accessmode(file->fs, file->device) & O_RDONLY)) { klogf("Permission error: %d\n", file->access); _set_error(FILE_PERMISSIONS_ERROR, "Invalid permissions"); _unlock_file(file); return -1; } if (!file->fs->pread) { klogf("Read not supported by filesystem: %x\n", file->fs->pread); _set_error(FILE_TYPE_ERROR, "Read not supported by the filesystem driver"); _unlock_file(file); return -1; } int ret = file->fs->pread(file->fs, file->device, file->internalfd, buf, bytes, off); //wrap around in pipe mode if (ret > 0 && ret < (int)bytes && (file->mode & O_PIPE_MODE)) { ret = file->fs->pread(file->fs, file->device, file->internalfd, buf+ret, bytes-ret, 0); } if (ret < 0) { _unlock_file(file); file->fs->lasterror_message[sizeof(file->fs->lasterror_message)-1] = 0; strncpy(file->errmsg, file->fs->lasterror_message, sizeof(file->errmsg)-1); file->errno = file->fs->lasterror; klogf("Read error:%d: %s\n", file->fs->lasterror, file->fs->lasterror_message); return -1; } //klogf("cursorr: %d, ret: %d\n", *cursor, ret); _unlock_file(file); return ret; }
/* Dispatch event handler or, if none exists, log information and kernel panic. */ void common_interrupt_handler(struct regs r) { kassert(r.int_no < 256); if (idt_dispatch_table[r.int_no] != NULL) { idt_dispatch_table[r.int_no](&r); } else { kprintf("Unhandled Interrupt Triggered!\nRegisters:"); klogf("Unhandled Interrupt Triggered!\nRegisters:"); kprintf("ds: %p edi: %p esi: %p ebp: %p esp: %p ebx: %p edx: %p " "ecx: %p eax: %p int_no: %p err_code: %p eip: %p cs: %p " "eflags: %p useresp: %p ss: %p", r); klogf("ds: %p edi: %p esi: %p ebp: %p esp: %p ebx: %p edx: %p ecx: %p " "eax: %p int_no: %p err_code: %p eip: %p cs: %p eflags: %p " "useresp: %p ss: %p", r); kabort(); } }
int lseek(int fd, int off, int whence) { if (!_valid_file(fd)) { klogf("lseek: Invalid file %x\n", fd); return -1; } FSFile *file = (FSFile*) fd; int reverse = (!!(file->mode & O_PIPE_MODE)) ^ (!!(file->mode & _O_REVERSE)); int ret = -1, *cursor = ((file->mode & O_PIPE_MODE) && reverse) ? &file->pipe_rcursor : &file->cursor; _lock_file(file); if (file->fs->lseek) { ret = file->fs->lseek(file->fs, file->device, file->internalfd, off, whence); if (ret < 0) { _unlock_file(file); return ret; } *cursor = ret; } else { //adjust internal pointer directly struct stat st = {0,}; file->fs->fstat(file->fs, file->device, file->internalfd, &st); if (whence == SEEK_SET) { *cursor = off; } else if (whence == SEEK_CUR) { *cursor += off; } else if (whence == SEEK_END) { intptr_t newoff = st.st_size - off; if (newoff < 0) newoff = 0; *cursor = newoff; } if (*cursor > st.st_size) { *cursor = st.st_size; } } _unlock_file(file); return ret; }
static page_frame_t kernel_page_table_install(struct multiboot_info *mb) { // Certain very important things already exist in physical memory. They // need to be marked as present so that the allocator doesn't grab them by // accident. // After they are marked as present they can safely be mapped with // map_page. // Iterate over the multiboot memory map table and mark certain addresses // as unusable. klogf("Marking unusable!\n"); multiboot_memory_map_t *mm_last = (multiboot_memory_map_t*)(mb->mmap_addr + mb->mmap_length); for (multiboot_memory_map_t *mm = (multiboot_memory_map_t*)mb->mmap_addr; mm < mm_last; mm = (multiboot_memory_map_t*)((uintptr_t)mm + mm->size + sizeof(mm->size))) { // If the memory is not available if (mm->type != MULTIBOOT_MEMORY_AVAILABLE) { klogf("Unusable physical address %p of type %p and length %p\n", mm->addr, mm->type, mm->len); for (uint64_t page = PAGE_ALIGN(mm->addr); page < NEXT_PAGE(mm->addr+mm->len); page += PAGE_SIZE) { use_frame(page); } } } klogf("mm_addr table %p\n", mb->mmap_addr); klogf("apm table %p\n", mb->apm_table); klogf("fb table %p\n", mb->framebuffer_addr); klogf("vbe int off %p\n", mb->vbe_interface_off); // Catch NULL pointer dereferences use_frame(0); // Mark all the pages the kernel sits on as used use_range(KERNEL_START, KERNEL_END); // Mark the kernel heap as in use use_frame(KHEAP_PHYS_ROOT); // Mark video memory as in use use_range(VGA_BEGIN, VGA_END); // Mark the paging directory as in use use_frame(PAGE_DIRECTORY); page_frame_t page_dir = bootstrap_kernel_page_table(); enable_paging(page_dir); return page_dir; }
int fs_ioctl_handle(int fd, intptr_t req, intptr_t arg) { if (!_valid_file(fd)) { klogf("lseek: Invalid file %x\n", fd); return -1; } FSFile *file = (FSFile*) fd; //int reverse = (!!(file->mode & O_PIPE_MODE)) ^ (!!(file->mode & _O_REVERSE)); int ret = -1; // *cursor = ((file->mode & O_PIPE_MODE) && reverse) ? &file->pipe_rcursor : &file->cursor; _lock_file(file); if (file->fs->ioctl) { ret = file->fs->ioctl(file->fs, file->device, file->internalfd, req, arg); } _unlock_file(file); return ret; }
void mal_defaultTimerIsr() { klogf(LOG_DEBUG, "timer\n"); }