Changeset 6b10dab in mainline for kernel/generic

Timestamp:

2010-12-14T15:26:36Z (15 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

dd8d5a7

Parents:

96b02eb9

Message:

ABI split: pass 64-bit task ID as plain 64-bit argument to SYS_IPC_CONNECT_KBOX, SYS_CAP_GRANT, SYS_CAP_REVOKE

Location:

kernel/generic

Files:

• include/ipc/sysipc.h (modified) (1 diff)
• include/security/cap.h (modified) (4 diffs)
• include/syscall/sysarg64.h (deleted)
• include/syscall/syscall.h (modified) (3 diffs)
• include/typedefs.h (modified) (1 diff)
• src/ipc/sysipc.c (modified) (3 diffs)
• src/security/cap.c (modified) (4 diffs)
• src/syscall/syscall.c (modified) (2 diffs)

kernel/generic/include/ipc/sysipc.h

@@ -40 +40 @@
 #include <typedefs.h>
 
-extern sysarg_t sys_ipc_call_sync_fast(sysarg_t phoneid, sysarg_t method, 
-    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, ipc_data_t *data);
-extern sysarg_t sys_ipc_call_sync_slow(sysarg_t phoneid, ipc_data_t *question,
-    ipc_data_t *reply);
-extern sysarg_t sys_ipc_call_async_fast(sysarg_t phoneid, sysarg_t method, 
-    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4);
-extern sysarg_t sys_ipc_call_async_slow(sysarg_t phoneid, ipc_data_t *data);
-extern sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval, 
-    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4);
-extern sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data);
-extern sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
-    unsigned int nonblocking);
+extern sysarg_t sys_ipc_call_sync_fast(sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, ipc_data_t *);
+extern sysarg_t sys_ipc_call_sync_slow(sysarg_t, ipc_data_t *, ipc_data_t *);
+extern sysarg_t sys_ipc_call_async_fast(sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t);
+extern sysarg_t sys_ipc_call_async_slow(sysarg_t, ipc_data_t *);
+extern sysarg_t sys_ipc_answer_fast(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t);
+extern sysarg_t sys_ipc_answer_slow(sysarg_t, ipc_data_t *);
+extern sysarg_t sys_ipc_wait_for_call(ipc_data_t *, uint32_t, unsigned int);
 extern sysarg_t sys_ipc_poke(void);
-extern sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid,
-    sysarg_t method, sysarg_t arg1, sysarg_t arg2, unsigned int mode);
-extern sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid,
-    ipc_data_t *data, unsigned int mode);
-extern sysarg_t sys_ipc_hangup(sysarg_t phoneid);
-extern sysarg_t sys_ipc_register_irq(inr_t inr, devno_t devno, sysarg_t method,
-    irq_code_t *ucode);
-extern sysarg_t sys_ipc_unregister_irq(inr_t inr, devno_t devno);
-extern sysarg_t sys_ipc_connect_kbox(sysarg64_t *task_id);
+extern sysarg_t sys_ipc_forward_fast(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, unsigned int);
+extern sysarg_t sys_ipc_forward_slow(sysarg_t, sysarg_t, ipc_data_t *,
+    unsigned int);
+extern sysarg_t sys_ipc_hangup(sysarg_t);
+extern sysarg_t sys_ipc_register_irq(inr_t, devno_t, sysarg_t, irq_code_t *);
+extern sysarg_t sys_ipc_unregister_irq(inr_t, devno_t);
+
+#ifdef __32_BITS__
+
+extern sysarg_t sys_ipc_connect_kbox(sysarg64_t *);
+
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+extern sysarg_t sys_ipc_connect_kbox(sysarg_t);
+
+#endif  /* __64_BITS__ */
 
 #endif

kernel/generic/include/security/cap.h

@@ -48 +48 @@
 #define __CAP_H__
 
-#include <syscall/sysarg64.h>
 #include <typedefs.h>
 
@@ -55 +54 @@
  * privilege to/from other tasks.
  */
-#define CAP_CAP                 (1<<0)
+#define CAP_CAP  (1 << 0)
 
 /**
@@ -61 +60 @@
  * to other tasks.
  */
