mac-rom/ProcessMgr/Memory.c

/*
	File:		Memory.c

	Contains:	Routines manage the Process Mgr's memory resources.

	Written by:	Erich Ringewald and his bestest buddy Philip York Goldman.

	Copyright:	© 1986-1992 by Apple Computer, Inc., all rights reserved.

	Change History (most recent first):
	 
		<12>	10/28/92	DTY		Use new Get/Set macros to access ExpandMem.
		<11>	 3/11/92	DTY		7 UpÕs patch to GMBlk doesnÕt respect the slop space in the
									system heap, so that the death notice session record will always
									be allocated. We do and we need to stop.
		<10>	11/22/91	DTY		Check allocateGMBlkInSysHeap in GMBlk before trying to allocate
									the block in the Process Manager heap. This is one of the fixes
									from 7-Up.
		 <9>	  4/5/91	JWM		DtY,#86193: GMBlk was fragmenting the system heap and did not
									honor emMinSysHeapFreeSpace. Added a ReserveMemSys call to help
									with the fragmentation problem. Added a check for leaving a
									minimum amount of space in the system heap.
		 <8>	 2/25/91	dba		pm: set up A5 in SysZoneFloatSizes
		 <7>	 2/21/91	DFH		dba,#82504, #82681, #83168, #83182, #83207: Temp mem heap calls
									are more accurate, now that we crawl the system heap to
									calculate the high free memory.
		 <6>	  2/9/91	JWM		DFH,#79583:Restart and Shutdown don't work in low memory
									conditions. A new routine was defined -- GMBlk. It is modeled
									after ProcessMgrHiNewHandle but checks the system heap if
									ProcessMgrHiNewHandle returns a null handle.
		 <5>	 1/14/91	DFH		(dba) Make system mode per process.
		 <3>	 11/5/90	DFH		Correct names for TEMPTOPMEM and TEMPDISPOSEHANDLE.
		 <0>	 1/23/87	PYG		New Today.

*/ 

#include <types.h>
#include <errors.h>
#include <memory.h>

#include "Glue.h"
#include "Lomem.h"
#include "Data.h"
#include "Zone.h"
#include "HList.h"

#ifdef MORE_SEGMENTS
#pragma segment kernel_segment
#endif MORE_SEGMENTS

/* The following routines implement selected Memory Manager functions
 * for the Process Mgr Zone.
 *
 * NOTE: Originally, the handle manipulation routines really did something
 * different from their "normal" counterparts.  Now, only the allocation
 * routine (new handle) is special, and the normal call set has been
 * made to work with temp blocks. 
 */

/* c_TempMaxMem.  This routine tries to calculate the size of the largest block we
 * could allocate in the Process Mgr zone.  Unfortunately, it is inaccurate
 * because it does not determine how much of the SYSHEAP space can actually be
 * used (it assumes all free/purgeable space is at the top).
 */
pascal u_size
c_TempMaxMem(u_size *pGrowSize)
	{
	u_size			retval;
	unsigned long	olda5;

	olda5 = ProcessMgrA5SimpleSetup();
	retval = ProcessMgrMaxBlock();
	
	/* Spec sez this is always zero if heap is not APPLZONE */
	if (pGrowSize != nil)
		*pGrowSize = 0;
	
	A5SimpleRestore(olda5);
	return(retval);
	}

/* c_TempFreeMem.  Potential free memory for Process Mgr heap also includes memory from
 * the top of the system heap.  Fairly useless, really.
 * NOTE: Assumes that FreeMem can not cause ProcessMgrZone to move, in that it restores
 * THEZONE unconditionally, instead of using SafeSetZone and SafeRestoreZone.
 */
