diff --git a/.settings/language.settings.xml b/.settings/language.settings.xml index 207fcc1..bfaac99 100644 --- a/.settings/language.settings.xml +++ b/.settings/language.settings.xml @@ -5,7 +5,7 @@ - + diff --git a/bin/init/main.c b/bin/init/main.c index 2875596..3376193 100644 --- a/bin/init/main.c +++ b/bin/init/main.c @@ -34,8 +34,8 @@ #include #include -static char *argv_shell[2] = { "shell", NULL, }; -static char *envp_shell[6] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", NULL, }; +static char *argv_login[2] = { "login", NULL, }; +static char *envp_login[6] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", NULL, }; int main(int argc,char **argv, char **envp) { int i=0x0; @@ -93,7 +93,8 @@ if (0 == i) { printf("Starting Login Daemon.\n"); - execve("sys:/bin/login", argv_shell, envp_shell); + printf("ARGV[0] %s - 0x%X\n", argv_login[0], &argv_login[0]); + execve("sys:/bin/login", argv_login, envp_login); printf("Error Starting System\n"); exit(0x0); } diff --git a/bin/login/main.c b/bin/login/main.c index f620c5e..37e006c 100644 --- a/bin/login/main.c +++ b/bin/login/main.c @@ -55,8 +55,11 @@ string[count] = '\0'; return(string); } + +static char *argv_shell[2] = { "shell", NULL, }; // ARGV For Initial Proccess +static char *envp_shell[6] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", NULL, }; //ENVP For Initial Proccess -int main() { +int main(int argc, char **argv, char **env) { FILE *fd; int shellPid = 0,i = 0x0; char userName[32]; @@ -133,7 +136,7 @@ fclose(fd); //chdir(data[i].path); chdir("sys:/bin/"); - execve(data[i].shell,0x0,0x0); + execve(data[i].shell,argv_shell,envp_shell); printf("Error: Problem Starting Shell\n"); exit(-1); } diff --git a/bin/shell/exec.c b/bin/shell/exec.c index 6a2ee04..c542678 100644 --- a/bin/shell/exec.c +++ b/bin/shell/exec.c @@ -30,6 +30,10 @@ int boo = 0x0; +static char *argv_init[2] = { "init", NULL, }; // ARGV For Initial Proccess +static char *envp_init[7] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", "LD_DEBUG=all", NULL, }; //ENVP For Initial Proccess + + void execProgram(inputBuffer *data) { char file[1024]; int cPid = 0x0; @@ -43,7 +47,7 @@ sprintf(file, "%s%s", cwd, data->argv[1]); // if (boo == 0) //execve(file,data->argv, 0x0); - execve(file,0x0, 0x0); + execve(file,argv_init, envp_init); /* else execn(file,&data->argv); diff --git a/sys/Makefile.incl b/sys/Makefile.incl index 12c9d5a..fc05a04 100644 --- a/sys/Makefile.incl +++ b/sys/Makefile.incl @@ -8,5 +8,5 @@ KMAKE= ${MAKE} ${KERNEL_FLAGS} INCLUDE=${KERNEL_INC} KERNEL=${KERNEL_NAME} INCLUDES = -I${INCLUDE} -CFLAGS = ${KFLAGS} -m32 -Wall -nostdlib -nostdinc -fno-builtin -fno-exceptions -ffreestanding -O +CFLAGS = ${KFLAGS} -m32 -Wall -nostdlib -nostdinc -fno-builtin -fno-exceptions -ffreestanding ROOT=/ubixos diff --git a/sys/fs/vfs/Makefile b/sys/fs/vfs/Makefile index fb5ef9d..6a32a0d 100644 --- a/sys/fs/vfs/Makefile +++ b/sys/fs/vfs/Makefile @@ -6,7 +6,7 @@ include ../../Makefile.incl # Objects -OBJS = mount.o file.o vfs.o +OBJS = mount.o file.o vfs.o stat.o namei.o inode.o all: $(OBJS) diff --git a/sys/fs/vfs/inode.c b/sys/fs/vfs/inode.c new file mode 100644 index 0000000..c1ef2ce --- /dev/null +++ b/sys/fs/vfs/inode.c @@ -0,0 +1,91 @@ +#include +#include +#include + +static struct inode *first_inode; +static struct wait_queue *inode_wait = NULL; +static int nr_inodes = 0, nr_free_inodes = 0; + +static void write_inode(struct inode * inode); +static void __wait_on_inode(struct inode * inode); +static inline void unlock_inode(struct inode * inode); + +static inline void wait_on_inode(struct inode * inode) { + if (inode->i_lock) + __wait_on_inode(inode); +} + +void iput(struct inode * inode) { + if (!inode) + return; + wait_on_inode(inode); + +#ifdef _BALLS + if (!inode->i_count) { + printk("VFS: iput: trying to free free inode\n"); + printk("VFS: device %d/%d, inode %lu, mode=0%07o\n", MAJOR(inode->i_rdev), MINOR(inode->i_rdev), inode->i_ino, inode->i_mode); + return; + } +#endif + + if (inode->i_pipe) + wake_up_interruptible(&PIPE_WAIT(*inode)); + repeat: if (inode->i_count > 1) { + inode->i_count--; + return; + } + wake_up(&inode_wait); + if (inode->i_pipe) { + unsigned long page = (unsigned long) PIPE_BASE(*inode); + PIPE_BASE (*inode) = NULL; + vmm_freeVirtualPage(page); + } + if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) { + inode->i_sb->s_op->put_inode(inode); + if (!inode->i_nlink) + return; + } + if (inode->i_dirt) { + write_inode(inode); /* we can sleep - so do again */ + wait_on_inode(inode); + goto repeat; + } + inode->i_count--; + nr_free_inodes++; + return; +} + +static void __wait_on_inode(struct inode * inode) { + struct wait_queue wait = { _current, NULL }; + + add_wait_queue(&inode->i_wait, &wait); + repeat: _current->state = UNINTERRUPTIBLE; + if (inode->i_lock) { + sched_yield(); + //schedule(); + goto repeat; + } + remove_wait_queue(&inode->i_wait, &wait); + _current->state = RUNNING; +} + +static void write_inode(struct inode * inode) { + if (!inode->i_dirt) + return; + wait_on_inode(inode); + if (!inode->i_dirt) + return; + if (!inode->i_sb || !inode->i_sb->s_op || !inode->i_sb->s_op->write_inode) { + inode->i_dirt = 0; + return; + } + inode->i_lock = 1; + inode->i_sb->s_op->write_inode(inode); + unlock_inode(inode); +} + + +static inline void unlock_inode(struct inode * inode) { + inode->i_lock = 0; + wake_up(&inode->i_wait); +} diff --git a/sys/fs/vfs/namei.c b/sys/fs/vfs/namei.c new file mode 100644 index 0000000..34153eb --- /dev/null +++ b/sys/fs/vfs/namei.c @@ -0,0 +1,144 @@ +#include +#include + +int follow_link(struct inode * dir, struct inode * inode, int flag, int mode, struct inode ** res_inode) { + if (!dir || !inode) { + iput(dir); + iput(inode); + *res_inode = NULL; + return -ENOENT; + } + if (!inode->i_op || !inode->i_op->follow_link) { + iput(dir); + *res_inode = inode; + return 0; + } + return inode->i_op->follow_link(dir, inode, flag, mode, res_inode); +} + +int permission(struct inode * inode, int mask) { + int mode = inode->i_mode; + + if (inode->i_op && inode->i_op->permission) + return inode->i_op->permission(inode, mask); + else if (_current->euid == inode->i_uid) + mode >>= 6; + else if (in_group_p(inode->i_gid)) + mode >>= 3; + if (((mode & mask & 0007) == mask)) // || suser()) + return 1; + return 0; +} + +int lookup(struct inode * dir, const char * name, int len, struct inode ** result) { + struct super_block * sb; + int perm; + + *result = NULL; + + if (!dir) + return -ENOENT; + /* check permissions before traversing mount-points */ + perm = permission(dir, MAY_EXEC); + if (len == 2 && name[0] == '.' && name[1] == '.') { + if (dir == _current->root) { + *result = dir; + return 0; + } else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) { + sb = dir->i_sb; + iput(dir); + dir = sb->s_covered; + if (!dir) + return -ENOENT; + dir->i_count++; + } + } + if (!dir->i_op || !dir->i_op->lookup) { + iput(dir); + return -ENOTDIR; + } + if (!perm) { + iput(dir); + return -EACCES; + } + if (!len) { + *result = dir; + return 0; + } + return dir->i_op->lookup(dir, name, len, result); +} + +static int dir_namei(const char * pathname, int * namelen, const char ** name, struct inode * base, struct inode ** res_inode) { + char c; + const char * thisname; + int len, error; + struct inode * inode; + + *res_inode = NULL; + if (!base) { + base = _current->pwd; + base->i_count++; + } + if ((c = *pathname) == '/') { + iput(base); + base = _current->root; + pathname++; + base->i_count++; + } + while (1) { + thisname = pathname; + for (len = 0; (c = *(pathname++)) && (c != '/'); len++) + /* nothing */; + if (!c) + break; + base->i_count++; + error = lookup(base, thisname, len, &inode); + if (error) { + iput(base); + return error; + } + error = follow_link(base, inode, 0, 0, &base); + if (error) + return error; + } + if (!base->i_op || !base->i_op->lookup) { + iput(base); + return -ENOTDIR; + } + *name = thisname; + *namelen = len; + *res_inode = base; + return 0; +} + +int namei(const char * pathname, struct inode * base, int follow_links, struct inode ** res_inode) { + const char *basename; + int namelen, error; + struct inode *inode; + + *res_inode = NULL; + + error = dir_namei(pathname, &namelen, &basename, base, &base); + if (error) + return error; + + base->i_count++; /* lookup uses up base */ + + error = lookup(base, basename, namelen, &inode); + + if (error) { + iput(base); + return error; + } + + if (follow_links) { + error = follow_link(base, inode, 0, 0, &inode); + if (error) + return error; + } else + iput(base); + + *res_inode = inode; + + return 0; +} diff --git a/sys/fs/vfs/stat.c b/sys/fs/vfs/stat.c new file mode 100644 index 0000000..a6cb89f --- /dev/null +++ b/sys/fs/vfs/stat.c @@ -0,0 +1,39 @@ +#include +#include +#include + +int sys_stat(char *path, struct stat *sb, int flags) { + int error = 0; + struct inode *inode; + + //NOTE: Should we verify that the memory is writable? + kprintf("SYS_STAT {%s}", path); + + switch (flags) { + case STAT_LSTAT: + namei(path, NULL, STAT_NO_FOLLOW, &inode); + break; + default: + error = -1; + break; + } + + sb->st_dev = 0x5E; + sb->st_ino = 0x3003; + sb->st_mode = 0x41FF; + sb->st_nlink = 0x2; + sb->st_uid = 0x0; + sb->st_gid = 0x0; + sb->st_rdev = 0x7FF3; + sb->st_size = 0xFFFFEB70; + + return(error); +} + + +/* Return stat of path do not follow if link return stat of link */ +int sys_lstat(struct thread *td, struct sys_lstat_args *args) { + td->td_retval[0] = sys_stat(args->path, args->sb, STAT_LSTAT); + return(0x0); +} + diff --git a/sys/fs/vfs/vfs.c b/sys/fs/vfs/vfs.c index f813947..7c971ca 100644 --- a/sys/fs/vfs/vfs.c +++ b/sys/fs/vfs/vfs.c @@ -161,7 +161,8 @@ if (nfp->fd == 0x0) td->td_retval[0] = -1; else - td->td_retval[0] = index; + td->td_retval[0] = nfp->fd;//MrOlsen 2018index; + return (error); } diff --git a/sys/i386/i386_exec.c b/sys/i386/i386_exec.c index ea3304a..f1e0a0f 100644 --- a/sys/i386/i386_exec.c +++ b/sys/i386/i386_exec.c @@ -39,9 +39,9 @@ #include #include -#define ENVP_PAGE 0x1000 -#define ARGV_PAGE 0x1000 -#define ELF_AUX 0x1000 +#define ENVP_PAGE 0x100 +#define ARGV_PAGE 0x100 +#define ELF_AUX 0x100 #define STACK_PAD 16 #define ENOEXEC -1 @@ -81,21 +81,26 @@ int argc = argv_count(argv_in); - *argv_out = (char **)kmalloc(sizeof(char *) * (argc + 2)); // + 1 For ARGC + 1 For NULL TERM - *args_out = (char **)kmalloc(ARGV_PAGE); + uint32_t *argv_tmp = (uint32_t *)kmalloc(sizeof(char *) * (argc + 2)); // + 1 For ARGC + 1 For NULL TERM - argv_out[0] = argc; + char *args_tmp = (char *)kmalloc(ARGV_PAGE); + + argv_tmp[0] = argc; uint32_t sp = 0x0; int i = 0x0; for (i = 1; i <=argc; i++) { - argv_out[i] = *args_out + sp; - strcpy(argv_out[i], argv_in[i - 1]); + argv_tmp[i] = args_tmp + sp; + strcpy(argv_tmp[i], argv_in[i - 1]); sp += strlen(argv_in[i - 1]) + 1; } - argv_out[i++] = 0x0; + + argv_tmp[i++] = 0x0; + + *argv_out = argv_tmp; + *args_out = args_tmp; } @@ -103,19 +108,23 @@ int envc = envp_count(envp_in); - *envp_out = (char **)kmalloc(sizeof(char *) * (envc + 1)); // + 1 For NULL TERM - *envs_out = (char **)kmalloc(ENVP_PAGE); + uint32_t *envp_tmp = (uint32_t *)kmalloc(sizeof(char *) * (envc + 1)); // + 1 For NULL TERM + + char *envs_tmp = (char *)kmalloc(ENVP_PAGE); uint32_t sp = 0x0; int i = 0x0; for (i = 0; i < envc; i++) { - envp_out[i] = *envs_out + sp; - strcpy(envp_out[i], envp_in[i]); + envp_tmp[i] = envs_tmp + sp; + strcpy(envp_tmp[i], envp_in[i]); sp += strlen(envp_in[i]) + 1; } - envp_out[i++] = 0x0; + envp_tmp[i++] = 0x0; + + *envp_out = envp_tmp; + *envs_out = envs_tmp; } @@ -233,9 +242,9 @@ uint32_t *tmp = 0x0; - Elf32_Ehdr *binaryHeader = 0x0; + Elf_Ehdr *binaryHeader = 0x0; - Elf32_Phdr *programHeader = 0x0; + Elf_Phdr *programHeader = 0x0; int argc = argv_count(argv); int envc = envp_count(envp); @@ -281,9 +290,9 @@ } /* Load ELF Header */ - binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr)); + binaryHeader = (Elf_Ehdr *) kmalloc(sizeof(Elf_Ehdr)); - fread(binaryHeader, sizeof(Elf32_Ehdr), 1, newProcess->imageFd); + fread(binaryHeader, sizeof(Elf_Ehdr), 1, newProcess->imageFd); /* Check If App Is A Real Application */ if ((binaryHeader->e_ident[1] != 'E') && (binaryHeader->e_ident[2] != 'L') && (binaryHeader->e_ident[3] != 'F')) { @@ -311,9 +320,7 @@ programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum); fseek(newProcess->imageFd, binaryHeader->e_phoff, 0); - //kprintf(">c:%i:0x%X:0x%X<",sizeof(Elf_Phdr)*binaryHeader->e_phnum,programHeader,tmpFd); fread(programHeader, (sizeof(Elf_Phdr) * binaryHeader->e_phnum), 1, newProcess->imageFd); - //kprintf(">d<"); /* Loop Through The Header And Load Sections Which Need To Be Loaded */ for (i = 0; i < binaryHeader->e_phnum; i++) { @@ -357,9 +364,7 @@ /* Kernel Stack 0x2000 bytes long */ - kprintf("PID: %i\n", newProcess->id); vmm_remapPage(vmm_findFreePage(newProcess->id), 0x5BC000, KERNEL_PAGE_DEFAULT | PAGE_STACK, newProcess->id); - kprintf("PID: %i\n", newProcess->id); vmm_remapPage(vmm_findFreePage(newProcess->id), 0x5BB000, KERNEL_PAGE_DEFAULT | PAGE_STACK, newProcess->id); /* Set All The Proper Information For The Task */ @@ -410,7 +415,7 @@ for (i = 1; i <= argc; i++) { tmp[i] = STACK_ADDR - ARGV_PAGE + sp; - strcpy(tmp[i], argv[i - 1]); + strcpy((char *)tmp[i], argv[i - 1]); sp += strlen(argv[i - 1]) + 1; } tmp[i++] = 0x0; @@ -418,7 +423,7 @@ sp = 0; for (int x = 0; x < envc; x++) { tmp[x + i] = STACK_ADDR - ARGV_PAGE - ENVP_PAGE + sp; - strcpy(tmp[x + i], envp[x]); + strcpy((char *)tmp[x + i], envp[x]); sp += strlen(envp[x]) + 1; } tmp[i + x] = 0x0; @@ -464,18 +469,19 @@ uint32_t cr3 = 0x0; - unsigned int *tmp = 0x0; + uint32_t *tmp = 0x0; uInt32 seg_size = 0x0; uInt32 seg_addr = 0x0; char *interp = 0x0; + uint32_t ldAddr = 0x0; fileDescriptor *fd = 0x0; - Elf32_Ehdr *binaryHeader = 0x0; - Elf32_Phdr *programHeader = 0x0; - Elf32_Shdr *sectionHeader = 0x0; + Elf_Ehdr *binaryHeader = 0x0; + Elf_Phdr *programHeader = 0x0; + Elf_Shdr *sectionHeader = 0x0; elf_file_t ef = 0x0; @@ -502,15 +508,17 @@ _current->imageFd = fd; /* Copy In ARGS & ENVS Before Cleaning Virtual Space */ - char *argv_out = 0x0; + uint32_t *argv_out = 0x0; char *args_out = 0x0; - args_copyin(&argv, &argv_out, &args_out); + kprintf("ARGV: 0x%X\n", &argv_out); - char *envp_out = 0x0; + args_copyin(argv, &argv_out, &args_out); + + uint32_t *envp_out = 0x0; char *envs_out = 0x0; - envs_copyin(&envp, &envp_out, &envs_out); + envs_copyin(envp, &envp_out, &envs_out); //! Clean the virtual of COW pages left over from the fork //vmm_cleanVirtualSpace( (uint32_t) _current->td.vm_daddr + (_current->td.vm_dsize << PAGE_SHIFT) ); @@ -518,10 +526,10 @@ vmm_cleanVirtualSpace((uint32_t) 0x8048000); /* Load ELF Header */ - if ((binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr))) == 0x0) + if ((binaryHeader = (Elf_Ehdr *) kmalloc(sizeof(Elf_Ehdr))) == 0x0) K_PANIC("MALLOC FAILED"); - fread(binaryHeader, sizeof(Elf32_Ehdr), 1, fd); + fread(binaryHeader, sizeof(Elf_Ehdr), 1, fd); /* Done Loading ELF Header */ /* Check If App Is A Real Application */ @@ -548,7 +556,7 @@ td->abi = binaryHeader->e_ident[EI_OSABI]; /* Load The Program Header(s) */ - if ((programHeader = (Elf32_Phdr *) kmalloc(sizeof(Elf32_Phdr) * binaryHeader->e_phnum)) == 0x0) + if ((programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum)) == 0x0) K_PANIC("MALLOC FAILED"); assert(programHeader); @@ -558,7 +566,7 @@ /* Done Loading Program Header(s) */ /* Load The Section Header(s) */ - if ((sectionHeader = (Elf32_Shdr *) kmalloc(sizeof(Elf32_Shdr) * binaryHeader->e_shnum)) == 0x0) + if ((sectionHeader = (Elf_Shdr *) kmalloc(sizeof(Elf_Shdr) * binaryHeader->e_shnum)) == 0x0) K_PANIC("MALLOC FAILED"); assert(sectionHeader); @@ -567,6 +575,7 @@ /* Done Loading Section Header(s) */ ef = kmalloc(sizeof(struct elf_file)); + memset(ef, 0x0, sizeof(struct elf_file)); /* Loop Through The Header And Load Sections Which Need To Be Loaded */ for (i = 0; i < binaryHeader->e_phnum; i++) { @@ -631,7 +640,7 @@ case PT_DYNAMIC: //newLoc = (char *)programHeader[i].phVaddr; //elfDynamicS = (elfDynamic *) programHeader[i].p_vaddr; - ef->dynamic = (Elf32_Dyn *) programHeader[i].p_vaddr; + ef->dynamic = (Elf_Dyn *) programHeader[i].p_vaddr; //fseek( fd, programHeader[i].phOffset, 0 ); //fread( (void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, fd ); break; @@ -641,13 +650,14 @@ fseek(fd, programHeader[i].p_offset, 0); fread((void *) interp, programHeader[i].p_filesz, 1, fd); kprintf("Interp: [%s]\n", interp); - //ldAddr = ldEnable(); - ef->ld_addr = ldEnable(); + ldAddr = ldEnable(); + //ef->ld_addr = ldEnable(); break; case PT_GNU_STACK: - break; + asm("nop"); + break; default: - break; + break; } } @@ -658,34 +668,30 @@ kprintf("Done Looping\n"); + ef->preloaded = 1; + ef->address = 0x0; elf_parse_dynamic(ef); - /* - _current->td.vm_dsize = seg_size >> PAGE_SHIFT; - _current->td.vm_daddr = (char *) seg_addr; - */ - + //asm("cld"); + //irqDisable(0); iFrame = (struct i386_frame *) (_current->tss.esp0 - sizeof(struct i386_frame)); - /* - iFrameNew = (struct i386_frame *) kmalloc( sizeof(struct i386_frame) ); - memcpy( iFrameNew, iFrame, sizeof(struct i386_frame) ); - */ + //iFrame->ebp = 0x0; - //! Adjust iframe -// iFrame = (struct i386_frame *) (_current->tss.esp0 - sizeof(struct i386_frame)); - //kprintf( "EBP-1(%i): EBP: [0x%X], EIP: [0x%X], ESP: [0x%X]\n", _current->id, iFrame->ebp, iFrame->eip, iFrame->user_esp ); - argc = 1; + if (ldAddr != 0x0) { + iFrame->eip = ldAddr; + kprintf("DYN"); + } + else { + iFrame->eip = binaryHeader->e_entry; + kprintf("STATIC"); + } - iFrame->ebp = 0x0; //STACK_ADDR; - iFrame->eip = binaryHeader->e_entry; - iFrame->edx = 0x0; - //iFrame->user_esp = ((uint32_t) STACK_ADDR) - ((sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2)); - //iFrame->user_esp = ((uint32_t) STACK_ADDR) - (128); //(sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2)); + //iFrame->edx = 0x0; - iFrame->user_esp = STACK_ADDR - ARGV_PAGE - ENVP_PAGE - ELF_AUX - (argc + 1) - (envc + 1) - STACK_PAD; + iFrame->user_esp = (uint32_t)STACK_ADDR - ARGV_PAGE - ENVP_PAGE - ELF_AUX - (argc + 1) - (envc + 1) - STACK_PAD; - tmp = (void *) iFrame->user_esp; //MrOlsen 2017-11-14 iFrame->user_ebp; + tmp = (uint32_t *)iFrame->user_esp; memset((char *) tmp, 0x0, ARGV_PAGE + ENVP_PAGE + ELF_AUX + (argc + 1) + (envc + 1) + STACK_PAD); @@ -694,30 +700,84 @@ uint32_t sp = 0x0; for (i = 1; i <= argc; i++) { - tmp[i] = STACK_ADDR - ARGV_PAGE + sp; - strcpy(tmp[i], argv_out[i]); + tmp[i] = (uint32_t)STACK_ADDR - ARGV_PAGE + sp; + strcpy((char *)tmp[i], (char *)argv_out[i]); sp += strlen(argv_out[i]) + 1; } - tmp[i++] = 0x0; - kfree(*argv_out); - kfree(*args_out); + tmp[i++] = (char *)0x0; + + kfree(argv_out); + kfree(args_out); sp = 0; + + x = 0; - for (int x = 0; x < envc; x++) { - tmp[x + i] = STACK_ADDR - ARGV_PAGE - ENVP_PAGE + sp; - strcpy(tmp[x + i], envp_out[x]); + for (x = 0; x < envc; x++) { + tmp[x + i] = (uint32_t)STACK_ADDR - ARGV_PAGE - ENVP_PAGE + sp; + strcpy((char *)tmp[x + i], (char *)envp_out[x]); sp += strlen(envp_out[x]) + 1; } - tmp[i + x] = 0x0; - kfree(*envp_out); - kfree(*envs_out); + tmp[i + x] = (char *)0x0; + + kfree(envp_out); + kfree(envs_out); + + i = i+ x + 1; + + tmp[i++] = 2; + tmp[i++] = -1;// _current->imageFd; + kprintf("AT_EXECFD: [%i]", tmp[i-1]); + + tmp[i++] = 3; + tmp[i++] = binaryHeader->e_phoff + 0x08048000; + kprintf("AT_PHDR: [0x%X]", tmp[i-1]); + + tmp[i++] = 4; + tmp[i++] = binaryHeader->e_phentsize; + kprintf("AT_PHENT: [0x%X]", tmp[i-1]); + + tmp[i++] = 5; + tmp[i++] = binaryHeader->e_phnum; + kprintf("AT_PHNUM: [0x%X]", tmp[i-1]); + + tmp[i++] = 6; + tmp[i++] = 0x1000; + + tmp[i++] = 7; + tmp[i++] = 0x0;//LD_START; + kprintf("AT_BASE: [0x%X]", tmp[i-1]); + + tmp[i++] = 8; + tmp[i++] = 0x0; + + tmp[i++] = 9; + tmp[i++] = binaryHeader->e_entry; + + tmp[i++] = 11; + tmp[i++] = 0x0; + + tmp[i++] = 12; + tmp[i++] = 0x0; + + tmp[i++] = 13; + tmp[i++] = 0x0; + + tmp[i++] = 14; + tmp[i++] = 0x0; + + tmp[i++] = 0; + tmp[i++] = 0; + /* Now That We Relocated The Binary We Can Unmap And Free Header Info */ kfree(binaryHeader); kfree(programHeader); + //irqEnable(0); + //asm("sti"); + /* _current->tss.es = 0x30 + 3; @@ -769,7 +829,7 @@ case DT_HASH: asm("nop"); /* From src/libexec/rtld-elf/rtld.c */ - const Elf32_Hashelt *hashtab = (const Elf32_Hashelt *) (ef->address + dynp->d_un.d_ptr); + const Elf_Hashelt *hashtab = (const Elf_Hashelt *) (ef->address + dynp->d_un.d_ptr); ef->nbuckets = hashtab[0]; ef->nchains = hashtab[1]; ef->buckets = hashtab + 2; @@ -782,36 +842,36 @@ ef->strsz = dynp->d_un.d_val; break; case DT_SYMTAB: - ef->symtab = (Elf32_Sym *) (ef->address + dynp->d_un.d_ptr); + ef->symtab = (Elf_Sym *) (ef->address + dynp->d_un.d_ptr); break; case DT_SYMENT: if (dynp->d_un.d_val != sizeof(Elf32_Sym)) return (ENOEXEC); break; case DT_REL: - ef->rel = (const Elf32_Rel *) (ef->address + dynp->d_un.d_ptr); + ef->rel = (const Elf_Rel *) (ef->address + dynp->d_un.d_ptr); break; case DT_RELSZ: ef->relsize = dynp->d_un.d_val; break; case DT_RELENT: - if (dynp->d_un.d_val != sizeof(Elf32_Rel)) + if (dynp->d_un.d_val != sizeof(Elf_Rel)) return (ENOEXEC); break; case DT_JMPREL: - ef->pltrel = (const Elf32_Rel *) (ef->address + dynp->d_un.d_ptr); + ef->pltrel = (const Elf_Rel *) (ef->address + dynp->d_un.d_ptr); break; case DT_PLTRELSZ: ef->pltrelsize = dynp->d_un.d_val; break; case DT_RELA: - ef->rela = (const Elf32_Rela *) (ef->address + dynp->d_un.d_ptr); + ef->rela = (const Elf_Rela *) (ef->address + dynp->d_un.d_ptr); break; case DT_RELASZ: ef->relasize = dynp->d_un.d_val; break; case DT_RELAENT: - if (dynp->d_un.d_val != sizeof(Elf32_Rela)) + if (dynp->d_un.d_val != sizeof(Elf_Rela)) return (ENOEXEC); break; case DT_PLTREL: @@ -820,14 +880,12 @@ return (ENOEXEC); break; case DT_PLTGOT: - ef->got = (Elf32_Addr *) (ef->address + dynp->d_un.d_ptr); + ef->got = (Elf_Addr *) (ef->address + dynp->d_un.d_ptr); + /* tmp = (void *) dynp->d_un.d_ptr; //elfDynamicS[i].dynPtr; - if (tmp == 0x0) - kpanic("tmp: NULL\n"); - else - kprintf("PLT[0x%X:0x%X]", tmp, ef->ld_addr); tmp[2] = (uInt32) ef->ld_addr; tmp[1] = (uInt32) ef; //0x0;//0xBEEFEAD;//STACK_ADDR - 128;//_current->imageFd;//0xBEEFDEAD;//ef; + */ break; default: asm("nop"); @@ -835,10 +893,13 @@ break; } } - ef->pltrela = (const Elf32_Rela *) ef->pltrel; + + if (plttype == DT_RELA) { + ef->pltrela = (const Elf_Rela *) ef->pltrel; ef->pltrel = NULL; ef->pltrelasize = ef->pltrelsize; ef->pltrelsize = 0; + } ef->ddbsymtab = ef->symtab; ef->ddbsymcnt = ef->nchains; diff --git a/sys/i386/sched.c b/sys/i386/sched.c index e808666..9488039 100644 --- a/sys/i386/sched.c +++ b/sys/i386/sched.c @@ -31,6 +31,7 @@ #include #include #include +#include #include #include #include @@ -55,6 +56,8 @@ static struct spinLock schedulerSpinLock = SPIN_LOCK_INITIALIZER; +int need_resched = 0; + /************************************************************************ Function: int sched_init() @@ -294,7 +297,88 @@ return (0x0); } -/*** - END - ***/ +void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait) +{ + unsigned long flags; + save_flags(flags); + cli(); + if (!*p) { + wait->next = wait; + *p = wait; + } else { + wait->next = (*p)->next; + (*p)->next = wait; + } + restore_flags(flags); +} + +void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait) { + unsigned long flags; + struct wait_queue * tmp; + + save_flags(flags); + cli(); + if ((*p == wait) && + ((*p = wait->next) == wait)) { + *p = NULL; + } else { + tmp = wait; + while (tmp->next != wait) { + tmp = tmp->next; + } + tmp->next = wait->next; + } + wait->next = NULL; + restore_flags(flags); +} + +void wake_up_interruptible(struct wait_queue **q) { + struct wait_queue *tmp; + kTask_t *p; + + if (!q || !(tmp = *q)) + return; + do { + if ((p = tmp->task) != NULL) { + if (p->state == INTERRUPTIBLE) { + p->state = RUNNING; + if (p->counter > _current->counter) + need_resched = 1; + } + } + if (!tmp->next) { + kprintf("wait_queue is bad (eip = %08lx)\n", ((unsigned long *) q)[-1]); + kprintf(" q = %p\n", q); + kprintf(" *q = %p\n", *q); + kprintf(" tmp = %p\n", tmp); + break; + } + tmp = tmp->next; + } while (tmp != *q); +} + +void wake_up(struct wait_queue **q) { + struct wait_queue *tmp; + kTask_t * p; + + if (!q || !(tmp = *q)) + return; + do { + if ((p = tmp->task) != NULL) { + if ((p->state == UNINTERRUPTIBLE) || (p->state == INTERRUPTIBLE)) { + p->state = RUNNING; + if (p->counter > _current->counter) + need_resched = 1; + } + } + if (!tmp->next) { + kprintf("wait_queue is bad (eip = %08lx)\n", ((unsigned long *) q)[-1]); + kprintf(" q = %p\n", q); + kprintf(" *q = %p\n", *q); + kprintf(" tmp = %p\n", tmp); + break; + } + tmp = tmp->next; + } while (tmp != *q); +} diff --git a/sys/i386/trap.c b/sys/i386/trap.c index 17ced12..d6e81e8 100644 --- a/sys/i386/trap.c +++ b/sys/i386/trap.c @@ -183,6 +183,8 @@ cr2 = rcr2(); kprintf("trap_code: %i(0x%X), EIP: 0x%X, CR2: 0x%X\n", frame->tf_trapno, frame->tf_trapno, frame->tf_eip, cr2); + + //kpanic("trap_code: %i(0x%X), EIP: 0x%X, CR2: 0x%X\n", frame->tf_trapno, frame->tf_trapno, frame->tf_eip, cr2); die_if_kernel("trapCode", frame, frame->tf_trapno); endTask( _current->id ); sched_yield(); diff --git a/sys/include/fs/msdos_fs.h b/sys/include/fs/msdos_fs.h new file mode 100644 index 0000000..372bbe0 --- /dev/null +++ b/sys/include/fs/msdos_fs.h @@ -0,0 +1,43 @@ +#ifndef _FS_MSDOS_FS_H +#define _FS_MSDOS_FS_H + +/* + * MS-DOS file system in-core superblock data + */ + +struct msdos_sb_info { + unsigned short cluster_size; /* sectors/cluster */ + unsigned char fats, fat_bits; /* number of FATs, FAT bits (12 or 16) */ + unsigned short fat_start, fat_length; /* FAT start & length (sec.) */ + unsigned short dir_start, dir_entries; /* root dir start & entries */ + unsigned short data_start; /* first data sector */ + unsigned long clusters; /* number of clusters */ + uid_t fs_uid; + gid_t fs_gid; + int quiet; /* fake successful chmods and chowns */ + unsigned short fs_umask; + unsigned char name_check; /* r = relaxed, n = normal, s = strict */ + unsigned char conversion; /* b = binary, t = text, a = auto */ + struct wait_queue *fat_wait; + int fat_lock; + int prev_free; /* previously returned free cluster number */ + int free_clusters; /* -1 if undefined */ +}; + +/* + * MS-DOS file system inode data in memory + */ + +struct msdos_inode_info { + int i_start; /* first cluster or 0 */ + int i_attrs; /* unused attribute bits */ + int i_busy; /* file is either deleted but still open, or + inconsistent (mkdir) */ + struct inode *i_depend; /* pointer to inode that depends on the + current inode */ + struct inode *i_old; /* pointer to the old inode this inode + depends on */ + int i_binary; /* file contains non-text data */ +}; + +#endif diff --git a/sys/include/fs/pipe_fs.h b/sys/include/fs/pipe_fs.h new file mode 100644 index 0000000..d87f50a --- /dev/null +++ b/sys/include/fs/pipe_fs.h @@ -0,0 +1,35 @@ +#ifndef _FS_PIPE_FS_H +#define _FS_PIPE_FS_H + +struct pipe_inode_info { + struct wait_queue *wait; + char *base; + unsigned int start; + unsigned int len; + unsigned int lock; + unsigned int rd_openers; + unsigned int wr_openers; + unsigned int readers; + unsigned int writers; +}; + +#define PIPE_WAIT(inode) ((inode).u.pipe_i.wait) +#define PIPE_BASE(inode) ((inode).u.pipe_i.base) +#define PIPE_START(inode) ((inode).u.pipe_i.start) +#define PIPE_LEN(inode) ((inode).u.pipe_i.len) +#define PIPE_RD_OPENERS(inode) ((inode).u.pipe_i.rd_openers) +#define PIPE_WR_OPENERS(inode) ((inode).u.pipe_i.wr_openers) +#define PIPE_READERS(inode) ((inode).u.pipe_i.readers) +#define PIPE_WRITERS(inode) ((inode).u.pipe_i.writers) +#define PIPE_LOCK(inode) ((inode).u.pipe_i.lock) +#define PIPE_SIZE(inode) PIPE_LEN(inode) + +#define PIPE_EMPTY(inode) (PIPE_SIZE(inode)==0) +#define PIPE_FULL(inode) (PIPE_SIZE(inode)==PIPE_BUF) +#define PIPE_FREE(inode) (PIPE_BUF - PIPE_LEN(inode)) +#define PIPE_END(inode) ((PIPE_START(inode)+PIPE_LEN(inode))&\ + (PIPE_BUF-1)) +#define PIPE_MAX_RCHUNK(inode) (PIPE_BUF - PIPE_START(inode)) +#define PIPE_MAX_WCHUNK(inode) (PIPE_BUF - PIPE_END(inode)) + +#endif diff --git a/sys/include/sys/elf.h b/sys/include/sys/elf.h index 16235a1..2cb4336 100644 --- a/sys/include/sys/elf.h +++ b/sys/include/sys/elf.h @@ -71,8 +71,6 @@ Elf_Addr pcpu_start; /* Pre-relocation pcpu set start. */ Elf_Addr pcpu_stop; /* Pre-relocation pcpu set stop. */ Elf_Addr pcpu_base; /* Relocated pcpu set address. */ - Elf_Addr ld_addr; // Entry Point Of Linker (Load It Too) - uint32_t fd; } *elf_file_t; #endif diff --git a/sys/include/sys/kern_descrip.h b/sys/include/sys/kern_descrip.h index bfcddfa..66a0b10 100644 --- a/sys/include/sys/kern_descrip.h +++ b/sys/include/sys/kern_descrip.h @@ -34,6 +34,7 @@ #include #include +#include typedef __mode_t mode_t; typedef __nlink_t nlink_t; @@ -96,12 +97,14 @@ fileDescriptor *fd; }; +#ifdef _BALLS /* TEMP */ struct __timespec { __time_t tv_sec; /* seconds */ long tv_nsec; /* and nanoseconds */ }; + struct stat { __dev_t st_dev; /* inode's device */ ino_t st_ino; /* inode's number */ @@ -147,6 +150,7 @@ unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec)); #endif }; +#endif int fcntl(struct thread *, struct fcntl_args *); diff --git a/sys/include/sys/sysproto.h b/sys/include/sys/sysproto.h index a7e433b..cf68ae1 100644 --- a/sys/include/sys/sysproto.h +++ b/sys/include/sys/sysproto.h @@ -308,7 +308,7 @@ struct getpid_args { register_t dummy; }; -struct issetugid_args { +struct sys_issetugid_args { register_t dummy; }; struct fcntl_args { @@ -376,6 +376,15 @@ char pos_r_[PADR_( off_t )]; }; +struct sys_lstat_args { + char path_l_[PADL_(char *)]; + char *path; + char path_r_[PADR_(char *)]; + char sb_l_[PADL_( struct stat *)]; + struct stat *sb; + char sb_r_[PADR_( struct stat *)]; +}; + struct obreak_args { char nsize_l_[PADL_( char * )]; char * nsize; @@ -489,11 +498,15 @@ int sys_mmap( struct thread *td, struct sys_mmap_args * ); int sys_sysctl( struct thread *td, struct sys_sysctl_args * ); +int sys_issetugid(struct thread *td, struct sys_issetugid_args * ); + int setitimer( struct thread *td, struct setitimer_args *uap ); int access( struct thread *td, struct access_args *uap ); int fstatfs( struct thread *td, struct fstatfs_args *uap ); int mprotect( struct thread *td, struct mprotect_args *uap ); +int sys_lstat(struct thread *td, struct sys_lstat_args * ); + #endif /*** diff --git a/sys/include/ubixos/errno.h b/sys/include/ubixos/errno.h new file mode 100644 index 0000000..29d909b --- /dev/null +++ b/sys/include/ubixos/errno.h @@ -0,0 +1,180 @@ +/** + * @file + * Posix Errno defines + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT + * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef _UBIXOS_ERRNO_H +#define _UBIXOS_ERRNO_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define EPERM 1 /* Operation not permitted */ +#define ENOENT 2 /* No such file or directory */ +#define ESRCH 3 /* No such process */ +#define EINTR 4 /* Interrupted system call */ +#define EIO 5 /* I/O error */ +#define ENXIO 6 /* No such device or address */ +#define E2BIG 7 /* Arg list too long */ +#define ENOEXEC 8 /* Exec format error */ +#define EBADF 9 /* Bad file number */ +#define ECHILD 10 /* No child processes */ +#define EAGAIN 11 /* Try again */ +#define ENOMEM 12 /* Out of memory */ +#define EACCES 13 /* Permission denied */ +#define EFAULT 14 /* Bad address */ +#define ENOTBLK 15 /* Block device required */ +#define EBUSY 16 /* Device or resource busy */ +#define EEXIST 17 /* File exists */ +#define EXDEV 18 /* Cross-device link */ +#define ENODEV 19 /* No such device */ +#define ENOTDIR 20 /* Not a directory */ +#define EISDIR 21 /* Is a directory */ +#define EINVAL 22 /* Invalid argument */ +#define ENFILE 23 /* File table overflow */ +#define EMFILE 24 /* Too many open files */ +#define ENOTTY 25 /* Not a typewriter */ +#define ETXTBSY 26 /* Text file busy */ +#define EFBIG 27 /* File too large */ +#define ENOSPC 28 /* No space left on device */ +#define ESPIPE 29 /* Illegal seek */ +#define EROFS 30 /* Read-only file system */ +#define EMLINK 31 /* Too many links */ +#define EPIPE 32 /* Broken pipe */ +#define EDOM 33 /* Math argument out of domain of func */ +#define ERANGE 34 /* Math result not representable */ +#define EDEADLK 35 /* Resource deadlock would occur */ +#define ENAMETOOLONG 36 /* File name too long */ +#define ENOLCK 37 /* No record locks available */ +#define ENOSYS 38 /* Function not implemented */ +#define ENOTEMPTY 39 /* Directory not empty */ +#define ELOOP 40 /* Too many symbolic links encountered */ +#define EWOULDBLOCK EAGAIN /* Operation would block */ +#define ENOMSG 42 /* No message of desired type */ +#define EIDRM 43 /* Identifier removed */ +#define ECHRNG 44 /* Channel number out of range */ +#define EL2NSYNC 45 /* Level 2 not synchronized */ +#define EL3HLT 46 /* Level 3 halted */ +#define EL3RST 47 /* Level 3 reset */ +#define ELNRNG 48 /* Link number out of range */ +#define EUNATCH 49 /* Protocol driver not attached */ +#define ENOCSI 50 /* No CSI structure available */ +#define EL2HLT 51 /* Level 2 halted */ +#define EBADE 52 /* Invalid exchange */ +#define EBADR 53 /* Invalid request descriptor */ +#define EXFULL 54 /* Exchange full */ +#define ENOANO 55 /* No anode */ +#define EBADRQC 56 /* Invalid request code */ +#define EBADSLT 57 /* Invalid slot */ + +#define EDEADLOCK EDEADLK + +#define EBFONT 59 /* Bad font file format */ +#define ENOSTR 60 /* Device not a stream */ +#define ENODATA 61 /* No data available */ +#define ETIME 62 /* Timer expired */ +#define ENOSR 63 /* Out of streams resources */ +#define ENONET 64 /* Machine is not on the network */ +#define ENOPKG 65 /* Package not installed */ +#define EREMOTE 66 /* Object is remote */ +#define ENOLINK 67 /* Link has been severed */ +#define EADV 68 /* Advertise error */ +#define ESRMNT 69 /* Srmount error */ +#define ECOMM 70 /* Communication error on send */ +#define EPROTO 71 /* Protocol error */ +#define EMULTIHOP 72 /* Multihop attempted */ +#define EDOTDOT 73 /* RFS specific error */ +#define EBADMSG 74 /* Not a data message */ +#define EOVERFLOW 75 /* Value too large for defined data type */ +#define ENOTUNIQ 76 /* Name not unique on network */ +#define EBADFD 77 /* File descriptor in bad state */ +#define EREMCHG 78 /* Remote address changed */ +#define ELIBACC 79 /* Can not access a needed shared library */ +#define ELIBBAD 80 /* Accessing a corrupted shared library */ +#define ELIBSCN 81 /* .lib section in a.out corrupted */ +#define ELIBMAX 82 /* Attempting to link in too many shared libraries */ +#define ELIBEXEC 83 /* Cannot exec a shared library directly */ +#define EILSEQ 84 /* Illegal byte sequence */ +#define ERESTART 85 /* Interrupted system call should be restarted */ +#define ESTRPIPE 86 /* Streams pipe error */ +#define EUSERS 87 /* Too many users */ +#define ENOTSOCK 88 /* Socket operation on non-socket */ +#define EDESTADDRREQ 89 /* Destination address required */ +#define EMSGSIZE 90 /* Message too long */ +#define EPROTOTYPE 91 /* Protocol wrong type for socket */ +#define ENOPROTOOPT 92 /* Protocol not available */ +#define EPROTONOSUPPORT 93 /* Protocol not supported */ +#define ESOCKTNOSUPPORT 94 /* Socket type not supported */ +#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */ +#define EPFNOSUPPORT 96 /* Protocol family not supported */ +#define EAFNOSUPPORT 97 /* Address family not supported by protocol */ +#define EADDRINUSE 98 /* Address already in use */ +#define EADDRNOTAVAIL 99 /* Cannot assign requested address */ +#define ENETDOWN 100 /* Network is down */ +#define ENETUNREACH 101 /* Network is unreachable */ +#define ENETRESET 102 /* Network dropped connection because of reset */ +#define ECONNABORTED 103 /* Software caused connection abort */ +#define ECONNRESET 104 /* Connection reset by peer */ +#define ENOBUFS 105 /* No buffer space available */ +#define EISCONN 106 /* Transport endpoint is already connected */ +#define ENOTCONN 107 /* Transport endpoint is not connected */ +#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */ +#define ETOOMANYREFS 109 /* Too many references: cannot splice */ +#define ETIMEDOUT 110 /* Connection timed out */ +#define ECONNREFUSED 111 /* Connection refused */ +#define EHOSTDOWN 112 /* Host is down */ +#define EHOSTUNREACH 113 /* No route to host */ +#define EALREADY 114 /* Operation already in progress */ +#define EINPROGRESS 115 /* Operation now in progress */ +#define ESTALE 116 /* Stale NFS file handle */ +#define EUCLEAN 117 /* Structure needs cleaning */ +#define ENOTNAM 118 /* Not a XENIX named type file */ +#define ENAVAIL 119 /* No XENIX semaphores available */ +#define EISNAM 120 /* Is a named type file */ +#define EREMOTEIO 121 /* Remote I/O error */ +#define EDQUOT 122 /* Quota exceeded */ + +#define ENOMEDIUM 123 /* No medium found */ +#define EMEDIUMTYPE 124 /* Wrong medium type */ + +#ifndef errno +extern int errno; +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_ERRNO_H */ diff --git a/sys/include/ubixos/sched.h b/sys/include/ubixos/sched.h index 229fe6c..f47e351 100644 --- a/sys/include/ubixos/sched.h +++ b/sys/include/ubixos/sched.h @@ -31,14 +31,17 @@ #define _SCHED_H #include -//#include #include #include #include #include +#include + +#define NOGROUP -1 +#define NGROUPS 32 typedef enum { - PLACEHOLDER = -2, DEAD = -1, NEW = 0, READY = 1, RUNNING = 2, IDLE = 3, FORK = 4, WAIT = 5 + PLACEHOLDER = -2, DEAD = -1, NEW = 0, READY = 1, RUNNING = 2, IDLE = 3, FORK = 4, WAIT = 5, UNINTERRUPTIBLE = 6, INTERRUPTIBLE = 7 } tState; struct osInfo { @@ -64,9 +67,16 @@ tState state; uint32_t gid; uint32_t uid; + uint16_t euid, suid; + uint16_t egid, sgid; uInt16 usedMath; tty_term *term; struct thread td; + struct inode *pwd; + struct inode *root; + struct inode *exec; + uint32_t counter; + uint16_t groups[NGROUPS]; } kTask_t; int sched_init(); @@ -85,96 +95,3 @@ extern kTask_t *_usedMath; #endif - -/*** - $Log: sched.h,v $ - Revision 1.3 2006/12/15 15:43:46 reddawg - Changes - - Revision 1.2 2006/10/27 16:42:42 reddawg - Testing - - Revision 1.1.1.1 2006/06/01 12:46:14 reddawg - ubix2 - - Revision 1.2 2005/10/12 00:13:37 reddawg - Removed - - Revision 1.1.1.1 2005/09/26 17:23:55 reddawg - no message - - Revision 1.30 2004/09/11 22:21:11 reddawg - oInfo.cwd is now an array no longer a pointer.. - - Revision 1.29 2004/09/08 23:19:58 reddawg - hmm - - Revision 1.28 2004/09/08 22:16:02 reddawg - Fixens - - Revision 1.27 2004/09/08 21:19:32 reddawg - All good now - - Revision 1.26 2004/09/07 21:54:38 reddawg - ok reverted back to old scheduling for now.... - - Revision 1.20 2004/08/09 12:58:05 reddawg - let me know when you got the surce - - Revision 1.19 2004/08/06 22:43:04 reddawg - ok - - Revision 1.18 2004/08/06 22:32:16 reddawg - Ubix Works Again - - Revision 1.16 2004/08/04 08:17:57 reddawg - tty: we have primative ttys try f1-f5 so it is easier to use and debug - ubixos - - Revision 1.15 2004/07/29 21:32:16 reddawg - My quick lunchs breaks worth of updates.... - - Revision 1.14 2004/07/21 17:15:02 reddawg - removed garbage - - Revision 1.13 2004/07/21 14:43:14 flameshadow - add: added cwc (current working container) to the osInfo strut - - Revision 1.12 2004/07/19 02:32:21 reddawg - sched: we now set task status to dead which then makes the scheduler do some clean it could be some minor overhead but i feel this is our most efficient approach right now to prevent corruption of the queues - - Revision 1.11 2004/07/19 02:08:27 reddawg - Cleaned out the rest of debuging code also temporarily disabled the ip stack to improve boot time - - Revision 1.10 2004/07/18 05:24:15 reddawg - Fixens - - Revision 1.9 2004/07/09 13:23:20 reddawg - sched: schedInit to sched_init - Adjusted initialization routines - - Revision 1.8 2004/06/22 14:02:14 solar - Added the PLACEHOLDER state for a task - - Revision 1.7 2004/06/18 13:01:47 solar - Added nice and timeSlice members to the kTask_t type - - Revision 1.6 2004/06/17 02:12:57 reddawg - Cleaned Out Dead Code - - Revision 1.5 2004/06/16 14:04:51 reddawg - Renamed a typedef - - Revision 1.4 2004/06/14 12:20:54 reddawg - notes: many bugs repaired and ld works 100% now. - - Revision 1.3 2004/05/21 15:49:13 reddawg - The os does better housekeeping now when a task is exited - - Revision 1.2 2004/05/21 15:20:00 reddawg - Cleaned up - - - END - ***/ - diff --git a/sys/include/ubixos/wait.h b/sys/include/ubixos/wait.h new file mode 100644 index 0000000..1abbef4 --- /dev/null +++ b/sys/include/ubixos/wait.h @@ -0,0 +1,24 @@ +#ifndef _UBIXOS_WAIT_H +#define _UBIXOS_WAIT_H + +#include + +struct wait_queue { + struct kTask_t *task; + struct wait_queue *next; +}; + +struct semaphore { + int sount; + struct wait_queue *wait; +}; + +#define sti() __asm__ __volatile__ ("sti": : :"memory") +#define cli() __asm__ __volatile__ ("cli": : :"memory") +#define nop() __asm__ __volatile__ ("nop") + +#define save_flags(x) __asm__ __volatile__("pushfl ; popl %0":"=r" (x): /* no input */ :"memory") + +#define restore_flags(x) __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"r" (x):"memory") + +#endif diff --git a/sys/include/vfs/stat.h b/sys/include/vfs/stat.h new file mode 100644 index 0000000..a637e14 --- /dev/null +++ b/sys/include/vfs/stat.h @@ -0,0 +1,42 @@ +#ifndef _VFS_STAT_H +#define _VFS_STAT_H + +#include + +#define STAT_LSTAT 0x00000001 + +#define STAT_NO_FOLLOW 0x00000000 +#define STAT_FOLLOW 0x00000001 + +struct __timespec { + __time_t tv_sec; /* seconds */ + long tv_nsec; /* and nanoseconds */ +}; + +struct stat { + __dev_t st_dev; /* inode's device */ + ino_t st_ino; /* inode's number */ + __mode_t st_mode; /* inode protection mode */ + __nlink_t st_nlink; /* number of hard links */ + uid_t st_uid; /* user ID of the file's owner */ + gid_t st_gid; /* group ID of the file's group */ + __dev_t st_rdev; /* device type */ + time_t st_atime; /* time of last access */ + long __st_atimensec; /* nsec of last access */ + time_t st_mtime; /* time of last data modification */ + long __st_mtimensec; /* nsec of last data modification */ + time_t st_ctime; /* time of last file status change */ + long __st_ctimensec; /* nsec of last file status change */ + off_t st_size; /* file size, in bytes */ + blkcnt_t st_blocks; /* blocks allocated for file */ + blksize_t st_blksize; /* optimal blocksize for I/O */ + fflags_t st_flags; /* user defined flags for file */ + __uint32_t st_gen; /* file generation number */ + __int32_t st_lspare; + time_t st_birthtime; /* time of file creation */ + long st_birthtimensec; /* nsec of file creation */ + unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec)); + unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec)); +}; + +#endif diff --git a/sys/include/vfs/vfs.h b/sys/include/vfs/vfs.h index 027b802..ddec899 100644 --- a/sys/include/vfs/vfs.h +++ b/sys/include/vfs/vfs.h @@ -35,6 +35,12 @@ #include #include #include +#include +#include + +#define MAY_EXEC 1 +#define MAY_WRITE 2 +#define MAY_READ 4 #define maxFd 32 #define fdAvail 1 @@ -68,13 +74,104 @@ }; +struct inode_operations { + struct file_operations * default_file_ops; + int (*create)(struct inode *, const char *, int, int, struct inode **); + int (*lookup)(struct inode *, const char *, int, struct inode **); + int (*link)(struct inode *, struct inode *, const char *, int); + int (*unlink)(struct inode *, const char *, int); + int (*symlink)(struct inode *, const char *, int, const char *); + int (*mkdir)(struct inode *, const char *, int, int); + int (*rmdir)(struct inode *, const char *, int); + int (*mknod)(struct inode *, const char *, int, int, int); + int (*rename)(struct inode *, const char *, int, struct inode *, const char *, int); + int (*readlink)(struct inode *, char *, int); + int (*follow_link)(struct inode *, struct inode *, int, int, struct inode **); + int (*bmap)(struct inode *, int); + void (*truncate)(struct inode *); + int (*permission)(struct inode *, int); +}; + /* VFS Functions */ int vfs_init(); int vfsRegisterFS(struct fileSystem); struct fileSystem *vfs_findFS(int); -#endif +#include +#include +#include -/*** - END - ***/ +struct super_operations { + void (*read_inode) (struct inode *); + int (*notify_change) (int flags, struct inode *); + void (*write_inode) (struct inode *); + void (*put_inode) (struct inode *); + void (*put_super) (struct super_block *); + void (*write_super) (struct super_block *); + void (*statfs) (struct super_block *, struct statfs *); + int (*remount_fs) (struct super_block *, int *, char *); +}; + +struct super_block { + __dev_t s_dev; + unsigned long s_blocksize; + unsigned char s_blocksize_bits; + unsigned char s_lock; + unsigned char s_rd_only; + unsigned char s_dirt; + struct super_operations *s_op; + unsigned long s_flags; + unsigned long s_magic; + unsigned long s_time; + struct inode * s_covered; + struct inode * s_mounted; + struct wait_queue * s_wait; + union { + struct msdos_sb_info msdos_sb; + struct fs ufs1_sb; + struct fs ufs2_sb; + } u; +}; + +struct inode { + __dev_t i_dev; + unsigned long i_ino; + __mode_t i_mode; + __nlink_t i_nlink; + uid_t i_uid; + gid_t i_gid; + __dev_t i_rdev; + off_t i_size; + time_t i_atime; + time_t i_mtime; + time_t i_ctime; + unsigned long i_blksize; + unsigned long i_blocks; + struct semaphore i_sem; + struct inode_operations * i_op; + struct super_block * i_sb; + struct wait_queue * i_wait; + struct file_lock * i_flock; + struct vm_area_struct * i_mmap; + struct inode * i_next, *i_prev; + struct inode * i_hash_next, *i_hash_prev; + struct inode * i_bound_to, *i_bound_by; + struct inode * i_mount; + struct socket * i_socket; + unsigned short i_count; + unsigned short i_flags; + unsigned char i_lock; + unsigned char i_dirt; + unsigned char i_pipe; + unsigned char i_seek; + unsigned char i_update; + union { + struct pipe_inode_info pipe_i; + struct msdos_inode_info msdos_i; + struct ufs1_dinode ufs1_i; + struct ufs2_dinode ufs2_i; + } u; +}; + + +#endif diff --git a/sys/kernel/access.c b/sys/kernel/access.c index 0c5d901..639b76d 100644 --- a/sys/kernel/access.c +++ b/sys/kernel/access.c @@ -75,7 +75,18 @@ return (-1); } -/*** - END - ***/ +int in_group_p(gid_t grp) +{ + int i; + if (grp == _current->egid) + return 1; + + for (i = 0; i < NGROUPS; i++) { + if (_current->groups[i] == NOGROUP) + break; + if (_current->groups[i] == grp) + return 1; + } + return 0; +} diff --git a/sys/kernel/gen_calls.c b/sys/kernel/gen_calls.c index f4efaa0..ca2372d 100644 --- a/sys/kernel/gen_calls.c +++ b/sys/kernel/gen_calls.c @@ -81,8 +81,7 @@ if ( uap->fd == 2 ) { kprintf( "stderr: %s", uap->buf ); } - - if ( uap->fd == 1 ) { + else if ( uap->fd == 1 ) { /* This is Horrible! */ in = (char *) uap->buf; buffer = kmalloc( 1024 ); @@ -103,10 +102,7 @@ return (0x0); } -int issetugid( register struct thread *td, struct issetugid_args *uap ) { -#ifdef DEBUG - kprintf("[%s:%i]",__FILE__,__LINE__); -#endif +int sys_issetugid( register struct thread *td, struct sys_issetugid_args *uap ) { td->td_retval[0] = 0; return (0); } @@ -171,10 +167,18 @@ int sys_invalid( struct thread *td, void *args ) { kprintf( "Invalid System Call #[%i], Pid: %i\n", td->frame->tf_eax, _current->id ); + //td->td_retval[0] =0; return (0); } int sys_read( struct thread *td, struct sys_read_args *args ) { + char *buf = args->buf; + kprintf("ARGS->fd: %i, NBYTE: %i\n", args->fd, args->nbyte); + buf[0] = 'C'; + buf[1] = 'A'; + buf[2] = 'T'; + buf[3] = '\0'; + td->td_retval[0] = 3; kprintf( "DUMMY FUNC FIX ME! sys_read" ); return (0); } diff --git a/sys/kernel/kern_sysctl.c b/sys/kernel/kern_sysctl.c index 2daf858..bd1d6e2 100644 --- a/sys/kernel/kern_sysctl.c +++ b/sys/kernel/kern_sysctl.c @@ -218,9 +218,9 @@ if ( tmpCtl == 0x0 ) { kprintf( "Invalid CTL\n" ); for ( i = 0x0; i < args->namelen; i++ ) - kprintf( "(%i)", args->name[i] ); + kprintf( "(%i)", (int)args->name[i] ); kprintf( "\n" ); - //endTask(_current->id); + td->td_retval[0] = -1; return (-1); } @@ -229,7 +229,7 @@ else memcpy( args->oldp, tmpCtl->value, tmpCtl->val_len ); - //td->td_retval[0] = 0x0; + td->td_retval[0] = 0x0; return (0x0); } diff --git a/sys/kernel/ld.c b/sys/kernel/ld.c index 3560f86..93e9033 100644 --- a/sys/kernel/ld.c +++ b/sys/kernel/ld.c @@ -48,7 +48,7 @@ char *dynStr = 0x0; uint32_t *reMap = 0x0; fileDescriptor *ldFd = 0x0; - Elf32_Ehdr *binaryHeader = 0x0; + Elf_Ehdr *binaryHeader = 0x0; Elf_Phdr *programHeader = 0x0; Elf_Shdr *sectionHeader = 0x0; Elf_Sym *relSymTab = 0x0; @@ -63,11 +63,13 @@ fseek(ldFd, 0x0, 0x0); binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr)); + assert(binaryHeader); fread(binaryHeader, sizeof(Elf32_Ehdr), 1, ldFd); programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum); assert(programHeader); + fseek(ldFd, binaryHeader->e_phoff, 0); fread(programHeader, sizeof(Elf_Shdr), binaryHeader->e_phnum, ldFd); diff --git a/sys/kernel/syscall_new.c b/sys/kernel/syscall_new.c index 4e2fd0a..e8ed0f7 100644 --- a/sys/kernel/syscall_new.c +++ b/sys/kernel/syscall_new.c @@ -61,7 +61,8 @@ } if ( code > totalCalls ) { - kprintf( "Invalid Call: [%i:%i]\n", frame->tf_eax, totalCalls ); + //kprintf( "Invalid Call: [%i:%i]\n", frame->tf_eax, totalCalls ); + die_if_kernel("Invalid System Call", frame, frame->tf_eax); kpanic("PID: %i", _current->id); } else if ( (uint32_t) systemCalls[code].sc_status == SYSCALL_INVALID ) { diff --git a/sys/kernel/syscalls.c b/sys/kernel/syscalls.c index c62eaf0..6c094e6 100644 --- a/sys/kernel/syscalls.c +++ b/sys/kernel/syscalls.c @@ -33,12 +33,12 @@ /* System Calls List */ struct syscall_entry systemCalls[] = { { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 0 - Invalid */ - { ARG_COUNT( sys_exit_args ), "exit", (sys_call_t *)sys_exit ,2}, - { ARG_COUNT( sys_fork_args ), "fork", (sys_call_t *)sys_fork , SYSCALL_VALID}, - { ARG_COUNT( sys_read_args ), "read", (sys_call_t *)sys_read ,2 }, + { ARG_COUNT( sys_exit_args ), "exit", (sys_call_t *)sys_exit ,2}, /* 1 - exit */ + { ARG_COUNT( sys_fork_args ), "fork", (sys_call_t *)sys_fork , SYSCALL_VALID}, /* 2 - fork */ + { ARG_COUNT( sys_read_args ), "read", (sys_call_t *)sys_read , SYSCALL_VALID}, /* 3 - read */ { ARG_COUNT( sys_write_args ), "write", (sys_call_t *)sys_write ,SYSCALL_VALID}, - { ARG_COUNT( sys_open_args ), "open", (sys_call_t *)sys_open ,2 }, - { ARG_COUNT( sys_close_args ), "close", (sys_call_t *)sys_close ,2 }, + { ARG_COUNT( sys_open_args ), "open", (sys_call_t *)sys_open , SYSCALL_DUMMY }, + { ARG_COUNT( sys_close_args ), "close", (sys_call_t *)sys_close , SYSCALL_VALID}, { ARG_COUNT( sys_wait4_args ), "wiat4", (sys_call_t *)sys_wait4 , 1}, { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 8 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 9 - Invalid */ @@ -91,7 +91,7 @@ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 56 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 57 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 58 - Invalid */ - { ARG_COUNT( sys_execve_args), "Exec VE", (sys_call_t *)sys_execve, SYSCALL_DUMMY }, /* 59 - Invalid */ + { ARG_COUNT( sys_execve_args), "Exec VE", (sys_call_t *)sys_execve, SYSCALL_DUMMY }, /* 59 - execve */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 60 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 61 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 62 - Invalid */ @@ -222,7 +222,7 @@ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 187 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 188 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 189 - Invalid */ - { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 190 - Invalid */ + { ARG_COUNT(sys_lstat_args), "LSTAT", (sys_call_t *)sys_lstat, SYSCALL_VALID }, /* 190 - sys_lstat */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 191 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 192 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 193 - Invalid */ @@ -285,7 +285,7 @@ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 250 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 251 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 252 - Invalid */ - { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 253 - Invalid */ + { ARG_COUNT(sys_issetugid_args), "ISSETUGID", (sys_call_t *)sys_issetugid, SYSCALL_VALID }, /* 253 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 254 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 255 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 256 - Invalid */ @@ -383,6 +383,165 @@ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 348 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 349 - Invalid */ { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 360 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 361 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 362 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 363 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 364 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 365 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 366 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 367 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 368 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 369 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 370 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 371 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 372 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 373 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 374 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 375 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 376 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 377 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 378 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 379 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 380 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 381 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 382 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 383 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 384 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 385 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 386 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 387 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 388 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 389 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 390 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 391 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 392 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 393 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 394 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 395 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 396 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 397 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 398 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 399 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 400 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { ARG_COUNT(sys_mmap_args), "MMAP", (sys_call_t *)sys_mmap, SYSCALL_VALID }, /* 477 - sys_mmap */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 350 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 351 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 352 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 353 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 354 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 355 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 356 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 357 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 358 - Invalid */ + { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 359 - Invalid */ }; int totalCalls = sizeof(systemCalls) / sizeof(struct syscall_entry); diff --git a/sys/vmm/Makefile b/sys/vmm/Makefile index 9b4b704..601de40 100644 --- a/sys/vmm/Makefile +++ b/sys/vmm/Makefile @@ -6,7 +6,7 @@ include ../Makefile.incl # Objects -OBJS = page_fault.o pagefault.o getfreevirtualpage.o copyvirtualspace.o setpageattributes.o unmappage.o getphysicaladdr.o getfreepage.o createvirtualspace.o vmm_memory.o paging.o vmm_init.o vmm_mmap.o +OBJS = page_fault.o pagefault.o getfreevirtualpage.o copyvirtualspace.o setpageattributes.o unmappage.o getphysicaladdr.o getfreepage.o createvirtualspace.o vmm_memory.o paging.o vmm_init.o vmm_mmap.o freevirtualpage.o all: $(OBJS) diff --git a/sys/vmm/freevirtualpage.c b/sys/vmm/freevirtualpage.c new file mode 100644 index 0000000..11dc32d --- /dev/null +++ b/sys/vmm/freevirtualpage.c @@ -0,0 +1,5 @@ +#include + +int vmm_freeVirtualPage(uint32_t addr) { + return(0); +} diff --git a/sys/vmm/paging.c b/sys/vmm/paging.c index f2f5097..e565c14 100644 --- a/sys/vmm/paging.c +++ b/sys/vmm/paging.c @@ -24,6 +24,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include #include #include #include @@ -518,53 +519,6 @@ return (0x0); } -int sys_mmap(struct thread *td, struct sys_mmap_args *uap) { - vm_offset_t addr = 0x0; - char *tmp = 0x0; - struct file *fd = 0x0; - - addr = (vm_offset_t) uap->addr; - - /* - #ifdef _VMM_DEBUG - */ - if (uap->addr != 0x0) { - kprintf("Address hints are not supported yet.\n"); - } - kprintf("uap->flags: [0x%X]\n", uap->flags); - kprintf("uap->addr: [0x%X]\n", uap->addr); - kprintf("uap->len: [0x%X]\n", uap->len); - kprintf("uap->prot: [0x%X]\n", uap->prot); - kprintf("uap->fd: [%i]\n", uap->fd); - kprintf("uap->pad: [0x%X]\n", uap->pad); - kprintf("uap->pos: [0x%X]\n", uap->pos); - /* - #endif - */ - - if (uap->fd == -1) { - //td->td_retval[0] = (int) vmm_getFreeVirtualPage( _current->id, uap->len / 0x1000, VM_TASK ); - //td->td_retval[0] = (int) - return (vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD)); - } - else { - kprintf("uap->flags: [0x%X]\n", uap->flags); - kprintf("uap->addr: [0x%X]\n", uap->addr); - kprintf("uap->len: [0x%X]\n", uap->len); - kprintf("uap->prot: [0x%X]\n", uap->prot); - kprintf("uap->fd: [%i]\n", uap->fd); - kprintf("uap->pad: [0x%X]\n", uap->pad); - kprintf("uap->pos: [0x%X]\n", uap->pos); - //K_PANIC("NOT YET\n"); - getfd(td, &fd, uap->fd); - tmp = (char *) vmm_getFreeVirtualPage(_current->id, uap->len / 0x1000, VM_TASK); - fread(tmp, uap->len, 0x1, fd->fd); - - td->td_retval[0] = (int) tmp; - } - return (0x0); -} - int obreak(struct thread *td, struct obreak_args *uap) { uint32_t i = 0x0; vm_offset_t old = 0x0; diff --git a/sys/vmm/vmm_mmap.c b/sys/vmm/vmm_mmap.c index e8f8456..158be12 100644 --- a/sys/vmm/vmm_mmap.c +++ b/sys/vmm/vmm_mmap.c @@ -28,14 +28,16 @@ *****************************************************************************************/ #include +#include #include #include #include #include +#include /* MrOlsen (2016-01-15) TEMP: Put These somewhere else */ -typedef __uint32_t __vm_size_t; -typedef __vm_size_t vm_size_t; +typedef __uint32_t __vm_size_t; +typedef __vm_size_t vm_size_t; #define EINVAL 22 /* Invalid argument */ #define MAP_ALIGNED(n) ((n) << MAP_ALIGNMENT_SHIFT) #define MAP_ALIGNMENT_SHIFT 24 @@ -43,7 +45,6 @@ #define MAP_ALIGNED_SUPER MAP_ALIGNED(1) /* align on a superpage */ #define NBBY 8 /* number of bits in a byte */ - /* PROTs */ #define PROT_NONE 0x00 /* no permissions */ #define PROT_READ 0x01 /* pages can be read */ @@ -72,7 +73,7 @@ #define MAP_FILE 0x0000 /* map from file (default) */ #define MAP_ANON 0x1000 /* allocated from memory, swap space */ -int freebsd6_mmap( struct thread *td, struct freebsd6_mmap_args *uap ) { +int freebsd6_mmap(struct thread *td, struct freebsd6_mmap_args *uap) { vm_size_t size, pageoff; off_t pos; int align, flags, error; @@ -86,15 +87,15 @@ flags = uap->flags; pos = uap->pos; - kprintf( "uap->flags: [0x%X]\n", uap->flags ); - kprintf( "uap->addr: [0x%X]\n", uap->addr ); - kprintf( "uap->len: [0x%X]\n", uap->len ); - kprintf( "uap->prot: [0x%X]\n", uap->prot ); - kprintf( "uap->fd: [%i]\n", uap->fd ); - kprintf( "uap->pad: [0x%X]\n", uap->pad ); - kprintf( "uap->pos: [0x%X]\n", uap->pos ); + kprintf("uap->flags: [0x%X]\n", uap->flags); + kprintf("uap->addr: [0x%X]\n", uap->addr); + kprintf("uap->len: [0x%X]\n", uap->len); + kprintf("uap->prot: [0x%X]\n", uap->prot); + kprintf("uap->fd: [%i]\n", uap->fd); + kprintf("uap->pad: [0x%X]\n", uap->pad); + kprintf("uap->pos: [0x%X]\n", uap->pos); - if ( (uap->flags & MAP_ANON) != 0 ) + if ((uap->flags & MAP_ANON) != 0) pos = 0; /* @@ -107,26 +108,25 @@ /* Adjust size for rounding (on both ends). */ size += pageoff; - size = (vm_size_t) round_page( size ); + size = (vm_size_t) round_page(size); /* Ensure alignment is at least a page and fits in a pointer. */ align = flags & MAP_ALIGNMENT_MASK; - if ( align != 0 && align != MAP_ALIGNED_SUPER && (align >> MAP_ALIGNMENT_SHIFT >= sizeof(void *) * NBBY || align >> MAP_ALIGNMENT_SHIFT < PAGE_SHIFT) ) + if (align != 0 && align != MAP_ALIGNED_SUPER && (align >> MAP_ALIGNMENT_SHIFT >= sizeof(void *) * NBBY || align >> MAP_ALIGNMENT_SHIFT < PAGE_SHIFT)) return (EINVAL); - if ( flags & MAP_FIXED ) { - kprintf( "FIXED NOT SUPPORTED YET" ); + if (flags & MAP_FIXED) { + kprintf("FIXED NOT SUPPORTED YET"); return (EINVAL); - } - else { + } else { /* At Some Point I Need To Proc Lock Incase It's Threaded */ -/* MrOlsen (2016-01-15) Temporary comment out - if ( addr == 0 || (addr >= round_page( (vm_offset_t) vms->vm_taddr ) && addr < round_page( (vm_offset_t) vms->vm_daddr + lim_max( td->td_proc, RLIMIT_DATA ) )) ) - addr = round_page( (vm_offset_t) vms->vm_daddr + lim_max( td->td_proc, RLIMIT_DATA ) ); -*/ + /* MrOlsen (2016-01-15) Temporary comment out + if ( addr == 0 || (addr >= round_page( (vm_offset_t) vms->vm_taddr ) && addr < round_page( (vm_offset_t) vms->vm_daddr + lim_max( td->td_proc, RLIMIT_DATA ) )) ) + addr = round_page( (vm_offset_t) vms->vm_daddr + lim_max( td->td_proc, RLIMIT_DATA ) ); + */ } - if ( flags & MAP_ANON ) { + if (flags & MAP_ANON) { /* * Mapping blank space is trivial. */ @@ -137,21 +137,57 @@ maxprot = VM_PROT_ALL; cap_maxprot = VM_PROT_ALL; */ - for ( i = addr; i < (addr + size); i += 0x1000 ) { - if ( vmm_remapPage( vmmFindFreePage( _current->id ), i, PAGE_DEFAULT, _current->id ) == 0x0 ) - K_PANIC( "remap Failed" ); + for (i = addr; i < (addr + size); i += 0x1000) { + if (vmm_remapPage(vmm_findFreePage(_current->id), i, PAGE_DEFAULT, _current->id) == 0x0) + K_PANIC("remap Failed"); } - kprintf( "td->vm_dsize should be adjust but isn't" ); - } - else { + kprintf("td->vm_dsize should be adjust but isn't"); + } else { /* Mapping File */ - kprintf( "File Mapping Not Supported Yet" ); + kprintf("File Mapping Not Supported Yet"); return (EINVAL); } return (0x0); } +int sys_mmap(struct thread *td, struct sys_mmap_args *uap) { + vm_offset_t addr = 0x0; + char *tmp = 0x0; + struct file *fd = 0x0; + + addr = (vm_offset_t) uap->addr; + + if (uap->addr != 0x0) { + kprintf("Address hints are not supported yet.\n"); + td->td_retval[0] = 0x0; + return(-1); + } + + if (uap->fd == -1) { + //td->td_retval[0] = (int) vmm_getFreeVirtualPage( _current->id, uap->len / 0x1000, VM_TASK ); + //td->td_retval[0] = (int) + td->td_retval[0] = vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD); + return (0x0); //vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD)); + } + else { + kprintf("uap->flags: [0x%X]\n", uap->flags); + kprintf("uap->addr: [0x%X]\n", uap->addr); + kprintf("uap->len: [0x%X]\n", uap->len); + kprintf("uap->prot: [0x%X]\n", uap->prot); + kprintf("uap->fd: [%i]\n", uap->fd); + kprintf("uap->pad: [0x%X]\n", uap->pad); + kprintf("uap->pos: [0x%X]\n", uap->pos); + //K_PANIC("NOT YET\n"); + getfd(td, &fd, uap->fd); + tmp = (char *) vmm_getFreeVirtualPage(_current->id, round_page(uap->len) / 0x1000, VM_TASK); + fread(tmp, uap->len, 0x1, fd->fd); + + td->td_retval[0] = (int) tmp; + } + return (0x0); +} + /*** END ***/