int main()
{
APTR ProcessorBase;
IPTR args[6] = { 0, 0, 0, 0, 0, 0 };
struct RDArgs *rda;
int max_cpus = 0;
int max_iter = 0;
int req_width = 0, req_height = 0;
char tmpbuf[200];
int explicit_mode = 0;
struct MsgPort *timerPort = CreateMsgPort();
struct timerequest *tr = CreateIORequest(timerPort, sizeof(struct timerequest));
struct TimerBase *TimerBase = NULL;
struct timeval start_time;
struct timeval now;
struct Window *displayWin;
struct BitMap *outputBMap = NULL;
IPTR coreCount = 1;
struct TagItem tags[] =
{
{GCIT_NumberOfProcessors, (IPTR)&coreCount},
{0, (IPTR)NULL}};
ProcessorBase = OpenResource(PROCESSORNAME);
if (!ProcessorBase)
return 0;
KernelBase = OpenResource("kernel.resource");
if (!KernelBase)
return 0;
if (timerPort)
{
FreeSignal(timerPort->mp_SigBit);
timerPort->mp_SigBit = -1;
timerPort->mp_Flags = PA_IGNORE;
}
if (tr)
{
if (!OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)tr, 0))
{
TimerBase = (struct TimerBase *)tr->tr_node.io_Device;
}
} else return 0;
GetCPUInfo(tags);
D(bug("[SMP-Smallpt] %s: detected %d CPU cores\n", __func__, coreCount);)
int main(int argc, char **argv) {
void *handle;
char *err;
if ((HostLibBase = OpenResource("hostlib.resource")) == NULL) {
fprintf(stderr, "can't open hostlib.resource\n");
return 1;
}
if ((handle = HostLib_Open("libSDL.so", &err)) == NULL) {
fprintf(stderr, "can't open sdl: %s\n", err);
return 1;
}
SDL_Init = HostLib_GetPointer(handle, "SDL_Init", NULL);
SDL_SetVideoMode = HostLib_GetPointer(handle, "SDL_SetVideoMode", NULL);
SDL_Quit = HostLib_GetPointer(handle, "SDL_Quit", NULL);
SDL_Init(0x20);
SDL_SetVideoMode(640, 480, 16, 0);
Delay(250);
SDL_Quit();
HostLib_Close(handle, NULL);
return 0;
}
static int gdi_hostlib_init(LIBBASETYPEPTR LIBBASE) {
D(bug("[gdi] hostlib init\n"));
/* if ((KernelBase = OpenResource("kernel.resource")) == NULL) {
kprintf("[gdi] couldn't open kernel.resource");
return FALSE;
}*/
if ((HostLibBase = OpenResource("hostlib.resource")) == NULL) {
kprintf("[gdi] couldn't open hostlib.resource");
return FALSE;
}
gdi_func = (struct gdi_func *)gdi_hostlib_load_so(GDI_SOFILE, gdi_func_names, &gdi_handle);
if (!gdi_func)
return FALSE;
user_func = (struct user_func *)gdi_hostlib_load_so(USER_SOFILE, user_func_names, &user_handle);
if (user_func) {
native_func = (struct native_func *)gdi_hostlib_load_so(NATIVE_SOFILE, native_func_names, &native_handle);
if (native_func)
return TRUE;
HostLib_DropInterface((APTR *)user_func);
HostLib_Close(user_handle, NULL);
}
HostLib_DropInterface((APTR *)gdi_func);
HostLib_Close(gdi_handle, NULL);
return FALSE;
}
nsresult
ChannelMediaDecoder::Load(nsIChannel* aChannel,
bool aIsPrivateBrowsing,
nsIStreamListener** aStreamListener)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mResource);
mResource =
BaseMediaResource::Create(mResourceCallback, aChannel, aIsPrivateBrowsing);
if (!mResource) {
return NS_ERROR_FAILURE;
}
nsresult rv = MediaShutdownManager::Instance().Register(this);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = OpenResource(aStreamListener);
NS_ENSURE_SUCCESS(rv, rv);
SetStateMachine(CreateStateMachine());
NS_ENSURE_TRUE(GetStateMachine(), NS_ERROR_FAILURE);
return InitializeStateMachine();
}
static int PCILx_Init(LIBBASETYPEPTR LIBBASE)
{
APTR KernelBase;
STRPTR arch;
int ret;
D(bug("LinuxPCI: Initializing\n"));
KernelBase = OpenResource("kernel.resource");
if (!KernelBase)
return FALSE;
/* Make sure we are running on Linux. Otherwise we will just
crash at first syscall. */
arch = (STRPTR)KrnGetSystemAttr(KATTR_Architecture);
if (strncmp(arch, "linux", 5))
{
D(bug("LinuxPCI: Running on %s, not on Linux\n", arch));
return FALSE;
}
ret = syscall1(__NR_iopl, 3);
D(bug("LinuxPCI: iopl(3)=%d\n", ret));
LIBBASE->psd.fd = syscall2(__NR_open, (IPTR)"/dev/mem", 2);
D(bug("LinuxPCI: /dev/mem fd=%d\n", LIBBASE->psd.fd));
if (ret==0)
return TRUE;
D(bug("LinuxPCI: has to be root in order to use this hidd\n"));
return FALSE;
}
int main(void) {
ARP2_SysCallBase = OpenResource(ARP2_SYSCALL_NAME);
if (ARP2_SysCallBase != NULL) {
LONG fd = arp2sys_open("/etc/passwd", O_RDONLY, 0);
PrintFault(IoErr(), "arp2sys_open");
Printf("Opened file %ld\n", fd);
if (fd != -1) {
char buf[512];
LONG count = arp2sys_read(fd, buf, sizeof (buf) - 1);
buf[511] = 0;
PrintFault(IoErr(), "arp2sys_read");
Printf("Read %ld bytes.\n", count);
PutStr(buf);
PutStr("\n");
}
arp2sys_close(fd);
PrintFault(IoErr(), "arp2sys_close");
Printf("Closed file %ld\n", fd);
}
return 0;
}
/* auto init */
static int BattClock_Init(struct BattClockBase *BattClockBase)
{
APTR HostLibBase;
ULONG r;
HostLibBase = OpenResource("hostlib.resource");
D(bug("[battclock] HostLibBase = 0x%08lX\n", HostLibBase));
if (HostLibBase)
{
BattClockBase->Lib = HostLib_Open(LIBC_NAME, NULL);
if (BattClockBase->Lib)
{
BattClockBase->SysIFace = (struct BattclockInterface *)HostLib_GetInterface(BattClockBase->Lib, Symbols, &r);
D(bug("[battclock] SysIFace = 0x%08lX, unresolved: %u\n", BattClockBase->SysIFace, r));
if (BattClockBase->SysIFace)
{
if (!r)
return 1;
HostLib_DropInterface((APTR)BattClockBase->SysIFace);
}
HostLib_Close(BattClockBase->Lib, NULL);
}
}
return 0;
}
char *platform_get_aros_runtime_cpu(void)
{
if (!modelstring) {
ProcessorBase = OpenResource(PROCESSORNAME);
GetCPUInfoTags(GCIT_ModelString, (IPTR)&modelstring, TAG_DONE);
}
return (char *)modelstring;
}
static struct DevBase *OS4DevInit(struct DevBase *dev_base, APTR seg_list,
struct ExecIFace *i_exec)
{
struct DevBase *base;
BOOL success = TRUE;
dev_base->i_exec = i_exec;
base = dev_base;
base->seg_list = seg_list;
base->sys_base = (APTR)i_exec->Data.LibBase;
base->device.dd_Library.lib_Node.ln_Type = NT_DEVICE;
base->device.dd_Library.lib_Node.ln_Name = (TEXT *)device_name;
base->device.dd_Library.lib_Flags = LIBF_SUMUSED | LIBF_CHANGED;
base->device.dd_Library.lib_Version = VERSION;
base->device.dd_Library.lib_Revision = REVISION;
base->device.dd_Library.lib_IdString = (TEXT *)version_string;
base->utility_base = (APTR)OpenLibrary(utility_name, UTILITY_VERSION);
base->expansion_base = OpenLibrary(expansion_name, EXPANSION_VERSION);
if(base->utility_base == NULL || base->expansion_base == NULL)
success = FALSE;
base->card_base = (APTR)OpenResource(card_name);
base->pccard_base = (APTR)OpenLibrary(pccard_name, PCCARD_VERSION);
if(OpenDevice(timer_name, UNIT_ECLOCK, (APTR)&base->timer_request, 0) !=
0)
success = FALSE;
NewList((APTR)(&dev_base->pci_units));
NewList((APTR)(&dev_base->pccard_units));
base->wrapper_int_code = (APTR)OS4Int;
if(success)
{
base->i_utility =
(APTR)GetInterface((APTR)UtilityBase, "main", 1, NULL);
base->i_pci =
(APTR)GetInterface(ExpansionBase, "pci", 1, NULL);
base->i_timer =
(APTR)GetInterface((APTR)TimerBase, "main", 1, NULL);
if(base->i_utility == NULL || base->i_pci == NULL
|| base->i_timer == NULL)
success = FALSE;
}
if(!success)
{
DeleteDevice(base);
base = NULL;
}
return base;
}
//
// Checks to see if the resource is already open - if so, it activates it.
// Otherwise, it opens a new document for it.
//
void AppState::OpenMostRecentResource(ResourceType type, uint16_t wNum)
{
CMainFrame *pMainWnd = static_cast<CMainFrame*>(_pApp->m_pMainWnd);
CResourceDocument *pDocAlready = pMainWnd->Tabs().ActivateResourceDocument(type, wNum);
if (pDocAlready == nullptr)
{
std::unique_ptr<ResourceBlob> blob = move(_resourceMap.MostRecentResource(type, wNum, true));
OpenResource(blob.get());
_resourceRecency.AddResourceToRecency(blob.get());
}
}
static int rtas_call(const char *method, int nargs, int nret, void *output, ...)
{
va_list args;
void *RTASBase = OpenResource("rtas.resource");
int retval;
va_start(args, output);
retval = RTASCall(method, nargs, nret, output, args);
va_end(args);
return retval;
}
static int rtas_init(struct RTASBase *RTASBase)
{
int retval = TRUE;
void *OpenFirmwareBase;
void *key, *prop;
D(bug("[RTAS] RTAS Init.\n"));
OpenFirmwareBase = RTASBase->OpenFirmwareBase = OpenResource("openfirmware.resource");
RTASBase->KernelBase = OpenResource("kernel.resource");
/* Get some addresses from OF tree */
if (OpenFirmwareBase)
{
key = OF_OpenKey("/rtas");
if (key)
{
prop = OF_FindProperty(key, "load_base");
if (prop)
{
void **reg = OF_GetPropValue(prop);
D(bug("[RTAS] RTAS loaded at %08x\n", *reg));
RTASBase->rtas_base = *reg;
}
prop = OF_FindProperty(key, "entry");
if (prop)
{
void **reg = OF_GetPropValue(prop);
D(bug("[RTAS] Entry at %08x\n", *reg));
RTASBase->rtas_entry = *reg;
}
}
}
else
retval = FALSE;
return retval;
}
int main(void)
{
struct TagItem *tags;
struct mb_mmap *mmap;
IPTR len;
APTR KernelBase = OpenResource("kernel.resource");
if (!KernelBase)
{
printf("Failed to open kernel.resource!\n");
return 20;
}
tags = KrnGetBootInfo();
if (!tags)
{
printf("No boot information from the bootstrap!\n");
return 20;
}
mmap = (struct mb_mmap *)GetTagData(KRN_MMAPAddress, 0, tags);
len = GetTagData(KRN_MMAPLength, 0, tags);
if (!mmap || !len)
{
printf("No memory map provided by the bootstrap!\n");
return 20;
}
printf("Memory map at 0x%p, length %lu:\n", mmap, len);
while (len >= sizeof(struct mb_mmap))
{
unsigned int type = mmap->type;
unsigned long long memaddr = mmap->addr;
unsigned long long memlen = mmap->len;
if (type > MMAP_TYPE_ACPINVS)
type = 0;
#if __WORDSIZE < 64
memaddr |= (unsigned long long)mmap->addr_high << 32;
memlen |= (unsigned long long)mmap->len_high << 32;
#endif
printf("Entry size %d type %d <%s> addr 0x%016llx len 0x%016llx\n", mmap->size, mmap->type, types[type], memaddr, memlen);
len -= mmap->size + 4;
mmap = (struct mb_mmap *)(mmap->size + (unsigned long)mmap + 4);
}
return 0;
}
static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR hdskBase)
{
HostLibBase = OpenResource("hostlib.resource");
D(bug("hostdisk: HostLibBase: 0x%p\n", HostLibBase));
if (!HostLibBase)
return FALSE;
InitSemaphore(&hdskBase->sigsem);
NEWLIST(&hdskBase->units);
D(bug("hostdisk: in libinit func. Returning %x (success) :-)\n", hdskBase));
return TRUE;
}
static inline ULONG GetPVR(void)
{
struct Library *ProcessorBase = OpenResource(PROCESSORNAME);
ULONG pvr = 0;
if (ProcessorBase) {
struct TagItem tags[] = {
{ GCIT_Model, (IPTR)&pvr },
{ TAG_END }
};
GetCPUInfo(tags);
}
return pvr;
}
static int Lowlevel_amiga_InitLib(struct LowLevelBase *LowLevelBase)
{
struct GfxBase *GfxBase;
GfxBase = TaggedOpenLibrary(TAGGEDOPEN_GRAPHICS);
LowLevelBase->ll_EClockMult = (GfxBase->DisplayFlags & REALLY_PAL) ? 23245 : 23459;
CloseLibrary((struct Library*)GfxBase);
LowLevelBase->ll_CIA.llciat_iCRBit = -1;
LowLevelBase->ll_PotgoBase = OpenResource("potgo.resource");
if (LowLevelBase->ll_PotgoBase == NULL)
return 0;
LowLevelBase->ll_PortType[0] = 0; /* Autosense */
LowLevelBase->ll_PortType[1] = 0; /* Autosense */
return 1;
}
/* auto init */
static int BattClock_Init(struct BattClockBase *BattClockBase)
{
APTR HostLibBase;
ULONG r;
HostLibBase = OpenResource("hostlib.resource");
D(bug("[battclock] HostLibBase = 0x%08lX\n", HostLibBase));
if (HostLibBase) {
BattClockBase->Lib = HostLib_Open("kernel32.dll", NULL);
if (BattClockBase->Lib) {
BattClockBase->KernelIFace = (struct KernelInterface *)HostLib_GetInterface(BattClockBase->Lib, Symbols, &r);
D(bug("[battclock] KernelIFace = 0x%08lX\n", BattClockBase->KernelIFace));
if (BattClockBase->KernelIFace) {
if (!r)
return 1;
HostLib_DropInterface((APTR)BattClockBase->KernelIFace);
}
HostLib_Close(BattClockBase->Lib, NULL);
}
}
return 0;
}
static int bsdsocket_Init(struct bsdsocketBase *SocketBase)
{
APTR HostLibBase = OpenResource("hostlib.resource");
if (!HostLibBase)
return FALSE;
SocketBase->HostLibBase = HostLibBase;
SocketBase->winsock = HostLib_Open("Ws2_32.dll", NULL);
if (!SocketBase->winsock)
return FALSE;
SocketBase->resolver = HostLib_Open("Libs\\Host\\bsdsocket.dll", NULL);
if (!SocketBase->resolver)
return FALSE;
SocketBase->WSIFace = (struct WinSockInterface *)HostLib_GetInterface(SocketBase->winsock, ws_functions, NULL);
if (!SocketBase->WSIFace)
{
D(bug("[socket] Failed to obtain winsock interface\n"));
return FALSE;
}
SocketBase->ResIFace = (struct HostSocketInterface *)HostLib_GetInterface(SocketBase->resolver, res_functions, NULL);
if (!SocketBase->ResIFace)
return FALSE;
NewList((struct List *)&SocketBase->socks);
Forbid();
SocketBase->ctl = SocketBase->ResIFace->sock_init();
Permit();
if (!SocketBase->ctl)
return FALSE;
return TRUE;
}
nsresult
ChannelMediaDecoder::Load(BaseMediaResource* aOriginal)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mResource);
mResource = aOriginal->CloneData(mResourceCallback);
if (!mResource) {
return NS_ERROR_FAILURE;
}
nsresult rv = MediaShutdownManager::Instance().Register(this);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = OpenResource(nullptr);
NS_ENSURE_SUCCESS(rv, rv);
SetStateMachine(CreateStateMachine());
NS_ENSURE_TRUE(GetStateMachine(), NS_ERROR_FAILURE);
return InitializeStateMachine();
}
/*
Here shall we start. Make function static as it shouldn't be visible from
outside.
*/
static int ata_init(struct ataBase *ATABase)
{
OOP_Object *storageRoot;
struct BootLoaderBase *BootLoaderBase;
D(bug("[ATA--] ata_init: ata.device Initialization\n"));
ATABase->ata_UtilityBase = OpenLibrary("utility.library", 36);
if (!ATABase->ata_UtilityBase)
return FALSE;
/*
* I've decided to use memory pools again. Alloc everything needed from
* a pool, so that we avoid memory fragmentation.
*/
ATABase->ata_MemPool = CreatePool(MEMF_CLEAR | MEMF_PUBLIC | MEMF_SEM_PROTECTED , 8192, 4096);
if (ATABase->ata_MemPool == NULL)
return FALSE;
D(bug("[ATA--] ata_init: MemPool @ %p\n", ATABase->ata_MemPool));
if (OOP_ObtainAttrBasesArray(&ATABase->unitAttrBase, attrBaseIDs))
return FALSE;
/* This is our own method base, so no check needed */
if (OOP_ObtainMethodBasesArray(&ATABase->hwMethodBase, &attrBaseIDs[ATA_METHOD_ID_START]))
return FALSE;
storageRoot = OOP_NewObject(NULL, CLID_Hidd_Storage, NULL);
if (!storageRoot)
storageRoot = OOP_NewObject(NULL, CLID_HW_Root, NULL);
if (!storageRoot)
return FALSE;
if (!HW_AddDriver(storageRoot, ATABase->ataClass, NULL))
return FALSE;
/* Set default ata.device config options */
ATABase->ata_32bit = FALSE;
ATABase->ata_NoMulti = FALSE;
ATABase->ata_NoDMA = FALSE;
ATABase->ata_Poll = FALSE;
/*
* start initialization:
* obtain kernel parameters
*/
BootLoaderBase = OpenResource("bootloader.resource");
D(bug("[ATA--] ata_init: BootloaderBase = %p\n", BootLoaderBase));
if (BootLoaderBase != NULL)
{
struct List *list;
struct Node *node;
list = (struct List *)GetBootInfo(BL_Args);
if (list)
{
ForeachNode(list, node)
{
if (strncmp(node->ln_Name, "ATA=", 4) == 0)
{
const char *CmdLine = &node->ln_Name[4];
if (strstr(CmdLine, "32bit"))
{
D(bug("[ATA ] ata_init: Using 32-bit IO transfers\n"));
ATABase->ata_32bit = TRUE;
}
if (strstr(CmdLine, "nomulti"))
{
D(bug("[ATA ] ata_init: Disabled multisector transfers\n"));
ATABase->ata_NoMulti = TRUE;
}
if (strstr(CmdLine, "nodma"))
{
D(bug("[ATA ] ata_init: Disabled DMA transfers\n"));
ATABase->ata_NoDMA = TRUE;
}
if (strstr(CmdLine, "poll"))
{
D(bug("[ATA ] ata_init: Using polling to detect end of busy state\n"));
ATABase->ata_Poll = TRUE;
}
}
}
}
}
/* Try to setup daemon task looking for diskchanges */
NEWLIST(&ATABase->Daemon_ios);
InitSemaphore(&ATABase->DaemonSem);
InitSemaphore(&ATABase->DetectionSem);
ATABase->daemonParent = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if (!NewCreateTask(TASKTAG_PC, DaemonCode,
TASKTAG_NAME , "ATA.daemon",
TASKTAG_STACKSIZE , STACK_SIZE,
TASKTAG_TASKMSGPORT, &ATABase->DaemonPort,
TASKTAG_PRI , TASK_PRI - 1, /* The daemon should have a little bit lower Pri than handler tasks */
TASKTAG_ARG1 , ATABase,
TAG_DONE))
{
D(bug("[ATA ] Failed to start up daemon!\n"));
return FALSE;
}
/* Wait for handshake */
Wait(SIGF_SINGLE);
D(bug("[ATA ] Daemon task set to 0x%p\n", ATABase->ata_Daemon));
return ATABase->ata_Daemon ? TRUE : FALSE;
}
int par_init(UBYTE useCRC)
{
int result = PAR_INIT_OK;
/* allocate signal for interrupt */
intSig = AllocSignal(-1);
if(intSig == -1) {
return PAR_INIT_NO_SIGNAL;
}
alloc_flags |= 8;
/* setup state structure */
state.s_Flags = 0;
state.s_IntSigMask = 1UL << intSig;
state.s_SysBase = SysBase;
state.s_ServerTask = FindTask(NULL);
state.s_UseCRC = useCRC;
/* register our time out flag */
timer_timeout_set_flag_ptr(&state.s_TimeOut);
if (MiscBase = OpenResource("misc.resource")) {
if (cia_base = OpenResource("ciaa.resource")) {
/* obtain exclusive access to the parallel hardware */
if (!AllocMiscResource(MR_PARALLELPORT, name))
{
alloc_flags |= 1;
if (!AllocMiscResource(MR_PARALLELBITS, name))
{
BOOL ok = FALSE;
alloc_flags |= 2;
/* allocate irq */
irq.is_Node.ln_Type = NT_INTERRUPT;
irq.is_Node.ln_Pri = 127;
irq.is_Node.ln_Name = name;
irq.is_Data = (APTR)&state;
irq.is_Code = (VOID (*)())&interrupt;
Disable();
/* add an interrupt handler for FLAG = ACK */
if (!AddICRVector(cia_base, CIAICRB_FLG, &irq))
{
DISABLEINT;
ok = TRUE;
}
Enable();
/* finish setting up interrupt handler */
if (ok) {
alloc_flags |= 4;
/* setup line */
PARINIT;
CLEARREQUEST;
/* irq setup */
CLEARINT;
ENABLEINT;
} else {
result = PAR_INIT_NO_CIA_IRQ;
}
} else {
result = PAR_INIT_NO_PARBITS_RES;
}
} else {
result = PAR_INIT_NO_PARPORT_RES;
}
}
}
return result;
}
int
ResourceEntry( void )
{
struct ISAPNPBase* ISAPNPBase;
struct RDArgs* rdargs;
int rc = -1;
struct
{
ULONG m_ShowConfig;
ULONG m_ShowOptions;
/* ULONG m_Remove;*/
} args = { FALSE, FALSE/*, FALSE*/ };
if( ! OpenLibs() )
{
CloseLibs();
return RETURN_FAIL;
}
ISAPNPBase = (struct ISAPNPBase* ) OpenResource( ISAPNPNAME );
if( ISAPNPBase == NULL )
{
Printf( ISAPNPNAME " not found.\n" );
CloseLibs();
return RETURN_FAIL;
}
rdargs = ReadArgs( TEMPLATE, (LONG *) &args, NULL );
if( rdargs != NULL )
{
if( ! args.m_ShowConfig && args.m_ShowOptions )
{
Printf( "SHOWOPTIONS can only be used together with SHOWCONFIG\n" );
rc = RETURN_ERROR;
}
else
{
if( args.m_ShowConfig )
{
ShowCards( args.m_ShowOptions, ISAPNPBase );
rc = RETURN_OK;
}
/* if( args.m_Remove )
{
// Dangerous! Only for debugging
FreeISAPNPBase( ISAPNPBase );
ISAPNPBase->m_ConfigDev->cd_Flags |= CDF_CONFIGME;
ISAPNPBase->m_ConfigDev->cd_Driver = NULL;
RemResource( ISAPNPBase );
rc = RETURN_OK;
}*/
}
FreeArgs( rdargs );
}
if( rc == -1 )
{
Printf( "Usage: ISA-PnP [ SHOWCONFIG [ SHOWOPTIONS ] ] [ REMOVE ]\n" );
rc = RETURN_ERROR;
}
CloseLibs();
return rc;
}
int main(void)
{
#if defined(KrnStatMemory)
#if defined(__AROSPLATFORM_SMP__)
void *ExecLockBase = OpenResource("execlock.resource");
#endif
APTR KernelBase;
struct Task *me;
ULONG page;
struct MemHeader *TestArea;
ULONG TestLength;
struct MemChunk *mc;
APTR region1, region2, region3, region4;
KernelBase = OpenResource("kernel.resource");
if (!KernelBase)
{
printf("Failed to open kernel.resource!\n");
return 1;
}
if (!KrnStatMemory(0, KMS_PageSize, &page, TAG_DONE))
{
printf("MMU support is not implemented for this system!\n"
"kernel.resource memory allocator will not work!\n");
return 1;
}
printf("System page size: %u (0x%08X)\n", (unsigned)page, (unsigned)page);
TestLength = PAGES_NUM * page;
TestArea = AllocMem(TestLength, MEMF_ANY);
printf("Allocated test region (%u bytes) at 0x%p\n", (unsigned)TestLength, TestArea);
if (!TestArea)
{
printf("Failed to allocate test region!\n");
return 1;
}
/* Install trap handler */
me = FindTask(NULL);
me->tc_TrapCode = TrapHandler;
/* Compose a MemHeader */
TestArea->mh_Node.ln_Succ = NULL;
TestArea->mh_Node.ln_Type = NT_MEMORY;
TestArea->mh_Node.ln_Name = "Kernel allocator test area";
TestArea->mh_Node.ln_Pri = 127; /* This MemHeader must be the first in the list, otherwise KrnFreePages() will find a wrong one */
TestArea->mh_Attributes = MEMF_FAST;
TestArea->mh_Lower = TestArea;
TestArea->mh_Upper = TestArea->mh_Lower + TestLength - 1;
TestArea->mh_First = TestArea->mh_Lower + MEMHEADER_TOTAL;
TestArea->mh_Free = TestLength - MEMHEADER_TOTAL;
mc = TestArea->mh_First;
mc->mc_Next = NULL;
mc->mc_Bytes = TestArea->mh_Free;
/* Give up the area to kernel allocator */
KrnInitMemory(TestArea);
if (mc->mc_Next || mc->mc_Bytes)
{
printf("KrnInitMemory() failed:\n"
" mc_Next is 0x%p\n"
" mc_Bytes is %lu\n",
mc->mc_Next, mc->mc_Bytes);
goto exit;
}
printf("Testing initial no-access protection...\n");
TestRead((UBYTE *)TestArea + page);
/*
* Insert the area into system list.
* We do it manually because in future AddMemList() will call KrnInitMemory() itself.
*/
#if defined(__AROSPLATFORM_SMP__)
if (ExecLockBase)
ObtainSystemLock(&SysBase->MemList, SPINLOCK_MODE_WRITE, LOCKF_FORBID);
else
Forbid();
#else
Forbid();
#endif
Enqueue(&SysBase->MemList, &TestArea->mh_Node);
#if defined(__AROSPLATFORM_SMP__)
if (ExecLockBase)
ReleaseSystemLock(&SysBase->MemList, LOCKF_FORBID);
else
Permit();
#else
Permit();
#endif
printf("Allocating region1 (two read-write pages)...\n");
region1 = KrnAllocPages(NULL, 2 * page, MEMF_FAST);
printf("region1 at 0x%p\n", region1);
DumpState(TestArea);
printf("Freeing region1...\n");
KrnFreePages(region1, 2 * page);
printf("Done!\n");
DumpState(TestArea);
printf("Allocating region1 (3 read-only pages)...\n");
region1 = KrnAllocPages(NULL, 3 * page, MEMF_FAST);
printf("region1 at 0x%p\n", region1);
DumpState(TestArea);
printf("Allocating region2 (4 write-only ;-) pages)...\n");
region2 = KrnAllocPages(NULL, 4 * page, MEMF_FAST);
printf("region2 at 0x%p\n", region2);
DumpState(TestArea);
printf("Attempting to allocate page with wrong flags...\n");
region3 = KrnAllocPages(NULL, page, MEMF_CHIP|MEMF_FAST);
printf("Region at 0x%p\n", region3);
if (region3)
{
printf("WARNING!!! This should have been NULL!\n");
KrnFreePages(region3, page);
}
printf("Freeing region1...\n");
KrnFreePages(region1, 3 * page);
printf("Done!\n");
DumpState(TestArea);
printf("Freeing region2...\n");
KrnFreePages(region2, 4 * page);
printf("Done!\n");
DumpState(TestArea);
printf("Allocating region1 (one read-write page)...\n");
region1 = KrnAllocPages(NULL, page, MEMF_FAST);
printf("region1 at 0x%p\n", region1);
DumpState(TestArea);
printf("Freeing region1...\n");
KrnFreePages(region1, page);
printf("Done!\n");
DumpState(TestArea);
printf("Now we'll try to fragment the memory\n");
printf("Allocating region1 (2 pages)...\n");
region1 = KrnAllocPages(NULL, 2 * page, MEMF_FAST);
printf("region1 at 0x%p\n", region1);
DumpState(TestArea);
printf("Allocating region2 (3 pages)...\n");
region2 = KrnAllocPages(NULL, 3 * page, MEMF_FAST);
printf("region2 at 0x%p\n", region2);
DumpState(TestArea);
printf("Allocating region 3 (1 page)...\n");
region3 = KrnAllocPages(NULL, page, MEMF_FAST);
printf("Region at 0x%p\n", region3);
DumpState(TestArea);
printf("Allocating region 4 (2 pages)...\n");
region4 = KrnAllocPages(NULL, 2 * page, MEMF_FAST);
printf("region4 at 0x%p\n", region1);
DumpState(TestArea);
printf("Freeing region1...\n");
KrnFreePages(region1, 2 * page);
printf("Done!\n");
DumpState(TestArea);
printf("Freeing region3...\n");
KrnFreePages(region3, page);
printf("Done!\n");
DumpState(TestArea);
printf("Allocating region 3 (1 page) again...\n");
region3 = KrnAllocPages(NULL, page, MEMF_FAST);
printf("Region at 0x%p\n", region3);
DumpState(TestArea);
printf("Freeing region2...\n");
KrnFreePages(region2, 3 * page);
printf("Done!\n");
DumpState(TestArea);
printf("Freeing region3...\n");
KrnFreePages(region3, page);
printf("Done!\n");
DumpState(TestArea);
printf("Freeing region4...\n");
KrnFreePages(region4, 2 * page);
printf("Done!\n");
DumpState(TestArea);
exit:
if (TestArea->mh_Node.ln_Succ)
{
Forbid();
Remove(&TestArea->mh_Node);
Permit();
}
FreeMem(TestArea, TestLength);
#else
printf("The test can't be built for this kernel.resource implementation\n");
#endif
return 0;
}
