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; }