Cleaned up table. Moved policies to table.

Small fixes to do_copy, do_privctl and do_fork.

diff --git a/kernel/ipc.h b/kernel/ipc.h
index ffff3cf2c11a9e9113003240dd8bfcba1b1eb312..04b86acd7fd3b0862d489e83adb0872d29e2a2d2 100644 (file)
--- a/kernel/ipc.h
+++ b/kernel/ipc.h
@@ -7,8 +7,6 @@
 #define SYSCALL_FUNC   0x0F    /* mask for system call function */
 #define SYSCALL_FLAGS   0xF0    /* mask for system call flags */
 #define NON_BLOCKING    0x10   /* prevent blocking, return error */
-#define FRESH_ANSWER    0x20   /* ignore pending notifications as answer */
-                               /* (default behaviour for SENDREC calls) */
 
 /* System call numbers that are passed when trapping to the kernel. The 
  * numbers are carefully defined so that it can easily be seen (based on 
@@ -25,13 +23,6 @@
 #define CHECK_DST     0x05     /* 0 1 0 1 : validate message destination */
 #define CHECK_SRC     0x02     /* 0 0 1 0 : validate message source */
 
-/* Call masks indicating which system calls (traps) a process can make. 
- * System processes can do anything; user processes are highly restricted. 
- */
-#define EMPTY_MASK             (0)
-#define FILLED_MASK            (~0)
-#define TASK_CALL_MASK         (1 << RECEIVE)
-#define USER_CALL_MASK         ((1 << SENDREC) | (1 << ECHO))
 
 /* Send masks determine to whom processes can send messages or notifications. 
  * The values here are used for the processes in the boot image. We rely on 
@@ -44,13 +35,12 @@
  * "BITCHUNK_BITS - NR_TASKS", because a bitchunk_t field is used to store 
  * the send masks in the table that describes that processes in the image.  
  */
-#define s_nr_to_id(n)          (NR_TASKS + (n) + 1)
-#define s(n)                   (1 << s_nr_to_id(n))
-#define USER_SEND_MASK         (s(PM_PROC_NR) | s(FS_PROC_NR))
-#define DRIVER_SEND_MASK       (s(PM_PROC_NR) | s(FS_PROC_NR) | s(SYSTEM) | \
-                                s(CLOCK) | s(PRINTF_PROC) | s(TTY))
-#define SERVER_SEND_MASK       (~0)
-#define SYSTEM_SEND_MASK       (~1)
+#define s_nr_to_id(n)  (NR_TASKS + (n) + 1)
+#define s(n)           (1 << s_nr_to_id(n))
+#define SERV_M         (~0)
+#define SYST_M         (~0)
+#define USER_M         (s(PM_PROC_NR)|s(FS_PROC_NR)|s(SM_PROC_NR))
+#define DRIV_M         (USER_M | s(SYSTEM)|s(CLOCK)|s(LOG_PROC_NR)|s(TTY))
 
 /* Sanity check to make sure the send masks can be set. */
 extern int dummy[(BITCHUNK_BITS-NR_TASKS > INIT_PROC_NR) ? 1 : -1];

diff --git a/kernel/proc.c b/kernel/proc.c
index ddba8b1fadf23c41838b759066737bd2c16507a3..9cae2905ca8199f55f1e22566cff7095d8a7e3a2 100755 (executable)
--- a/kernel/proc.c
+++ b/kernel/proc.c
@@ -117,8 +117,10 @@ message *m_ptr;                    /* pointer to message in the caller's space */
       return(ECALLDENIED);     
   
   /* Require a valid source and/ or destination process, unless echoing. */
-  if (! (isokprocn(src_dst) || src_dst == ANY || function == ECHO))  
+  if (! (isokprocn(src_dst) || src_dst == ANY || function == ECHO)) { 
+      kprintf("sys_call: function %d, src_dst %d\n", function, src_dst);
       return(EBADSRCDST);
+  }
 
   /* If the call involves a message buffer, i.e., for SEND, RECEIVE, SENDREC, 
    * or ECHO, check the message pointer. This check allows a message to be 

diff --git a/kernel/proc.h b/kernel/proc.h
index e40beb2341d29f2905fbe6520c17ab0669c6eb1f..6e5bc8da37e5fe6ad611e8bda8f58c2244a1c202 100755 (executable)
--- a/kernel/proc.h
+++ b/kernel/proc.h
@@ -66,6 +66,7 @@ struct proc {
 #define SIGNALED       0x10    /* set when new kernel signal arrives */
 #define SIG_PENDING    0x20    /* unready while signal being processed */
 #define P_STOP         0x40    /* set when process is being traced */
