KCall methods do not depend on m_source and m_type fields

- substituted the use of the m_source message field by
  caller->p_endpoint in kernel calls. It is the same information, just
  passed more intuitively.

- the last dependency on m_type field is removed.

- do_unused() is substituted by a check for NULL.

- this pretty much removes the depency of kernel calls on the general
  message format. In the future this may be used to pass the kcall
  arguments in a different structure or registers (x86-64, ARM?) The
  kcall number may be passed in a register already.

diff --git a/kernel/system.c b/kernel/system.c
index ef405463fef1085593f0cdb982c2142e26b69002..4cb223852acc068195476fb1294d1b57b7707e4d 100644 (file)
--- a/kernel/system.c
+++ b/kernel/system.c
@@ -109,7 +109,13 @@ PRIVATE int kernel_call_dispatch(struct proc * caller, message *msg)
          result = ECALLDENIED;                 /* illegal message type */
   } else {
          /* handle the system call */
-         result = (*call_vec[call_nr])(caller, msg);
+         if (call_vec[call_nr])
+                 result = (*call_vec[call_nr])(caller, msg);
+         else {
+                 printf("Unused kernel call %d from %d\n",
+                                 call_nr, caller->p_endpoint);
+                 result = EBADREQUEST;
+         }
   }
 
   return result;
@@ -170,7 +176,7 @@ PUBLIC void system_init(void)
    * if an illegal call number is used. The ordering is not important here.
    */
   for (i=0; i<NR_SYS_CALLS; i++) {
-      call_vec[i] = do_unused;
+      call_vec[i] = NULL;
       callnames[i] = "unused";
   }
 

diff --git a/kernel/system.h b/kernel/system.h
index 39da172c521edd0850f7ad183001dd8eedf4dd5e..2b589c4b631abbd695e5db4d4e15b32c8bd5c1b6 100644 (file)
--- a/kernel/system.h
+++ b/kernel/system.h
@@ -1,5 +1,5 @@
 /* Function prototypes for the system library.  The prototypes in this file 
- * are undefined to do_unused if the kernel call is not enabled in config.h. 
+ * are undefined to NULL if the kernel call is not enabled in config.h.
  * The implementation is contained in src/kernel/system/.  
  *
  * The system library allows to access system services by doing a kernel call.
@@ -36,147 +36,144 @@
 #include "proto.h"
 #include "proc.h"
 
-/* Default handler for unused kernel calls. */
-_PROTOTYPE( int do_unused, (struct proc * caller, message *m_ptr) );
-
 _PROTOTYPE( int do_exec, (struct proc * caller, message *m_ptr) );
 #if ! USE_EXEC
-#define do_exec do_unused
+#define do_exec NULL
 #endif
 
 _PROTOTYPE( int do_fork, (struct proc * caller, message *m_ptr) );
 #if ! USE_FORK
-#define do_fork do_unused
+#define do_fork NULL
 #endif
 
 _PROTOTYPE( int do_newmap, (struct proc * caller, message *m_ptr) );
 #if ! USE_NEWMAP
-#define do_newmap do_unused
+#define do_newmap NULL
 #endif
 
 _PROTOTYPE( int do_clear, (struct proc * caller, message *m_ptr) );
 #if ! USE_CLEAR
-#define do_clear do_unused
+#define do_clear NULL
 #endif
 
 _PROTOTYPE( int do_trace, (struct proc * caller, message *m_ptr) );
 #if ! USE_TRACE
-#define do_trace do_unused
+#define do_trace NULL
 #endif
 
 _PROTOTYPE( int do_runctl, (struct proc * caller, message *m_ptr) );
 #if ! USE_RUNCTL
-#define do_runctl do_unused
+#define do_runctl NULL
 #endif
 
 _PROTOTYPE( int do_update, (struct proc * caller, message *m_ptr) );
 #if ! USE_UPDATE
-#define do_update do_unused
+#define do_update NULL
 #endif
 
 _PROTOTYPE( int do_exit, (struct proc * caller, message *m_ptr) );
 #if ! USE_EXIT
-#define do_exit do_unused
+#define do_exit NULL
 #endif
 
 _PROTOTYPE( int do_copy, (struct proc * caller, message *m_ptr) );
 #define do_vircopy     do_copy
 #if ! (USE_VIRCOPY || USE_PHYSCOPY)
-#define do_copy do_unused
+#define do_copy NULL
 #endif
 
 _PROTOTYPE( int do_umap, (struct proc * caller, message *m_ptr) );
 #if ! USE_UMAP
