mac-rom/ProcessMgr/Aux.c

573 lines
14 KiB
C
Raw Normal View History

/*
File: Aux.c
Contains: Process Mgr support for A/UX.
NOTE: None of the code in this file is referenced unless the build
defines the HAS_AUX_PROCESSMGR condition.
Written by: David Harrison
Copyright: <EFBFBD> 1980-1992 by Apple Computer, Inc., all rights reserved.
Change History (most recent first):
<5> 8/26/92 DTY Roll in latest changes for A/UX.
<4> 4/1/91 DFH (with John Iarocci) Bring this file up to date.
<2> 12/5/90 DFH Fixed warning in AUX_Block re: unused param.
<0> 12/4/90 DFH New Today.
*/
#include <Files.h>
#include <QuickDraw.h>
#include <Resources.h>
#include <Retrace.h>
#include <Errors.h>
#include <MFPrivate.h>
#include "Data.h"
#include "OSDispatchPrivate.h"
#include "Glue.h"
#include "SysMisc.h"
#include "Aux.h"
#include "Patches.h"
#include "Lomem.h"
/* Variables local to this module */
static short auxMaxSelector = -1;
static long ProcessMgrTaskID = -1;
static Getnextevent_ptr realGNE;
static Eventavail_ptr realEA;
static AUXDispatch_ptr realAD;
/* Some function prototypes that should be in (yet another) header file */
OSErr NewProcess(InternalLaunchPBPtr pParams);
short GetNextPseudoEvent(short, EventRecord *, Boolean);
void OpenAppWDs(PEntryPtr);
/* Handy macro to determine whether given event is best handled by AUX. */
#define IsAUXEvent(pEvent) ((pEvent->what >= FIRST_AUX_EVENT) && (pEvent->what <= LAST_AUX_EVENT))
#pragma segment AUX_SEGMENT
/* AUX_Setup. Set things up as necessary for A/UX. */
void
AUX_Setup(void)
{
/* Determine level of functionality. This check can probably go away once
* we settle on a common version of A/UX
*/
auxMaxSelector = AUX_Highest();
/* Set extra patches so we can fool ourselves */
realGNE = (Getnextevent_ptr) NGetTrapAddress(0xa970, ToolTrap);
NSetTrapAddress((long) AUX_GetNextEvent, 0xa970, ToolTrap);
realEA = (Eventavail_ptr) NGetTrapAddress(0xa971, ToolTrap);
NSetTrapAddress((long) AUX_EventAvail, 0xa971, ToolTrap);
realAD = (AUXDispatch_ptr) NGetTrapAddress(0xabf9, ToolTrap);
NSetTrapAddress((long) AUX_Dispatch_Patch, 0xabf9, ToolTrap);
}
/* AUX_EventAvail. Similar to our replacement for getnextevent, we also replace
* EventAvail for usage by Process Mgr only.
*/
pascal short
AUX_EventAvail(short evtMask, EventRecord *theEvent)
{
Boolean oldMask;
EventRecord anEvent;
oldMask = AUX_SetAUXMask(true);
for (;;)
{
(void) (*realEA)(evtMask, theEvent);
if (IsAUXEvent(theEvent) == false)
break;
/* if an A/UX event is available, remove it from the queue and deal with it */
AUX_GetAnyEventGlue(0, &anEvent, 0, 0, true);
(void) AUX_HandleEvent(&anEvent);
};
(void) AUX_SetAUXMask(oldMask);
return theEvent->what == nullEvent ? wFalse : wTrue;
}
/* AUX_Dispatch_Patch. Patch AUX_Dispatch so we can look for a AUX_BEGINAPPLICATION
* selector and execute within the ProcessManagers context
*/
pascal long
AUX_Dispatch_Patch(short selector, char *p)
{
unsigned long olda5;
long retval;
olda5 = ProcessMgrA5SimpleSetup();
if (selector != AUX_BEGINAPPLICATION)
retval = (*realAD)(selector, p);
else
/* Fix up working directories for home directory and files in APPPARMHANDLE */
OpenAppWDs(pCurrentProcess);
A5SimpleRestore(olda5);
return(retval);
}
/* AUX_Block. */
void
AUX_Block(PEntryPtr)
{
}
/* AUX_CoffLaunch. If a coff binary toolbox program is executed, it will first issue a
* UI_ATTACH ioctl, which will send us an attachEvt. Upon seeing the attach event, we
* use AUX_MakeLayer to create a minimal process which can then be switched to using the
* normal context switching code. The coff binary will then call (via OSDispatch) this
* routine to really fill the process out. All this is necessary because the coff
* program must execute in a separate A/UX process and it's accesses to the shared data
* areas must be synchronized.
*/
pascal short
AUX_CoffLaunch(u_long reqSize, u_long taskmode, StringPtr procName, short vrefnum, u_long ssize)
{
#pragma unused (reqSize, taskmode, procName, vrefnum, ssize)
return pCurrentProcess->p_mypid;
}
/* AUX_FindProc. Find the process associated with taskId. */
PEntryPtr
AUX_FindProc(taskId)
{
PEntryPtr pProc;
pProc = pProcessList;
while (pProc != nil)
{
if (pProc->aux_realpid == taskId)
break;
pProc = pProc->p_NextProcess;
}
return pProc;
}
/* AUX_ForkExec. Fork and exec a new coff binary. */
short
AUX_ForkExecGlue(short vrefnum, char *name)
{
ForkExecRec params;
assert(AUX_FORKEXEC <= auxMaxSelector);
params.vrefnum = vrefnum;
params.name = name;
if (AUX_ForkExec(&params) != 0)
return permErr;
else
return params.pid;
}
/* AUX_GetAnyEventGlue. Handy routine for calling AUX_GetAnyEvent, since latter is
* rather awkward.
*/
short
AUX_GetAnyEventGlue(short evtMask, EventRecord *theEvent, long timeout, RgnHandle bounds, Boolean pullit)
{
GetAnyEventRec params;
assert(AUX_GETANYEVENT <= auxMaxSelector);
params.mask = evtMask;
params.timeout = timeout;
params.mouseBounds = bounds;
params.pullIt = pullit;
(void) AUX_GetAnyEvent(&params);
*theEvent = params.event;
return theEvent->what != nullEvent ? -1 : 0;
}
/* AUX_GetMinTimeout. Compute the minimum timeout necessary, we use this so we can
* sleep in the kernel instead of spinning in user mode.
*/
long
AUX_GetMinTimeout(void)
{
extern Boolean napOver;
if ((pFrontProcess->p_waitnexteventlevel > 0) /* GetNextEvent never blocks */
&& (coercionState == CS_DONE) /* if coercing, don't want physical events */
&& (napOver == 0) /* somebody needs attention */
&& (pSleepingStateList != nil)) /* somebody is sleeping */
return (pSleepingStateList->p_wakeuptime - TICKS);
else
return 0;
}
/* AUX_GetMouseBounds. Compute the rectangle for mouse moved events. Once again, this
* is so we can sleep in the kernel instead of user mode spinning.
*/
RgnHandle
AUX_GetMouseBounds(void)
{
extern RgnHandle mousebox;
return mousebox;
}
/* AUX_GetNextEvent. Our replacement for the real GetNextEvent. This isn't the one
* seen by the user program, but is the one we will use to actually get events out of
* the queue. Ours is different because we can get some funky events back from the
* kernel and mere mortals shouldn't ever get them.
*
* NOTE: ProcessManager overpatches this trap, but calls us in event_common when
* the process state is PRRUN.
*/
pascal short
AUX_GetNextEvent(short evtMask, register EventRecord *theEvent)
{
Boolean oldMask;
short realRetVal;
oldMask = AUX_SetAUXMask(true);
while ((realRetVal = (*realGNE)(evtMask, theEvent)) && AUX_HandleEvent(theEvent))
{
/* Just loop. All the work is done in the loop control. */
}
(void) AUX_SetAUXMask(oldMask);
return realRetVal;
}
/* AUX_GetTaskGlue. Handy utility to return the A/UX style task identifier of this
* process so we can do a real context switch to it later.
*/
long
AUX_GetTaskGlue(void)
{
long taskId;
assert(AUX_GETTASK <= auxMaxSelector);
AUX_GetTask(&taskId);
return taskId;
}
/* AUX_HandleEvent. Handle an A/UX specific event. */
short
AUX_HandleEvent(EventRecord *theEvent)
{
short retVal;
retVal = wTrue;
if (IsAUXEvent(theEvent) == false)
return wFalse;
switch(theEvent->what)
{
/* somebody's UI_SETSELECT broke, make 'em runnable. */
case auxSelectEvent:
AUX_MakeRunnable(theEvent->message);
break;
/* a new layer was asynchronously created, fit it in to the scheduling */
case auxAttachEvent:
AUX_MakeLayer(theEvent->message, theEvent->modifiers, theEvent->when);
break;
/* a layer went away by mistake (kill(9...) for instance, clean it up */
case auxExitEvent:
AUX_KillLayer(theEvent->message);
break;
}
theEvent->what = nullEvent;
return retVal;
}
#define LAUNCH_DELAY (60*60) /* one minute */
/* AUX_IdleProc. */
void
AUX_IdleProc(void)
{
register PEntryPtr myProc;
unsigned long olda5;
EventRecord anEvent;
olda5 = ProcessMgrA5Setup();
myProc = pCurrentProcess;
for (;;)
{
assert(myProc->aux_waitproc);
(void) AUX_GetAnyEventGlue(0, &anEvent, LAUNCH_DELAY, 0, true);
/* Handle the attach. aux_restore_ctx should get us out of here, never to return. */
if ((anEvent.what == auxAttachEvent) && (anEvent.message == myProc->aux_waitproc))
{
myProc->aux_realpid = myProc->aux_waitproc;
myProc->aux_waitproc = 0;
AUX_SwitchGlue(myProc->aux_realpid);
aux_restore_ctx(pCurrentProcess->p_sp);
dbmsg("How the <20> did I get here?");
}
/* AUX event was not the usual attach, or an attach came from an incorrect
* AUX process. Feebly try to handle the event. Then die.
*/
(void) AUX_HandleEvent(&anEvent);
AUX_Kill(myProc->aux_waitproc);
ExitToShell();
}
}
/* AUX_KernelEvents. */
short
AUX_KernelEvents(EventRecord *theEvent)
{
short foundSome;
foundSome = 0;
while (AUX_GetAnyEventGlue(0, theEvent, 0, 0, 1) && IsAUXEvent(theEvent) != 0)
{
(void) AUX_HandleEvent(theEvent);
foundSome++;
}
return foundSome;
}
/* AUX_KillLayer. Get rid of an abnormally terminated process */
void
AUX_KillLayer(long taskId)
{
register PEntryPtr pProc;
if ((pProc = AUX_FindProc(taskId)) != nil)
(void) KillProcess(&pProc->p_serialNumber);
}
/* AUX_Launch. */
OSErr
AUX_Launch(InternalLaunchPBPtr pParams)
{
short realPid;
PEntryPtr pProc;
OSErr err;
WDPBRec wd;
/* setup a WDPBRec to pass to AUX_ForkExec through the AUXDispatch */
wd.ioCompletion = nil;
wd.ioNamePtr = nil;
wd.ioWDProcID = 0;
wd.ioVRefNum = pParams->ilAppSpecPtr->vRefNum;
wd.ioWDDirID = pParams->ilAppSpecPtr->parID;
PBOpenWD(&wd, true);
realPid = AUX_ForkExecGlue(wd.ioVRefNum, pParams->ilAppSpecPtr->name);
/* Close the WD, if we opened it */
if (wd.ioWDCreated != 0)
PBCloseWD(&wd, SyncHFS);
/* Negative result is an OSErr. Result should never be 0. Positive result is AUX pid. */
if (realPid < 0)
return((OSErr) realPid);
pParams->ilTaskMode |= COFF_BINARY;
if ((err = NewProcess(pParams)) != noErr)
{
dbmsg("AUX_Launch: NewProcess failed");
AUX_Kill(realPid);
return(err);
}
pProc = pParams->ilResultProc;
pProc->aux_waitproc = realPid;
pProc->aux_realpid = AUX_ProcessMgrTask();
return(noErr);
}
/* AUX_MakeLayer. Create an empty process. After the A/UX process switch it will be
* filled out by whomever did the UI_ATTACH.
*/
void
AUX_MakeLayer(long taskId, unsigned short flags, long size)
{
register PEntryPtr pProc;
InternalLaunchPB launchPB;
CoffName coffname;
coffname.taskid = taskId;
if ((pProc = AUX_Unblock(taskId)) != nil)
return;
if (AUX_COFF_FSSpec(&coffname) != noErr)
return;
launchPB.ilAppSpecPtr = &coffname.fsspec;
launchPB.ilTaskMode = COFF_BINARY | ASYNC_LAUNCH | (unsigned long) flags;
launchPB.ilDAInfoPtr = nil;
launchPB.ilPartitionSize = size + DEFLTSTACK - MACPLUS_DEFLTSTACK;
launchPB.ilStackSize = DEFLTSTACK;
launchPB.ilAppParameters = nil;
launchPB.ilAppParamHdl = nil;
if (NewProcess(&launchPB) != noErr)
{
dbmsg("AUX_MakeLayer: NewProcess failed");
AUX_Kill(taskId);
return;
}
pProc = launchPB.ilResultProc;
pProc->aux_realpid = taskId;
pProc->aux_waitproc = 0;
(void) WakeUpProcess(&pFrontProcess->p_serialNumber);
}
/* AUX_MakeRunnable. Make an application contained in a different task runnable. taskId
* refers to the kernel event layer identifier we got back from AUX_GetTask and stowed
* away in auxInfo.
*/
void
AUX_MakeRunnable(long taskId)
{
PEntryPtr pProc;
if ((pProc = AUX_FindProc(taskId)) != nil)
(void) WakeUpProcess(&pProc->p_serialNumber);
}
/* AUX_ProcessMgrTask. Return the task descriptor for Macintosh Applications */
long
AUX_ProcessMgrTask(void)
{
if (ProcessMgrTaskID < 0)
AUX_GetTask(&ProcessMgrTaskID);
return ProcessMgrTaskID;
}
/* AUX_SwitchGlue. Force an A/UX kernel context switch. */
void
AUX_SwitchGlue(long taskId)
{
long rval;
EventRecord anEvent;
assert(AUX_SWITCH <= auxMaxSelector);
/* If the Process Mgr process this task is associated with is gone, kill this task
* after the switch, if this is the original Process Mgr process we have to
* leave it laying around anyway.
* NOTE: Inverting taskID tells AUX_Switch to kill the originating process after
* enabling the new one.
*/
if (((rval = AUX_GetTaskGlue()) != AUX_ProcessMgrTask()) && AUX_FindProc(rval) == 0)
taskId = (-(taskId));
for (;;)
{
/* Try switch. On error we try to destroy the layer (AUX_KillLayer won't
* return). If it does, we aren't in a valid process, so we pick a new one.
*/
if (AUX_Switch(taskId) != 0)
{
AUX_KillLayer(taskId);
cpu_resched();
}
/* Normally, when we get back from the AUX_Switch, we will have already been
* made the current process. If the task id of this a/ux process is not the
* same as where we think we ought to be, we got woken up because the current
* process died (most likely, perhaps theres something else, so we're pretending
* to be paranoid) so we reap and handle any a/ux events. If it's true that
* the current process really did die, we will eventually receive an exitEvent,
* which will result in the associated Process Mgr process being killed and the
* processor reschedule, in which case we won't ever return to this routine.
*/
if (pCurrentProcess->aux_realpid == AUX_GetTaskGlue())
break;
/* AUX_HandleEvent won't return if the process we're switching to has exited,
* thus giving us an exitEvent
*/
do
{
(void) AUX_GetAnyEventGlue(0, &anEvent, 0l, 0l, true);
} while (AUX_HandleEvent(&anEvent));
dbmsg("AUX_SwitchGlue: probably shouldn't ever get here");
/* having handled whatever broke us out of our interminable sleep, try again */
}
}
/* AUX_Unblock. Find the nacent Process Mgr process associated with the given taskID,
* and declare it alive and well.
*/
PEntryPtr
AUX_Unblock(long taskId)
{
PEntryPtr pProc;
pProc = pProcessList;
while (pProc != nil)
{
if (pProc->aux_waitproc == taskId)
{
pProc->aux_waitproc = 0;
pProc->aux_realpid = taskId;
break;
}
pProc = pProc->p_NextProcess;
}
return pProc;
}
/* AUX_WaitForEvent. */
short
AUX_WaitForEvent(short mask, EventRecord *theEvent)
{
if (pCurrentProcess)
if (GetNextPseudoEvent(mask, theEvent, false))
return wTrue;
(void) AUX_GetAnyEventGlue(mask, theEvent, AUX_GetMinTimeout(), AUX_GetMouseBounds(), false);
return theEvent->what == nullEvent ? wFalse : wTrue;
}
/* AUX_WaitNextEvent. */
short
AUX_WaitNextEvent(short mask, EventRecord *theEvent, long timeout, RgnHandle mbox)
{
short rval;
AUX_SetTimeOut(timeout);
AUX_SetBounds(mbox);
rval = GetNextEvent(mask, theEvent);
AUX_SetTimeOut(0);
AUX_SetBounds(nil);
return rval;
}