-#define CAP_MEM_MANAGER         (1<<1)
+#define CAP_MEM_MANAGER  (1 << 1)
 
 /**
@@ -67 +66 @@
  * to other tasks.
  */
-#define CAP_IO_MANAGER          (1<<2)
+#define CAP_IO_MANAGER  (1 << 2)
 
 /**
  * CAP_IRQ_REG entitles its holder to register IRQ handlers.
  */
-#define CAP_IRQ_REG             (1<<3) 
+#define CAP_IRQ_REG  (1 << 3)
 
 typedef uint32_t cap_t;
 
-extern sysarg_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps);
-extern sysarg_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps);
+#ifdef __32_BITS__
+
+extern sysarg_t sys_cap_grant(sysarg64_t *, cap_t);
+extern sysarg_t sys_cap_revoke(sysarg64_t *, cap_t);
+
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+extern sysarg_t sys_cap_grant(sysarg_t, cap_t);
+extern sysarg_t sys_cap_revoke(sysarg_t, cap_t);
+
+#endif  /* __64_BITS__ */
 
 #endif

kernel/generic/include/syscall/syscall.h

@@ -38 +38 @@
 typedef enum {
         SYS_KLOG = 0,
-        SYS_TLS_SET = 1, /* Hardcoded in AMD64, IA32 uspace - fibril.S */
+        SYS_TLS_SET = 1,  /* Hardcoded for AMD64, IA-32 (fibril.S in uspace) */
         
         SYS_THREAD_CREATE,
@@ -71 +71 @@
         SYS_IPC_REGISTER_IRQ,
         SYS_IPC_UNREGISTER_IRQ,
+        SYS_IPC_CONNECT_KBOX,
         
         SYS_EVENT_SUBSCRIBE,
@@ -90 +91 @@
         SYS_DEBUG_DISABLE_CONSOLE,
         
-        SYS_IPC_CONNECT_KBOX,
         SYSCALL_END
 } syscall_t;

kernel/generic/include/typedefs.h

@@ -73 +73 @@
 typedef volatile uint32_t ioport32_t;
 
+#ifdef __32_BITS__
+
+/** Explicit 64-bit arguments passed to syscalls. */
+typedef uint64_t sysarg64_t;
+
+#endif /* __32_BITS__ */
+
 #endif
 

kernel/generic/src/ipc/sysipc.c

@@ -49 +49 @@
 #include <syscall/copy.h>
 #include <security/cap.h>
+#include <console/console.h>
 #include <mm/as.h>
 #include <print.h>
@@ -1128 +1129 @@
 }
 
-#include <console/console.h>
-
-/** Syscall connect to a task by id.
+#ifdef __32_BITS__
+
+/** Syscall connect to a task by ID (32 bits)
  *
  * @return Phone id on success, or negative error code.
  *
  */
-sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
+sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid)
 {
 #ifdef CONFIG_UDEBUG
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
         if (rc != 0)
                 return (sysarg_t) rc;
         
-        LOG("sys_ipc_connect_kbox(%" PRIu64 ")", taskid_arg.value);
-        
-        return ipc_connect_kbox(taskid_arg.value);
+        return ipc_connect_kbox((task_id_t) taskid);
 #else
         return (sysarg_t) ENOTSUP;
@@ -1151 +1150 @@
 }
 
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Syscall connect to a task by ID (64 bits)
+ *
+ * @return Phone id on success, or negative error code.
+ *
+ */
+sysarg_t sys_ipc_connect_kbox(sysarg_t taskid)
+{
+#ifdef CONFIG_UDEBUG
+        return ipc_connect_kbox((task_id_t) taskid);
+#else
+        return (sysarg_t) ENOTSUP;
+#endif
+}
+
+#endif  /* __64_BITS__ */
+
 /** @}
  */

kernel/generic/src/security/cap.c

@@ -41 +41 @@
 #include <proc/task.h>
 #include <synch/spinlock.h>
-#include <syscall/sysarg64.h>
 #include <syscall/copy.h>
 #include <arch.h>