pascal u_size
c_TempFreeMem(void)
	{
	u_size			retval, lowPM;
	THz				theZone;
	unsigned long	olda5;

	olda5 = ProcessMgrA5SimpleSetup();
	theZone = THEZONE;
	THEZONE = ProcessMgrZone;
	
	/* Initially, calculate space as straddle block (top of system heap and bottom of
	 * Process Mgr heap) plus the free memory in the Process Mgr heap.  This is too much,
	 * since the bottom space in the Process Mgr heap is counted twice, so we finish by
	 * subtracting that much off.  StraddleBlockSize returns 0 if the amount available
	 * in the straddle is less than our threshold, but lowPM can still be non-zero.
	 * NOTE: lowPM can be greater than FreeMem(), since the former includes purgeable
	 * space but the latter does not.  This is why we are careful when subtracting.
	 */
	if ((retval = StraddleBlockSize(&lowPM, nil, nil, nil) + FreeMem()) > lowPM)
		retval -= lowPM;
	else
		retval = 0;
		
	THEZONE = theZone;
	A5SimpleRestore(olda5);
	return(retval);
	}

/* c_TempTopMem.  Return the value of MEMTOP we saw at startup. This call is
 * obsolete in Process Mgr 7.0 and later, because Gestalt is better.
 */
pascal Ptr
c_TempTopMem(void)
	{
	unsigned long	olda5;
	Ptr				retval;

	olda5 = ProcessMgrA5SimpleSetup();
	retval = initMemTop;
	A5SimpleRestore(olda5);
	return(retval);
	}

/* c_SysZoneFloatSizes.  Find the sizes of the blocks that form the straddle block
 * across the top of the system heap and bottom of the Temp Memory heap.  This is
 * the area where the bottom of the Temp Memory heap can float when allocations from
 * one heap require abducting memory from the other heap.
 */
pascal OSErr
c_SysZoneFloatSizes(unsigned long *hiSysRoom, unsigned long *lowTempRoom)
	{
	/* Set up A5 so that we can get at Process Mgr. globals */
	unsigned long savedA5 = ProcessMgrA5SimpleSetup();

	/* Find space available at top of system zone */
	if (hiSysRoom != nil)
		*hiSysRoom = GetSystemHiFreeBytes();

	/* Find space available at bottom of Process Mgr (aka Temp Memory) zone */
	if (lowTempRoom != nil)
		*lowTempRoom = GetProcessMgrLoFreeBytes(nil, nil);
	
	/* For now, no error is possible */
	A5SimpleRestore(savedA5);
	return(noErr);
	}

/* GMBlk.  Attempts to allocate a handle high in the ProcessMgrZone.  If there is no
 * memory in the ProcessMgrZone, check the system zone for the space requested.
 * GMBlk pays attention to emMinSysHeapFreeSpace (denotes how much free we should
 * keep in the system zone.)  If there is space in sysZone we call ReserveMemSys
 * (forces next block allocated to be low in the system heap), then NewHandleSys
 * for the memory.  NOTE:  FreeMemSys() - logicalSize is conservative.  The ReserveMemSys
 * will rearrange the heap.
 * GMBlk is called by some puppet string routines, some routines in AppleEventExtensions 
 * and most memory allocation paths in ePPC.  Most of the memory will be locked due to being
 * accessed from interrupt level by the PPCToolbox.
 */
Handle
GMBlk(u_size logicalSize, OSErr *error)
	{
	Handle	aHdl;

	// <11> If allocateGMBlkInSysHeap is set, it means that an application is quitting, and weÕre trying to allocate
	//		a session record for the appDiedEvent.  In this case, always create this session record, even if it means
	//		taking the system heap down below the gauranteed minimum free space.  To save some
	//		code, weÕre going to do this with a skanky goto.  This saves two tests of allocateGMBlkInSysHeap.
		

	if (allocateGMBlkInSysHeap)													// <11>
		goto allocateBlock;														// <11>
		
	aHdl = ProcessMgrHiNewHandle(logicalSize, nil);
	if ((*error = MEMERROR) != noErr)
		{
		if ((FreeMemSys() - logicalSize) > GetExpandMemMinSysHeapFreeSpace())
			{	
allocateBlock:
			ReserveMemSys(logicalSize);
			if ((*error = MEMERROR) == noErr)
				{
				aHdl = NewHandleSys(logicalSize);
				*error = MEMERROR;
				}
			}
		else
			*error = memFullErr;
		}
	return(aHdl);
	}

