kernel/system.c

   1 /* This task handles the interface between the kernel and user-level servers.
   2  * System services can be accessed by doing a system call. System calls are
   3  * transformed into request messages, which are handled by this task. By
   4  * convention, a sys_call() is transformed in a SYS_CALL request message that
   5  * is handled in a function named do_call().
   6  *
   7  * A private call vector is used to map all system calls to the functions that
   8  * handle them. The actual handler functions are contained in separate files
   9  * to keep this file clean. The call vector is used in the system task's main
  10  * loop to handle all incoming requests.
  11  *
  12  * In addition to the main sys_task() entry point, which starts the main loop,
  13  * there are several other minor entry points:
  14  *   get_priv:          assign privilege structure to user or system process
  15  *   set_sendto_bit:    allow a process to send messages to a new target
  16  *   unset_sendto_bit:  disallow a process from sending messages to a target
  17  *   send_sig:          send a signal directly to a system process
  18  *   cause_sig:         take action to cause a signal to occur via a signal mgr
  19  *   sig_delay_done:    tell PM that a process is not sending
  20  *   umap_bios:         map virtual address in BIOS_SEG to physical
  21  *   get_randomness:    accumulate randomness in a buffer
  22  *   clear_endpoint:    remove a process' ability to send and receive messages
  23  *
  24  * Changes:
  25 *    Nov 22, 2009   get_priv supports static priv ids (Cristiano Giuffrida)
  26  *   Aug 04, 2005   check if system call is allowed  (Jorrit N. Herder)
  27  *   Jul 20, 2005   send signal to services with message  (Jorrit N. Herder)
  28  *   Jan 15, 2005   new, generalized virtual copy function  (Jorrit N. Herder)
  29  *   Oct 10, 2004   dispatch system calls from call vector  (Jorrit N. Herder)
  30  *   Sep 30, 2004   source code documentation updated  (Jorrit N. Herder)
  31  */
  32
  33 #include "debug.h"
  34 #include "kernel.h"
  35 #include "system.h"
  36 #include "proc.h"
  37 #include "vm.h"
  38 #include <stdlib.h>
  39 #include <assert.h>
  40 #include <signal.h>
  41 #include <unistd.h>
  42 #include <sys/sigcontext.h>
  43 #include <minix/endpoint.h>
  44 #include <minix/safecopies.h>
  45
  46 /* Declaration of the call vector that defines the mapping of system calls
  47  * to handler functions. The vector is initialized in sys_init() with map(),
  48  * which makes sure the system call numbers are ok. No space is allocated,
  49  * because the dummy is declared extern. If an illegal call is given, the
  50  * array size will be negative and this won't compile.
  51  */
  52 PUBLIC int (*call_vec[NR_SYS_CALLS])(struct proc * caller, message *m_ptr);
  53 char *callnames[NR_SYS_CALLS];
  54
  55 #define map(call_nr, handler) \
  56     {extern int dummy[NR_SYS_CALLS>(unsigned)(call_nr-KERNEL_CALL) ? 1:-1];} \
  57     callnames[(call_nr-KERNEL_CALL)] = #call_nr;        \
  58     call_vec[(call_nr-KERNEL_CALL)] = (handler)
  59
  60 PRIVATE void kernel_call_finish(struct proc * caller, message *msg, int result)
  61 {
  62   if(result == VMSUSPEND) {
  63           /* Special case: message has to be saved for handling
  64            * until VM tells us it's allowed. VM has been notified
  65            * and we must wait for its reply to restart the call.
  66            */
  67           assert(RTS_ISSET(caller, RTS_VMREQUEST));
  68           assert(caller->p_vmrequest.type == VMSTYPE_KERNELCALL);
  69           caller->p_vmrequest.saved.reqmsg = *msg;
  70           caller->p_misc_flags |= MF_KCALL_RESUME;
  71   } else {
  72           /*
  73            * call is finished, we could have been suspended because of VM,
  74            * remove the request message
  75            */
  76           caller->p_vmrequest.saved.reqmsg.m_source = NONE;
  77           if (result != EDONTREPLY) {
  78                   /* copy the result as a message to the original user buffer */
  79                   msg->m_source = SYSTEM;
  80                   msg->m_type = result;         /* report status of call */
  81                   if (copy_msg_to_user(caller, msg,
  82                                   (message *)caller->p_delivermsg_vir)) {
  83                           printf("WARNING wrong user pointer 0x%08x from "
  84                                           "process %s / %d\n",
  85                                           caller->p_delivermsg_vir,
  86                                           caller->p_name,
  87                                           caller->p_endpoint);
  88                   }
  89           }
  90   }
  91 }
  92
  93 PRIVATE int kernel_call_dispatch(struct proc * caller, message *msg)
  94 {
  95   int result = OK;
  96   int call_nr;
  97
  98   call_nr = msg->m_type - KERNEL_CALL;
  99
 100   /* See if the caller made a valid request and try to handle it. */
 101   if (call_nr < 0 || call_nr >= NR_SYS_CALLS) { /* check call number */
 102           printf("SYSTEM: illegal request %d from %d.\n",
 103                           call_nr,msg->m_source);
 104           result = EBADREQUEST;                 /* illegal message type */
 105   }
 106   else if (!GET_BIT(priv(caller)->s_k_call_mask, call_nr)) {
 107           printf("SYSTEM: denied request %d from %d.\n",
 108                           call_nr,msg->m_source);
 109           result = ECALLDENIED;                 /* illegal message type */
 110   } else {
 111           /* handle the system call */
 112           result = (*call_vec[call_nr])(caller, msg);
 113   }
 114
 115   return result;
 116 }
 117
 118 /*===========================================================================*
 119  *                              kernel_call                                  *
 120  *===========================================================================*/
 121 /*
 122  * this function checks the basic syscall parameters and if accepted it
 123  * dispatches its handling to the right handler
 124  */
 125 PUBLIC void kernel_call(message *m_user, struct proc * caller)
 126 {
 127   int result = OK;
 128   message msg;
 129
 130   caller->p_delivermsg_vir = (vir_bytes) m_user;
 131   /*
 132    * the ldt and cr3 of the caller process is loaded because it just've trapped
 133    * into the kernel or was already set in schedcheck() before we resume
 134    * execution of an interrupted kernel call
 135    */
 136   if (copy_msg_from_user(caller, m_user, &msg) == 0) {
 137           msg.m_source = caller->p_endpoint;
 138           result = kernel_call_dispatch(caller, &msg);
 139   }
 140   else {
 141           printf("WARNING wrong user pointer 0x%08x from process %s / %d\n",
 142                           m_user, caller->p_name, caller->p_endpoint);
 143           result = EBADREQUEST;
 144   }
 145
 146   kernel_call_finish(caller, &msg, result);
 147 }
 148
 149 /*===========================================================================*
 150  *                              initialize                                   *
 151  *===========================================================================*/
 152 PUBLIC void system_init(void)
 153 {
 154   register struct priv *sp;
 155   int i;
 156
 157   /* Initialize IRQ handler hooks. Mark all hooks available. */
 158   for (i=0; i<NR_IRQ_HOOKS; i++) {
 159       irq_hooks[i].proc_nr_e = NONE;
 160   }
 161
 162   /* Initialize all alarm timers for all processes. */
 163   for (sp=BEG_PRIV_ADDR; sp < END_PRIV_ADDR; sp++) {
 164     tmr_inittimer(&(sp->s_alarm_timer));
 165   }
 166
 167   /* Initialize the call vector to a safe default handler. Some system calls
 168    * may be disabled or nonexistant. Then explicitely map known calls to their
 169    * handler functions. This is done with a macro that gives a compile error
 170    * if an illegal call number is used. The ordering is not important here.
 171    */
 172   for (i=0; i<NR_SYS_CALLS; i++) {
 173       call_vec[i] = do_unused;
 174       callnames[i] = "unused";
 175   }
 176
 177   /* Process management. */
 178   map(SYS_FORK, do_fork);               /* a process forked a new process */
 179   map(SYS_EXEC, do_exec);               /* update process after execute */
 180   map(SYS_CLEAR, do_clear);             /* clean up after process exit */
 181   map(SYS_EXIT, do_exit);               /* a system process wants to exit */
 182   map(SYS_PRIVCTL, do_privctl);         /* system privileges control */
 183   map(SYS_TRACE, do_trace);             /* request a trace operation */
 184   map(SYS_SETGRANT, do_setgrant);       /* get/set own parameters */
 185   map(SYS_RUNCTL, do_runctl);           /* set/clear stop flag of a process */
 186   map(SYS_UPDATE, do_update);           /* update a process into another */
 187   map(SYS_STATECTL, do_statectl);       /* let a process control its state */
 188
 189   /* Signal handling. */
 190   map(SYS_KILL, do_kill);               /* cause a process to be signaled */
 191   map(SYS_GETKSIG, do_getksig);         /* signal manager checks for signals */
 192   map(SYS_ENDKSIG, do_endksig);         /* signal manager finished signal */
 193   map(SYS_SIGSEND, do_sigsend);         /* start POSIX-style signal */
 194   map(SYS_SIGRETURN, do_sigreturn);     /* return from POSIX-style signal */
 195
 196   /* Device I/O. */
 197   map(SYS_IRQCTL, do_irqctl);           /* interrupt control operations */
 198   map(SYS_DEVIO, do_devio);             /* inb, inw, inl, outb, outw, outl */
 199   map(SYS_VDEVIO, do_vdevio);           /* vector with devio requests */
 200
 201   /* Memory management. */
 202   map(SYS_NEWMAP, do_newmap);           /* set up a process memory map */
 203   map(SYS_SEGCTL, do_segctl);           /* add segment and get selector */
 204   map(SYS_MEMSET, do_memset);           /* write char to memory area */
 205   map(SYS_VMCTL, do_vmctl);             /* various VM process settings */
 206
 207   /* Copying. */
 208   map(SYS_UMAP, do_umap);               /* map virtual to physical address */
 209   map(SYS_VIRCOPY, do_vircopy);         /* use pure virtual addressing */
 210   map(SYS_PHYSCOPY, do_copy);           /* use physical addressing */
 211   map(SYS_SAFECOPYFROM, do_safecopy);   /* copy with pre-granted permission */
 212   map(SYS_SAFECOPYTO, do_safecopy);     /* copy with pre-granted permission */
 213   map(SYS_VSAFECOPY, do_vsafecopy);     /* vectored safecopy */
 214
 215   /* Mapping. */
 216   map(SYS_SAFEMAP, do_safemap);         /* map pages from other process */
 217   map(SYS_SAFEREVMAP, do_saferevmap);   /* grantor revokes the map grant */
 218   map(SYS_SAFEUNMAP, do_safeunmap);     /* requestor unmaps the mapped pages */
 219
 220   /* Clock functionality. */
 221   map(SYS_TIMES, do_times);             /* get uptime and process times */
 222   map(SYS_SETALARM, do_setalarm);       /* schedule a synchronous alarm */
 223   map(SYS_STIME, do_stime);             /* set the boottime */
 224   map(SYS_VTIMER, do_vtimer);           /* set or retrieve a virtual timer */
 225
 226   /* System control. */
 227   map(SYS_ABORT, do_abort);             /* abort MINIX */
 228   map(SYS_GETINFO, do_getinfo);         /* request system information */
 229   map(SYS_SYSCTL, do_sysctl);           /* misc system manipulation */
 230
 231   /* Profiling. */
 232   map(SYS_SPROF, do_sprofile);         /* start/stop statistical profiling */
 233   map(SYS_CPROF, do_cprofile);         /* get/reset call profiling data */
 234   map(SYS_PROFBUF, do_profbuf);        /* announce locations to kernel */
 235
 236   /* i386-specific. */
 237 #if _MINIX_CHIP == _CHIP_INTEL
 238   map(SYS_INT86, do_int86);             /* real-mode BIOS calls */
 239   map(SYS_READBIOS, do_readbios);       /* read from BIOS locations */
 240   map(SYS_IOPENABLE, do_iopenable);     /* Enable I/O */
 241   map(SYS_SDEVIO, do_sdevio);           /* phys_insb, _insw, _outsb, _outsw */
 242
 243   /* Machine state switching. */
 244   map(SYS_SETMCONTEXT, do_setmcontext); /* set machine context */
 245   map(SYS_GETMCONTEXT, do_getmcontext); /* get machine context */
 246 #endif
 247
 248   /* Scheduling */
 249   map(SYS_SCHEDULE, do_schedule);       /* reschedule a process */
 250   map(SYS_SCHEDCTL, do_schedctl);       /* change process scheduler */
 251
 252 }
 253 /*===========================================================================*
 254  *                              get_priv                                     *
 255  *===========================================================================*/
 256 PUBLIC int get_priv(rc, priv_id)
 257 register struct proc *rc;               /* new (child) process pointer */
 258 int priv_id;                            /* privilege id */
 259 {
 260 /* Allocate a new privilege structure for a system process. Privilege ids
 261  * can be assigned either statically or dynamically.
 262  */
 263   register struct priv *sp;                 /* privilege structure */
 264
 265   if(priv_id == NULL_PRIV_ID) {             /* allocate slot dynamically */
 266       for (sp = BEG_DYN_PRIV_ADDR; sp < END_DYN_PRIV_ADDR; ++sp)
 267           if (sp->s_proc_nr == NONE) break;
 268       if (sp >= END_DYN_PRIV_ADDR) return(ENOSPC);
 269   }
 270   else {                                    /* allocate slot from id */
 271       if(!is_static_priv_id(priv_id)) {
 272           return EINVAL;                    /* invalid static priv id */
 273       }
 274       if(priv[priv_id].s_proc_nr != NONE) {
 275           return EBUSY;                     /* slot already in use */
 276       }
 277       sp = &priv[priv_id];
 278   }
 279   rc->p_priv = sp;                          /* assign new slot */
 280   rc->p_priv->s_proc_nr = proc_nr(rc);      /* set association */
 281
 282   return(OK);
 283 }
 284
 285 /*===========================================================================*
 286  *                              set_sendto_bit                               *
 287  *===========================================================================*/
 288 PUBLIC void set_sendto_bit(const struct proc *rp, int id)
 289 {
 290 /* Allow a process to send messages to the process(es) associated with the
 291  * system privilege structure with the given ID.
 292  */
 293
 294   /* Disallow the process from sending to a process privilege structure with no
 295    * associated process, and disallow the process from sending to itself.
 296    */
 297   if (id_to_nr(id) == NONE || priv_id(rp) == id) {
 298         unset_sys_bit(priv(rp)->s_ipc_to, id);
 299         return;
 300   }
 301
 302   set_sys_bit(priv(rp)->s_ipc_to, id);
 303
 304   /* The process that this process can now send to, must be able to reply (or
 305    * vice versa). Therefore, its send mask should be updated as well. Ignore
 306    * receivers that don't support traps other than RECEIVE, they can't reply
 307    * or send messages anyway.
 308    */
 309   if (priv_addr(id)->s_trap_mask & ~((1 << RECEIVE)))
 310       set_sys_bit(priv_addr(id)->s_ipc_to, priv_id(rp));
 311 }
 312
 313 /*===========================================================================*
 314  *                              unset_sendto_bit                             *
 315  *===========================================================================*/
 316 PUBLIC void unset_sendto_bit(const struct proc *rp, int id)
 317 {
 318 /* Prevent a process from sending to another process. Retain the send mask
 319  * symmetry by also unsetting the bit for the other direction.
 320  */
 321
 322   unset_sys_bit(priv(rp)->s_ipc_to, id);
 323
 324   unset_sys_bit(priv_addr(id)->s_ipc_to, priv_id(rp));
 325 }
 326
 327 /*===========================================================================*
 328  *                              send_sig                                     *
 329  *===========================================================================*/
 330 PUBLIC void send_sig(endpoint_t proc_nr, int sig_nr)
 331 {
 332 /* Notify a system process about a signal. This is straightforward. Simply
 333  * set the signal that is to be delivered in the pending signals map and
 334  * send a notification with source SYSTEM.
 335  */
 336   register struct proc *rp;
 337
 338   if(!isokprocn(proc_nr) || isemptyn(proc_nr))
 339         panic("send_sig to empty process: %d",  proc_nr);
 340
 341   rp = proc_addr(proc_nr);
 342   sigaddset(&priv(rp)->s_sig_pending, sig_nr);
 343   mini_notify(proc_addr(SYSTEM), rp->p_endpoint);
 344 }
 345
 346 /*===========================================================================*
 347  *                              cause_sig                                    *
 348  *===========================================================================*/
 349 PUBLIC void cause_sig(proc_nr, sig_nr)
 350 proc_nr_t proc_nr;              /* process to be signalled */
 351 int sig_nr;                     /* signal to be sent */
 352 {
 353 /* A system process wants to send a signal to a process.  Examples are:
 354  *  - HARDWARE wanting to cause a SIGSEGV after a CPU exception
 355  *  - TTY wanting to cause SIGINT upon getting a DEL
 356  *  - FS wanting to cause SIGPIPE for a broken pipe
 357  * Signals are handled by sending a message to the signal manager assigned to
 358  * the process. This function handles the signals and makes sure the signal
 359  * manager gets them by sending a notification. The process being signaled
 360  * is blocked while the signal manager has not finished all signals for it.
 361  * Race conditions between calls to this function and the system calls that
 362  * process pending kernel signals cannot exist. Signal related functions are
 363  * only called when a user process causes a CPU exception and from the kernel
 364  * process level, which runs to completion.
 365  */
 366   register struct proc *rp;
 367   endpoint_t sig_mgr;
 368
 369   /* Lookup signal manager. */
 370   rp = proc_addr(proc_nr);
 371   sig_mgr = priv(rp)->s_sig_mgr;
 372
 373   /* If the target is the signal manager of itself, send the signal directly. */
 374   if(rp->p_endpoint == sig_mgr) {
 375        if(SIGS_IS_LETHAL(sig_nr)) {
 376            panic("cause_sig: signal manager gets lethal signal for itself");
 377        }
 378        sigaddset(&priv(rp)->s_sig_pending, sig_nr);
 379        send_sig(rp->p_endpoint, SIGKSIGSM);
 380        return;
 381   }
 382
 383   /* Check if the signal is already pending. Process it otherwise. */
 384   if (! sigismember(&rp->p_pending, sig_nr)) {
 385       sigaddset(&rp->p_pending, sig_nr);
 386       if (! (RTS_ISSET(rp, RTS_SIGNALED))) {            /* other pending */
 387           RTS_SET(rp, RTS_SIGNALED | RTS_SIG_PENDING);
 388           send_sig(sig_mgr, SIGKSIG);
 389       }
 390   }
 391 }
 392
 393 /*===========================================================================*
 394  *                              sig_delay_done                               *
 395  *===========================================================================*/
 396 PUBLIC void sig_delay_done(struct proc *rp)
 397 {
 398 /* A process is now known not to send any direct messages.
 399  * Tell PM that the stop delay has ended, by sending a signal to the process.
 400  * Used for actual signal delivery.
 401  */
 402
 403   rp->p_misc_flags &= ~MF_SIG_DELAY;
 404
 405   cause_sig(proc_nr(rp), SIGSNDELAY);
 406 }
 407
 408 #if _MINIX_CHIP == _CHIP_INTEL
 409
 410 /*===========================================================================*
 411  *                              umap_bios                                    *
 412  *===========================================================================*/
 413 PUBLIC phys_bytes umap_bios(vir_addr, bytes)
 414 vir_bytes vir_addr;             /* virtual address in BIOS segment */
 415 vir_bytes bytes;                /* # of bytes to be copied */
 416 {
 417 /* Calculate the physical memory address at the BIOS. Note: currently, BIOS
 418  * address zero (the first BIOS interrupt vector) is not considered as an
 419  * error here, but since the physical address will be zero as well, the
 420  * calling function will think an error occurred. This is not a problem,
 421  * since no one uses the first BIOS interrupt vector.
 422  */
 423
 424   /* Check all acceptable ranges. */
 425   if (vir_addr >= BIOS_MEM_BEGIN && vir_addr + bytes <= BIOS_MEM_END)
 426         return (phys_bytes) vir_addr;
 427   else if (vir_addr >= BASE_MEM_TOP && vir_addr + bytes <= UPPER_MEM_END)
 428         return (phys_bytes) vir_addr;
 429
 430   printf("Warning, error in umap_bios, virtual address 0x%x\n", vir_addr);
 431   return 0;
 432 }
 433 #endif
 434
 435 /*===========================================================================*
 436  *                              umap_grant                                   *
 437  *===========================================================================*/
 438 PUBLIC phys_bytes umap_grant(rp, grant, bytes)
 439 struct proc *rp;                /* pointer to proc table entry for process */
 440 cp_grant_id_t grant;            /* grant no. */
 441 vir_bytes bytes;                /* size */
 442 {
 443         int proc_nr;
 444         vir_bytes offset, ret;
 445         endpoint_t granter;
 446
 447         /* See if the grant in that process is sensible, and
 448          * find out the virtual address and (optionally) new
 449          * process for that address.
 450          *
 451          * Then convert that process to a slot number.
 452          */
 453         if(verify_grant(rp->p_endpoint, ANY, grant, bytes, 0, 0,
 454                 &offset, &granter) != OK) {
 455                 printf("SYSTEM: umap_grant: verify_grant failed\n");
 456                 return 0;
 457         }
 458
 459         if(!isokendpt(granter, &proc_nr)) {
 460                 printf("SYSTEM: umap_grant: isokendpt failed\n");
 461                 return 0;
 462         }
 463
 464         /* Do the mapping from virtual to physical. */
 465         ret = umap_virtual(proc_addr(proc_nr), D, offset, bytes);
 466         if(!ret) {
 467                 printf("SYSTEM:umap_grant:umap_virtual failed; grant %s:%d -> %s: vir 0x%lx\n",
 468                         rp->p_name, grant,
 469                         proc_addr(proc_nr)->p_name, offset);
 470         }
 471         return ret;
 472 }
 473
 474 /*===========================================================================*
 475  *                               clear_endpoint                              *
 476  *===========================================================================*/
 477 PUBLIC void clear_endpoint(rc)
 478 register struct proc *rc;               /* slot of process to clean up */
 479 {
 480   if(isemptyp(rc)) panic("clear_proc: empty process: %d",  rc->p_endpoint);
 481
 482   /* Make sure that the exiting process is no longer scheduled. */
 483   RTS_SET(rc, RTS_NO_ENDPOINT);
 484   if (priv(rc)->s_flags & SYS_PROC)
 485   {
 486         priv(rc)->s_asynsize= 0;
 487   }
 488
 489   /* If the process happens to be queued trying to send a
 490    * message, then it must be removed from the message queues.
 491    */
 492   clear_ipc(rc);
 493
 494   /* Likewise, if another process was sending or receive a message to or from
 495    * the exiting process, it must be alerted that process no longer is alive.
 496    * Check all processes.
 497    */
 498   clear_ipc_refs(rc, EDEADSRCDST);
 499
 500 }
 501
 502 /*===========================================================================*
 503  *                               clear_ipc                                   *
 504  *===========================================================================*/
 505 PUBLIC void clear_ipc(rc)
 506 register struct proc *rc;               /* slot of process to clean up */
 507 {
 508 /* Clear IPC data for a given process slot. */
 509   struct proc **xpp;                    /* iterate over caller queue */
 510
 511   if (RTS_ISSET(rc, RTS_SENDING)) {
 512       int target_proc;
 513
 514       okendpt(rc->p_sendto_e, &target_proc);
 515       xpp = &proc_addr(target_proc)->p_caller_q; /* destination's queue */
 516       while (*xpp) {            /* check entire queue */
 517           if (*xpp == rc) {                     /* process is on the queue */
 518               *xpp = (*xpp)->p_q_link;          /* replace by next process */
 519 #if DEBUG_ENABLE_IPC_WARNINGS
 520               printf("endpoint %d / %s removed from queue at %d\n",
 521                   rc->p_endpoint, rc->p_name, rc->p_sendto_e);
 522 #endif
 523               break;                            /* can only be queued once */
 524           }
 525           xpp = &(*xpp)->p_q_link;              /* proceed to next queued */
 526       }
 527       rc->p_rts_flags &= ~RTS_SENDING;
 528   }
 529   rc->p_rts_flags &= ~RTS_RECEIVING;
 530 }
 531
 532 /*===========================================================================*
 533  *                             clear_ipc_refs                                *
 534  *===========================================================================*/
 535 PUBLIC void clear_ipc_refs(rc, caller_ret)
 536 register struct proc *rc;               /* slot of process to clean up */
 537 int caller_ret;                         /* code to return on callers */
 538 {
 539 /* Clear IPC references for a given process slot. */
 540   struct proc *rp;                      /* iterate over process table */
 541
 542   for (rp = BEG_PROC_ADDR; rp < END_PROC_ADDR; rp++) {
 543       if(isemptyp(rp))
 544         continue;
 545
 546       /* Unset pending notification bits. */
 547       unset_sys_bit(priv(rp)->s_notify_pending, priv(rc)->s_id);
 548
 549       /* XXX FIXME: Cleanup should be done for senda() as well. For this to be
 550        * done in a realistic way, we need a better implementation of senda
 551        * with a bitmap similar to s_notify_pending for notify() rather than
 552        * a single global MF_ASYNMSG flag. The current arrangement exposes
 553        * several performance issues.
 554        */
 555
 556       /* Check if process depends on given process. */
 557       if (P_BLOCKEDON(rp) == rc->p_endpoint) {
 558           rp->p_reg.retreg = caller_ret;        /* return requested code */
 559           RTS_UNSET(rp, (RTS_RECEIVING|RTS_SENDING)); /* no longer blocking */
 560       }
 561   }
 562 }
 563
 564 /*===========================================================================*
 565  *                              kernel_call_resume                           *
 566  *===========================================================================*/
 567 PUBLIC void kernel_call_resume(struct proc *caller)
 568 {
 569         int result;
 570
 571         assert(!RTS_ISSET(caller, RTS_SLOT_FREE));
 572         assert(!RTS_ISSET(caller, RTS_VMREQUEST));
 573
 574         assert(caller->p_vmrequest.saved.reqmsg.m_source == caller->p_endpoint);
 575
 576         /*
 577         printf("KERNEL_CALL restart from %s / %d rts 0x%08x misc 0x%08x\n",
 578                         caller->p_name, caller->p_endpoint,
 579                         caller->p_rts_flags, caller->p_misc_flags);
 580          */
 581
 582         /*
 583          * we are resuming the kernel call so we have to remove this flag so it
 584          * can be set again
 585          */
 586         caller->p_misc_flags &= ~MF_KCALL_RESUME;
 587         result = kernel_call_dispatch(caller, &caller->p_vmrequest.saved.reqmsg);
 588         kernel_call_finish(caller, &caller->p_vmrequest.saved.reqmsg, result);
 589 }