@@ -79 +78 @@
  * The calling task must have the CAP_CAP capability.
  *
- * @param uspace_taskid_arg Userspace structure holding destination task ID.
- * @param caps Capabilities to grant.
- *
- * @return Zero on success or an error code from @ref errno.h.
- *
- */
-sysarg_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to grant.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+static sysarg_t cap_grant(task_id_t taskid, cap_t caps)
 {
         if (!(cap_get(TASK) & CAP_CAP))
                 return (sysarg_t) EPERM;
         
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
-        if (rc != 0)
-                return (sysarg_t) rc;
-        
         irq_spinlock_lock(&tasks_lock, true);
-        task_t *task = task_find_by_id((task_id_t) taskid_arg.value);
+        task_t *task = task_find_by_id(taskid);
         
         if ((!task) || (!context_check(CONTEXT, task->context))) {
@@ -116 +110 @@
  * attempt to revoke capabilities from itself.
  *
- * @param uspace_taskid_arg Userspace structure holding destination task ID.
- * @param caps Capabilities to revoke.
- *
- * @return Zero on success or an error code from @ref errno.h.
- *
- */
-sysarg_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
-{
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
-        if (rc != 0)
-                return (sysarg_t) rc;
-        
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to revoke.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+static sysarg_t cap_revoke(task_id_t taskid, cap_t caps)
+{
         irq_spinlock_lock(&tasks_lock, true);
         
-        task_t *task = task_find_by_id((task_id_t) taskid_arg.value);
+        task_t *task = task_find_by_id(taskid);
         if ((!task) || (!context_check(CONTEXT, task->context))) {
                 irq_spinlock_unlock(&tasks_lock, true);
@@ -157 +146 @@
 }
 
+#ifdef __32_BITS__
+
+/** Grant capabilities to a task (32 bits)
+ *
+ * The calling task must have the CAP_CAP capability.
+ *
+ * @param uspace_taskid User-space pointer to destination task ID.
+ * @param caps          Capabilities to grant.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_grant(sysarg64_t *uspace_taskid, cap_t caps)
+{
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
+        if (rc != 0)
+                return (sysarg_t) rc;
+        
+        return cap_grant((task_id_t) taskid, caps);
+}
+
+/** Revoke capabilities from a task (32 bits)
+ *
+ * The calling task must have the CAP_CAP capability or the caller must
+ * attempt to revoke capabilities from itself.
+ *
+ * @param uspace_taskid User-space pointer to destination task ID.
+ * @param caps          Capabilities to revoke.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_revoke(sysarg64_t *uspace_taskid, cap_t caps)
+{
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
+        if (rc != 0)
+                return (sysarg_t) rc;
+        
+        return cap_revoke((task_id_t) taskid, caps);
+}
+
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Grant capabilities to a task (64 bits)
+ *
+ * The calling task must have the CAP_CAP capability.
+ *
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to grant.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_grant(sysarg_t taskid, cap_t caps)
+{
+        return cap_grant((task_id_t) taskid, caps);
+}
+
+/** Revoke capabilities from a task (64 bits)
+ *
+ * The calling task must have the CAP_CAP capability or the caller must
+ * attempt to revoke capabilities from itself.
+ *
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to revoke.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_revoke(sysarg_t taskid, cap_t caps)
+{
+        return cap_revoke((task_id_t) taskid, caps);
+}
+
+#endif  /* __64_BITS__ */
+
 /** @}
  */

kernel/generic/src/syscall/syscall.c

@@ -147 +147 @@
         (syshandler_t) sys_ipc_register_irq,
         (syshandler_t) sys_ipc_unregister_irq,
+        (syshandler_t) sys_ipc_connect_kbox,
         
         /* Event notification syscalls. */
@@ -169 +170 @@
         /* Debug calls */
         (syshandler_t) sys_debug_enable_console,
-        (syshandler_t) sys_debug_disable_console,
-        
-        (syshandler_t) sys_ipc_connect_kbox
+        (syshandler_t) sys_debug_disable_console
 };