/* ProcessMgrNewHandle.  Allocate a handle in the ProcessMgrZone.
 * Assumes A5 == PROCESSMGRGLOBALS
 */
Handle
ProcessMgrNewHandle(u_size logicalSize)
	{
	Handle		retVal;
	THz			theZone;
	
	SafeSetZone(theZone, ProcessMgrZone);		
	retVal = NewHandle(logicalSize);
	SafeRestoreZone(theZone);

	/* Be kind to the system heap and make sure we're not taking too much. */
	ReclaimSpaceIfSysHeapLow(&retVal);

	return(retVal);
	}

/* c_TempNewHandle.  Allocates a relocateable block from our zone for general use
 * by an application.  We record the allocation so all such can be deallocated when
 * the application terminates.  Allocates the block high in case the caller decides
 * to lock it without moving it high.
 */
pascal Handle								
c_TempNewHandle(u_size logicalSize, OSErr *pResultCode)
	{
	Handle			retVal;
	HListHdl		hList;
	unsigned long	olda5;

	olda5 = ProcessMgrA5SimpleSetup();
	assert((pCurrentProcess->p_pcb != nil) && ((*pCurrentProcess->p_pcb)->tempMemHListHdl != nil));

	retVal = ProcessMgrHiNewHandle(logicalSize, nil);
	if ((*pResultCode = MEMERROR) == noErr)
		{
		hList = (pCurrentProcess->p_systemModeLevel == 0) ? (*pCurrentProcess->p_pcb)->tempMemHListHdl : SystemTempMemHList;
		if (AddToHList(hList,(HListElem)retVal) != noErr)
			{
			*pResultCode = MEMERROR;
			DisposHandle(retVal);
			retVal = nil;
			}
		}

	A5SimpleRestore(olda5);
	return(retVal);
	}
	
/* LikelyTempMemHList.  Before we leap right into a semi-expensive scan of a guy's
 * temp memory lists, we can make couple of cheap checks to eliminate values that
 * can not be found.  First, if the value is lower than the beginning of the Process Mgr
 * zone, it is out of bounds (like nil or in the system heap).  Second, we make sure
 * the value is not within the application partition (this works even if its from a
 * zone-within-a-zone in the application).
 * IMPORTANT: Assumes the tElem has already been stripped, if necessary.
 * NOTE: The elimination checks should stay fairly modest, because many processes
 * won't have any temporary memory at all, meaning the list search is cheap anyway.
 * NOTE:  Assumes a5 == PROCESSMGRGLOBALS
 */
Boolean
LikelyTempMemHList(HListElem tElem, HListHdl *hList)
	{
	Boolean			retVal;
	PEntryPtr		theProc;

	retVal = false;
	theProc = pCurrentProcess;
	if ( ((Ptr) tElem > ProcessMgrZone)
		&& (theProc != nil)
		&& (((Ptr)tElem < theProc->p_zone)
			|| ((Ptr)tElem >= ((Ptr)theProc->p_zone + theProc->p_size))) )
		{
		*hList = (*theProc->p_pcb)->tempMemHListHdl;
		retVal = true;
		}
	
	return(retVal);
	}

/* InCurrTempMem.  Takes a potential HListElem from the temporary memory allocations
 * of the current process, and verifies it.  Returns an OSErr if we couldn't spot it. 
 * NOTE:  Assumes a5 == PROCESSMGRGLOBALS
 */
OSErr
InCurrTempMem(HListElem hElem)
	{
	OSErr			retval=qErr;
	HListHdl		hList;
	
	hElem = (HListElem) StripAddress((Ptr) hElem);
	if (LikelyTempMemHList(hElem,&hList))
		{
		if (HListExists(hList))
			retval = InHList(hList,hElem);
		
		if (retval != noErr)
			retval = InHList(SystemTempMemHList, hElem);
		}
		
	return(retval);	
	}

