minix/lib/libsys/asynsend.c

178 lines
4.6 KiB
C
Raw Normal View History

#define _SYSTEM 1
2008-11-19 13:35:46 +01:00
#include <minix/config.h>
#include <assert.h>
#include <sys/types.h>
#include <minix/const.h>
#include <minix/type.h>
2009-08-17 20:48:57 +02:00
#include <stdlib.h>
2008-11-19 13:35:46 +01:00
#include <unistd.h>
#include <minix/syslib.h>
#include <minix/sysutil.h>
#include <minix/sys_config.h>
2008-11-19 13:35:46 +01:00
#include <limits.h>
#include <errno.h>
#define ASYN_NR (2*_NR_PROCS)
2012-03-25 20:25:53 +02:00
static asynmsg_t msgtable[ASYN_NR];
static int first_slot = 0, next_slot = 0;
static int initialized = 0;
2008-11-19 13:35:46 +01:00
/*===========================================================================*
* asynsend3 *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
int asynsend3(dst, mp, fl)
2008-11-19 13:35:46 +01:00
endpoint_t dst;
message *mp;
Merge of David's ptrace branch. Summary: o Support for ptrace T_ATTACH/T_DETACH and T_SYSCALL o PM signal handling logic should now work properly, even with debuggers being present o Asynchronous PM/VFS protocol, full IPC support for senda(), and AMF_NOREPLY senda() flag DETAILS Process stop and delay call handling of PM: o Added sys_runctl() kernel call with sys_stop() and sys_resume() aliases, for PM to stop and resume a process o Added exception for sending/syscall-traced processes to sys_runctl(), and matching SIGKREADY pseudo-signal to PM o Fixed PM signal logic to deal with requests from a process after stopping it (so-called "delay calls"), using the SIGKREADY facility o Fixed various PM panics due to race conditions with delay calls versus VFS calls o Removed special PRIO_STOP priority value o Added SYS_LOCK RTS kernel flag, to stop an individual process from running while modifying its process structure Signal and debugger handling in PM: o Fixed debugger signals being dropped if a second signal arrives when the debugger has not retrieved the first one o Fixed debugger signals being sent to the debugger more than once o Fixed debugger signals unpausing process in VFS; removed PM_UNPAUSE_TR protocol message o Detached debugger signals from general signal logic and from being blocked on VFS calls, meaning that even VFS can now be traced o Fixed debugger being unable to receive more than one pending signal in one process stop o Fixed signal delivery being delayed needlessly when multiple signals are pending o Fixed wait test for tracer, which was returning for children that were not waited for o Removed second parallel pending call from PM to VFS for any process o Fixed process becoming runnable between exec() and debugger trap o Added support for notifying the debugger before the parent when a debugged child exits o Fixed debugger death causing child to remain stopped forever o Fixed consistently incorrect use of _NSIG Extensions to ptrace(): o Added T_ATTACH and T_DETACH ptrace request, to attach and detach a debugger to and from a process o Added T_SYSCALL ptrace request, to trace system calls o Added T_SETOPT ptrace request, to set trace options o Added TO_TRACEFORK trace option, to attach automatically to children of a traced process o Added TO_ALTEXEC trace option, to send SIGSTOP instead of SIGTRAP upon a successful exec() of the tracee o Extended T_GETUSER ptrace support to allow retrieving a process's priv structure o Removed T_STOP ptrace request again, as it does not help implementing debuggers properly o Added MINIX3-specific ptrace test (test42) o Added proper manual page for ptrace(2) Asynchronous PM/VFS interface: o Fixed asynchronous messages not being checked when receive() is called with an endpoint other than ANY o Added AMF_NOREPLY senda() flag, preventing such messages from satisfying the receive part of a sendrec() o Added asynsend3() that takes optional flags; asynsend() is now a #define passing in 0 as third parameter o Made PM/VFS protocol asynchronous; reintroduced tell_fs() o Made PM_BASE request/reply number range unique o Hacked in a horrible temporary workaround into RS to deal with newly revealed RS-PM-VFS race condition triangle until VFS is asynchronous System signal handling: o Fixed shutdown logic of device drivers; removed old SIGKSTOP signal o Removed is-superuser check from PM's do_procstat() (aka getsigset()) o Added sigset macros to allow system processes to deal with the full signal set, rather than just the POSIX subset Miscellaneous PM fixes: o Split do_getset into do_get and do_set, merging common code and making structure clearer o Fixed setpriority() being able to put to sleep processes using an invalid parameter, or revive zombie processes o Made find_proc() global; removed obsolete proc_from_pid() o Cleanup here and there Also included: o Fixed false-positive boot order kernel warning o Removed last traces of old NOTIFY_FROM code THINGS OF POSSIBLE INTEREST o It should now be possible to run PM at any priority, even lower than user processes o No assumptions are made about communication speed between PM and VFS, although communication must be FIFO o A debugger will now receive incoming debuggee signals at kill time only; the process may not yet be fully stopped o A first step has been made towards making the SYSTEM task preemptible
2009-09-30 11:57:22 +02:00
int fl;
2008-11-19 13:35:46 +01:00
{
int i, r, src_ind, dst_ind;
unsigned flags;
static int inside = 0;
int len, needack = 0;
/* Debug printf() causes asynchronous sends? */
if (inside) /* Panic will not work either then, so exit */
exit(1);
inside = 1;
if(!initialized) {
/* Initialize table by marking all entries empty */
for (i = 0; i < ASYN_NR; i++) msgtable[i].flags = AMF_EMPTY;
initialized = 1;
}
/* Update first_slot. That is, find the first not-completed slot by the
* kernel since the last time we sent this table (e.g., the receiving end of
* the message wasn't ready yet).
*/
for (; first_slot < next_slot; first_slot++) {
flags = msgtable[first_slot].flags;
if ((flags & (AMF_VALID|AMF_DONE)) == (AMF_VALID|AMF_DONE)) {
/* Marked in use by us (VALID) and processed by the kernel */
if (msgtable[first_slot].result != OK) {
#if NDEBUG
printf("asynsend: found entry %d with error %d\n",
first_slot, msgtable[first_slot].result);
#endif
needack = (flags & (AMF_NOTIFY|AMF_NOTIFY_ERR));
2008-11-19 13:35:46 +01:00
}
continue;
2008-11-19 13:35:46 +01:00
}
if (flags != AMF_EMPTY)
/* Found first not-completed table entry */
break;
}
/* Reset to the beginning of the table when all messages are completed */
if (first_slot >= next_slot && !needack)
next_slot = first_slot = 0;
/* Can the table handle one more message? */
if (next_slot >= ASYN_NR) {
/* We're full; tell the kernel to stop processing for now */
if ((r = ipc_senda(NULL, 0)) != OK)
panic("asynsend: ipc_senda failed: %d", r);
/* Move all unprocessed messages to the beginning */
dst_ind = 0;
for (src_ind = first_slot; src_ind < next_slot; src_ind++) {
flags = msgtable[src_ind].flags;
/* Skip empty entries */
if (flags == AMF_EMPTY) continue;
/* and completed entries only if result is OK or if error
* doesn't need to be acknowledged */
if ((flags & (AMF_VALID|AMF_DONE)) == (AMF_VALID|AMF_DONE)) {
if (msgtable[src_ind].result == OK)
continue;
else {
#if NDEBUG
2008-11-19 13:35:46 +01:00
printf(
"asynsend: found entry %d with error %d\n",
src_ind, msgtable[src_ind].result);
2008-11-19 13:35:46 +01:00
#endif
if (!(flags & (AMF_NOTIFY|AMF_NOTIFY_ERR)))
/* Don't need to ack this error */
continue;
2008-11-19 13:35:46 +01:00
}
}
/* Copy/move in use entry */
#if NDEBUG
printf("asynsend: copying entry %d to %d\n", src_ind, dst_ind);
2008-11-19 13:35:46 +01:00
#endif
if (src_ind != dst_ind) msgtable[dst_ind] = msgtable[src_ind];
2008-11-19 13:35:46 +01:00
dst_ind++;
}
/* Mark unused entries empty */
for (i = dst_ind; i < ASYN_NR; i++) msgtable[i].flags = AMF_EMPTY;
first_slot = 0;
next_slot = dst_ind;
if (next_slot >= ASYN_NR) /* Cleanup failed */
panic("asynsend: msgtable full");
}
fl |= AMF_VALID; /* Mark in use */
msgtable[next_slot].dst = dst;
msgtable[next_slot].msg = *mp;
msgtable[next_slot].flags = fl; /* Has to be last. The kernel
2008-11-19 13:35:46 +01:00
* scans this table while we
* are sleeping.
*/
next_slot++;
assert(next_slot >= first_slot);
len = next_slot - first_slot;
assert(first_slot + len <= ASYN_NR);
assert(len >= 0);
inside = 0;
/* Tell the kernel to rescan the table */
return ipc_senda(&msgtable[first_slot], len);
}
2008-11-19 13:35:46 +01:00
/*===========================================================================*
* asyn_geterror *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
int asyn_geterror(endpoint_t *dst, message *msg, int *err)
{
int src_ind, flags, result;
if (!initialized) return(0);
for (src_ind = 0; src_ind < next_slot; src_ind++) {
flags = msgtable[src_ind].flags;
result = msgtable[src_ind].result;
2008-11-19 13:35:46 +01:00
/* Find a message that has been completed with an error */
if ((flags & (AMF_VALID|AMF_DONE)) == (AMF_VALID|AMF_DONE)) {
if (result != OK && (flags & (AMF_NOTIFY|AMF_NOTIFY_ERR))) {
/* Found one */
if (dst != NULL) *dst = msgtable[src_ind].dst;
if (msg != NULL) *msg = msgtable[src_ind].msg;
if (err != NULL) *err = result;
2008-11-19 13:35:46 +01:00
/* Acknowledge error so it can be cleaned up upon next
* asynsend */
msgtable[src_ind].result = OK;
return(1);
}
}
}
2008-11-19 13:35:46 +01:00
return(0);
2008-11-19 13:35:46 +01:00
}