+#define NO_PRIV                0x80    /* keep forked system process from running */
 
 /* Scheduling priorities for p_priority. Values must start at zero (highest
  * priority) and increment. Priorities of the processes in the boot image can 

diff --git a/kernel/system/do_copy.c b/kernel/system/do_copy.c
index 9212329cbe90b0b2e22f741b510338f864906144..d685a4cfab40386703d22886c86e0e35bf6f96c5 100644 (file)
--- a/kernel/system/do_copy.c
+++ b/kernel/system/do_copy.c
@@ -27,7 +27,7 @@ register message *m_ptr;      /* pointer to request message */
  * are two different system calls so that permissions can be checked. 
  */
   struct vir_addr vir_addr[2]; /* virtual source and destination address */
-  vir_bytes bytes;             /* number of bytes to copy */
+  phys_bytes bytes;            /* number of bytes to copy */
   int i;
 
   /* Dismember the command message. */

diff --git a/kernel/system/do_fork.c b/kernel/system/do_fork.c
index a342d2e6b7c82f0cf532e9c55eabc69c0e463bd8..a68f65250155355c334d13a17e039fa42bfb9d58 100644 (file)
--- a/kernel/system/do_fork.c
+++ b/kernel/system/do_fork.c
@@ -32,17 +32,19 @@ register message *m_ptr;    /* pointer to request message */
   rpc = proc_addr(m_ptr->PR_PROC_NR);
   if (isemptyp(rpp) || ! isemptyp(rpc)) return(EINVAL);
 
-  /* If this is a system process, make sure the child process gets its own
-   * privilege structure for accounting. This is the only part that can fail,
-   * so do this before allocating the process table slot.
+#if DEAD_CODE
+  /* If the parent is a privileged process, ensure the child process also gets 
+   * its own privilege structure for accounting. This is the only part that can 
+   * fail, so do this before allocating the process table slot.
    */
-  if (priv(rpc)->s_flags & SYS_PROC) {
+  if (priv(rpp)->s_flags & SYS_PROC) {
       if (OK != (i=get_priv(rpc, SYS_PROC))) return(i);        /* get structure */
       for (i=0; i< BITMAP_CHUNKS(NR_SYS_PROCS); i++)   /* remove pending: */
           priv(rpc)->s_notify_pending.chunk[i] = 0;    /* - notifications */
       priv(rpc)->s_int_pending = 0;                    /* - interrupts */
       sigemptyset(&priv(rpc)->s_sig_pending);          /* - signals */
   }
+#endif
 
   /* Copy parent 'proc' struct to child. And reinitialize some fields. */
 #if (CHIP == INTEL)
@@ -63,6 +65,14 @@ register message *m_ptr;     /* pointer to request message */
   rpc->p_user_time = 0;                /* set all the accounting times to 0 */
   rpc->p_sys_time = 0;
 
+  /* If the parent is a privileged process, take away the privileges from the 
+   * child process and inhibit it from running by setting the NO_PRIV flag.
+   * The caller should explicitely set the new privileges before executing.
+   */
+  if (priv(rpp)->s_flags & SYS_PROC) {
+      rpc->p_priv = priv_addr(USER_PRIV_ID);
+      rpc->p_rts_flags |= NO_PRIV;
+  }
   return(OK);
 }
 

diff --git a/kernel/system/do_privctl.c b/kernel/system/do_privctl.c
index 0882569c8d534a3c719ea9be6cd02f9446b0b969..3fbf495e43633f373d735f2977a6693cf6c21c1b 100644 (file)
--- a/kernel/system/do_privctl.c
+++ b/kernel/system/do_privctl.c
@@ -2,14 +2,17 @@
  *   m_type:   SYS_PRIVCTL
  *
  * The parameters for this system call are:
