minix/servers/pm/main.c

   1 /* This file contains the main program of the process manager and some related
   2  * procedures.  When MINIX starts up, the kernel runs for a little while,
   3  * initializing itself and its tasks, and then it runs PM and VFS.  Both PM
   4  * and VFS initialize themselves as far as they can. PM asks the kernel for
   5  * all free memory and starts serving requests.
   6  *
   7  * The entry points into this file are:
   8  *   main:      starts PM running
   9  *   reply:     send a reply to a process making a PM system call
  10  */
  11
  12 #include "pm.h"
  13 #include <minix/callnr.h>
  14 #include <minix/com.h>
  15 #include <minix/ds.h>
  16 #include <minix/type.h>
  17 #include <minix/endpoint.h>
  18 #include <minix/minlib.h>
  19 #include <minix/type.h>
  20 #include <minix/vm.h>
  21 #include <signal.h>
  22 #include <stdlib.h>
  23 #include <fcntl.h>
  24 #include <sys/resource.h>
  25 #include <sys/utsname.h>
  26 #include <sys/wait.h>
  27 #include <machine/archtypes.h>
  28 #include <env.h>
  29 #include <assert.h>
  30 #include "mproc.h"
  31
  32 #include "kernel/const.h"
  33 #include "kernel/config.h"
  34 #include "kernel/proc.h"
  35
  36 #if ENABLE_SYSCALL_STATS
  37 EXTERN unsigned long calls_stats[NR_PM_CALLS];
  38 #endif
  39
  40 static int get_nice_value(int queue);
  41 static void handle_vfs_reply(void);
  42
  43 /* SEF functions and variables. */
  44 static void sef_local_startup(void);
  45 static int sef_cb_init_fresh(int type, sef_init_info_t *info);
  46
  47 /*===========================================================================*
  48  *                              main                                         *
  49  *===========================================================================*/
  50 int main()
  51 {
  52 /* Main routine of the process manager. */
  53   unsigned int call_index;
  54   int ipc_status, result;
  55
  56   /* SEF local startup. */
  57   sef_local_startup();
  58
  59   /* This is PM's main loop-  get work and do it, forever and forever. */
  60   while (TRUE) {
  61         /* Wait for the next message. */
  62         if (sef_receive_status(ANY, &m_in, &ipc_status) != OK)
  63                 panic("PM sef_receive_status error");
  64
  65         /* Check for system notifications first. Special cases. */
  66         if (is_ipc_notify(ipc_status)) {
  67                 if (_ENDPOINT_P(m_in.m_source) == CLOCK)
  68                         expire_timers(m_in.m_notify.timestamp);
  69
  70                 /* done, continue */
  71                 continue;
  72         }
  73
  74         /* Extract useful information from the message. */
  75         who_e = m_in.m_source;  /* who sent the message */
  76         if (pm_isokendpt(who_e, &who_p) != OK)
  77                 panic("PM got message from invalid endpoint: %d", who_e);
  78         mp = &mproc[who_p];     /* process slot of caller */
  79         call_nr = m_in.m_type;  /* system call number */
  80
  81         /* Drop delayed calls from exiting processes. */
  82         if (mp->mp_flags & EXITING)
  83                 continue;
  84
  85         if (IS_VFS_PM_RS(call_nr) && who_e == VFS_PROC_NR) {
  86                 handle_vfs_reply();
  87
  88                 result = SUSPEND;               /* don't reply */
  89         } else if (IS_PM_CALL(call_nr)) {
  90                 /* If the system call number is valid, perform the call. */
  91                 call_index = (unsigned int) (call_nr - PM_BASE);
  92
  93                 if (call_index < NR_PM_CALLS && call_vec[call_index] != NULL) {
  94 #if ENABLE_SYSCALL_STATS
  95                         calls_stats[call_index]++;
  96 #endif
  97
  98                         result = (*call_vec[call_index])();
  99                 } else
 100                         result = ENOSYS;
 101         } else
 102                 result = ENOSYS;
 103
 104         /* Send reply. */
 105         if (result != SUSPEND) reply(who_p, result);
 106   }
 107   return(OK);
 108 }
 109
 110 /*===========================================================================*
 111  *                             sef_local_startup                             *
 112  *===========================================================================*/
 113 static void sef_local_startup()
 114 {
 115   /* Register init callbacks. */
 116   sef_setcb_init_fresh(sef_cb_init_fresh);
 117   sef_setcb_init_restart(sef_cb_init_fail);
 118
 119   /* No live update support for now. */
 120
 121   /* Register signal callbacks. */
 122   sef_setcb_signal_manager(process_ksig);
 123
 124   /* Let SEF perform startup. */
 125   sef_startup();
 126 }
 127
 128 /*===========================================================================*
 129  *                          sef_cb_init_fresh                                *
 130  *===========================================================================*/
 131 static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
 132 {
 133 /* Initialize the process manager. */
 134   int s;
 135   static struct boot_image image[NR_BOOT_PROCS];
 136   register struct boot_image *ip;
 137   static char core_sigs[] = { SIGQUIT, SIGILL, SIGTRAP, SIGABRT,
 138                                 SIGEMT, SIGFPE, SIGBUS, SIGSEGV };
 139   static char ign_sigs[] = { SIGCHLD, SIGWINCH, SIGCONT, SIGINFO };
 140   static char noign_sigs[] = { SIGILL, SIGTRAP, SIGEMT, SIGFPE,
 141                                 SIGBUS, SIGSEGV };
 142   register struct mproc *rmp;
 143   register char *sig_ptr;
 144   message mess;
 145
 146   /* Initialize process table, including timers. */
 147   for (rmp=&mproc[0]; rmp<&mproc[NR_PROCS]; rmp++) {
 148         init_timer(&rmp->mp_timer);
 149         rmp->mp_magic = MP_MAGIC;
 150   }
 151
 152   /* Build the set of signals which cause core dumps, and the set of signals
 153    * that are by default ignored.
 154    */
 155   sigemptyset(&core_sset);
 156   for (sig_ptr = core_sigs; sig_ptr < core_sigs+sizeof(core_sigs); sig_ptr++)
 157         sigaddset(&core_sset, *sig_ptr);
 158   sigemptyset(&ign_sset);
 159   for (sig_ptr = ign_sigs; sig_ptr < ign_sigs+sizeof(ign_sigs); sig_ptr++)
 160         sigaddset(&ign_sset, *sig_ptr);
 161   sigemptyset(&noign_sset);
 162   for (sig_ptr = noign_sigs; sig_ptr < noign_sigs+sizeof(noign_sigs); sig_ptr++)
 163         sigaddset(&noign_sset, *sig_ptr);
 164
 165   /* Obtain a copy of the boot monitor parameters.
 166    */
 167   if ((s=sys_getmonparams(monitor_params, sizeof(monitor_params))) != OK)
 168       panic("get monitor params failed: %d", s);
 169
 170   /* Initialize PM's process table. Request a copy of the system image table
 171    * that is defined at the kernel level to see which slots to fill in.
 172    */
 173   if (OK != (s=sys_getimage(image)))
 174         panic("couldn't get image table: %d", s);
 175   procs_in_use = 0;                             /* start populating table */
 176   for (ip = &image[0]; ip < &image[NR_BOOT_PROCS]; ip++) {
 177         if (ip->proc_nr >= 0) {                 /* task have negative nrs */
 178                 procs_in_use += 1;              /* found user process */
 179
 180                 /* Set process details found in the image table. */
 181                 rmp = &mproc[ip->proc_nr];
 182                 strlcpy(rmp->mp_name, ip->proc_name, PROC_NAME_LEN);
 183                 (void) sigemptyset(&rmp->mp_ignore);
 184                 (void) sigemptyset(&rmp->mp_sigmask);
 185                 (void) sigemptyset(&rmp->mp_catch);
 186                 if (ip->proc_nr == INIT_PROC_NR) {      /* user process */
 187                         /* INIT is root, we make it father of itself. This is
 188                          * not really OK, INIT should have no father, i.e.
 189                          * a father with pid NO_PID. But PM currently assumes
 190                          * that mp_parent always points to a valid slot number.
 191                          */
 192                         rmp->mp_parent = INIT_PROC_NR;
 193                         rmp->mp_procgrp = rmp->mp_pid = INIT_PID;
 194                         rmp->mp_flags |= IN_USE;
 195
 196                         /* Set scheduling info */
 197                         rmp->mp_scheduler = KERNEL;
 198                         rmp->mp_nice = get_nice_value(USR_Q);
 199                 }
 200                 else {                                  /* system process */
 201                         if(ip->proc_nr == RS_PROC_NR) {
 202                                 rmp->mp_parent = INIT_PROC_NR;
 203                         }
 204                         else {
 205                                 rmp->mp_parent = RS_PROC_NR;
 206                         }
 207                         rmp->mp_pid = get_free_pid();
 208                         rmp->mp_flags |= IN_USE | PRIV_PROC;
 209
 210                         /* RS schedules this process */
 211                         rmp->mp_scheduler = NONE;
 212                         rmp->mp_nice = get_nice_value(SRV_Q);
 213                 }
 214
 215                 /* Get kernel endpoint identifier. */
 216                 rmp->mp_endpoint = ip->endpoint;
 217
 218                 /* Tell VFS about this system process. */
 219                 memset(&mess, 0, sizeof(mess));
 220                 mess.m_type = VFS_PM_INIT;
 221                 mess.VFS_PM_SLOT = ip->proc_nr;
 222                 mess.VFS_PM_PID = rmp->mp_pid;
 223                 mess.VFS_PM_ENDPT = rmp->mp_endpoint;
 224                 if (OK != (s=ipc_send(VFS_PROC_NR, &mess)))
 225                         panic("can't sync up with VFS: %d", s);
 226         }
 227   }
 228
 229   /* Tell VFS that no more system processes follow and synchronize. */
 230   memset(&mess, 0, sizeof(mess));
 231   mess.m_type = VFS_PM_INIT;
 232   mess.VFS_PM_ENDPT = NONE;
 233   if (ipc_sendrec(VFS_PROC_NR, &mess) != OK || mess.m_type != OK)
 234         panic("can't sync up with VFS");
 235
 236 #if defined(__i386__)
 237         uts_val.machine[0] = 'i';
 238         strcpy(uts_val.machine + 1, itoa(getprocessor()));
 239 #elif defined(__arm__)
 240         strcpy(uts_val.machine, "arm");
 241 #endif
 242
 243  system_hz = sys_hz();
 244
 245   /* Initialize user-space scheduling. */
 246   sched_init();
 247
 248   return(OK);
 249 }
 250
 251 /*===========================================================================*
 252  *                              reply                                        *
 253  *===========================================================================*/
 254 void reply(proc_nr, result)
 255 int proc_nr;                    /* process to reply to */
 256 int result;                     /* result of call (usually OK or error #) */
 257 {
 258 /* Send a reply to a user process.  System calls may occasionally fill in other
 259  * fields, this is only for the main return value and for sending the reply.
 260  */
 261   struct mproc *rmp;
 262   int r;
 263
 264   if(proc_nr < 0 || proc_nr >= NR_PROCS)
 265       panic("reply arg out of range: %d", proc_nr);
 266
 267   rmp = &mproc[proc_nr];
 268   rmp->mp_reply.m_type = result;
 269
 270   if ((r = ipc_sendnb(rmp->mp_endpoint, &rmp->mp_reply)) != OK)
 271         printf("PM can't reply to %d (%s): %d\n", rmp->mp_endpoint,
 272                 rmp->mp_name, r);
 273 }
 274
 275 /*===========================================================================*
 276  *                              get_nice_value                               *
 277  *===========================================================================*/
 278 static int get_nice_value(queue)
 279 int queue;                              /* store mem chunks here */
 280 {
 281 /* Processes in the boot image have a priority assigned. The PM doesn't know
 282  * about priorities, but uses 'nice' values instead. The priority is between
 283  * MIN_USER_Q and MAX_USER_Q. We have to scale between PRIO_MIN and PRIO_MAX.
 284  */
 285   int nice_val = (queue - USER_Q) * (PRIO_MAX-PRIO_MIN+1) /
 286       (MIN_USER_Q-MAX_USER_Q+1);
 287   if (nice_val > PRIO_MAX) nice_val = PRIO_MAX; /* shouldn't happen */
 288   if (nice_val < PRIO_MIN) nice_val = PRIO_MIN; /* shouldn't happen */
 289   return nice_val;
 290 }
 291
 292 /*===========================================================================*
 293  *                              handle_vfs_reply                             *
 294  *===========================================================================*/
 295 static void handle_vfs_reply()
 296 {
 297   struct mproc *rmp;
 298   endpoint_t proc_e;
 299   int r, proc_n, new_parent;
 300
 301   /* VFS_PM_REBOOT is the only request not associated with a process.
 302    * Handle its reply first.
 303    */
 304   if (call_nr == VFS_PM_REBOOT_REPLY) {
 305         /* Ask the kernel to abort. All system services, including
 306          * the PM, will get a HARD_STOP notification. Await the
 307          * notification in the main loop.
 308          */
 309         sys_abort(abort_flag);
 310
 311         return;
 312   }
 313
 314   /* Get the process associated with this call */
 315   proc_e = m_in.VFS_PM_ENDPT;
 316
 317   if (pm_isokendpt(proc_e, &proc_n) != OK) {
 318         panic("handle_vfs_reply: got bad endpoint from VFS: %d", proc_e);
 319   }
 320
 321   rmp = &mproc[proc_n];
 322
 323   /* Now that VFS replied, mark the process as VFS-idle again */
 324   if (!(rmp->mp_flags & VFS_CALL))
 325         panic("handle_vfs_reply: reply without request: %d", call_nr);
 326
 327   new_parent = rmp->mp_flags & NEW_PARENT;
 328   rmp->mp_flags &= ~(VFS_CALL | NEW_PARENT);
 329
 330   if (rmp->mp_flags & UNPAUSED)
 331         panic("handle_vfs_reply: UNPAUSED set on entry: %d", call_nr);
 332
 333   /* Call-specific handler code */
 334   switch (call_nr) {
 335   case VFS_PM_SETUID_REPLY:
 336   case VFS_PM_SETGID_REPLY:
 337   case VFS_PM_SETGROUPS_REPLY:
 338         /* Wake up the original caller */
 339         reply(rmp-mproc, OK);
 340
 341         break;
 342
 343   case VFS_PM_SETSID_REPLY:
 344         /* Wake up the original caller */
 345         reply(rmp-mproc, rmp->mp_procgrp);
 346
 347         break;
 348
 349   case VFS_PM_EXEC_REPLY:
 350         exec_restart(rmp, m_in.VFS_PM_STATUS, (vir_bytes)m_in.VFS_PM_PC,
 351                 (vir_bytes)m_in.VFS_PM_NEWSP,
 352                 (vir_bytes)m_in.VFS_PM_NEWPS_STR);
 353
 354         break;
 355
 356   case VFS_PM_EXIT_REPLY:
 357         exit_restart(rmp, FALSE /*dump_core*/);
 358
 359         break;
 360
 361   case VFS_PM_CORE_REPLY:
 362         if (m_in.VFS_PM_STATUS == OK)
 363                 rmp->mp_sigstatus |= WCOREFLAG;
 364
 365         exit_restart(rmp, TRUE /*dump_core*/);
 366
 367         break;
 368
 369   case VFS_PM_FORK_REPLY:
 370         /* Schedule the newly created process ... */
 371         r = OK;
 372         if (rmp->mp_scheduler != KERNEL && rmp->mp_scheduler != NONE) {
 373                 r = sched_start_user(rmp->mp_scheduler, rmp);
 374         }
 375
 376         /* If scheduling the process failed, we want to tear down the process
 377          * and fail the fork */
 378         if (r != OK) {
 379                 /* Tear down the newly created process */
 380                 rmp->mp_scheduler = NONE; /* don't try to stop scheduling */
 381                 exit_proc(rmp, -1, FALSE /*dump_core*/);
 382
 383                 /* Wake up the parent with a failed fork (unless dead) */
 384                 if (!new_parent)
 385                         reply(rmp->mp_parent, -1);
 386         }
 387         else {
 388                 /* Wake up the child */
 389                 reply(proc_n, OK);
 390
 391                 /* Wake up the parent, unless the parent is already dead */
 392                 if (!new_parent)
 393                         reply(rmp->mp_parent, rmp->mp_pid);
 394         }
 395
 396         break;
 397
 398   case VFS_PM_SRV_FORK_REPLY:
 399         /* Nothing to do */
 400
 401         break;
 402
 403   case VFS_PM_UNPAUSE_REPLY:
 404         /* The target process must always be stopped while unpausing; otherwise
 405          * it could just end up pausing itself on a new call afterwards.
 406          */
 407         assert(rmp->mp_flags & PROC_STOPPED);
 408
 409         /* Process is now unpaused */
 410         rmp->mp_flags |= UNPAUSED;
 411
 412         break;
 413
 414   default:
 415         panic("handle_vfs_reply: unknown reply code: %d", call_nr);
 416   }
 417
 418   /* Now that the process is idle again, look at pending signals */
 419   if ((rmp->mp_flags & (IN_USE | EXITING)) == IN_USE)
 420           restart_sigs(rmp);
 421 }