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");
}
