Fixed 32bit error in lseek
[akaros.git] / kern / src / syscall.c
index dd26908..2673eb5 100644 (file)
 #include <manager.h>
 #include <ros/procinfo.h>
 
+static int execargs_stringer(struct proc *p, char *d, size_t slen,
+                            char *path, size_t path_l,
+                            char *argenv, size_t argenv_l);
+
 /* Global, used by the kernel monitor for syscall debugging. */
 bool systrace_loud = FALSE;
 
@@ -120,7 +124,7 @@ static void systrace_start_trace(struct kthread *kthread, struct syscall *sysc)
 {
        struct proc *p = current;
        struct systrace_record *trace;
-       long data_arg;
+       uintreg_t data_arg;
        size_t data_len = 0;
 
        kthread->strace = 0;
@@ -145,6 +149,11 @@ static void systrace_start_trace(struct kthread *kthread, struct syscall *sysc)
        }
        if (!trace)
                return;
+       /* if you ever need to debug just one strace function, this is
+        * handy way to do it: just bail out if it's not the one you
+        * want.
+        * if (sysc->num != SYS_exec)
+        * return; */
        trace->start_timestamp = read_tsc();
        trace->end_timestamp = 0;
        trace->syscallno = sysc->num;
@@ -171,12 +180,32 @@ static void systrace_start_trace(struct kthread *kthread, struct syscall *sysc)
                data_arg = sysc->arg1;
                data_len = sysc->arg2;
                break;
+       case SYS_exec:
+               trace->datalen = execargs_stringer(current,
+                                                  (char *)trace->data,
+                                                  sizeof(trace->data),
+                                                  (char *)sysc->arg0,
+                                                  sysc->arg1,
+                                                  (char *)sysc->arg2,
+                                                  sysc->arg3);
+               break;
+       case SYS_proc_create:
+               trace->datalen = execargs_stringer(current,
+                                                  (char *)trace->data,
+                                                  sizeof(trace->data),
+                                                  (char *)sysc->arg0,
+                                                  sysc->arg1,
+                                                  (char *)sysc->arg2,
+                                                  sysc->arg3);
+               break;
        }
-       trace->datalen = MIN(sizeof(trace->data), data_len);
-       if (trace->datalen)
+       if (data_len) {
+               trace->datalen = MIN(sizeof(trace->data), data_len);
                copy_from_user(trace->data, (void*)data_arg, trace->datalen);
+       }
 
        systrace_output(trace, p->strace, TRUE);
+
        kthread->strace = trace;
 }
 
@@ -258,7 +287,7 @@ static void finish_sysc(struct syscall *sysc, struct proc *p)
         * to not muck with the flags while we're signalling. */
        atomic_or(&sysc->flags, SC_K_LOCK | SC_DONE);
        __signal_syscall(sysc, p);
-       atomic_and(&sysc->flags, ~SC_K_LOCK); 
+       atomic_and(&sysc->flags, ~SC_K_LOCK);
 }
 
 /* Helper that "finishes" the current async syscall.  This should be used with
@@ -635,42 +664,44 @@ static int sys_proc_create(struct proc *p, char *path, size_t path_l,
        /* TODO: 9ns support */
        program = do_file_open(t_path, O_READ, 0);
        if (!program)
-               goto error_user_memdup;
-
+               goto error_with_path;
+       if (!is_valid_elf(program)) {
+               set_errno(ENOEXEC);
+               goto error_with_file;
+       }
        /* Check the size of the argenv array, error out if too large. */
        if ((argenv_l < sizeof(struct argenv)) || (argenv_l > ARG_MAX)) {
                set_error(EINVAL, "The argenv array has an invalid size: %lu\n",
                                  argenv_l);
-               goto error_user_memdup;
+               goto error_with_file;
        }
        /* Copy the argenv array into a kernel buffer. Delay processing of the
         * array to load_elf(). */
        kargenv = user_memdup_errno(p, argenv, argenv_l);
        if (!kargenv) {
-               set_errstr("Failed to copy in the args");
-               goto error_user_memdup;
+               set_error(EINVAL, "Failed to copy in the args");
+               goto error_with_file;
        }
        /* Unpack the argenv array into more usable variables. Integrity checking
         * done along side this as well. */
        if (unpack_argenv(kargenv, argenv_l, &argc, &argv, &envc, &envp)) {
-               set_errstr("Failed to unpack the args");
-               goto error_unpack;
+               set_error(EINVAL, "Failed to unpack the args");
+               goto error_with_kargenv;
        }
-
        /* TODO: need to split the proc creation, since you must load after setting
         * args/env, since auxp gets set up there. */
        //new_p = proc_create(program, 0, 0);
        if (proc_alloc(&new_p, current, flags)) {
-               set_errstr("Failed to alloc new proc");
-               goto error_proc_alloc;
+               set_error(ENOMEM, "Failed to alloc new proc");
+               goto error_with_kargenv;
        }
        inherit_strace(p, new_p);
        /* close the CLOEXEC ones, even though this isn't really an exec */
        close_fdt(&new_p->open_files, TRUE);
        /* Load the elf. */
        if (load_elf(new_p, program, argc, argv, envc, envp)) {
-               set_errstr("Failed to load elf");
-               goto error_load_elf;
+               set_error(EINVAL, "Failed to load elf");
+               goto error_with_proc;
        }
        /* progname is argv0, which accounts for symlinks */
        proc_set_progname(new_p, argc ? argv[0] : NULL);