/* RemoveCurrTempMem.  Takes a potential HListElem from the temporary memory allocations
 * of the current process, and de-registers the allocation.  Returns an OSErr if we didn't
 * deregister anything. 
 * NOTE:  Assumes a5 == PROCESSMGRGLOBALS
 */
OSErr
RemoveCurrTempMem(HListElem hElem)
	{
	Boolean			retval=qErr;
	HListHdl		hList;
	
	hElem = (HListElem) StripAddress((Ptr) hElem);
	if (LikelyTempMemHList(hElem, &hList))
		{
		if (HListExists(hList))
			retval = RemoveFromHList(hList, hElem);
		
		if (retval != noErr)
			retval = RemoveFromHList(SystemTempMemHList, hElem);
		}
		
	return retval;	
	}

/* RecoverCurrTempHdl.  Takes a potential master pointer of a temporary memory handle, and
 * returns the handle.  It's similar to RecoverHandle.
 * NOTE:  Assumes a5 == PROCESSMGRGLOBALS
 */
Handle
RecoverCurrTempHdl(Ptr targetPtr)
	{
	Handle			retVal;
	HListHdl		hList;
	
	retVal = nil;
	targetPtr = StripAddress((Ptr) targetPtr);
	if (LikelyTempMemHList((HListElem) targetPtr, &hList))
		{
		if (HListExists(hList))
			retVal = (Handle) RecoverHListElem(hList, targetPtr);
		
		if (retVal == nil)
			retVal = (Handle) RecoverHListElem(SystemTempMemHList, targetPtr);
		}
	
	return(retVal);
	}
	
/* These have to stay in seg Main since they call glue but don't set up a5 */
#ifdef MORE_SEGMENTS
#pragma segment Main
#endif MORE_SEGMENTS

/* TempHLock.  Lock the relocatable block, preventing it from being moved
 * within its heap zone.
 */
pascal void
c_TempHLock(Handle hdl, OSErr *pResultCode)
	{
	HLock(hdl);
	*pResultCode = MEMERROR;
	}


/* TempHUnLock.  UnLock the relocatable block, allowing it to be moved within
 * its heap zone.
 */
pascal void
c_TempHUnLock(Handle hdl, OSErr *pResultCode)
	{
	HUnlock(hdl);
	*pResultCode = MEMERROR;
	}


/* TempDisposeHandle.  Release the memory occupied by the relocatable block whose
 * handle is h.
 */
pascal void
c_TempDisposeHandle(Handle hdl, OSErr *pResultCode)
	{
	DisposHandle(hdl);
	*pResultCode = MEMERROR;
	}
	
#ifdef MM_DEBUG
/* Check for entries in the system resource map that have MPs in an application heap.
 * The check is enabled by holding down the command key (by itself).
 */
Boolean
ToggleDoCheck(Boolean alreadyChecking)
	{
	EventRecord		doCheckEventRec;
	Boolean			doToggle;

#define noEventMask 0
#define CHECK_SKIP_MODIFIERS (cmdKey+shiftKey+optionKey)
#define DONT_SKIP_MODIFIERS (cmdKey+optionKey)
	(void)OSEventAvail(noEventMask, &doCheckEventRec);
	
	if ( (doCheckEventRec.modifiers & CHECK_SKIP_MODIFIERS) == DONT_SKIP_MODIFIERS )
		{
		if (alreadyChecking = !alreadyChecking)
			dbmsg("Turning on sys map and MP checking...");
		else
			dbmsg("Turning off sys map and MP checking...");
		}
	return alreadyChecking;
	}

static Boolean	doCheck = true;
static Boolean	isSafeNow = false;

