Message Queues, Threads, and surroundings cleanup (#1178)

* message queues, threads, and surroundings cleanup

* Format, make the formatter prefer clang-format-11 if found

* Fix __osThreadTail type

* Q -> Queue, thread defines renamed

* Reformat, add missing NULL

* Suggested changes and further casting cleanup

* Reformat

* padmgr name fixes

17 files changed, 144 insertions, 145 deletions

diff --git a/src/code/__osMalloc.c b/src/code/__osMalloc.c
index 0b66eb353..ddf3024fa 100644
--- a/src/code/__osMalloc.c
+++ b/src/code/__osMalloc.c
@@ -56,15 +56,15 @@ void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena*
 }
 
 void ArenaImpl_LockInit(Arena* arena) {
-    osCreateMesgQueue(&arena->lock, &sArenaLockMsg, 1);
+    osCreateMesgQueue(&arena->lockQueue, &sArenaLockMsg, 1);
 }
 
 void ArenaImpl_Lock(Arena* arena) {
-    osSendMesg(&arena->lock, NULL, OS_MESG_BLOCK);
+    osSendMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
 }
 
 void ArenaImpl_Unlock(Arena* arena) {
-    osRecvMesg(&arena->lock, NULL, OS_MESG_BLOCK);
+    osRecvMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
 }
 
 ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {
diff --git a/src/code/audioMgr.c b/src/code/audioMgr.c
index a4775861e..ccef4dbb2 100644
--- a/src/code/audioMgr.c
+++ b/src/code/audioMgr.c
@@ -1,11 +1,10 @@
 #include "global.h"
 
 void func_800C3C80(AudioMgr* audioMgr) {
-    AudioTask* task;
+    AudioTask* task = audioMgr->rspTask;
 
-    task = audioMgr->rspTask;
-    if (audioMgr->rspTask->taskQueue != NULL) {
-        osSendMesg(task->taskQueue, NULL, OS_MESG_BLOCK);
+    if (audioMgr->rspTask->msgQueue != NULL) {
+        osSendMesg(task->msgQueue, NULL, OS_MESG_BLOCK);
     }
 }
 
@@ -17,14 +16,14 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
     }
     if (audioMgr->rspTask != NULL) {
         audioMgr->audioTask.next = NULL;
-        audioMgr->audioTask.flags = 2;
+        audioMgr->audioTask.flags = OS_SC_NEEDS_RSP;
         audioMgr->audioTask.framebuffer = NULL;
 
         audioMgr->audioTask.list = audioMgr->rspTask->task;
-        audioMgr->audioTask.msgQ = &audioMgr->unk_AC;
+        audioMgr->audioTask.msgQueue = &audioMgr->taskQueue;
 
         audioMgr->audioTask.msg = NULL;
-        osSendMesg(&audioMgr->sched->cmdQ, &audioMgr->audioTask, OS_MESG_BLOCK);
+        osSendMesg(&audioMgr->sched->cmdQueue, (OSMesg)&audioMgr->audioTask, OS_MESG_BLOCK);
         Sched_SendEntryMsg(audioMgr->sched);
     }
 
@@ -37,7 +36,7 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
     D_8016A558 += osGetTime() - D_8016A550;
     D_8016A550 = 0;
     if (audioMgr->rspTask != NULL) {
-        osRecvMesg(&audioMgr->unk_AC, NULL, OS_MESG_BLOCK);
+        osRecvMesg(&audioMgr->taskQueue, NULL, OS_MESG_BLOCK);
         func_800C3C80(audioMgr);
     }
     audioMgr->rspTask = rspTask;
@@ -58,16 +57,16 @@ void AudioMgr_ThreadEntry(void* arg0) {
     Audio_Init();
     AudioLoad_SetDmaHandler(DmaMgr_DmaHandler);
     Audio_InitSound();
-    osSendMesg(&audioMgr->unk_C8, NULL, OS_MESG_BLOCK);
-    IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->unk_74);
+    osSendMesg(&audioMgr->lockQueue, NULL, OS_MESG_BLOCK);
+    IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->interruptQueue);
 
     while (true) {
-        osRecvMesg(&audioMgr->unk_74, (OSMesg*)&msg, OS_MESG_BLOCK);
+        osRecvMesg(&audioMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
         switch (*msg) {
             case OS_SC_RETRACE_MSG:
                 AudioMgr_HandleRetrace(audioMgr);
-                while (audioMgr->unk_74.validCount != 0) {
-                    osRecvMesg(&audioMgr->unk_74, (OSMesg*)&msg, OS_MESG_BLOCK);
+                while (!MQ_IS_EMPTY(&audioMgr->interruptQueue)) {
+                    osRecvMesg(&audioMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
                     switch (*msg) {
                         case OS_SC_RETRACE_MSG:
                             break;
@@ -85,7 +84,7 @@ void AudioMgr_ThreadEntry(void* arg0) {
 }
 
 void AudioMgr_Unlock(AudioMgr* audioMgr) {
-    osRecvMesg(&audioMgr->unk_C8, NULL, OS_MESG_BLOCK);
+    osRecvMesg(&audioMgr->lockQueue, NULL, OS_MESG_BLOCK);
 }
 
 void AudioMgr_Init(AudioMgr* audioMgr, void* stack, OSPri pri, OSId id, SchedContext* sched, IrqMgr* irqMgr) {
@@ -95,12 +94,12 @@ void AudioMgr_Init(AudioMgr* audioMgr, void* stack, OSPri pri, OSId id, SchedCon
     audioMgr->irqMgr = irqMgr;
     audioMgr->rspTask = NULL;
 
-    osCreateMesgQueue(&audioMgr->unk_AC, &audioMgr->unk_C4, 1);
-    osCreateMesgQueue(&audioMgr->unk_74, &audioMgr->unk_8C, 8);
-    osCreateMesgQueue(&audioMgr->unk_C8, &audioMgr->unk_E0, 1);
+    osCreateMesgQueue(&audioMgr->taskQueue, audioMgr->taskMsgBuf, ARRAY_COUNT(audioMgr->taskMsgBuf));
+    osCreateMesgQueue(&audioMgr->interruptQueue, audioMgr->interruptMsgBuf, ARRAY_COUNT(audioMgr->interruptMsgBuf));
+    osCreateMesgQueue(&audioMgr->lockQueue, audioMgr->lockMsgBuf, ARRAY_COUNT(audioMgr->lockMsgBuf));
 
-    osSendMesg(&audioMgr->unk_AC, NULL, OS_MESG_BLOCK);
+    osSendMesg(&audioMgr->taskQueue, NULL, OS_MESG_BLOCK);
 
-    osCreateThread(&audioMgr->unk_E8, id, AudioMgr_ThreadEntry, audioMgr, stack, pri);
-    osStartThread(&audioMgr->unk_E8);
+    osCreateThread(&audioMgr->thread, id, AudioMgr_ThreadEntry, audioMgr, stack, pri);
+    osStartThread(&audioMgr->thread);
 }
diff --git a/src/code/audio_load.c b/src/code/audio_load.c
index 21655c0f9..092ae1d3f 100644
--- a/src/code/audio_load.c
+++ b/src/code/audio_load.c
@@ -58,7 +58,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus);
 void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3);
 
 OSMesgQueue sScriptLoadQueue;
-OSMesg sScriptLoadMesgBuf[0x10];
+OSMesg sScriptLoadMsgBuf[16];
 s8* sScriptLoadDonePointers[0x10];
 s32 sAudioLoadPad1[2]; // file padding
 
@@ -193,7 +193,7 @@ void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef,
     dma->ttl = 3;
     dma->devAddr = dmaDevAddr;
     dma->sizeUnused = transfer;
-    AudioLoad_Dma(&gAudioContext.currAudioFrameDmaIoMesgBuf[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL,
+    AudioLoad_Dma(&gAudioContext.currAudioFrameDmaIoMsgBuf[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL,
                   OS_READ, dmaDevAddr, dma->ramAddr, transfer, &gAudioContext.currAudioFrameDmaQueue, medium,
                   "SUPERDMA");
     *dmaIndexRef = dmaIndex;
@@ -442,7 +442,7 @@ s32 AudioLoad_SyncLoadInstrument(s32 fontId, s32 instId, s32 drumId) {
 
 void AudioLoad_AsyncLoad(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
     if (AudioLoad_AsyncLoadInner(tableType, id, nChunks, retData, retQueue) == NULL) {
-        osSendMesg(retQueue, 0xFFFFFFFF, OS_MESG_NOBLOCK);
+        osSendMesg(retQueue, (OSMesg)0xFFFFFFFF, OS_MESG_NOBLOCK);
     }
 }
 
@@ -967,7 +967,7 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData,
     ret = AudioLoad_SearchCaches(tableType, realId);
     if (ret != NULL) {
         status = 2;
-        osSendMesg(retQueue, MK_ASYNC_MSG(retData, 0, 0, 0), OS_MESG_NOBLOCK);
+        osSendMesg(retQueue, (OSMesg)MK_ASYNC_MSG(retData, 0, 0, 0), OS_MESG_NOBLOCK);
     } else {
         sp50 = AudioLoad_GetLoadTable(tableType);
         size = sp50->entries[realId].size;
@@ -1106,11 +1106,12 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
     gAudioContext.rspTask[0].task.t.data_size = 0;
     gAudioContext.rspTask[1].task.t.data_size = 0;
     osCreateMesgQueue(&gAudioContext.syncDmaQueue, &gAudioContext.syncDmaMesg, 1);
-    osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMesgBuf, 0x40);
-    osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMesgBuf,
-                      ARRAY_COUNT(gAudioContext.externalLoadMesgBuf));
-    osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMesgBuf,
-                      ARRAY_COUNT(gAudioContext.externalLoadMesgBuf));
+    osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMsgBuf,
+                      ARRAY_COUNT(gAudioContext.currAudioFrameDmaMsgBuf));
+    osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMsgBuf,
+                      ARRAY_COUNT(gAudioContext.externalLoadMsgBuf));
+    osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMsgBuf,
+                      ARRAY_COUNT(gAudioContext.externalLoadMsgBuf));
     gAudioContext.curAudioFrameDmaCount = 0;
     gAudioContext.sampleDmaCount = 0;
     gAudioContext.cartHandle = osCartRomInit();
@@ -1161,7 +1162,7 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
 
     AudioHeap_AllocPoolInit(&gAudioContext.permanentPool, temp_v0_3, D_8014A6C4.permanentPoolSize);
     gAudioContextInitalized = true;
-    osSendMesg(gAudioContext.taskStartQueueP, (void*)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
+    osSendMesg(gAudioContext.taskStartQueueP, (OSMesg)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
 }
 
 void AudioLoad_InitSlowLoads(void) {
@@ -1273,7 +1274,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
         switch (gAudioContext.slowLoads[i].status) {
             case LOAD_STATUS_LOADING:
                 if (slowLoad->medium != MEDIUM_UNK) {
-                    osRecvMesg(&slowLoad->msgqueue, NULL, OS_MESG_BLOCK);
+                    osRecvMesg(&slowLoad->msgQueue, NULL, OS_MESG_BLOCK);
                 }
 
                 if (resetStatus != 0) {
@@ -1313,9 +1314,9 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
 
 void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size) {
     Audio_InvalDCache(slowLoad->curRamAddr, size);
-    osCreateMesgQueue(&slowLoad->msgqueue, &slowLoad->msg, 1);
+    osCreateMesgQueue(&slowLoad->msgQueue, &slowLoad->msg, 1);
     AudioLoad_Dma(&slowLoad->ioMesg, OS_MESG_PRI_NORMAL, 0, slowLoad->curDevAddr, slowLoad->curRamAddr, size,
-                  &slowLoad->msgqueue, slowLoad->medium, "SLOWCOPY");
+                  &slowLoad->msgQueue, slowLoad->medium, "SLOWCOPY");
 }
 
 void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3) {
@@ -1376,7 +1377,7 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoadUnkMedium(s32 unkMediumParam, u32 devAdd
         return NULL;
     }
 
-    osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, asyncLoad, OS_MESG_NOBLOCK);
+    osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg)asyncLoad, OS_MESG_NOBLOCK);
     asyncLoad->unkMediumParam = unkMediumParam;
     return asyncLoad;
 }
@@ -2017,5 +2018,5 @@ void AudioLoad_ProcessScriptLoads(void) {
 }
 
 void AudioLoad_InitScriptLoads(void) {
-    osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMesgBuf, ARRAY_COUNT(sScriptLoadMesgBuf));
+    osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMsgBuf, ARRAY_COUNT(sScriptLoadMsgBuf));
 }
diff --git a/src/code/code_800E4FE0.c b/src/code/code_800E4FE0.c
index 8a1ed54b1..4d3d8afb4 100644
--- a/src/code/code_800E4FE0.c
+++ b/src/code/code_800E4FE0.c
@@ -67,7 +67,7 @@ AudioTask* func_800E5000(void) {
         }
     }
 