@@ -682,18 +713,17 @@ static int sys_proc_create(struct proc *p, char *path, size_t path_l,
        profiler_notify_new_process(new_p);
        proc_decref(new_p);     /* give up the reference created in proc_create() */
        return pid;
-error_load_elf:
-       set_errno(EINVAL);
+error_with_proc:
        /* proc_destroy will decref once, which is for the ref created in
         * proc_create().  We don't decref again (the usual "+1 for existing"),
         * since the scheduler, which usually handles that, hasn't heard about the
         * process (via __proc_ready()). */
        proc_destroy(new_p);
-error_proc_alloc:
-       kref_put(&program->f_kref);
-error_unpack:
+error_with_kargenv:
        user_memdup_free(p, kargenv);
-error_user_memdup:
+error_with_file:
+       kref_put(&program->f_kref);
+error_with_path:
        free_path(p, t_path);
        return -1;
 }
@@ -839,11 +869,65 @@ static ssize_t sys_fork(env_t* e)
        return ret;
 }
 
+/* string for sys_exec arguments. Assumes that d is pointing to zero'd
+ * storage or storage that does not require null termination or
+ * provides the null. */
+static int execargs_stringer(struct proc *p, char *d, size_t slen,
+                            char *path, size_t path_l,
+                            char *argenv, size_t argenv_l)
+{
+       int argc, envc, i;
+       char **argv, **envp;
+       struct argenv *kargenv;
+       int amt;
+       char *s = d;
+       char *e = d + slen;
+
+       if (path_l > slen)
+               path_l = slen;
+       if (memcpy_from_user(p, d, path, path_l)) {
+               s = seprintf(s, e, "Invalid exec path");
+               return s - d;
+       }
+       s += path_l;
+
+       /* yes, this code is cloned from below. I wrote a helper but
+        * Barret and I concluded after talking about it that the
+        * helper was not really helper-ful, as it has almost 10
+        * arguments. Please, don't suggest a cpp macro. Thank you. */
+       /* Check the size of the argenv array, error out if too large. */
+       if ((argenv_l < sizeof(struct argenv)) || (argenv_l > ARG_MAX)) {
+               s = seprintf(s, e, "The argenv array has an invalid size: %lu\n",
+                                 argenv_l);
+               return s - d;
+       }
+       /* Copy the argenv array into a kernel buffer. */
+       kargenv = user_memdup_errno(p, argenv, argenv_l);
+       if (!kargenv) {
+               s = seprintf(s, e, "Failed to copy in the args and environment");
+               return s - d;
+       }
+       /* Unpack the argenv array into more usable variables. Integrity checking
+        * done along side this as well. */
+       if (unpack_argenv(kargenv, argenv_l, &argc, &argv, &envc, &envp)) {
+               s = seprintf(s, e, "Failed to unpack the args");
+               user_memdup_free(p, kargenv);
+               return s - d;
+       }
+       s = seprintf(s, e, "[%d]{", argc);
+       for (i = 0; i < argc; i++)
+               s = seprintf(s, e, "%s, ", argv[i]);
+       s = seprintf(s, e, "}");
+
+       user_memdup_free(p, kargenv);
+       return s - d;
+}
+
 /* Load the binary "path" into the current process, and start executing it.
  * argv and envp are magically bundled in procinfo for now.  Keep in sync with
  * glibc's sysdeps/ros/execve.c.  Once past a certain point, this function won't
  * return.  It assumes (and checks) that it is current.  Don't give it an extra
- * refcnt'd *p (syscall won't do that). 
+ * refcnt'd *p (syscall won't do that).
  * Note: if someone batched syscalls with this call, they could clobber their
  * old memory (and will likely PF and die).  Don't do it... */
 static int sys_exec(struct proc *p, char *path, size_t path_l,
@@ -1392,7 +1476,7 @@ static int sys_vmm_poke_guest(struct proc *p, int guest_pcoreid)
 
 /* Pokes the ksched for the given resource for target_pid.  If the target pid
  * == 0, we just poke for the calling process.  The common case is poking for
- * self, so we avoid the lookup. 
+ * self, so we avoid the lookup.
  *
  * Not sure if you could harm someone via asking the kernel to look at them, so
  * we'll do a 'controls' check for now.  In the future, we might have something
@@ -1785,10 +1869,8 @@ static intreg_t sys_llseek(struct proc *p, int fd, off_t offset_hi,
                ret = file->f_op->llseek(file, tempoff, &retoff, whence);
                kref_put(&file->f_kref);
        } else {
-               /* won't return here if error ... */
-               ret = sysseek(fd, tempoff, whence);
-               retoff = ret;
-               ret = 0;
+               retoff = sysseek(fd, tempoff, whence);
+               ret = (retoff < 0);
        }
 
        if (ret)
@@ -2319,7 +2401,7 @@ intreg_t sys_rename(struct proc *p, char *old_path, size_t old_path_l,
        printd("Newchan: %C\n", newchan);
        printd("Newchan: mchan %C\n", newchan->mchan);
 
-       if ((newchan->dev != oldchan->dev) || 
+       if ((newchan->dev != oldchan->dev) ||
                (newchan->type != oldchan->type)) {
                printd("Old chan and new chan do not match\n");
                set_errno(ENODEV);
@@ -2374,7 +2456,7 @@ intreg_t sys_rename(struct proc *p, char *old_path, size_t old_path_l,
        };
        printk("syswstat returns %d\n", retval);
 
-done: 
+done:
        free_path(p, from_path);
        free_path(p, to_path);
        cclose(oldchan);