- *    m2_i1:   CTL_PROC_NR     (process number of caller)      
+ *    m1_i1:   PR_PROC_NR      (process number of caller)      
  */
 
 #include "../system.h"
 #include "../ipc.h"
+#include <signal.h>
 
 #if USE_PRIVCTL
 
+#define FILLED_MASK    (~0)
+
 /*===========================================================================*
  *                             do_privctl                                   *
  *===========================================================================*/
@@ -19,21 +22,40 @@ message *m_ptr;                     /* pointer to request message */
 /* Handle sys_privctl(). Update a process' privileges. If the process is not
  * yet a system process, make sure it gets its own privilege structure.
  */
+  register struct proc *caller_ptr;
   register struct proc *rp;
   register struct priv *sp;
   int proc_nr;
+  int priv_id;
+  int old_flags;
   int i;
 
-  /* Extract message parameters. */
-  proc_nr = m_ptr->CTL_PROC_NR;
-  if (proc_nr == SELF) proc_nr = m_ptr->m_source;
+  /* Check whether caller is allowed to make this call. Privileged proceses 
+   * can only update the privileges of processes that are inhibited from 
+   * running by the NO_PRIV flag. This flag is set when a privileged process
+   * forks. 
+   */
+  caller_ptr = proc_addr(m_ptr->m_source);
+  if (! (priv(caller_ptr)->s_flags & SYS_PROC)) return(EPERM); 
+  proc_nr = m_ptr->PR_PROC_NR;
   if (! isokprocn(proc_nr)) return(EINVAL);
-
   rp = proc_addr(proc_nr);
+  if (! (rp->p_rts_flags & NO_PRIV)) return(EPERM);
 
-  /* Make sure this process has its own privileges structure. */
-  if (! (priv(rp)->s_flags & SYS_PROC)) 
-      if ((i=get_priv(rp, SYS_PROC)) != OK) return(i);
+  /* Make sure this process has its own privileges structure. This may fail, 
+   * since there are only a limited number of system processes. Then copy the
+   * privileges from the caller and restore some defaults.
+   */
+  if ((i=get_priv(rp, SYS_PROC)) != OK) return(i);
+  priv_id = priv(rp)->s_id;                    /* backup privilege id */
+  *priv(rp) = *priv(caller_ptr);               /* copy privileges */
+  priv(rp)->s_id = priv_id;                    /* restore privilege id */
+  priv(rp)->s_proc_nr = proc_nr;               /* reassociate process nr */
+
+  for (i=0; i< BITMAP_CHUNKS(NR_SYS_PROCS); i++)       /* remove pending: */
+      priv(rp)->s_notify_pending.chunk[i] = 0;         /* - notifications */
+  priv(rp)->s_int_pending = 0;                         /* - interrupts */
+  sigemptyset(&priv(rp)->s_sig_pending);               /* - signals */
 
   /* Now update the process' privileges as requested. */
   rp->p_priv->s_call_mask = FILLED_MASK;
@@ -50,6 +72,11 @@ message *m_ptr;                      /* pointer to request message */
           set_sys_bit(priv_addr(i)->s_send_mask, priv_id(rp));
       }
   }
+
+  /* Done. Privileges have been set. Allow process to run again. */
+  old_flags = rp->p_rts_flags;         /* save value of the flags */
+  rp->p_rts_flags &= ~NO_PRIV;                 
+  if (old_flags != 0 && rp->p_rts_flags == 0) lock_ready(rp);
   return(OK);
 }
 

diff --git a/kernel/table.c b/kernel/table.c
index 7aad531145ae2b71eaf482798567a642a89e456e..466c4e9f92486d9da104537117b1f391fd61111a 100755 (executable)
--- a/kernel/table.c
+++ b/kernel/table.c
@@ -26,7 +26,6 @@
  *    Oct 17, 2004   updated above and tasktab comments  (Jorrit N. Herder)
  *    May 01, 2004   changed struct for system image  (Jorrit N. Herder)
  */
-
 #define _TABLE
 
 #include "kernel.h"
@@ -35,75 +34,57 @@
 #include <minix/com.h>
 #include <ibm/int86.h>
 
-/* Define stack sizes for all tasks included in the system image. */
+/* Define stack sizes for the kernel tasks included in the system image. */
 #define NO_STACK       0
 #define SMALL_STACK    (128 * sizeof(char *))
