Removes sys_resource_req (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Thu, 1 Mar 2012 00:30:44 +0000 (16:30 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 1 Mar 2012 00:34:21 +0000 (16:34 -0800)
Reinstall your kernel header (or the kernel will catch the invalid
syscall).

kern/include/resource.h
kern/include/ros/bits/syscall.h
kern/src/resource.c
kern/src/syscall.c
user/parlib/include/parlib.h
user/parlib/syscall.c

index becc4c1..bfa9ca1 100644 (file)
@@ -16,8 +16,6 @@
 #include <process.h>
 
 bool core_request(struct proc *p);
-error_t resource_req(struct proc *p, int type, size_t amt_wanted,
-                     size_t amt_wanted_min, uint32_t flags);
 
 void print_resources(struct proc *p);
 void print_all_resources(void);
index 45c67c4..0e28761 100644 (file)
@@ -33,7 +33,7 @@
 /* sys_brk removed */
 #define SYS_shared_page_alloc          22
 #define SYS_shared_page_free           23
-#define SYS_resource_req                       24
+/* sys_resource_req removed */
 #define SYS_notify                                     25
 #define SYS_self_notify                                26
 #define SYS_halt_core                          27
index 27168b4..678c4a6 100644 (file)
@@ -91,35 +91,6 @@ bool core_request(struct proc *p)
        return FALSE;           /* Not giving them anything more */
 }
 
-error_t resource_req(struct proc *p, int type, size_t amt_wanted,
-                     size_t amt_wanted_min, uint32_t flags)
-{
-       error_t retval;
-       printd("Received request for type: %d, amt_wanted: %d, amt_wanted_min: %d, "
-              "flag: %d\n", type, amt_wanted, amt_wanted_min, flags);
-       if (flags & REQ_ASYNC)
-               // We have no sense of time yet, or of half-filling requests
-               printk("[kernel] Async requests treated synchronously for now.\n");
-
-       switch (type) {
-               case RES_CORES:
-                       return -EFAIL;
-                       break;
-               case RES_MEMORY:
-                       // not clear if we should be in RUNNABLE_M or not
-                       printk("[kernel] Memory requests are not implemented.\n");
-                       return -EFAIL;
-                       break;
-               case RES_APPLE_PIES:
-                       printk("You can have all the apple pies you want.\n");
-                       break;
-               default:
-                       printk("[kernel] Unknown resource!  No oranges for you!\n");
-                       return -EINVAL;
-       }
-       return 0;
-}
-
 void print_resources(struct proc *p)
 {
        printk("--------------------\n");
index ba89259..d1beec4 100644 (file)
@@ -24,7 +24,6 @@
 #include <syscall.h>
 #include <kmalloc.h>
 #include <stdio.h>
-#include <resource.h>
 #include <frontend.h>
 #include <colored_caches.h>
 #include <hashtable.h>
@@ -74,8 +73,8 @@ static void finish_sysc(struct syscall *sysc, struct proc *p)
 
 /* Helper that "finishes" the current async syscall.  This should be used when
  * we are calling a function in a syscall that might not return and won't be
- * able to use the normal syscall return path, such as proc_yield() and
- * resource_req().  Call this from within syscall.c (I don't want it global).
+ * able to use the normal syscall return path, such as proc_yield().  Call this
+ * from within syscall.c (I don't want it global).
  *
  * It is possible for another user thread to see the syscall being done early -
  * they just need to be careful with the weird proc management calls (as in,
@@ -639,16 +638,6 @@ static int sys_shared_page_free(env_t* p1, void*DANGEROUS addr, pid_t p2)
        return -1;
 }
 
-
-static int sys_resource_req(struct proc *p, int type, unsigned int amt_wanted,
-                            unsigned int amt_wanted_min, int flags)
-{
-       /* resource_req returns and we'll eventually finish the sysc later.  The
-        * original context may restart on a remote core before we return and
-        * finish, but that's fine thanks to the async kernel interface. */
-       return resource_req(p, type, amt_wanted, amt_wanted_min, flags);
-}
-
 /* Untested.  Will notify the target on the given vcore, if the caller controls
  * the target.  Will honor the target's wanted/vcoreid.  u_ne can be NULL. */
 static int sys_notify(struct proc *p, int target_pid, unsigned int ev_type,
@@ -731,7 +720,10 @@ static int sys_halt_core(struct proc *p, unsigned int usec)
        return 0;
 }
 
-/* Changes a process into _M mode, or -EINVAL if it already is an mcp */
+/* Changes a process into _M mode, or -EINVAL if it already is an mcp.
+ * __proc_change_to_m() returns and we'll eventually finish the sysc later.  The
+ * original context may restart on a remote core before we return and finish,
+ * but that's fine thanks to the async kernel interface. */
 static int sys_change_to_m(struct proc *p)
 {
        int retval = 0;
@@ -1361,7 +1353,6 @@ const static struct sys_table_entry syscall_table[] = {
        [SYS_mprotect] = {(syscall_t)sys_mprotect, "mprotect"},
        [SYS_shared_page_alloc] = {(syscall_t)sys_shared_page_alloc, "pa"},
        [SYS_shared_page_free] = {(syscall_t)sys_shared_page_free, "pf"},
-       [SYS_resource_req] = {(syscall_t)sys_resource_req, "resource_req"},
        [SYS_notify] = {(syscall_t)sys_notify, "notify"},
        [SYS_self_notify] = {(syscall_t)sys_self_notify, "self_notify"},
        [SYS_halt_core] = {(syscall_t)sys_halt_core, "halt_core"},
index b4227b6..1e6f350 100644 (file)
@@ -14,7 +14,6 @@
 #include <ros/syscall.h>
 #include <ros/procinfo.h>
 #include <ros/procdata.h>
-#include <ros/resource.h>
 #include <stdint.h>
 #include <ros_debug.h>
 
@@ -40,7 +39,6 @@ int         sys_proc_run(int pid);
 ssize_t     sys_shared_page_alloc(void *COUNT(PGSIZE) *addr, pid_t p2, 
                                   int p1_flags, int p2_flags);
 ssize_t     sys_shared_page_free(void *COUNT(PGSIZE) addr, pid_t p2);
-ssize_t     sys_resource_req(int type, size_t amt_max, size_t amt_min, uint32_t flags);
 void        sys_reboot();
 int         gettimeofday(struct timeval* tp, void* tzp);
 void *COUNT(length) sys_mmap(void *SNT addr, size_t length, int prot, int flags,
index d835fa1..12157e6 100644 (file)
@@ -75,12 +75,6 @@ ssize_t sys_eth_read(void* buf, size_t len)
        return ros_syscall(SYS_eth_read, buf, len, 0, 0, 0, 0);
 }
 
-/* Request resources from the kernel.  Flags in ros/resource.h. */
-ssize_t sys_resource_req(int type, size_t amt_max, size_t amt_min, uint32_t flags)
-{
-       return ros_syscall(SYS_resource_req, type, amt_max, amt_min, flags, 0, 0);
-}
-
 void sys_reboot(void)
 {
        ros_syscall(SYS_reboot, 0, 0, 0, 0, 0, 0);