void
CheckSysMapForBadMPs(void)
	{
	short			*pTypeList;
	TypeEntry		*pCurType;
	RefEntry		*pCurRef;
	short			cTypes, cResources;
	u_long			sysLimit;
	
	isSafeNow = true;
	
	if ((doCheck = ToggleDoCheck(doCheck)) == false)
			return;
		
	pTypeList = *SYSMAPHANDLE + 24;
	pTypeList = *SYSMAPHANDLE + *pTypeList;
	pCurType = pTypeList + 1;
	cTypes = *pTypeList;
	sysLimit = StripAddress((Ptr) SYSZONE->bkLim);
	while (cTypes >= 0)
		{
		pCurRef = (Ptr)pTypeList + pCurType->refListOffset;
		
		cResources = pCurType->cResources;
		while (cResources >= 0)
			{
			if ((StripAddress((Ptr) pCurRef) > sysLimit)
				dbmsg("Bad Resource!");
			pCurRef++;
			--cResources;
			}
		
		pCurType++;
		--cTypes;
		}
	}
	
#define IS_HANDLE_IN_ZONE(theHdl, theZone) (((Ptr)(theHdl) > (Ptr)(theZone)) && ((Ptr)(theHdl) < (theZone)->bkLim))

/* Check that all (free) MPs in this zone fall within this zone */
void	
CheckZoneForBadFreeMPs(THz theZone)
	{
	Ptr					*pMP;
	
	if (!doCheck)
		return;
		
	theZone = StripAddress((Ptr) theZone);
		
	for (pMP = theZone->hFstFree; pMP != nil; pMP = (Ptr *)*pMP)
		{
		pMP = StripAddress((Ptr) pMP);
		if (!(IS_HANDLE_IN_ZONE(pMP, theZone)))
			{
			dbmsg("Bad free MP list in given zone");
			}
		}
	}
	
/* Return the correct zone for the purged handle.
 * A5 world needed:  PROCESSMGRGLOBALS
 */
THz
GetCorrectZone(Handle purgedHdl)
	{
	PEntryPtr	pProc;
	THz			theZone;
	
	if ((Ptr)purgedHdl < SYSZONE || (Ptr)purgedHdl > ProcessMgrZone->bkLim)
		return nil;			/* Out of all bounds */
	
	if ((Ptr)purgedHdl < SYSZONE->bkLim)
		return SYSZONE;
		
	pProc = pProcessList;
	while (pProc != nil)
		{
		assert(IsProcessEntry(pProc));
		theZone = (THz)(StripAddess(pProc->p_zone));
			
		if (IS_HANDLE_IN_ZONE(purgedHdl, theZone))
			return theZone;
		pProc = pProc->p_NextProcess;
		}
	
	/* Couldn't find in any of the app zones so must be in Process Mgr zone */
	return ProcessMgrZone;
	}
	
/* Check if given handle is "bad" */
void
CheckBadHandle(Handle hdl)
	{
	unsigned long		olda5;
	THz					correctZone, GetCorrectZone(Handle);
	THz					pZone = &correctZone;
	
	olda5 = ProcessMgrA5SimpleSetup();
	
	hdl = (Handle)(StripAddress((Ptr) hdl));		/* Strip! */
	
	if (isSafeNow && doCheck)
		{
		if (hdl == nil)
			{
			dbmsg("Operating on nil handle");
			}
		else if (*hdl == nil)
			{
			/* Purged */
			if ((correctZone = GetCorrectZone(hdl)) == nil)
				dbmsg("Couldn't find a zone for purged handle");
			else if (correctZone != THEZONE)
				{
				if (THEZONE == ProcessMgrZone)
					{
					dbmsg("Purged handle op possibly trashing ProcessMgrZone MP list");
					}
				else if (THEZONE == SYSZONE)
					{
					dbmsg("Purged handle op possibly trashing sys zone MP list");
					}
				else if (!(THEZONE == APPLZONE && correctZone == SYSZONE))
					{
					dbmsg("Bad zone for operation on purged handle");
					}
				}
			}
		}
		
	A5SimpleRestore(olda5);
	}
			
#endif MM_DEBUG