-#define do_umap do_unused
+#define do_umap NULL
 #endif
 
 _PROTOTYPE( int do_memset, (struct proc * caller, message *m_ptr) );
 #if ! USE_MEMSET
-#define do_memset do_unused
+#define do_memset NULL
 #endif
 
 _PROTOTYPE( int do_abort, (struct proc * caller, message *m_ptr) );
 #if ! USE_ABORT
-#define do_abort do_unused
+#define do_abort NULL
 #endif
 
 _PROTOTYPE( int do_getinfo, (struct proc * caller, message *m_ptr) );
 #if ! USE_GETINFO
-#define do_getinfo do_unused
+#define do_getinfo NULL
 #endif
 
 _PROTOTYPE( int do_privctl, (struct proc * caller, message *m_ptr) );
 #if ! USE_PRIVCTL
-#define do_privctl do_unused
+#define do_privctl NULL
 #endif
 
 _PROTOTYPE( int do_segctl, (struct proc * caller, message *m_ptr) );
 #if ! USE_SEGCTL
-#define do_segctl do_unused
+#define do_segctl NULL
 #endif
 
 _PROTOTYPE( int do_irqctl, (struct proc * caller, message *m_ptr) );
 #if ! USE_IRQCTL
-#define do_irqctl do_unused
+#define do_irqctl NULL
 #endif
 
 _PROTOTYPE( int do_devio, (struct proc * caller, message *m_ptr) );
 #if ! USE_DEVIO
-#define do_devio do_unused
+#define do_devio NULL
 #endif
 
 _PROTOTYPE( int do_vdevio, (struct proc * caller, message *m_ptr) );
 #if ! USE_VDEVIO
-#define do_vdevio do_unused
+#define do_vdevio NULL
 #endif
 
 _PROTOTYPE( int do_int86, (struct proc * caller, message *m_ptr) );
 
 _PROTOTYPE( int do_sdevio, (struct proc * caller, message *m_ptr) );
 #if ! USE_SDEVIO
-#define do_sdevio do_unused
+#define do_sdevio NULL
 #endif
 
 _PROTOTYPE( int do_kill, (struct proc * caller, message *m_ptr) );
 #if ! USE_KILL
-#define do_kill do_unused
+#define do_kill NULL
 #endif
 
 _PROTOTYPE( int do_getksig, (struct proc * caller, message *m_ptr) );
 #if ! USE_GETKSIG
-#define do_getksig do_unused
+#define do_getksig NULL
 #endif
 
 _PROTOTYPE( int do_endksig, (struct proc * caller, message *m_ptr) );
 #if ! USE_ENDKSIG
-#define do_endksig do_unused
+#define do_endksig NULL
 #endif
 
 _PROTOTYPE( int do_sigsend, (struct proc * caller, message *m_ptr) );
 #if ! USE_SIGSEND
-#define do_sigsend do_unused
+#define do_sigsend NULL
 #endif
 
 _PROTOTYPE( int do_sigreturn, (struct proc * caller, message *m_ptr) );
 #if ! USE_SIGRETURN
-#define do_sigreturn do_unused
+#define do_sigreturn NULL
 #endif
 
 _PROTOTYPE( int do_times, (struct proc * caller, message *m_ptr) );
 #if ! USE_TIMES
-#define do_times do_unused
+#define do_times NULL
 #endif
 
 _PROTOTYPE( int do_setalarm, (struct proc * caller, message *m_ptr) );
 #if ! USE_SETALARM
-#define do_setalarm do_unused
+#define do_setalarm NULL
 #endif
 
 _PROTOTYPE( int do_stime, (struct proc * caller, message *m_ptr) );
 
 _PROTOTYPE( int do_vtimer, (struct proc * caller, message *m_ptr) );
 #if ! USE_VTIMER
-#define do_vtimer do_unused
+#define do_vtimer NULL
 #endif
 
 _PROTOTYPE( int do_safecopy_to, (struct proc * caller, message *m_ptr) );
@@ -193,7 +190,7 @@ _PROTOTYPE( int do_safeunmap, (struct proc * caller, message *m_ptr) );
 
 _PROTOTYPE( int do_sprofile, (struct proc * caller, message *m_ptr) );
 #if ! SPROFILE
-#define do_sprofile do_unused
+#define do_sprofile NULL
 #endif
 
 _PROTOTYPE( int do_cprofile, (struct proc * caller, message *m_ptr) );