-    osSendMesg(gAudioContext.taskStartQueueP, gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
+    osSendMesg(gAudioContext.taskStartQueueP, (OSMesg)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
     gAudioContext.rspTaskIdx ^= 1;
     gAudioContext.curAIBufIdx++;
     gAudioContext.curAIBufIdx %= 3;
@@ -99,7 +99,7 @@ AudioTask* func_800E5000(void) {
         }
     }
 
-    sp48 = gAudioContext.currAudioFrameDmaQueue.validCount;
+    sp48 = MQ_GET_COUNT(&gAudioContext.currAudioFrameDmaQueue);
     if (sp48 != 0) {
         for (i = 0; i < sp48; i++) {
             osRecvMesg(&gAudioContext.currAudioFrameDmaQueue, NULL, OS_MESG_NOBLOCK);
@@ -114,7 +114,8 @@ AudioTask* func_800E5000(void) {
     if (gAudioContext.resetStatus != 0) {
         if (AudioHeap_ResetStep() == 0) {
             if (gAudioContext.resetStatus == 0) {
-                osSendMesg(gAudioContext.audioResetQueueP, gAudioContext.audioResetSpecIdToLoad, OS_MESG_NOBLOCK);
+                osSendMesg(gAudioContext.audioResetQueueP, (OSMesg)(u32)gAudioContext.audioResetSpecIdToLoad,
+                           OS_MESG_NOBLOCK);
             }
 
             sWaitingAudioTask = NULL;
@@ -171,7 +172,7 @@ AudioTask* func_800E5000(void) {
     gWaveSamples[8] = (s16*)(((u8*)func_800E4FE0) + (gAudioContext.audioRandom & 0xFFF0));
 
     index = gAudioContext.rspTaskIdx;
-    gAudioContext.currTask->taskQueue = NULL;
+    gAudioContext.currTask->msgQueue = NULL;
     gAudioContext.currTask->unk_44 = NULL;
 
     task = &gAudioContext.currTask->task.t;
@@ -348,11 +349,12 @@ void Audio_InitMesgQueuesInternal(void) {
     gAudioContext.taskStartQueueP = &gAudioContext.taskStartQueue;
     gAudioContext.cmdProcQueueP = &gAudioContext.cmdProcQueue;
     gAudioContext.audioResetQueueP = &gAudioContext.audioResetQueue;
-    osCreateMesgQueue(gAudioContext.taskStartQueueP, gAudioContext.taskStartMsgs,
-                      ARRAY_COUNT(gAudioContext.taskStartMsgs));
-    osCreateMesgQueue(gAudioContext.cmdProcQueueP, gAudioContext.cmdProcMsgs, ARRAY_COUNT(gAudioContext.cmdProcMsgs));
-    osCreateMesgQueue(gAudioContext.audioResetQueueP, gAudioContext.audioResetMesgs,
-                      ARRAY_COUNT(gAudioContext.audioResetMesgs));
+    osCreateMesgQueue(gAudioContext.taskStartQueueP, gAudioContext.taskStartMsgBuf,
+                      ARRAY_COUNT(gAudioContext.taskStartMsgBuf));
+    osCreateMesgQueue(gAudioContext.cmdProcQueueP, gAudioContext.cmdProcMsgBuf,
+                      ARRAY_COUNT(gAudioContext.cmdProcMsgBuf));
+    osCreateMesgQueue(gAudioContext.audioResetQueueP, gAudioContext.audioResetMsgBuf,
+                      ARRAY_COUNT(gAudioContext.audioResetMsgBuf));
 }
 
 void Audio_QueueCmd(u32 opArgs, void** data) {
@@ -398,7 +400,7 @@ s32 Audio_ScheduleProcessCmds(void) {
 
     ret =
         osSendMesg(gAudioContext.cmdProcQueueP,
-                   (void*)(((gAudioContext.cmdRdPos & 0xFF) << 8) | (gAudioContext.cmdWrPos & 0xFF)), OS_MESG_NOBLOCK);
+                   (OSMesg)(((gAudioContext.cmdRdPos & 0xFF) << 8) | (gAudioContext.cmdWrPos & 0xFF)), OS_MESG_NOBLOCK);
     if (ret != -1) {
         gAudioContext.cmdRdPos = gAudioContext.cmdWrPos;
         ret = 0;
@@ -514,7 +516,7 @@ s32 func_800E5EDC(void) {
 void func_800E5F34(void) {
     // macro?
     // clang-format off
-    s32 chk = -1; s32 sp28; do {} while (osRecvMesg(gAudioContext.audioResetQueueP, (OSMesg*)&sp28, OS_MESG_NOBLOCK) != chk);
+    s32 chk = -1; OSMesg msg; do {} while (osRecvMesg(gAudioContext.audioResetQueueP, &msg, OS_MESG_NOBLOCK) != chk);
     // clang-format on
 }
 
diff --git a/src/code/fault.c b/src/code/fault.c
index d1cd9627a..e03c94d59 100644
--- a/src/code/fault.c
+++ b/src/code/fault.c
@@ -128,8 +128,8 @@ void Fault_ClientRunTask(FaultClientTask* task) {
         // Run the fault client callback on a separate thread
         thread = alloca(sizeof(OSThread));
 
-        osCreateThread(thread, 2, Fault_ClientProcessThread, task, sFaultInstance->clientThreadSp,
-                       OS_PRIORITY_APPMAX - 1);
+        osCreateThread(thread, THREAD_ID_FAULT, Fault_ClientProcessThread, task, sFaultInstance->clientThreadSp,
+                       THREAD_PRI_FAULT_CLIENT);
         osStartThread(thread);
     } else {
         // Run the fault client callback on this thread
@@ -1265,7 +1265,8 @@ void Fault_Init(void) {
     gFaultMgr.faultHandlerEnabled = true;
     osCreateMesgQueue(&sFaultInstance->queue, &sFaultInstance->msg, 1);
     StackCheck_Init(&sFaultThreadInfo, &sFaultStack, STACK_TOP(sFaultStack), 0, 0x100, "fault");
-    osCreateThread(&sFaultInstance->thread, 2, Fault_ThreadEntry, 0, STACK_TOP(sFaultStack), OS_PRIORITY_APPMAX);
+    osCreateThread(&sFaultInstance->thread, THREAD_ID_FAULT, Fault_ThreadEntry, 0, STACK_TOP(sFaultStack),
+                   THREAD_PRI_FAULT);
     osStartThread(&sFaultInstance->thread);
 }
 
diff --git a/src/code/graph.c b/src/code/graph.c
index c178fa9e8..ecb6eb506 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -227,7 +227,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
         gfxCtx->fbIdx--;
     }
 
-    scTask->msgQ = &gfxCtx->queue;
+    scTask->msgQueue = &gfxCtx->queue;
     scTask->msg = NULL;
 
     cfb = &sGraphCfbInfos[sGraphCfbInfoIdx++];
@@ -245,9 +245,9 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
 
     if (1) {}
 
-    gfxCtx->schedMsgQ = &gSchedContext.cmdQ;
+    gfxCtx->schedMsgQueue = &gSchedContext.cmdQueue;
 
-    osSendMesg(&gSchedContext.cmdQ, scTask, OS_MESG_BLOCK);
+    osSendMesg(&gSchedContext.cmdQueue, (OSMesg)scTask, OS_MESG_BLOCK);
     Sched_SendEntryMsg(&gSchedContext);
 }
 
diff --git a/src/code/irqmgr.c b/src/code/irqmgr.c
index 9df7563d8..d29be5082 100644
--- a/src/code/irqmgr.c
+++ b/src/code/irqmgr.c
@@ -50,18 +50,18 @@ u32 sIrqMgrRetraceCount = 0;
  *
  * @param irqMgr the IrqMgr instance to register with.
  * @param client client to register.
- * @param msgQ message queue to send notifications of interrupts to, associated with the client.
+ * @param msgQueue message queue to send notifications of interrupts to, associated with the client.
  */
-void IrqMgr_AddClient(IrqMgr* irqMgr, IrqMgrClient* client, OSMesgQueue* msgQ) {
+void IrqMgr_AddClient(IrqMgr* irqMgr, IrqMgrClient* client, OSMesgQueue* msgQueue) {
     OSIntMask prevInt;
 
     LogUtils_CheckNullPointer("this", irqMgr, "../irqmgr.c", 96);
     LogUtils_CheckNullPointer("c", client, "../irqmgr.c", 97);
-    LogUtils_CheckNullPointer("msgQ", msgQ, "../irqmgr.c", 98);
+    LogUtils_CheckNullPointer("msgQ", msgQueue, "../irqmgr.c", 98);
 
     prevInt = osSetIntMask(OS_IM_NONE);
 
-    client->queue = msgQ;
+    client->queue = msgQueue;
     client->prev = irqMgr->clients;
     irqMgr->clients = client;
 
@@ -298,6 +298,6 @@ void IrqMgr_Init(IrqMgr* irqMgr, void* stack, OSPri pri, u8 retraceCount) {
     osCreateMesgQueue(&irqMgr->queue, irqMgr->msgBuf, ARRAY_COUNT(irqMgr->msgBuf));
     osSetEventMesg(OS_EVENT_PRENMI, &irqMgr->queue, (OSMesg)IRQ_PRENMI_MSG);
     osViSetEvent(&irqMgr->queue, (OSMesg)IRQ_RETRACE_MSG, retraceCount);
-    osCreateThread(&irqMgr->thread, 19, IrqMgr_ThreadEntry, irqMgr, stack, pri);
+    osCreateThread(&irqMgr->thread, THREAD_ID_IRQMGR, IrqMgr_ThreadEntry, irqMgr, stack, pri);
     osStartThread(&irqMgr->thread);
 }
diff --git a/src/code/main.c b/src/code/main.c
index 775ba3e72..9794054c7 100644
--- a/src/code/main.c
+++ b/src/code/main.c
@@ -22,8 +22,8 @@ StackEntry sAudioStackInfo;
 StackEntry sPadMgrStackInfo;
 StackEntry sIrqMgrStackInfo;
 AudioMgr gAudioMgr;
-OSMesgQueue sSiIntMsgQ;
-OSMesg sSiIntMsgBuf[1];
+OSMesgQueue sSerialEventQueue;
+OSMesg sSerialMsgBuf[1];
 
 void Main_LogSystemHeap(void) {
     osSyncPrintf(VT_FGCOL(GREEN));
@@ -35,7 +35,7 @@ void Main_LogSystemHeap(void) {
 
 void Main(void* arg) {
     IrqMgrClient irqClient;
-    OSMesgQueue irqMgrMsgQ;
+    OSMesgQueue irqMgrMsgQueue;
     OSMesg irqMgrMsgBuf[60];
     u32 systemHeapStart;
     u32 fb;
@@ -69,37 +69,38 @@ void Main(void* arg) {
 
     R_ENABLE_ARENA_DBG = 0;
 
-    osCreateMesgQueue(&sSiIntMsgQ, sSiIntMsgBuf, ARRAY_COUNT(sSiIntMsgBuf));
-    osSetEventMesg(OS_EVENT_SI, &sSiIntMsgQ, NULL);
+    osCreateMesgQueue(&sSerialEventQueue, sSerialMsgBuf, ARRAY_COUNT(sSerialMsgBuf));
+    osSetEventMesg(OS_EVENT_SI, &sSerialEventQueue, NULL);
 
     Main_LogSystemHeap();
 
-    osCreateMesgQueue(&irqMgrMsgQ, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
+    osCreateMesgQueue(&irqMgrMsgQueue, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
     StackCheck_Init(&sIrqMgrStackInfo, sIrqMgrStack, STACK_TOP(sIrqMgrStack), 0, 0x100, "irqmgr");
-    IrqMgr_Init(&gIrqMgr, STACK_TOP(sIrqMgrStack), Z_PRIORITY_IRQMGR, 1);
+    IrqMgr_Init(&gIrqMgr, STACK_TOP(sIrqMgrStack), THREAD_PRI_IRQMGR, 1);
 
     osSyncPrintf("タスクスケジューラの初期化\n"); // "Initialize the task scheduler"
     StackCheck_Init(&sSchedStackInfo, sSchedStack, STACK_TOP(sSchedStack), 0, 0x100, "sched");
-    Sched_Init(&gSchedContext, STACK_TOP(sSchedStack), Z_PRIORITY_SCHED, D_80013960, 1, &gIrqMgr);
+    Sched_Init(&gSchedContext, STACK_TOP(sSchedStack), THREAD_PRI_SCHED, D_80013960, 1, &gIrqMgr);
 
-    IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);
+    IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQueue);
 
     StackCheck_Init(&sAudioStackInfo, sAudioStack, STACK_TOP(sAudioStack), 0, 0x100, "audio");
-    AudioMgr_Init(&gAudioMgr, STACK_TOP(sAudioStack), Z_PRIORITY_AUDIOMGR, 10, &gSchedContext, &gIrqMgr);
+    AudioMgr_Init(&gAudioMgr, STACK_TOP(sAudioStack), THREAD_PRI_AUDIOMGR, THREAD_ID_AUDIOMGR, &gSchedContext,
+                  &gIrqMgr);
 
     StackCheck_Init(&sPadMgrStackInfo, sPadMgrStack, STACK_TOP(sPadMgrStack), 0, 0x100, "padmgr");
-    PadMgr_Init(&gPadMgr, &sSiIntMsgQ, &gIrqMgr, 7, Z_PRIORITY_PADMGR, STACK_TOP(sPadMgrStack));
+    PadMgr_Init(&gPadMgr, &sSerialEventQueue, &gIrqMgr, THREAD_ID_PADMGR, THREAD_PRI_PADMGR, STACK_TOP(sPadMgrStack));
 
     AudioMgr_Unlock(&gAudioMgr);
 
     StackCheck_Init(&sGraphStackInfo, sGraphStack, STACK_TOP(sGraphStack), 0, 0x100, "graph");
-    osCreateThread(&sGraphThread, 4, Graph_ThreadEntry, arg, STACK_TOP(sGraphStack), Z_PRIORITY_GRAPH);
+    osCreateThread(&sGraphThread, THREAD_ID_GRAPH, Graph_ThreadEntry, arg, STACK_TOP(sGraphStack), THREAD_PRI_GRAPH);
     osStartThread(&sGraphThread);
-    osSetThreadPri(NULL, 15);
+    osSetThreadPri(NULL, THREAD_PRI_MAIN);
 
     while (true) {
         msg = NULL;
-        osRecvMesg(&irqMgrMsgQ, (OSMesg)&msg, OS_MESG_BLOCK);
+        osRecvMesg(&irqMgrMsgQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
         if (msg == NULL) {
             break;
         }
diff --git a/src/code/padmgr.c b/src/code/padmgr.c
index 68c34d369..160a5301f 100644
--- a/src/code/padmgr.c
+++ b/src/code/padmgr.c
@@ -4,47 +4,47 @@
 s32 D_8012D280 = 1;
 
 OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) {
-    OSMesgQueue* ctrlrQ = NULL;
+    OSMesgQueue* serialEventQueue = NULL;
 
     if (D_8012D280 > 2) {
         // "serialMsgQ Waiting for lock"
         osSyncPrintf("%2d %d serialMsgQロック待ち         %08x %08x          %08x\n", osGetThreadId(NULL),
-                     padMgr->serialMsgQ.validCount, padMgr, &padMgr->serialMsgQ, &ctrlrQ);
+                     MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, &serialEventQueue);
     }
 
-    osRecvMesg(&padMgr->serialMsgQ, (OSMesg)&ctrlrQ, OS_MESG_BLOCK);
+    osRecvMesg(&padMgr->serialLockQueue, (OSMesg*)&serialEventQueue, OS_MESG_BLOCK);
 
     if (D_8012D280 > 2) {
         // "serialMsgQ Locked"
         osSyncPrintf("%2d %d serialMsgQをロックしました                     %08x\n", osGetThreadId(NULL),
-                     padMgr->serialMsgQ.validCount, ctrlrQ);
+                     MQ_GET_COUNT(&padMgr->serialLockQueue), serialEventQueue);
     }
 
-    return ctrlrQ;
+    return serialEventQueue;
 }
 
-void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* ctrlrQ) {
+void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* serialEventQueue) {
     if (D_8012D280 > 2) {
         // "serialMsgQ Unlock"
         osSyncPrintf("%2d %d serialMsgQロック解除します   %08x %08x %08x\n", osGetThreadId(NULL),
-                     padMgr->serialMsgQ.validCount, padMgr, &padMgr->serialMsgQ, ctrlrQ);
+                     MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, serialEventQueue);
     }
 
-    osSendMesg(&padMgr->serialMsgQ, ctrlrQ, OS_MESG_BLOCK);
+    osSendMesg(&padMgr->serialLockQueue, (OSMesg)serialEventQueue, OS_MESG_BLOCK);
 
     if (D_8012D280 > 2) {
         // "serialMsgQ Unlocked"
         osSyncPrintf("%2d %d serialMsgQロック解除しました %08x %08x %08x\n", osGetThreadId(NULL),
-                     padMgr->serialMsgQ.validCount, padMgr, &padMgr->serialMsgQ, ctrlrQ);
+                     MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, serialEventQueue);
     }
 }
 
 void PadMgr_LockPadData(PadMgr* padMgr) {
-    osRecvMesg(&padMgr->lockMsgQ, NULL, OS_MESG_BLOCK);
+    osRecvMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
 }
 
 void PadMgr_UnlockPadData(PadMgr* padMgr) {
-    osSendMesg(&padMgr->lockMsgQ, NULL, OS_MESG_BLOCK);
+    osSendMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
 }
 
 void PadMgr_RumbleControl(PadMgr* padMgr) {
@@ -52,7 +52,7 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
     static u32 frame;
     s32 temp = 1;
     s32 triedRumbleComm;
-    OSMesgQueue* ctrlrQ = PadMgr_LockSerialMesgQueue(padMgr);
+    OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
     s32 var4;
     s32 i;
 
@@ -133,7 +133,7 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
         i = frame % 4;
 
         if (padMgr->ctrlrIsConnected[i] && (padMgr->padStatus[i].status & 1) && (padMgr->pakType[i] != 1)) {
-            var4 = osMotorInit(ctrlrQ, &padMgr->pfs[i], i);
+            var4 = osMotorInit(serialEventQueue, &padMgr->pfs[i], i);
 
             if (var4 == 0) {
                 padMgr->pakType[i] = 1;
@@ -156,15 +156,15 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
     }
 
     frame++;
-    PadMgr_UnlockSerialMesgQueue(padMgr, ctrlrQ);
+    PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
 }
 
 void PadMgr_RumbleStop(PadMgr* padMgr) {
     s32 i;
-    OSMesgQueue* ctrlrQ = PadMgr_LockSerialMesgQueue(padMgr);
+    OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
 
     for (i = 0; i < 4; i++) {
-        if (osMotorInit(ctrlrQ, &padMgr->pfs[i], i) == 0) {
+        if (osMotorInit(serialEventQueue, &padMgr->pfs[i], i) == 0) {
             if ((gFaultMgr.msgId == 0) && (padMgr->rumbleOnFrames != 0)) {
                 osSyncPrintf(VT_FGCOL(YELLOW));
                 // "Stop vibration pack"
@@ -176,7 +176,7 @@ void PadMgr_RumbleStop(PadMgr* padMgr) {
         }
     }
 
-    PadMgr_UnlockSerialMesgQueue(padMgr, ctrlrQ);
+    PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
 }
 
 void PadMgr_RumbleReset(PadMgr* padMgr) {
@@ -265,23 +265,23 @@ void PadMgr_ProcessInputs(PadMgr* padMgr) {
 
 void PadMgr_HandleRetraceMsg(PadMgr* padMgr) {
     s32 i;
-    OSMesgQueue* queue = PadMgr_LockSerialMesgQueue(padMgr);
+    OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
     u32 mask;
 
-    osContStartReadData(queue);
+    osContStartReadData(serialEventQueue);
     if (padMgr->retraceCallback) {
         padMgr->retraceCallback(padMgr, padMgr->retraceCallbackValue);
     }
-    osRecvMesg(queue, NULL, OS_MESG_BLOCK);
+    osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
     osContGetReadData(padMgr->pads);
     if (padMgr->preNMIShutdown) {
         bzero(padMgr->pads, sizeof(padMgr->pads));
     }
     PadMgr_ProcessInputs(padMgr);
-    osContStartQuery(queue);
-    osRecvMesg(queue, NULL, OS_MESG_BLOCK);
+    osContStartQuery(serialEventQueue);
+    osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
     osContGetQuery(padMgr->padStatus);
-    PadMgr_UnlockSerialMesgQueue(padMgr, queue);
+    PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
 
     mask = 0;
     for (i = 0; i < 4; i++) {
@@ -351,22 +351,22 @@ void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 mode) {
 }
 
 void PadMgr_ThreadEntry(PadMgr* padMgr) {
-    s16* mesg = NULL;
+    s16* msg = NULL;
     s32 exit;
 
     osSyncPrintf("コントローラスレッド実行開始\n"); // "Controller thread execution start"
 
     exit = false;
     while (!exit) {
-        if ((D_8012D280 > 2) && (padMgr->interruptMsgQ.validCount == 0)) {
+        if ((D_8012D280 > 2) && MQ_IS_EMPTY(&padMgr->interruptQueue)) {
             // "Waiting for controller thread event"
             osSyncPrintf("コントローラスレッドイベント待ち %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
         }
 
-        osRecvMesg(&padMgr->interruptMsgQ, (OSMesg)&mesg, OS_MESG_BLOCK);
-        LogUtils_CheckNullPointer("msg", mesg, "../padmgr.c", 563);
+        osRecvMesg(&padMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
+        LogUtils_CheckNullPointer("msg", msg, "../padmgr.c", 563);
 
-        switch (*mesg) {
+        switch (*msg) {
             case OS_SC_RETRACE_MSG:
                 if (D_8012D280 > 2) {
                     osSyncPrintf("padmgr_HandleRetraceMsg START %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
@@ -393,19 +393,19 @@ void PadMgr_ThreadEntry(PadMgr* padMgr) {
     osSyncPrintf("コントローラスレッド実行終了\n"); // "Controller thread execution end"
 }
 
-void PadMgr_Init(PadMgr* padMgr, OSMesgQueue* siIntMsgQ, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack) {
+void PadMgr_Init(PadMgr* padMgr, OSMesgQueue* serialEventQueue, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack) {
     osSyncPrintf("パッドマネージャ作成 padmgr_Create()\n"); // "Pad Manager creation"
 
     bzero(padMgr, sizeof(PadMgr));
     padMgr->irqMgr = irqMgr;
 
-    osCreateMesgQueue(&padMgr->interruptMsgQ, padMgr->interruptMsgBuf, 4);
-    IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptMsgQ);
-    osCreateMesgQueue(&padMgr->serialMsgQ, padMgr->serialMsgBuf, 1);
-    PadMgr_UnlockSerialMesgQueue(padMgr, siIntMsgQ);
-    osCreateMesgQueue(&padMgr->lockMsgQ, padMgr->lockMsgBuf, 1);
+    osCreateMesgQueue(&padMgr->interruptQueue, padMgr->interruptMsgBuf, ARRAY_COUNT(padMgr->interruptMsgBuf));
+    IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptQueue);
+    osCreateMesgQueue(&padMgr->serialLockQueue, padMgr->serialLockMsgBuf, ARRAY_COUNT(padMgr->serialLockMsgBuf));
+    PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
+    osCreateMesgQueue(&padMgr->lockQueue, padMgr->lockMsgBuf, ARRAY_COUNT(padMgr->lockMsgBuf));
     PadMgr_UnlockPadData(padMgr);
-    PadSetup_Init(siIntMsgQ, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus);
+    PadSetup_Init(serialEventQueue, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus);
 
     padMgr->nControllers = 4;
     osContSetCh(padMgr->nControllers);
diff --git a/src/code/sched.c b/src/code/sched.c
index 504ed4c71..cdf22616e 100644
--- a/src/code/sched.c
+++ b/src/code/sched.c
@@ -82,12 +82,12 @@ void Sched_HandleReset(SchedContext* sc) {
             if (sc->curRSPTask != NULL) {
                 LOG_TIME("(((u64)(now - graph_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
                          OS_CYCLES_TO_USEC(now - sRSPGFXStartTime), "../sched.c", 427);
-                osSendMesg(&sc->interruptQ, RSP_DONE_MSG, OS_MESG_NOBLOCK);
+                osSendMesg(&sc->interruptQueue, (OSMesg)RSP_DONE_MSG, OS_MESG_NOBLOCK);
             }
             if (sc->curRDPTask != NULL) {
                 LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
                          OS_CYCLES_TO_USEC(now - sRDPStartTime), "../sched.c", 431);
-                osSendMesg(&sc->interruptQ, RDP_DONE_MSG, OS_MESG_NOBLOCK);
+                osSendMesg(&sc->interruptQueue, (OSMesg)RDP_DONE_MSG, OS_MESG_NOBLOCK);
             }
         }
     }
@@ -231,8 +231,8 @@ void func_800C8BC4(SchedContext* sc, OSScTask* task) {
 
 u32 Sched_IsComplete(SchedContext* sc, OSScTask* task) {
     if (!(task->state & (OS_SC_DP | OS_SC_SP))) {
-        if (task->msgQ != NULL) {
-            osSendMesg(task->msgQ, task->msg, OS_MESG_BLOCK);
+        if (task->msgQueue != NULL) {
+            osSendMesg(task->msgQueue, task->msg, OS_MESG_BLOCK);
         }
 
         if (task->flags & OS_SC_SWAPBUFFER) {
@@ -292,10 +292,10 @@ void Sched_HandleEntry(SchedContext* sc) {
     OSScTask* nextRSP = NULL;
     OSScTask* nextRDP = NULL;
     s32 state;
-    OSMesg msg = NULL;
+    OSScTask* task = NULL;
 
-    while (osRecvMesg(&sc->cmdQ, &msg, OS_MESG_NOBLOCK) != -1) {
-        Sched_QueueTask(sc, msg);
+    while (osRecvMesg(&sc->cmdQueue, (OSMesg*)&task, OS_MESG_NOBLOCK) != -1) {
+        Sched_QueueTask(sc, task);
     }
 
     if (sc->doAudio != 0 && sc->curRSPTask != NULL) {
@@ -425,22 +425,20 @@ void Sched_SendEntryMsg(SchedContext* sc) {
         osSyncPrintf("osScKickEntryMsg\n");
     }
 
-    osSendMesg(&sc->interruptQ, ENTRY_MSG, OS_MESG_BLOCK);
+    osSendMesg(&sc->interruptQueue, (OSMesg)ENTRY_MSG, OS_MESG_BLOCK);
 }
 
 void Sched_ThreadEntry(void* arg) {
-    void* msg;
+    OSMesg msg = NULL;
     SchedContext* sc = (SchedContext*)arg;
 
-    msg = NULL;
-
     while (true) {
         if (sLogScheduler) {
             // "%08d: standby"
             osSyncPrintf("%08d:待機中\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
         }
 
-        osRecvMesg(&sc->interruptQ, &msg, OS_MESG_BLOCK);
+        osRecvMesg(&sc->interruptQueue, &msg, OS_MESG_BLOCK);
 
         switch ((s32)msg) {
             case ENTRY_MSG:
@@ -461,8 +459,6 @@ void Sched_ThreadEntry(void* arg) {
                 }
                 Sched_HandleRDPDone(sc);
                 continue;
-            default:
-                break;
         }
         switch (((OSScMsg*)msg)->type) {
             case 1:
@@ -481,11 +477,11 @@ void Sched_ThreadEntry(void* arg) {
 void Sched_Init(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, IrqMgr* irqMgr) {
     bzero(sc, sizeof(SchedContext));
     sc->unk_24C = 1;
-    osCreateMesgQueue(&sc->interruptQ, sc->intBuf, 8);
-    osCreateMesgQueue(&sc->cmdQ, sc->cmdMsgBuf, 8);
-    osSetEventMesg(OS_EVENT_SP, &sc->interruptQ, RSP_DONE_MSG);
-    osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, RDP_DONE_MSG);
-    IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQ);
-    osCreateThread(&sc->thread, 5, Sched_ThreadEntry, sc, stack, priority);
+    osCreateMesgQueue(&sc->interruptQueue, sc->interruptMsgBuf, ARRAY_COUNT(sc->interruptMsgBuf));
+    osCreateMesgQueue(&sc->cmdQueue, sc->cmdMsgBuf, ARRAY_COUNT(sc->cmdMsgBuf));
+    osSetEventMesg(OS_EVENT_SP, &sc->interruptQueue, RSP_DONE_MSG);
+    osSetEventMesg(OS_EVENT_DP, &sc->interruptQueue, RDP_DONE_MSG);
+    IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQueue);
+    osCreateThread(&sc->thread, THREAD_ID_SCHED, Sched_ThreadEntry, sc, stack, priority);
     osStartThread(&sc->thread);
 }
diff --git a/src/code/z_jpeg.c b/src/code/z_jpeg.c
index 6f57e12ac..fbb4dc6f6 100644
--- a/src/code/z_jpeg.c
+++ b/src/code/z_jpeg.c
@@ -55,12 +55,12 @@ void Jpeg_ScheduleDecoderTask(JpegContext* ctx) {
 
     ctx->scTask.next = NULL;
     ctx->scTask.flags = OS_SC_NEEDS_RSP;
-    ctx->scTask.msgQ = &ctx->mq;
+    ctx->scTask.msgQueue = &ctx->mq;
     ctx->scTask.msg = NULL;
     ctx->scTask.framebuffer = NULL;
     ctx->scTask.list.t = sJpegTask;
 
-    osSendMesg(&gSchedContext.cmdQ, (OSMesg)&ctx->scTask, OS_MESG_BLOCK);
+    osSendMesg(&gSchedContext.cmdQueue, (OSMesg)&ctx->scTask, OS_MESG_BLOCK);
     Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
     osRecvMesg(&ctx->mq, NULL, OS_MESG_BLOCK);
 }
diff --git a/src/code/z_kankyo.c b/src/code/z_kankyo.c
index 5bc7a99a1..68593c156 100644
--- a/src/code/z_kankyo.c
+++ b/src/code/z_kankyo.c
@@ -731,11 +731,11 @@ void Environment_UpdateSkybox(u8 skyboxId, EnvironmentContext* envCtx, SkyboxCon
         }
 
         if ((envCtx->skyboxDmaState == SKYBOX_DMA_FILE1_START) || (envCtx->skyboxDmaState == SKYBOX_DMA_FILE2_START)) {
-            if (osRecvMesg(&envCtx->loadQueue, 0, OS_MESG_NOBLOCK) == 0) {
+            if (osRecvMesg(&envCtx->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
                 envCtx->skyboxDmaState++;
             }
         } else if (envCtx->skyboxDmaState >= SKYBOX_DMA_FILE1_DONE) {
-            if (osRecvMesg(&envCtx->loadQueue, 0, OS_MESG_NOBLOCK) == 0) {
+            if (osRecvMesg(&envCtx->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
                 envCtx->skyboxDmaState = SKYBOX_DMA_INACTIVE;
             }
         }
diff --git a/src/code/z_msgevent.c b/src/code/z_msgevent.c
index 267180e1f..5cca1c717 100644
--- a/src/code/z_msgevent.c
+++ b/src/code/z_msgevent.c
@@ -1,7 +1,6 @@
 #include "global.h"
 
 void MsgEvent_SendNullTask(void) {
-    s32 pad[4];
     OSScTask task;
     OSMesgQueue queue;
     OSMesg msg;
@@ -9,12 +8,12 @@ void MsgEvent_SendNullTask(void) {
 
     task.next = NULL;
     task.flags = OS_SC_RCP_MASK;
-    task.msgQ = &queue;
+    task.msgQueue = &queue;
     task.msg = NULL;
     task.framebuffer = NULL;
     task.list.t.type = M_NULTASK;
-    osCreateMesgQueue(task.msgQ, &msg, 1);
-    osSendMesg(&gSchedContext.cmdQ, &task, OS_MESG_BLOCK);
+    osCreateMesgQueue(task.msgQueue, &msg, 1);
+    osSendMesg(&gSchedContext.cmdQueue, (OSMesg)&task, OS_MESG_BLOCK);
     Sched_SendEntryMsg(&gSchedContext);
     osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
 }
diff --git a/src/code/z_player_lib.c b/src/code/z_player_lib.c
index 2c7b07c6a..30ea4a4ac 100644
--- a/src/code/z_player_lib.c
+++ b/src/code/z_player_lib.c
@@ -1307,7 +1307,7 @@ void Player_DrawGetItemImpl(GlobalContext* globalCtx, Player* this, Vec3f* refPo
 }
 
 void Player_DrawGetItem(GlobalContext* globalCtx, Player* this) {
-    if (!this->giObjectLoading || !osRecvMesg(&this->giObjectLoadQueue, NULL, OS_MESG_NOBLOCK)) {
+    if (!this->giObjectLoading || osRecvMesg(&this->giObjectLoadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
         this->giObjectLoading = false;
         Player_DrawGetItemImpl(globalCtx, this, &sGetItemRefPos, ABS(this->unk_862));
     }
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 9487ac866..e03ecfebe 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -569,7 +569,7 @@ s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum) {
 
 s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx) {
     if (roomCtx->status == 1) {
-        if (!osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK)) {
+        if (osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
             roomCtx->status = 0;
             roomCtx->curRoom.segment = roomCtx->unk_34;
             gSegments[3] = VIRTUAL_TO_PHYSICAL(roomCtx->unk_34);
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index b0b5b7c63..5cf17d0eb 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -91,7 +91,7 @@ void Object_UpdateBank(ObjectContext* objectCtx) {
                 osSyncPrintf("OBJECT EXCHANGE BANK-%2d SIZE %8.3fK SEG=%08x\n", i, size / 1024.0f, status->segment);
                 DmaMgr_SendRequest2(&status->dmaRequest, status->segment, objectFile->vromStart, size, 0,
                                     &status->loadQueue, NULL, "../z_scene.c", 266);
-            } else if (!osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK)) {
+            } else if (osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
                 status->id = -status->id;
             }
         }
diff --git a/src/code/z_ss_sram.c b/src/code/z_ss_sram.c
index 847482d19..3a4251a1c 100644
--- a/src/code/z_ss_sram.c
+++ b/src/code/z_ss_sram.c
@@ -4,7 +4,7 @@
 typedef struct {
     /* 0x00 */ OSPiHandle piHandle;
     /* 0x74 */ OSIoMesg ioMesg;
-    /* 0x8C */ OSMesgQueue mesgQ;
+    /* 0x8C */ OSMesgQueue msgQueue;
 } SsSramContext; // size = 0xA4
 
 SsSramContext sSsSramContext = { 0 };
@@ -32,20 +32,20 @@ void SsSram_Init(u32 addr, u8 handleType, u8 handleDomain, u8 handleLatency, u8
         __osRestoreInt(prevInt);
 
         sSsSramContext.ioMesg.hdr.pri = OS_MESG_PRI_NORMAL;
-        sSsSramContext.ioMesg.hdr.retQueue = &sSsSramContext.mesgQ;
+        sSsSramContext.ioMesg.hdr.retQueue = &sSsSramContext.msgQueue;
         sSsSramContext.ioMesg.devAddr = addr;
     }
 }
 
 void SsSram_Dma(void* dramAddr, size_t size, s32 direction) {
-    OSMesg mesg;
+    OSMesg msg;
 
-    osCreateMesgQueue(&sSsSramContext.mesgQ, &mesg, 1);
+    osCreateMesgQueue(&sSsSramContext.msgQueue, &msg, 1);
     sSsSramContext.ioMesg.dramAddr = dramAddr;
     sSsSramContext.ioMesg.size = size;
     osWritebackDCache(dramAddr, size);
     osEPiStartDma(&sSsSramContext.piHandle, &sSsSramContext.ioMesg, direction);
-    osRecvMesg(&sSsSramContext.mesgQ, &mesg, OS_MESG_BLOCK);
+    osRecvMesg(&sSsSramContext.msgQueue, &msg, OS_MESG_BLOCK);
     osInvalDCache(dramAddr, size);
 }