/*
* Function called when user-level code hits a fatal fault.
*/
static
void
kill_curthread(vaddr_t epc, unsigned code, vaddr_t vaddr)
{
int sig = 0;
KASSERT(code < NTRAPCODES);
switch (code) {
case EX_IRQ:
sig = SIGINT;
break;
case EX_IBE:
sig = SIGBUS;
break;
case EX_DBE:
sig = SIGBUS;
break;
case EX_SYS:
/* should not be seen */
KASSERT(0);
sig = SIGABRT;
break;
case EX_MOD:
case EX_TLBL:
case EX_TLBS:
sig = SIGSEGV;
break;
case EX_ADEL:
case EX_ADES:
sig = SIGBUS;
break;
case EX_BP:
sig = SIGTRAP;
break;
case EX_RI:
sig = SIGILL;
break;
case EX_CPU:
sig = SIGSEGV;
break;
case EX_OVF:
sig = SIGFPE;
break;
}
/*
* You will probably want to change this.
*/
sys__exit(0);
kprintf("Fatal user mode trap %u sig %d (%s, epc 0x%x, vaddr 0x%x)\n",
code, sig, trapcodenames[code], epc, vaddr);
panic("I don't know how to handle this\n");
}
/*
* Function called when user-level code hits a fatal fault.
*/
static
void
kill_curthread(u_int32_t epc, unsigned code, u_int32_t vaddr)
{
assert(code<NTRAPCODES);
kprintf("Fatal user mode trap %u (%s, epc 0x%x, vaddr 0x%x)\n",
code, trapcodenames[code], epc, vaddr);
/*
* You will probably want to change this.
*/
sys__exit(code);
panic("I don't know how to handle this\n");
}
void process_command(char* string) {
prepare_shell();
if (((string != NULL) && (string[0] == '\0')) || !strlen(string))
return;
int argc;
char *sdup = strdup(string);
char **argv = buildargv(sdup, &argc);
kfree(sdup);
if (argc == 0) {
freeargv(argv);
return;
}
char* command = argv[0];
int i = findCommand(command);
if (i >= 0) {
void (*command_function)(int, char **) = (void(*)(int, char**))CommandTable[i].function;
command_function(argc, argv);
}
else {
//not a valid command
//are we trying to execute a binary?
FILE* stream = fopen(command, "r");
if (stream) {
int pid = sys_fork();
if (!pid) {
execve(command, 0, 0);
sys__exit(1);
}
else {
int status;
waitpid(pid, &status, 0);
}
}
else {
//invalid input
printf("Command '\e[9;%s\e[15;' not found.", command);
}
fclose(stream);
}
/*
* Get an empty chunk from the swap area to store a swapped out page
* We use a bitmap to describe the swap area. So, just look get an unmarked
* bit index from the swap_memmap and return the address of the chunk indexed
* by the index found. If there is no empty chunk then we are in great trouble.
* We can't handle this request, so kill the thread and exit.
*/
u_int32_t get_empty_chunk()
{
int spl=splhigh();
unsigned chunk_index;
int no_free_chunk = bitmap_alloc(swap_memmap, &chunk_index);
if(!no_free_chunk)
{
splx(spl);
return (chunk_index*PAGE_SIZE);
}
else
{
splx(spl);
kprintf("VM: Swap Space full, killing curthread");
sys__exit(0);
}
}
/* Signal handler to help us recover from dying while we are attached to
* other threads.
*/
static void SignalHandler(int signum, siginfo_t *si, void *data) {
if (sig_pids != NULL) {
if (signum == SIGABRT) {
while (sig_num_threads-- > 0) {
/* Not sure if sched_yield is really necessary here, but it does not */
/* hurt, and it might be necessary for the same reasons that we have */
/* to do so in sys_ptrace_detach(). */
sys_sched_yield();
sys_ptrace(PTRACE_KILL, sig_pids[sig_num_threads], 0, 0);
}
} else if (sig_num_threads > 0) {
ResumeAllProcessThreads(sig_num_threads, (int *)sig_pids);
}
}
sig_pids = NULL;
if (sig_marker >= 0)
NO_INTR(sys_close(sig_marker));
sig_marker = -1;
if (sig_proc >= 0)
NO_INTR(sys_close(sig_proc));
sig_proc = -1;
sys__exit(signum == SIGABRT ? 1 : 2);
}
void
mips_syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
assert(curspl==0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS_getpid:
retval = ((int32_t)sys_getpid());
err=retval;
break;
case SYS_waitpid:
//just passing the the first arg from users waitpid
err = (sys_waitpid(tf->tf_a0,&retval,0));
break;
case SYS__exit:
retval = ((int32_t)sys__exit());
err=retval;
break;
case SYS_fork:
//http://jhshi.me/2012/03/21/os161-how-to-add-a-system-call/
err = ((int32_t)sys_fork(tf));
break;
case SYS_execv:
break;
case SYS_read:
//err = ((int32_t)sys_read(tf->tf_a0,(userptr_t)tf->tf_a1,tf->tf_a2)); //original
err = ((int32_t)sys_read(tf->tf_a0,(char*)tf->tf_a1,tf->tf_a2));
break;
case SYS_write:
err = ((int32_t)sys_write(tf->tf_a0,(char*)tf->tf_a1,tf->tf_a2));
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
assert(curspl==0);
}
/**
* SPB & FAR
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno, err;
int32_t retval;
off_t pos = 0;
off_t lsret;
int whence;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0, (userptr_t)tf->tf_a1);
break;
case SYS_open:
err = sys_open((const char*)tf->tf_a0, tf->tf_a1, &retval);
break;
case SYS_read:
err = sys_read((int)tf->tf_a0,(void*)tf->tf_a1,(size_t)tf->tf_a2,&retval);
break;
case SYS_write:
err = sys_write((int)tf->tf_a0,(const void*)tf->tf_a1,(size_t)tf->tf_a2,&retval);
break;
case SYS_close:
err = sys_close((int)tf->tf_a0, &retval);
break;
case SYS_lseek:
pos |= (off_t)tf->tf_a2;
pos <<= 32; //puts a2 and a3 into one var.
pos |= (off_t)tf->tf_a3;
err = copyin((const userptr_t)tf->tf_sp+16, &whence, sizeof(whence));
if (err)
break;
err = sys_lseek((int)tf->tf_a0, pos, (int)whence, &lsret);
if(!err){
retval = lsret>>32;
tf->tf_v1 = lsret;
}
break;
case SYS_dup2:
err = sys_dup2((int)tf->tf_a0 , (int)tf->tf_a1, &retval);
break;
case SYS_chdir:
err = sys_chdir((const char*)tf->tf_a0);
break;
case SYS___getcwd:
err = sys___getcwd((char*)tf->tf_a0, (size_t)tf->tf_a1, &retval);
break;
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
case SYS__exit:
err = sys__exit((int)tf->tf_a0, &retval);
break;
case SYS_waitpid:
err = sys_waitpid((int) tf->tf_a0, (int*) tf->tf_a1, tf->tf_a2, &retval);
break;
case SYS_execv:
err = sys_execv((const char*) tf->tf_a0, (char**) tf->tf_a1, &retval);
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
static void ListerThread(struct ListerParams *args) {
int found_parent = 0;
pid_t clone_pid = sys_gettid(), ppid = sys_getppid();
char proc_self_task[80], marker_name[48], *marker_path;
const char *proc_paths[3];
const char *const *proc_path = proc_paths;
int proc = -1, marker = -1, num_threads = 0;
int max_threads = 0, sig;
struct kernel_stat marker_sb, proc_sb;
stack_t altstack;
/* Create "marker" that we can use to detect threads sharing the same
* address space and the same file handles. By setting the FD_CLOEXEC flag
* we minimize the risk of misidentifying child processes as threads;
* and since there is still a race condition, we will filter those out
* later, anyway.
*/
if ((marker = sys_socket(PF_LOCAL, SOCK_DGRAM, 0)) < 0 ||
sys_fcntl(marker, F_SETFD, FD_CLOEXEC) < 0) {
failure:
args->result = -1;
args->err = errno;
if (marker >= 0)
NO_INTR(sys_close(marker));
sig_marker = marker = -1;
if (proc >= 0)
NO_INTR(sys_close(proc));
sig_proc = proc = -1;
sys__exit(1);
}
/* Compute search paths for finding thread directories in /proc */
local_itoa(strrchr(strcpy(proc_self_task, "/proc/"), '\000'), ppid);
strcpy(marker_name, proc_self_task);
marker_path = marker_name + strlen(marker_name);
strcat(proc_self_task, "/task/");
proc_paths[0] = proc_self_task; /* /proc/$$/task/ */
proc_paths[1] = "/proc/"; /* /proc/ */
proc_paths[2] = NULL;
/* Compute path for marker socket in /proc */
local_itoa(strcpy(marker_path, "/fd/") + 4, marker);
if (sys_stat(marker_name, &marker_sb) < 0) {
goto failure;
}
/* Catch signals on an alternate pre-allocated stack. This way, we can
* safely execute the signal handler even if we ran out of memory.
*/
memset(&altstack, 0, sizeof(altstack));
altstack.ss_sp = args->altstack_mem;
altstack.ss_flags = 0;
altstack.ss_size = ALT_STACKSIZE;
sys_sigaltstack(&altstack, (const stack_t *)NULL);
/* Some kernels forget to wake up traced processes, when the
* tracer dies. So, intercept synchronous signals and make sure
* that we wake up our tracees before dying. It is the caller's
* responsibility to ensure that asynchronous signals do not
* interfere with this function.
*/
sig_marker = marker;
sig_proc = -1;
for (sig = 0; sig < sizeof(sync_signals)/sizeof(*sync_signals); sig++) {
struct kernel_sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction_ = SignalHandler;
sys_sigfillset(&sa.sa_mask);
sa.sa_flags = SA_ONSTACK|SA_SIGINFO|SA_RESETHAND;
sys_sigaction(sync_signals[sig], &sa, (struct kernel_sigaction *)NULL);
}
/* Read process directories in /proc/... */
for (;;) {
/* Some kernels know about threads, and hide them in "/proc"
* (although they are still there, if you know the process
* id). Threads are moved into a separate "task" directory. We
* check there first, and then fall back on the older naming
* convention if necessary.
*/
if ((sig_proc = proc = c_open(*proc_path, O_RDONLY|O_DIRECTORY, 0)) < 0) {
if (*++proc_path != NULL)
continue;
goto failure;
}
if (sys_fstat(proc, &proc_sb) < 0)
goto failure;
/* Since we are suspending threads, we cannot call any libc
* functions that might acquire locks. Most notably, we cannot
* call malloc(). So, we have to allocate memory on the stack,
* instead. Since we do not know how much memory we need, we
* make a best guess. And if we guessed incorrectly we retry on
* a second iteration (by jumping to "detach_threads").
*
* Unless the number of threads is increasing very rapidly, we
* should never need to do so, though, as our guestimate is very
* conservative.
*/
if (max_threads < proc_sb.st_nlink + 100)
max_threads = proc_sb.st_nlink + 100;
/* scope */ {
pid_t pids[max_threads];
int added_entries = 0;
sig_num_threads = num_threads;
sig_pids = pids;
for (;;) {
struct kernel_dirent *entry;
char buf[4096];
ssize_t nbytes = sys_getdents(proc, (struct kernel_dirent *)buf,
sizeof(buf));
if (nbytes < 0)
goto failure;
else if (nbytes == 0) {
if (added_entries) {
/* Need to keep iterating over "/proc" in multiple
* passes until we no longer find any more threads. This
* algorithm eventually completes, when all threads have
* been suspended.
*/
added_entries = 0;
sys_lseek(proc, 0, SEEK_SET);
continue;
}
break;
}
for (entry = (struct kernel_dirent *)buf;
entry < (struct kernel_dirent *)&buf[nbytes];
entry = (struct kernel_dirent *)((char *)entry+entry->d_reclen)) {
if (entry->d_ino != 0) {
const char *ptr = entry->d_name;
pid_t pid;
/* Some kernels hide threads by preceding the pid with a '.' */
if (*ptr == '.')
ptr++;
/* If the directory is not numeric, it cannot be a
* process/thread
*/
if (*ptr < '0' || *ptr > '9')
continue;
pid = local_atoi(ptr);
/* Attach (and suspend) all threads */
if (pid && pid != clone_pid) {
struct kernel_stat tmp_sb;
char fname[entry->d_reclen + 48];
strcat(strcat(strcpy(fname, "/proc/"),
entry->d_name), marker_path);
/* Check if the marker is identical to the one we created */
if (sys_stat(fname, &tmp_sb) >= 0 &&
marker_sb.st_ino == tmp_sb.st_ino) {
long i, j;
/* Found one of our threads, make sure it is no duplicate */
for (i = 0; i < num_threads; i++) {
/* Linear search is slow, but should not matter much for
* the typically small number of threads.
*/
if (pids[i] == pid) {
/* Found a duplicate; most likely on second pass */
goto next_entry;
}
}
/* Check whether data structure needs growing */
if (num_threads >= max_threads) {
/* Back to square one, this time with more memory */
NO_INTR(sys_close(proc));
goto detach_threads;
}
/* Attaching to thread suspends it */
pids[num_threads++] = pid;
sig_num_threads = num_threads;
if (sys_ptrace(PTRACE_ATTACH, pid, (void *)0,
(void *)0) < 0) {
/* If operation failed, ignore thread. Maybe it
* just died? There might also be a race
* condition with a concurrent core dumper or
* with a debugger. In that case, we will just
* make a best effort, rather than failing
* entirely.
*/
num_threads--;
sig_num_threads = num_threads;
goto next_entry;
}
while (sys_waitpid(pid, (int *)0, __WALL) < 0) {
if (errno != EINTR) {
sys_ptrace_detach(pid);
num_threads--;
sig_num_threads = num_threads;
goto next_entry;
}
}
if (sys_ptrace(PTRACE_PEEKDATA, pid, &i, &j) || i++ != j ||
sys_ptrace(PTRACE_PEEKDATA, pid, &i, &j) || i != j) {
/* Address spaces are distinct, even though both
* processes show the "marker". This is probably
* a forked child process rather than a thread.
*/
sys_ptrace_detach(pid);
num_threads--;
sig_num_threads = num_threads;
} else {
found_parent |= pid == ppid;
added_entries++;
}
}
}
}
next_entry:;
}
}
NO_INTR(sys_close(proc));
sig_proc = proc = -1;
/* If we failed to find any threads, try looking somewhere else in
* /proc. Maybe, threads are reported differently on this system.
*/
if (num_threads > 1 || !*++proc_path) {
NO_INTR(sys_close(marker));
sig_marker = marker = -1;
/* If we never found the parent process, something is very wrong.
* Most likely, we are running in debugger. Any attempt to operate
* on the threads would be very incomplete. Let's just report an
* error to the caller.
*/
if (!found_parent) {
ResumeAllProcessThreads(num_threads, pids);
sys__exit(3);
}
/* Now we are ready to call the callback,
* which takes care of resuming the threads for us.
*/
args->result = args->callback(args->parameter, num_threads,
pids, args->ap);
args->err = errno;
/* Callback should have resumed threads, but better safe than sorry */
if (ResumeAllProcessThreads(num_threads, pids)) {
/* Callback forgot to resume at least one thread, report error */
args->err = EINVAL;
args->result = -1;
}
sys__exit(0);
}
detach_threads:
/* Resume all threads prior to retrying the operation */
ResumeAllProcessThreads(num_threads, pids);
sig_pids = NULL;
num_threads = 0;
sig_num_threads = num_threads;
max_threads += 100;
}
}
}
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
uint32_t v0, v1;
off_t pos;
int whence;
//userptr_t *status;
struct stat statbuf;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1); /* the syscall ov*/
break;
case SYS_open:
err = sys_open((const_userptr_t)tf->tf_a0, tf->tf_a1, (mode_t)tf ->tf_a2, &retval);
break;
case SYS_close:
err = sys_close((tf->tf_a0),&retval);
break;
case SYS_read:
err = sys_read(tf->tf_a0, (userptr_t)tf->tf_a1, (size_t)tf -> tf_a2, &retval);
//retval = (int32_t)bytes;
break;
case SYS_write:
err = sys_write(tf->tf_a0, (userptr_t)tf->tf_a1, (size_t)tf -> tf_a2, &retval);
//retval = (int32_t)bytes;
break;
case SYS_lseek:
pos = tf->tf_a2;
pos = pos << 32;
pos += tf -> tf_a3;
err = copyin((const_userptr_t)tf->tf_sp+16,&whence,sizeof(int));
if(err)
{
break;
}
err = sys_lseek(tf->tf_a0, pos, whence, &v0, &v1);
if(err)
{
break;
}
retval = v0;
tf->tf_v1 = v1;
break;
case SYS__exit:
sys__exit(tf->tf_a0);
// We are only here because of one of 2 reasons. We tried to kill the initial thread
// while there was/were (an) immediate child(ren) of it running.
// *NOTE* I'm actually NOT sure if that's a valid reason to be here
// Second reason? Something went horribly, horribly wrong
err = 0;
break;
case SYS_dup2:
err = sys_dup2(tf->tf_a0,tf->tf_a1,&retval);
break;
case SYS_fstat:
err = sys_fstat(tf->tf_a0, &statbuf);
break;
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
case SYS_waitpid:
err = sys_waitpid(tf->tf_a0, (int*)tf->tf_a1, (int)tf->tf_a2, &retval);
break;
case SYS___getcwd:
err = sys___getcwd((char*)tf->tf_a0,(size_t)tf->tf_a1,&retval);
break;
case SYS_chdir:
err = sys_chdir((char*)tf->tf_a0,&retval);
break;
case SYS_execv:
err = sys_execv((const char*)tf->tf_a0, (char**)tf->tf_a1);
break;
case SYS_sbrk:
err = sbrk((int)tf->tf_a0,&retval);
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
/* call functions based on the call number. */
void
mips_syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
assert(curspl==0);
callno = tf->tf_v0; // the system call number is
//passed in the v0 register.
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS_execv:
// err = sys_execv_(tf);
err = sys_execv(tf->tf_a0, tf->tf_a1);
break;
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_waitpid:
err = sys_waitpid(tf->tf_a0,tf->tf_a1, &retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
case SYS__exit:
err = sys__exit(tf->tf_a0, &retval);
break;
case SYS_read:
err = sys_read(tf, &retval);
break;
case SYS_write:
// err = sys_write(tf, &retval);
err = sys_write(tf->tf_a0, tf->tf_a1, tf->tf_a2, &retval);
break;
case SYS_sbrk:
err = sys_sbrk(tf->tf_a0, &retval);
break;
/* Add stuff here */
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
assert(curspl==0);
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
/* note the casts to userptr_t */
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
/* process calls */
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_execv:
err = sys_execv(
(userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
case SYS__exit:
sys__exit(tf->tf_a0);
panic("Returning from exit\n");
case SYS_waitpid:
err = sys_waitpid(
tf->tf_a0,
(userptr_t)tf->tf_a1,
tf->tf_a2,
&retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
/* file calls */
case SYS_open:
err = sys_open(
(userptr_t)tf->tf_a0,
tf->tf_a1,
tf->tf_a2,
&retval);
break;
case SYS_dup2:
err = sys_dup2(
tf->tf_a0,
tf->tf_a1,
&retval);
break;
case SYS_close:
err = sys_close(tf->tf_a0);
break;
case SYS_read:
err = sys_read(
tf->tf_a0,
(userptr_t)tf->tf_a1,
tf->tf_a2,
&retval);
break;
case SYS_write:
err = sys_write(
tf->tf_a0,
(userptr_t)tf->tf_a1,
tf->tf_a2,
&retval);
break;
case SYS_lseek:
{
/*
* Because the position argument is 64 bits wide,
* it goes in the a2/a3 registers and we have to
* get "whence" from the stack. Furthermore, the
* return value is 64 bits wide, so the extra
* part of it goes in the v1 register.
*
* This is a trifle messy.
*/
uint64_t offset;
int whence;
off_t retval64;
join32to64(tf->tf_a2, tf->tf_a3, &offset);
err = copyin((userptr_t)tf->tf_sp + 16,
&whence, sizeof(int));
if (err) {
break;
}
err = sys_lseek(tf->tf_a0, offset, whence, &retval64);
if (err) {
break;
}
split64to32(retval64, &tf->tf_v0, &tf->tf_v1);
retval = tf->tf_v0;
}
break;
case SYS_chdir:
err = sys_chdir((userptr_t)tf->tf_a0);
break;
case SYS___getcwd:
err = sys___getcwd(
(userptr_t)tf->tf_a0,
tf->tf_a1,
&retval);
break;
/* Even more system calls will go here */
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
void
mips_syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
assert(curspl==0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
#if OPT_A2
case SYS_open:
err = sys_open((char *)tf->tf_a0, tf->tf_a1, tf->tf_a2);
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_close:
err = sys_close(tf->tf_a0);
break;
case SYS_read:
err = sys_read(tf->tf_a0, (void *)tf->tf_a1, tf->tf_a2);
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_write:
err = sys_write(tf->tf_a0, (void *)tf->tf_a1, tf->tf_a2);
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_fork:
err = sys_fork(tf);
if (err >= 0)
{
retval = err;
err = 0;
}
break;
case SYS_getpid:
err = sys_getpid();
if (err > 0)
{
retval = err;
err = 0;
}
break;
case SYS_waitpid:
err = sys_waitpid(tf->tf_a0, (int *)tf->tf_a1, (int)tf->tf_a2);
break;
case SYS__exit:
sys__exit(0);
break;
case SYS_execv:
err = sys_execv((char *)tf->tf_a0, (char **)tf->tf_a1);
break;
#endif
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err < 0) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = (-1)*(err);
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
assert(curspl==0);
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception-*.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
int whence = 0;
off_t position = 0;
int32_t retval2 = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
/* Add stuff here */
case SYS_write:
err = sys_write((int)tf->tf_a0,(const void *)tf->tf_a1,(size_t)tf->tf_a2, &retval);
break;
case SYS_read:
err = sys_read(tf->tf_a0, (void *) tf->tf_a1, (size_t) tf->tf_a2, &retval);
break;
case SYS_open:
err = sys_open((char *)tf->tf_a0, tf->tf_a1, (mode_t)tf->tf_a2, &retval);
break;
case SYS_close:
err = sys_close(tf->tf_a0);
break;
case SYS_dup2:
err = sys_dup2(tf->tf_a0, tf->tf_a1, &retval);
break;
case SYS_lseek:
position |= (off_t)tf->tf_a2;
position <<= 32;
position |= (off_t)tf->tf_a3;
err = copyin((const userptr_t)tf->tf_sp+16, &whence, sizeof(whence));
if (err)
break;
err = sys_lseek((int)tf->tf_a0, position, (int)whence, &retval, &retval2);
if(!err)
tf->tf_v1 = retval2;
break;
case SYS_fork:
err = sys_fork(tf,&retval);
break;
case SYS_getpid:
err = sys_getpid((pid_t *)&retval);
break;
case SYS_waitpid:
err = sys_waitpid((pid_t)tf->tf_a0, (userptr_t)tf->tf_a1, (int)tf->tf_a2, (pid_t *)&retval);
break;
case SYS__exit:
sys__exit((int)tf->tf_a0);
err = -1;
//will never come here as it doesnt return
break;
case SYS_execv:
err=sys_execv((const char *)tf->tf_a0,(char **)tf->tf_a1);
break;
case SYS_sbrk:
err=(int)sys_sbrk((intptr_t)tf->tf_a0, (vaddr_t *)&retval);
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception-*.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int32_t retval1;
int err;
off_t pos;
int whence;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
/* Start of process system calls */
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_execv:
err = sys_execv((const char*)tf->tf_a0,(char **) tf->tf_a1);
break;
case SYS__exit:
sys__exit(tf->tf_a0);
break;
case SYS_waitpid:
err = sys_waitpid((pid_t)tf->tf_a0, (int *)tf->tf_a1, tf->tf_a2, &retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
/* End of process system calls */
case SYS_open:
err = sys_open((char *)tf->tf_a0,tf->tf_a1,(mode_t)tf->tf_a2,&retval);
break;
case SYS_close :
err = sys_close(tf->tf_a0, &retval);
break;
case SYS_write :
err = sys_write(tf->tf_a0,(void *) tf->tf_a1,(size_t)tf->tf_a2, &retval);
break;
case SYS_read:
err = sys_read(tf->tf_a0,(void *) tf->tf_a1,(size_t)tf->tf_a2, &retval);
break;
case SYS_lseek:
pos = ( (off_t)tf->tf_a2 << 32 | tf->tf_a3);
if (copyin((const_userptr_t) tf->tf_sp+16, &whence, sizeof(int)) ) {
err = EINVAL ; // definitely an error
break;
}
err = sys_lseek(tf->tf_a0, pos,whence, &retval, &retval1);
if (err == 0) { // if call has passed, then we need to copy retval1 to tf->tf_v1 (low32)
tf->tf_v1 = retval1;
}
break;
case SYS___getcwd:
//char *buf, size_t buflen, int *retval
err = sys__getcwd((char *)tf->tf_a0, (size_t) tf->tf_a1, &retval);
break;
case SYS_dup2:
err = sys_dup2(tf->tf_a0, tf->tf_a1, &retval);
break;
case SYS_chdir:
err = sys_chdir((const char *)tf->tf_a0,&retval);
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
//kprintf("Starting syscall\n");
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
#ifdef UW
case SYS_write:
err = sys_write((int)tf->tf_a0,
(userptr_t)tf->tf_a1,
(int)tf->tf_a2,
(int *)(&retval));
break;
case SYS__exit:
sys__exit((int)tf->tf_a0);
/* sys__exit does not return, execution should not get here */
panic("unexpected return from sys__exit");
break;
case SYS_getpid:
err = sys_getpid((pid_t *)&retval);
break;
case SYS_waitpid:
err = sys_waitpid((pid_t)tf->tf_a0,
(userptr_t)tf->tf_a1,
(int)tf->tf_a2,
(pid_t *)&retval);
break;
case SYS_fork:
err = sys_fork(tf, (pid_t *)&retval);
break;
case SYS_execv:
err=sys_execv((char *)tf->tf_a0, (char **) tf->tf_a1);
break;
#endif // UW
/* Add stuff here */
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception-*.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void syscall(struct trapframe *tf) {
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
off_t pos, new_pos;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS___time:
err = sys___time((userptr_t) tf->tf_a0, (userptr_t) tf->tf_a1);
break;
case SYS_open:
err = sys_open((userptr_t) tf->tf_a0, (int) tf->tf_a1,
(int) tf->tf_a2, &retval);
break;
case SYS_read:
err = sys_read((int) tf->tf_a0, (userptr_t) tf->tf_a1,
(int) tf->tf_a2, &retval);
break;
case SYS_write:
err = sys_write((int) tf->tf_a0, (userptr_t) tf->tf_a1,
(int) tf->tf_a2, &retval);
break;
case SYS_lseek:
pos = (((off_t)tf->tf_a2 << 32) | tf->tf_a3);
err = sys_lseek((userptr_t) tf->tf_a0, pos,
(userptr_t)(tf->tf_sp+16), &new_pos);
if (err == 0)
{
retval = (int32_t)(new_pos >> 32);
tf->tf_v1 = (int32_t)(new_pos & 0xFFFFFFFF);
}
break;
case SYS_close:
err = sys_close((userptr_t) tf->tf_a0, &retval);
break;
case SYS_dup2:
err = sys_dup2((userptr_t) tf->tf_a0, (userptr_t) tf->tf_a1, &retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
case SYS_sbrk:
err = sys_sbrk((userptr_t)tf->tf_a0, &retval);
break;
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_execv:
err = sys_execv((userptr_t) tf->tf_a0, (userptr_t) tf->tf_a1, &retval);
retval = 0;
break;
case SYS_waitpid:
err = sys_waitpid((userptr_t) tf->tf_a0, (userptr_t) tf->tf_a1,
(userptr_t) tf->tf_a2, &retval);
break;
case SYS__exit:
//kprintf("TEMPPPP:Exit has been called! \n");
err = sys__exit((int) tf->tf_a0);
break;
/* Add stuff here */
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
/*
* System call dispatcher.
*
* A pointer to the trapframe created during exception entry (in
* exception-*.S) is passed in.
*
* The calling conventions for syscalls are as follows: Like ordinary
* function calls, the first 4 32-bit arguments are passed in the 4
* argument registers a0-a3. 64-bit arguments are passed in *aligned*
* pairs of registers, that is, either a0/a1 or a2/a3. This means that
* if the first argument is 32-bit and the second is 64-bit, a1 is
* unused.
*
* This much is the same as the calling conventions for ordinary
* function calls. In addition, the system call number is passed in
* the v0 register.
*
* On successful return, the return value is passed back in the v0
* register, or v0 and v1 if 64-bit. This is also like an ordinary
* function call, and additionally the a3 register is also set to 0 to
* indicate success.
*
* On an error return, the error code is passed back in the v0
* register, and the a3 register is set to 1 to indicate failure.
* (Userlevel code takes care of storing the error code in errno and
* returning the value -1 from the actual userlevel syscall function.
* See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)
*
* Upon syscall return the program counter stored in the trapframe
* must be incremented by one instruction; otherwise the exception
* return code will restart the "syscall" instruction and the system
* call will repeat forever.
*
* If you run out of registers (which happens quickly with 64-bit
* values) further arguments must be fetched from the user-level
* stack, starting at sp+16 to skip over the slots for the
* registerized values, with copyin().
*/
void
syscall(struct trapframe *tf)
{
int callno;
int32_t retval;
int err;
KASSERT(curthread != NULL);
KASSERT(curthread->t_curspl == 0);
KASSERT(curthread->t_iplhigh_count == 0);
callno = tf->tf_v0;
/*
* Initialize retval to 0. Many of the system calls don't
* really return a value, just 0 for success and -1 on
* error. Since retval is the value returned on success,
* initialize it to 0 by default; thus it's not necessary to
* deal with it except for calls that return other values,
* like write.
*/
retval = 0;
switch (callno) {
case SYS_reboot:
err = sys_reboot(tf->tf_a0);
break;
case SYS_open:
{
err = sys_open((const_userptr_t)tf->tf_a0, tf->tf_a1, tf->tf_a2, &retval);
break;
}
case SYS_close:
{
err = sys_close(tf->tf_a0);
break;
}
case SYS_read:
{
err = sys_read(tf->tf_a0, (userptr_t)tf->tf_a1, tf->tf_a2, &retval);
break;
}
case SYS_write:
{
err = sys_write(tf->tf_a0, (const userptr_t)tf->tf_a1, tf->tf_a2, &retval);
break;
}
case SYS_lseek:
{
// a little tricky, one of the inputs and the return value are 64 bits long.
int fd = tf->tf_a0;
off_t pos_left32 = tf->tf_a2;
off_t pos_right32 = tf->tf_a3;
//pos_left32 <<= 32; // pos_right32 is changing after this line . WTF !!! .. FOLLOW UP !!
off_t left = pos_left32 << 32;
//off_t pos = pos_left32 | pos_right32;
off_t pos = left | pos_right32;
int whence;
err = copyin((const userptr_t)tf->tf_sp+16, (void*)&whence, sizeof(int));
if(err)
break;
off_t lseek_retval;
err = sys_lseek(fd, pos, whence, &lseek_retval);
if(err)
break;
// check this. how does the value get copied
retval = lseek_retval >> 32;
off_t lseek_right32 = lseek_retval;
lseek_right32 = lseek_right32 << 32;
lseek_right32 = lseek_right32 >> 32;
tf->tf_v1 = lseek_right32;
break;
}
case SYS_dup2:
{
err = sys_dup2(tf->tf_a0, tf->tf_a1, &retval);
break;
}
case SYS_chdir:
{
err = sys_chdir((const userptr_t)tf->tf_a0);
break;
}
case SYS___getcwd:
{
err = sys_getcwd((userptr_t)tf->tf_a0, tf->tf_a1);
break;
}
case SYS___time:
err = sys___time((userptr_t)tf->tf_a0,
(userptr_t)tf->tf_a1);
break;
/* Add stuff here */
case SYS_fork:
err = sys_fork(tf, &retval);
break;
case SYS_getpid:
err = sys_getpid(&retval);
break;
case SYS__exit:
err = sys__exit(tf->tf_a0);
break;
case SYS_waitpid:
err = sys_waitpid(tf->tf_a0, (userptr_t)tf->tf_a1, tf->tf_a2, &retval);
break;
case SYS_execv:
err = sys_execv((userptr_t)tf->tf_a0, (userptr_t *)tf->tf_a1);
break;
case SYS_sbrk:
err = sys_sbrk((intptr_t)tf->tf_a0, &retval);
break;
default:
kprintf("Unknown syscall %d\n", callno);
err = ENOSYS;
break;
}
if (err) {
/*
* Return the error code. This gets converted at
* userlevel to a return value of -1 and the error
* code in errno.
*/
tf->tf_v0 = err;
tf->tf_a3 = 1; /* signal an error */
}
else {
/* Success. */
tf->tf_v0 = retval;
tf->tf_a3 = 0; /* signal no error */
}
/*
* Now, advance the program counter, to avoid restarting
* the syscall over and over again.
*/
tf->tf_epc += 4;
/* Make sure the syscall code didn't forget to lower spl */
KASSERT(curthread->t_curspl == 0);
/* ...or leak any spinlocks */
KASSERT(curthread->t_iplhigh_count == 0);
}