@@ -202,8 +199,8 @@ _PROTOTYPE( int do_profbuf, (struct proc * caller, message *m_ptr) );
 _PROTOTYPE( int do_getmcontext, (struct proc * caller, message *m_ptr) );
 _PROTOTYPE( int do_setmcontext, (struct proc * caller, message *m_ptr) );
 #if ! USE_MCONTEXT
-#define do_getmcontext do_unused
-#define do_setmcontext do_unused
+#define do_getmcontext NULL
+#define do_setmcontext NULL
 #endif
 
 _PROTOTYPE( int do_schedule,    (struct proc * caller, message *m_ptr) );
@@ -211,7 +208,7 @@ _PROTOTYPE( int do_schedctl, (struct proc * caller, message *m_ptr) );
 
 _PROTOTYPE( int do_statectl, (struct proc * caller, message *m_ptr) );
 #if ! USE_STATECTL
-#define do_statectl do_unused
+#define do_statectl NULL
 #endif
 
 #endif /* SYSTEM_H */

diff --git a/kernel/system/Makefile.inc b/kernel/system/Makefile.inc
index 3a9445353a0b092c8d64efe77c620360d6ff4131..8c1cb6887936a0257bd950bde2a3d63d1114b319 100644 (file)
--- a/kernel/system/Makefile.inc
+++ b/kernel/system/Makefile.inc
@@ -3,7 +3,6 @@
 
 .PATH: ${.CURDIR}/system
 SRCS+=         \
-       do_unused.c \
        do_fork.c \
        do_exec.c \
        do_newmap.c \

diff --git a/kernel/system/do_copy.c b/kernel/system/do_copy.c
index 736a655026d90f18ecbce3dae6249cf70379c797..20142b3e9ae13447fc8601458527efc987ac9faa 100644 (file)
--- a/kernel/system/do_copy.c
+++ b/kernel/system/do_copy.c
@@ -30,9 +30,9 @@ PUBLIC int do_copy(struct proc * caller, message * m_ptr)
   int i;
 
 #if 0