-#if (CHIP == INTEL)                    /* 3 intr, 3 temps, 4 db */
-#define        IDLE_S          ((3+3+4) * sizeof(char *))  
-#else
-#define IDLE_S         SMALL_STACK
-#endif
-#define        HARDWARE_S      NO_STACK        /* dummy task, uses kernel stack */
-#define        SYSTEM_S        SMALL_STACK
-#define        CLOCK_S         SMALL_STACK
+#define IDLE_S         SMALL_STACK     /* 3 intr, 3 temps, 4 db for Intel */
+#define        HRDW_S          NO_STACK        /* dummy task, uses kernel stack */
+#define        TASK_S          SMALL_STACK     /* system and clock task */
 
 /* Stack space for all the task stacks.  Declared as (char *) to align it. */
-#define        TOT_STACK_SPACE (IDLE_S + HARDWARE_S + CLOCK_S + SYSTEM_S)
+#define        TOT_STACK_SPACE (IDLE_S + HRDW_S + (2 * TASK_S))
 PUBLIC char *t_stack[TOT_STACK_SPACE / sizeof(char *)];
        
+/* Define flags for the various process types. */
+#define IDLE_F                 (BILLABLE | SYS_PROC)           /* idle task */
+#define TASK_F                 (SYS_PROC)                      /* kernel tasks */
+#define SERV_F                 (PREEMPTIBLE | SYS_PROC)        /* system services */
+#define USER_F         (PREEMPTIBLE | BILLABLE)        /* user processes */
+
+/* Define system call traps for the various process types. These call masks
+ * determine what system call traps a process is allowed to make.
+ */
+#define TASK_T         (1 << RECEIVE)                  /* clock and system */
+#define SERV_T         (~0)                            /* system services */
+#define USER_T          ((1 << SENDREC) | (1 << ECHO)) /* user processes */
+
 
 /* The system image table lists all programs that are part of the boot image. 
  * The order of the entries here MUST agree with the order of the programs
  * in the boot image and all kernel tasks must come first.
- * Each entry provides the process number, type, scheduling priority, send
- * mask, and a name for the process table. For kernel processes, the startup 
- * routine and stack size is also provided.
+ * Each entry provides the process number, flags, quantum size (qs), scheduling 
+ * queue, allowed traps, ipc mask, and a name for the process table. The 
+ * initial program counter and stack size is also provided for kernel tasks.
  */
