76 lines
2.7 KiB
C
76 lines
2.7 KiB
C
#include "ulib.h"
|
|
|
|
/*
|
|
* Only ever spawned by jobtest.c, with two shared pipe handles as argv[1]
|
|
* (the "ready" pipe, this process writes) and argv[2] (the "go" pipe, this
|
|
* process reads) -- decToString'd exactly like fifomaster.c's/sigtarget.c's
|
|
* children. Proves job control (signal.h's SIGSTOP/SIGCONT) works end to
|
|
* end against a thread that is genuinely Blocked mid-syscall, not just
|
|
* Runnable: this process parks in a real blocking userRead on the go pipe,
|
|
* jobtest.c stops it there with a real userSigSend(target, sigStop) (not a
|
|
* kernel-internal shortcut), writes the byte it is waiting for WHILE it is
|
|
* stopped, and only then sends sigCont -- the read can only ever complete
|
|
* through the exact restart-syscall retry loop sysRead already uses
|
|
* (syscall.c), which only runs again once threadContinue has moved this
|
|
* thread back to threadRunnable.
|
|
*
|
|
* No sleep/timing guess anywhere in this file or jobtest.c: every step is
|
|
* ordered by a real blocking read or a real userWait, the same
|
|
* happens-before discipline sigtarget.c's rendezvous pipe already
|
|
* established for a different race.
|
|
*/
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
print("jobtarget: start, pid=");
|
|
printDec(userGetpid());
|
|
print("\n");
|
|
|
|
if (argc != 3) {
|
|
print("jobtarget: FAIL expected two argv (ready handle, go handle)\n");
|
|
return 1;
|
|
}
|
|
|
|
long readyHandle = parseDec(argv[1]);
|
|
long goHandle = parseDec(argv[2]);
|
|
|
|
long goFd = userPipeAttach(goHandle, 0);
|
|
if (goFd < 0) {
|
|
print("jobtarget: FAIL attach go pipe as reader\n");
|
|
return 1;
|
|
}
|
|
|
|
long readyFd = userPipeAttach(readyHandle, 1);
|
|
if (readyFd < 0) {
|
|
print("jobtarget: FAIL attach ready pipe as writer\n");
|
|
return 1;
|
|
}
|
|
if (userWrite((int)readyFd, "r", 1) != 1) {
|
|
print("jobtarget: FAIL write ready byte\n");
|
|
return 1;
|
|
}
|
|
userClose((int)readyFd);
|
|
print("jobtarget: ready, blocking on go pipe\n");
|
|
|
|
char goByte = 0;
|
|
/* Real blocking read: parks this thread (threadBlocked) until a byte is
|
|
actually available. jobtest.c raises SIGSTOP against this exact
|
|
blocking read, then writes the byte, then raises SIGCONT -- the read
|
|
below can only return once BOTH have happened, since sysRead's own
|
|
restart-syscall retry (syscall.c) never runs again while this thread
|
|
is threadStopped instead of threadRunnable. */
|
|
if (userRead((int)goFd, &goByte, 1) != 1) {
|
|
print("jobtarget: FAIL read go byte\n");
|
|
return 1;
|
|
}
|
|
userClose((int)goFd);
|
|
|
|
if (goByte != 'g') {
|
|
print("jobtarget: FAIL wrong go byte\n");
|
|
return 1;
|
|
}
|
|
print("jobtarget: received go\n");
|
|
|
|
return 55;
|
|
}
|