-  if (m_ptr->m_source != PM_PROC_NR && m_ptr->m_source != VFS_PROC_NR &&
-       m_ptr->m_source != RS_PROC_NR && m_ptr->m_source != MEM_PROC_NR &&
-       m_ptr->m_source != VM_PROC_NR)
+  if (caller->p_endpoint != PM_PROC_NR && caller->p_endpoint != VFS_PROC_NR &&
+       caller->p_endpoint != RS_PROC_NR && caller->p_endpoint != MEM_PROC_NR &&
+       caller->p_endpoint != VM_PROC_NR)
   {
        static int first=1;
        if (first)
@@ -40,7 +40,7 @@ PUBLIC int do_copy(struct proc * caller, message * m_ptr)
                first= 0;
                printf(
 "do_copy: got request from %d (source %d, seg %d, destination %d, seg %d)\n",
-                       m_ptr->m_source,
+                       caller->p_endpoint,
                        m_ptr->CP_SRC_ENDPT,
                        m_ptr->CP_SRC_SPACE,
                        m_ptr->CP_DST_ENDPT,
@@ -65,7 +65,7 @@ PUBLIC int do_copy(struct proc * caller, message * m_ptr)
        int p;
       /* Check if process number was given implictly with SELF and is valid. */
       if (vir_addr[i].proc_nr_e == SELF)
-       vir_addr[i].proc_nr_e = m_ptr->m_source;
+       vir_addr[i].proc_nr_e = caller->p_endpoint;
       if (vir_addr[i].segment != PHYS_SEG) {
        if(! isokendpt(vir_addr[i].proc_nr_e, &p)) {
          printf("do_copy: %d: seg 0x%x, %d not ok endpoint\n",
@@ -73,10 +73,6 @@ PUBLIC int do_copy(struct proc * caller, message * m_ptr)
           return(EINVAL); 
         }
       }
-
-      /* Check if physical addressing is used without SYS_PHYSCOPY. */
-      if ((vir_addr[i].segment & PHYS_SEG) &&
-          m_ptr->m_type != SYS_PHYSCOPY) return(EPERM);
   }
 
   /* Check for overflow. This would happen for 64K segments and 16-bit 

diff --git a/kernel/system/do_irqctl.c b/kernel/system/do_irqctl.c
index 2e14eedb3a2cb308ca26900e146f7d205e988717..08e1076349dced22b30bd178f7b37db57bf7bb18 100644 (file)
--- a/kernel/system/do_irqctl.c
+++ b/kernel/system/do_irqctl.c
@@ -43,7 +43,7 @@ PUBLIC int do_irqctl(struct proc * caller, message * m_ptr)
   case IRQ_DISABLE: 
       if (irq_hook_id >= NR_IRQ_HOOKS || irq_hook_id < 0 ||
           irq_hooks[irq_hook_id].proc_nr_e == NONE) return(EINVAL);
-      if (irq_hooks[irq_hook_id].proc_nr_e != m_ptr->m_source) return(EPERM);
+      if (irq_hooks[irq_hook_id].proc_nr_e != caller->p_endpoint) return(EPERM);
       if (m_ptr->IRQ_REQUEST == IRQ_ENABLE) {
           enable_irq(&irq_hooks[irq_hook_id]); 
       }
@@ -76,7 +76,7 @@ PUBLIC int do_irqctl(struct proc * caller, message * m_ptr)
        {
                printf(
                "do_irqctl: IRQ check failed for proc %d, IRQ %d\n",
-                       m_ptr->m_source, irq_vec);
+                       caller->p_endpoint, irq_vec);
                return EPERM;
        }
     }
@@ -90,7 +90,7 @@ PUBLIC int do_irqctl(struct proc * caller, message * m_ptr)
       /* Try to find an existing mapping to override. */
       hook_ptr = NULL;
       for (i=0; !hook_ptr && i<NR_IRQ_HOOKS; i++) {
-          if (irq_hooks[i].proc_nr_e == m_ptr->m_source
+          if (irq_hooks[i].proc_nr_e == caller->p_endpoint
               && irq_hooks[i].notify_id == notify_id) {
               irq_hook_id = i;
               hook_ptr = &irq_hooks[irq_hook_id];      /* existing hook */
@@ -108,7 +108,7 @@ PUBLIC int do_irqctl(struct proc * caller, message * m_ptr)
       if (hook_ptr == NULL) return(ENOSPC);
 
       /* Install the handler. */
-      hook_ptr->proc_nr_e = m_ptr->m_source;   /* process to notify */         
+      hook_ptr->proc_nr_e = caller->p_endpoint;        /* process to notify */
       hook_ptr->notify_id = notify_id;         /* identifier to pass */        
       hook_ptr->policy = m_ptr->IRQ_POLICY;    /* policy for interrupts */
       put_irq_handler(hook_ptr, irq_vec, generic_handler);
@@ -121,7 +121,7 @@ PUBLIC int do_irqctl(struct proc * caller, message * m_ptr)
       if (irq_hook_id < 0 || irq_hook_id >= NR_IRQ_HOOKS ||
                irq_hooks[irq_hook_id].proc_nr_e == NONE) {
            return(EINVAL);
-      } else if (m_ptr->m_source != irq_hooks[irq_hook_id].proc_nr_e) {
+      } else if (caller->p_endpoint != irq_hooks[irq_hook_id].proc_nr_e) {
            return(EPERM);
       }
       /* Remove the handler and return. */

diff --git a/kernel/system/do_profbuf.c b/kernel/system/do_profbuf.c
index 3600f26fc7a83a43fc7c65585315a5508dfb62ef..7b87df0163b13883fc7c8dcc7225150d345ca88e 100644 (file)
--- a/kernel/system/do_profbuf.c
+++ b/kernel/system/do_profbuf.c
@@ -26,7 +26,7 @@ PUBLIC int do_profbuf(struct proc * caller, message * m_ptr)
   struct proc *rp;                          
 
   /* Store process name, control struct, table locations. */
-  if(!isokendpt(m_ptr->m_source, &proc_nr))
+  if(!isokendpt(caller->p_endpoint, &proc_nr))
        return EDEADSRCDST;
 
   if(cprof_procs_no >= NR_SYS_PROCS)

diff --git a/kernel/system/do_setalarm.c b/kernel/system/do_setalarm.c
index 0825a5a3683547a9afc2741159058e036b5dfd8e..d28007a814a5852384f428349337ba9eaf8c4ce8 100644 (file)
--- a/kernel/system/do_setalarm.c
+++ b/kernel/system/do_setalarm.c
@@ -34,7 +34,7 @@ PUBLIC int do_setalarm(struct proc * caller, message * m_ptr)
 
   /* Get the timer structure and set the parameters for this alarm. */
   tp = &(priv(caller)->s_alarm_timer);
-  tmr_arg(tp)->ta_int = m_ptr->m_source;
+  tmr_arg(tp)->ta_int = caller->p_endpoint;
   tp->tmr_func = cause_alarm; 
 
   /* Return the ticks left on the previous alarm. */

diff --git a/kernel/system/do_times.c b/kernel/system/do_times.c
index dd6d7e4c47fb0096237c90b85fe3b06e829fa963..0de86debf334715779c8bd49126e796b1492c37c 100644 (file)
--- a/kernel/system/do_times.c
+++ b/kernel/system/do_times.c
@@ -28,7 +28,7 @@ PUBLIC int do_times(struct proc * caller, message * m_ptr)
    * The clock's interrupt handler may run to update the user or system time
    * while in this code, but that cannot do any harm.
    */
-  e_proc_nr = (m_ptr->T_ENDPT == SELF) ? m_ptr->m_source : m_ptr->T_ENDPT;
+  e_proc_nr = (m_ptr->T_ENDPT == SELF) ? caller->p_endpoint : m_ptr->T_ENDPT;
   if(e_proc_nr != NONE && isokendpt(e_proc_nr, &proc_nr)) {
       rp = proc_addr(proc_nr);
       m_ptr->T_USER_TIME   = rp->p_user_time;

diff --git a/kernel/system/do_unused.c b/kernel/system/do_unused.c
deleted file mode 100644 (file)
index 155968b..0000000
--- a/kernel/system/do_unused.c
+++ /dev/null
@@ -1,16 +0,0 @@
-/* This file provides a catch-all handler for unused kernel calls. A kernel 
- * call may be unused when it is not defined or when it is disabled in the
- * kernel's configuration.
- */
-#include "kernel/system.h"
-
-/*===========================================================================*
- *                               do_unused                                  *
- *===========================================================================*/
-PUBLIC int do_unused(struct proc * caller, message * m_ptr)
-{
-  printf("SYSTEM: got unused request %d from %d\n",
-                 m_ptr->m_type, m_ptr->m_source);
-  return(EBADREQUEST);                 /* illegal message type */
-}
-

diff --git a/kernel/system/do_vdevio.c b/kernel/system/do_vdevio.c
index d3be18e67a4725361bef774cf46797ce82147b56..88524357bf0b6f8d54701faf16ac4c73667ab518 100644 (file)
--- a/kernel/system/do_vdevio.c
+++ b/kernel/system/do_vdevio.c
@@ -94,7 +94,7 @@ PUBLIC int do_vdevio(struct proc * caller, message * m_ptr)
                {
                        printf(
                "do_vdevio: I/O port check failed for proc %d, port 0x%x\n",
-                               m_ptr->m_source, port);
+                               caller->p_endpoint, port);
                        return EPERM;
                }
        }

diff --git a/kernel/system/do_vmctl.c b/kernel/system/do_vmctl.c
index b18cbde6e39477b9d909931d180aa3682ebc1dcb..c5fdbd865f8810eaa091be2673ba3d623b871c55 100644 (file)
--- a/kernel/system/do_vmctl.c
+++ b/kernel/system/do_vmctl.c
@@ -22,7 +22,7 @@ PUBLIC int do_vmctl(struct proc * caller, message * m_ptr)
   endpoint_t ep = m_ptr->SVMCTL_WHO;
   struct proc *p, *rp, *target;
 
-  if(ep == SELF) { ep = m_ptr->m_source; }
+  if(ep == SELF) { ep = caller->p_endpoint; }
 
   if(!isokendpt(ep, &proc_nr)) {
        printf("do_vmctl: unexpected endpoint %d from VM\n", ep);

diff --git a/kernel/system/do_vtimer.c b/kernel/system/do_vtimer.c
index a3fb883770aa90cd3b757828369a4fbce5c5eb23..a0c6de045e7b537eeeb2d639d6a3dce1ddd17151 100644 (file)
--- a/kernel/system/do_vtimer.c
+++ b/kernel/system/do_vtimer.c
@@ -34,7 +34,7 @@ PUBLIC int do_vtimer(struct proc * caller, message * m_ptr)
       return(EINVAL);
 
   /* The target process must be valid. */
-  proc_nr_e = (m_ptr->VT_ENDPT == SELF) ? m_ptr->m_source : m_ptr->VT_ENDPT;
+  proc_nr_e = (m_ptr->VT_ENDPT == SELF) ? caller->p_endpoint : m_ptr->VT_ENDPT;
   if (!isokendpt(proc_nr_e, &proc_nr)) return(EINVAL);
   rp = proc_addr(proc_nr);