void kmain( void* mdb,u32i magic ) { if( magic != 0x2BADB002 ) { while(1); } InitDescriptorTables(); VideoInit(); SetColor(BLACK,BRIGHT_WHITE); KPrintf("This is Atomic Kernel 12715A\n"); KPrintf("Starting Timer..."); InitTimer(100); KPrintf("Done.\n"); KPrintf("Starting Keyboard..."); InitKeyboard(); KPrintf("Done.\n"); KPrintf("Starting Paging..."); InitialisePaging(); KPrintf("Done.\n"); KPrintf("Starting Heap..."); HeapInit(); KPrintf("Done.\n"); u32i *A,*B,*C; A = Kmalloc(8); B = Kmalloc(8); KPrintf("A:%x,B:%x",A,B); KFree(A); KFree(B); C = Kmalloc(16); KPrintf("C:%x\n",C); while(1); }
struct Mount *AllocAssign (char *alias, char *path) { struct Mount *assign; int alias_len; alias_len = StrLen (alias) + 1; if ((assign = KMalloc (sizeof (struct Mount))) != NULL) { if ((assign->name = KMalloc (alias_len)) != NULL) { StrLCpy (assign->name, alias, alias_len); if (ValidAlias (assign->name) == 0) { if ((assign->pathname = TranslatePathnameAliases (path)) != NULL) { assign->type = MOUNT_ASSIGN; AddMount (assign); return assign; } } KFree (assign->name); } KFree (assign); } return NULL; }
int CreatePathInfo (struct PathInfo *pi, char *pathname, bool keep_canon) { pi->buffer = NULL; pi->canon = NULL; if ((pi->canon = CanonPathname(pathname)) != NULL) { if ((pi->buffer = TranslatePathnameAliases (pi->canon)) != NULL) { if (InitPathInfo (pi) == 0) { KPRINTF ("pi->canon = %s", pi->canon); if (keep_canon != KEEP_CANON) { KFree (pi->canon); pi->canon = NULL; } return 0; } KFree (pi->buffer); } KFree (pi->canon); } SetError (ENOENT); return -1; }
void FreeAssign (struct Mount *assign) { RemMount (assign); KFree (assign->name); KFree (assign->pathname); KFree (assign); }
static void MPIData_extend(KonohaContext *kctx, kMPIData *p, int size) { size_t newSize = p->offset + size; if(p->size < newSize) { switch(p->typeId) { case KMPI_BYTES: { kBytes *b = (kBytes *)KLIB new_kObjectDontUseThis(kctx, CT_Bytes, (uintptr_t)newSize, OnStack); memcpy(b->buf, p->b->buf, p->size); p->b = b; p->size = newSize; break; } case KMPI_FARRAY: { kfloat_t *fa = KCalloc_UNTRACE(sizeof(kfloat_t), newSize); memcpy(fa, p->fa, p->size * sizeof(kfloat_t)); KFree(p->fa, p->size * sizeof(kfloat_t)); p->fa = fa; p->size = newSize; break; } case KMPI_IARRAY: { kint_t *ia = KCalloc_UNTRACE(sizeof(kint_t), newSize); memcpy(ia, p->ia, p->size * sizeof(kint_t)); KFree(p->ia, p->size * sizeof(kint_t)); p->ia = ia; p->size = newSize; break; } default: abort(); } } }
void FreePathInfo (struct PathInfo *pi) { if (pi->canon != NULL) KFree (pi->canon); KFree (pi->buffer); }
static void KRuntimeContext_Free(KonohaContext *kctx, KonohaContextVar *ctx) { if(ctx->stack->evaljmpbuf != NULL) { KFree(ctx->stack->evaljmpbuf, sizeof(jmpbuf_i)); } KLIB KArray_Free(kctx, &ctx->stack->cwb); KFree(ctx->stack->stack, sizeof(KonohaStack) * ctx->stack->stacksize); KFree(ctx->stack, sizeof(KRuntimeContextVar)); }
OVS_ARGUMENT* CreateArgFromPacketInfo(const OVS_OFPACKET_INFO* pPacketInfo, const OVS_OFPACKET_INFO* pMask, UINT16 groupType) { OVS_ARGUMENT_SLIST_ENTRY* pList = NULL; UINT16 count = 0; UINT size = 0; OVS_ARGUMENT* args = NULL, *pResult = NULL; OVS_ARGUMENT_GROUP* pArgGroup = NULL; pList = _CreateArgListFromPacketInfo(pPacketInfo, pMask); if (!pList) { DEBUGP(LOG_ERROR, __FUNCTION__ " _CreateArgListFromPacketInfo failed\n"); return NULL; } args = ArgumentListToArray(pList, &count, &size); if (!args) { DEBUGP(LOG_ERROR, __FUNCTION__ " could not convert arg list to array\n"); DestroyOrFreeArgList(&pList, /*destroy*/ TRUE); return NULL; } OVS_CHECK(size <= MAXUINT16); pArgGroup = KZAlloc(sizeof(OVS_ARGUMENT_GROUP)); if (!pArgGroup) { DEBUGP(LOG_ERROR, __FUNCTION__ " failed allocating arg group\n"); DestroyOrFreeArgList(&pList, /*destroy*/ TRUE); KFree(args); return NULL; } pArgGroup->args = args; pArgGroup->count = count; pArgGroup->groupSize = (UINT16)size; pResult = CreateArgumentFromGroup(groupType, pArgGroup); if (!pResult) { DEBUGP(LOG_ERROR, "CreateArgumentFromGroup failed\n"); DestroyOrFreeArgList(&pList, /*destroy*/ TRUE); KFree(args); return NULL; } DBGPRINT_ARG(LOG_INFO, pResult, 0, 0); DestroyOrFreeArgList(&pList, /*destroy*/ FALSE); VerifyGroup_Size_Recursive(pArgGroup); return pResult; }
VOID DbgPrintArg(ULONG logLevel, _In_ OVS_ARGUMENT* pArg, int depth, int index) { char* padding = NULL; OVS_CHECK(pArg); OVS_CHECK(depth >= 0); padding = KAlloc(depth + 1); if (!padding) { return; } memset(padding, '\t', depth); padding[depth] = 0; DbgPrintArgType(logLevel, pArg->type, padding, index); DEBUGP_ARG(logLevel, "%ssize: 0x%x\n", padding, pArg->length); if (IsArgTypeGroup(pArg->type)) { ++depth; DbgPrintArgGroup(logLevel, pArg->data, depth); } KFree(padding); }
static BOOLEAN _CreateActionsGroupToList(OVS_ARGTYPE groupType, const OVS_ARGUMENT_GROUP* pArgGroup, OVS_ARGUMENT_SLIST_ENTRY** ppArgList) { OVS_ARGUMENT_SLIST_ENTRY* pCurListArg = NULL, *pHeadArg = NULL; OVS_ARGUMENT* pGroupArg = NULL; BOOLEAN ok = TRUE; pHeadArg = KZAlloc(sizeof(OVS_ARGUMENT_SLIST_ENTRY)); if (!pHeadArg) { return FALSE; } pCurListArg = pHeadArg; ok = _CreateActionsArgsToList(pArgGroup, &pCurListArg); if (!ok) { return FALSE; } pGroupArg = CreateGroupArgFromList(groupType, &pHeadArg); if (!pGroupArg) { KFree(pHeadArg); return FALSE; } ok = AppendArgumentToList(pGroupArg, ppArgList); if (!ok) { return FALSE; } return TRUE; }
VOID DbgPrintArgGroup(ULONG logLevel, _In_ OVS_ARGUMENT_GROUP* pGroup, int depth) { char* padding = NULL; OVS_CHECK(pGroup); OVS_CHECK(depth >= 0); padding = KAlloc(depth + 1); if (!padding) { return; } memset(padding, '\t', depth); padding[depth] = 0; DEBUGP_ARG(logLevel, "%sgroup: count=0x%x; size=0x%x\n", padding, pGroup->count, pGroup->groupSize); for (UINT i = 0; i < pGroup->count; ++i) { DbgPrintArg(logLevel, pGroup->args + i, depth + 1, i); } DEBUGP_ARG(logLevel, "\n"); KFree(padding); }
static void FreeVirtualCode(KonohaContext *kctx, struct KVirtualCode *vcode) { OPTHCODE *opTHCODE = (OPTHCODE *)(vcode - 1); if(opTHCODE->opcode == OPCODE_THCODE && opTHCODE->codesize > 0) { KFree(opTHCODE, opTHCODE->codesize); } }
static void kKonohaFactory_Free(KonohaContext *kctx, kObject *o) { struct kKonohaFactoryVar *f = (struct kKonohaFactoryVar *)o; if(f->factory != NULL) { KFree(f->factory, sizeof(KonohaFactory)); } }
VOID DestroyArgumentGroup(_In_ OVS_ARGUMENT_GROUP* pGroup) { if (pGroup) { DestroyArguments(pGroup->args, pGroup->count); KFree(pGroup); } }
VOID DestroyArgument(_In_ OVS_ARGUMENT* pArg) { if (pArg) { DestroyArgumentData(pArg); KFree(pArg); } }
static void SockAddr_Free(KonohaContext *kctx, kObject *o) { struct _kSockAddr *sa = (struct _kSockAddr *)o; if(sa->sockaddr_in != NULL) { KFree(sa->sockaddr_in, sizeof(struct sockaddr_in)); sa->sockaddr_in = NULL; } }
static void kBytes_Free(KonohaContext *kctx, kObject *o) { struct kBytesVar *ba = (struct kBytesVar *)o; if(ba->byteptr != NULL) { KFree(ba->buf, ba->bytesize); ba->byteptr = NULL; ba->bytesize = 0; } }
static struct KGammaLocalData *kNameSpace_PopGamma(KonohaContext *kctx, kNameSpace *ns, struct KGammaLocalData *oldone, struct KGammaLocalData *checksum) { struct KGammaLocalData *newone = ns->genv; assert(checksum == newone); ns->genv = oldone; if(newone->localScope.allocsize > 0) { KFree(newone->localScope.varItems, newone->localScope.allocsize); } return newone; }
//## Bytes Bytes.new(int size); static KMETHOD Bytes_new(KonohaContext *kctx, KonohaStack *sfp) { kBytes *ba = sfp[0].asBytes; size_t size = (size_t)sfp[1].intValue; if(ba->byteptr == NULL) KFree(ba->buf, ba->bytesize); ((struct kBytesVar *)ba)->byteptr = (const char *)KCalloc(size, 1, NULL); ((struct kBytesVar *)ba)->bytesize = size; KReturn(ba); }
static void kResultSet_Free(KonohaContext *kctx, kObject *o) { kResultSet *rs = (kResultSet *)o; if(rs->column_size > 0) { KFree(rs->column, sizeof(KColumn) * rs->column_size); } if(rs->qcur != NULL) { rs->driver->qcurfree(rs->qcur); rs->qcur = NULL; } rs->connectionNULL = NULL; }
static BOOLEAN _SampleActionToList(const OVS_ARGUMENT_GROUP* pArgGroup, OVS_ARGUMENT_SLIST_ENTRY** ppArgList) { BOOLEAN ok = TRUE; OVS_ARGUMENT_SLIST_ENTRY* pCurListArg = NULL, *pHeadArg = NULL; pHeadArg = KZAlloc(sizeof(OVS_ARGUMENT_SLIST_ENTRY)); if (!pHeadArg) { return FALSE; } pCurListArg = pHeadArg; OVS_ARGUMENT* pGroupArg = NULL; for (UINT i = 0; i < pArgGroup->count; ++i) { const OVS_ARGUMENT* pArg = pArgGroup->args + i; OVS_ARGTYPE argType = pArg->type; switch (argType) { case OVS_ARGTYPE_ACTION_SAMPLE_PROBABILITY: if (!CreateArgInList_WithSize(OVS_ARGTYPE_ACTION_SAMPLE_PROBABILITY, pArg->data, pArg->length, &pCurListArg)) { return FALSE; } break; case OVS_ARGTYPE_ACTION_SAMPLE_ACTIONS_GROUP: _CreateActionsGroupToList(OVS_ARGTYPE_ACTION_SAMPLE_ACTIONS_GROUP, pArg->data, &pCurListArg); break; } } pGroupArg = CreateGroupArgFromList(OVS_ARGTYPE_ACTION_SAMPLE_GROUP, &pHeadArg); if (!pGroupArg) { KFree(pHeadArg); return FALSE; } ok = AppendArgumentToList(pGroupArg, ppArgList); if (!ok) { DestroyArgument(pGroupArg); } return ok; }
char *AllocPathname (char *src) { char *buf; if ((buf = KMalloc (MAX_PATHNAME_SZ)) != NULL) { if (CopyInStr (current_process->user_as, buf, src, MAX_PATHNAME_SZ) == 0) return buf; else KFree (buf); } return NULL; }
VOID DestroyArguments(_In_ OVS_ARGUMENT* argArray, UINT count) { if (argArray != NULL && count > 0) { for (UINT i = 0; i < count; ++i) { OVS_ARGUMENT* pArg = argArray + i; DestroyArgumentData(pArg); } KFree(argArray); } }
static void KonohaContext_Free(KonohaContext *kctx, KonohaContextVar *ctx) { size_t i; for(i = 1; i < KRuntimeModel_MAXSIZE; i++) { // 0 is LOGGER, free lately KModelContext *p = ctx->localContexts[i]; if(p != NULL && p->free != NULL) { p->free(ctx, p); } } KRuntimeContext_Free(kctx, ctx); if(IS_RootKonohaContext(ctx)){ // share PLATAPI ExecutionEngineModule.DeleteExecutionEngine(ctx); KonohaLibVar *kklib = (KonohaLibVar *)ctx - 1; for(i = 0; i < KRuntimeModel_MAXSIZE; i++) { KRuntimeModel *p = ctx->runtimeModels[i]; if(p == NULL) continue; if(p->allocSize > 0) { KFree(p, p->allocSize); } else if(p->freeModel != NULL) { p->freeModel(kctx, p); } } PLATAPI GCModule.DeleteGcContext(ctx); PLATAPI JsonModule.DeleteJsonContext(ctx); KRuntime_Free(kctx, ctx); free(kctx->localContexts); free(kctx->runtimeModels); free(kklib/*, sizeof(KonohaLib) + sizeof(KonohaContextVar)*/); } else { PLATAPI GCModule.DeleteGcContext(ctx); PLATAPI JsonModule.DeleteJsonContext(ctx); KFree(ctx->localContexts, sizeof(KModelContext *) * KRuntimeModel_MAXSIZE); KFree(ctx, sizeof(KonohaContextVar)); } }
void CDFreeNode (struct CDSB *cdsb, struct CDNode *node) { node->reference_cnt--; if (node == &cdsb->root_node) { return; } if (node->reference_cnt == 0) { LIST_REM_ENTRY (&cdsb->node_list, node, node_entry); KFree (node); } }
void FreeNode (struct FatSB *fsb, struct FatNode *node) { node->reference_cnt--; if (node == &fsb->root_node) { return; } FlushDirent (fsb, node); if (node->reference_cnt == 0) { LIST_REM_ENTRY (&fsb->node_list, node, node_entry); KFree (node); } }
VOID DestroyArgumentData(_In_ OVS_ARGUMENT* pArg) { OVS_CHECK(pArg); if (IsArgTypeGroup(pArg->type)) { OVS_ARGUMENT_GROUP* pGroup = pArg->data; DestroyArgumentGroup(pGroup); } else { //free arg data if (pArg->freeData) { KFree(pArg->data); } } }
int cd_closedevice (void *ioreq) { struct FSReq *fsreq = ioreq; struct BlkReq blkreq; struct CDSB *cdsb; KPRINTF ("cd_closedevice()"); cdsb = fsreq->unitp; RWWriteLock (&mountlist_rwlock); if (cdsb->reference_cnt == 0) { KSignal (cdsb->pid, SIG_TERM); WaitPid (cdsb->pid, NULL, 0); blkreq.device = cdsb->device; blkreq.unitp = cdsb->unitp; CloseDevice (&blkreq); cd_device.reference_cnt --; RemMount (cdsb->device_mount); FreeBuf (cdsb->buf); KFree (cdsb); fsreq->error = 0; fsreq->rc = 0; } else { fsreq->error = EBUSY; fsreq->rc = -1; } RWUnlock (&mountlist_rwlock); KPRINTF ("cd_closedevice() +"); return 0; }
VOID Arp_DestroyTable() { OVS_ARP_TABLE_ENTRY* pArpEntry = NULL; PLIST_ENTRY headList = NULL; LOCK_STATE_EX lockState = { 0 }; NdisAcquireRWLockWrite(g_pArpRWLock, &lockState, 0); while (!IsListEmpty(&g_arpTable)) { headList = RemoveHeadList(&g_arpTable); pArpEntry = CONTAINING_RECORD(headList, OVS_ARP_TABLE_ENTRY, listEntry); KFree(pArpEntry); } NdisReleaseRWLock(g_pArpRWLock, &lockState); }
void AtaTaskInit (void) { KPRINTF ("AtaTaskInit()"); ata_pid = GetPID(); if ((ata_buffer = KMalloc (ATA_BUFFER_SZ)) != NULL) { if ((ata_timer_signal = AllocSignal()) != -1) { if ((ata_alarm_signal = AllocSignal()) != -1) { if ((ata_msgport = CreateMsgPort()) != NULL) { if (AtaInitUnits() == 0) { ata_init_error = 0; KSignal (GetPPID(), SIG_INIT); return; } DeleteMsgPort (ata_msgport); } FreeSignal (ata_alarm_signal); } FreeSignal (ata_timer_signal); } KFree (ata_buffer); } ata_init_error = -1; KSignal (GetPPID(), SIG_INIT); Exit(-1); }