-#define USER_F         (PREEMPTIBLE | BILLABLE)
-#define IDLE_F                 (BILLABLE | SYS_PROC)
-#define SYS_F                  (PREEMPTIBLE | SYS_PROC)
-#define TASK_F                 (SYS_PROC)      
-
-#define IDLE_T         32              /* ticks */
-#define USER_T          8              /* ticks */
-#define SYS_T          16              /* ticks */
-
 PUBLIC struct boot_image image[] = {
- { IDLE,    idle_task,  IDLE_F, IDLE_T,   IDLE_Q,  IDLE_S,    EMPTY_MASK, EMPTY_MASK,    "IDLE"    },
- { CLOCK,   clock_task, TASK_F, SYS_T,   TASK_Q, CLOCK_S,   TASK_CALL_MASK, SYSTEM_SEND_MASK,   "CLOCK"   },
- { SYSTEM,  sys_task,   TASK_F, SYS_T,   TASK_Q, SYSTEM_S,     TASK_CALL_MASK, SYSTEM_SEND_MASK,  "SYSTEM"     },
- { HARDWARE,   0,       TASK_F, SYS_T,   TASK_Q, HARDWARE_S, EMPTY_MASK, SYSTEM_SEND_MASK, "KERNEL" },
- { PM_PROC_NR, 0,       SYS_F, SYS_T, 3, 0,          FILLED_MASK,   SERVER_SEND_MASK,      "PM"      },
- { FS_PROC_NR, 0,       SYS_F, SYS_T, 4, 0,          FILLED_MASK,   SERVER_SEND_MASK,      "FS"      },
- { SM_PROC_NR, 0,       SYS_F, SYS_T, 3, 0,          FILLED_MASK,   SYSTEM_SEND_MASK,      "SM"      },
- { IS_PROC_NR, 0,       SYS_F, SYS_T, 2, 0,           FILLED_MASK,  DRIVER_SEND_MASK,      "IS"      },
- { TTY, 0,              SYS_F, SYS_T, 1, 0,           FILLED_MASK, SYSTEM_SEND_MASK,      "TTY"      },
- { MEMORY, 0,           SYS_F, SYS_T, 2, 0,           FILLED_MASK,  DRIVER_SEND_MASK,     "MEMORY" },
+/* process nr,    pc,  flags, qs,  queue,  stack,  traps, ipc mask,  name */ 
+ { IDLE,   idle_task, IDLE_F, 32, IDLE_Q, IDLE_S,      0,      0, "IDLE"    },
+ { CLOCK, clock_task, TASK_F,  0, TASK_Q, TASK_S, TASK_T,      0, "CLOCK"   },
+ { SYSTEM,  sys_task, TASK_F,  0, TASK_Q, TASK_S, TASK_T,      0, "SYSTEM"  },
+ { HARDWARE,       0, TASK_F,  0, TASK_Q, HRDW_S,      0,      0, "KERNEL"  },
+ { PM_PROC_NR,     0, SERV_F, 16,      3, 0,      SERV_T, SERV_M, "PM"      },
+ { FS_PROC_NR,     0, SERV_F, 16,      4, 0,      SERV_T, SERV_M, "FS"      },
+ { SM_PROC_NR,     0, SERV_F, 16,      3, 0,      SERV_T, SYST_M, "SM"      },
+ { TTY,            0, SERV_F, 16,      1, 0,      SERV_T, SYST_M, "TTY"     },
+ { MEMORY,         0, SERV_F, 16,      2, 0,      SERV_T, DRIV_M, "MEMORY"  },
+ { LOG_PROC_NR,    0, SERV_F, 16,      2, 0,      SERV_T, SYST_M, "LOG"     },
 #if ENABLE_AT_WINI
- { AT_WINI, 0,            SYS_F, SYS_T, 2, 0,          FILLED_MASK, DRIVER_SEND_MASK,      "AT_WINI" },
-#endif
-#if ENABLE_FLOPPY
- { FLOPPY, 0,            SYS_F, SYS_T, 2, 0,           FILLED_MASK,  DRIVER_SEND_MASK,  "FLOPPY" },
-#endif
-#if ENABLE_PRINTER
- { PRINTER, 0,            SYS_F, SYS_T, 3, 0,         FILLED_MASK,  DRIVER_SEND_MASK,     "PRINTER" },
-#endif
-#if ENABLE_RTL8139
- { RTL8139, 0,            SYS_F, SYS_T, 2, 0,           FILLED_MASK,  DRIVER_SEND_MASK,  "RTL8139" },
-#endif
-#if ENABLE_FXP
- { FXP, 0,                SYS_F, SYS_T, 2, 0,           FILLED_MASK,  DRIVER_SEND_MASK,  "FXP" },
-#endif
-#if ENABLE_DPETH
- { DPETH, 0,              SYS_F, SYS_T, 2, 0,           FILLED_MASK,  DRIVER_SEND_MASK,  "DPETH" },
-#endif
-#if ENABLE_LOG
- { LOG_PROC_NR, 0,     SYS_F, SYS_T, 2, 0,           FILLED_MASK,  SYSTEM_SEND_MASK,  "LOG" },
+ { AT_WINI,        0, SERV_F, 16,      2, 0,      SERV_T, DRIV_M, "AT_WINI" },
 #endif
 #if ENABLE_BIOS_WINI
- { BIOS_WINI, 0,     SYS_F, SYS_T, 2, 0,           FILLED_MASK,  SYSTEM_SEND_MASK,  "BIOS" },
+ { BIOS_WINI,      0, SERV_F, 16,      2, 0,      SERV_T, SYST_M, "BIOS"    },
 #endif
- { INIT_PROC_NR, 0,    USER_F, USER_T, USER_Q, 0,         USER_CALL_MASK,    USER_SEND_MASK,  "INIT"    },
+ { INIT_PROC_NR,   0, USER_F,  8, USER_Q, 0,      USER_T, USER_M, "INIT"    },
 };
 
 /* Verify the size of the system image table at compile time. If the number