diff --git a/Common/ChunkFile.h b/Common/ChunkFile.h
index eda388211e..c6dd5d6de0 100644
--- a/Common/ChunkFile.h
+++ b/Common/ChunkFile.h
@@ -114,6 +114,43 @@ public:
 		}
 	}
 
+	template<class K, class T>
+	void Do(std::multimap<K, T> &x)
+	{
+		unsigned int number = (unsigned int)x.size();
+		Do(number);
+		switch (mode) {
+		case MODE_READ:
+			{
+				x.clear();
+				while (number > 0)
+				{
+					K first;
+					Do(first);
+					T second;
+					Do(second);
+					x.insert(std::make_pair(first, second));
+					--number;
+				}
+			}
+			break;
+		case MODE_WRITE:
+		case MODE_MEASURE:
+		case MODE_VERIFY:
+			{
+				typename std::multimap<K, T>::iterator itr = x.begin();
+				while (number > 0)
+				{
+					Do(itr->first);
+					Do(itr->second);
+					--number;
+					++itr;
+				}
+			}
+			break;
+		}
+	}
+
 	// Store vectors.
 	template<class T>
 	void Do(std::vector<T> &x)
diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp
index 20f3af0997..67f6b073db 100644
--- a/Core/HLE/sceKernel.cpp
+++ b/Core/HLE/sceKernel.cpp
@@ -59,8 +59,6 @@
 
 #include "../Util/PPGeDraw.h"
 
-extern MetaFileSystem pspFileSystem;
-
 /*
 17: [MIPS32 R4K 00000000 ]: Loader: Type: 1 Vaddr: 00000000 Filesz: 2856816 Memsz: 2856816 
 18: [MIPS32 R4K 00000000 ]: Loader: Loadable Segment Copied to 0898dab0, size 002b9770
@@ -69,6 +67,7 @@ extern MetaFileSystem pspFileSystem;
 */
 
 static bool kernelRunning = false;
+KernelObjectPool kernelObjects;
 
 void __KernelInit()
 {
@@ -140,13 +139,19 @@ void __KernelShutdown()
 
 void __KernelDoState(PointerWrap &p)
 {
+	p.Do(kernelRunning);
 	kernelObjects.DoState(p);
 	p.DoMarker("KernelObjects");
-	// TODO
-	// modules
-	// core timing
-	// memstick
-	// filesystem
+
+	// TODO: Put these in the correct order...
+	__KernelAlarmDoState(p);
+	__KernelEventFlagDoState(p);
+	__KernelMbxDoState(p);
+	__KernelMemoryDoState(p);
+	__KernelModuleDoState(p);
+	__KernelMutexDoState(p);
+	__KernelSemaDoState(p);
+	// TODO: more modules
 }
 
 bool __KernelIsRunning() {
@@ -232,8 +237,6 @@ void sceKernelDcacheWritebackInvalidateAll()
 	gpu->InvalidateCache(0, -1);
 }
 
-KernelObjectPool kernelObjects;
-
 KernelObjectPool::KernelObjectPool()
 {
 	memset(occupied, 0, sizeof(bool)*maxCount);
diff --git a/Core/HLE/sceKernelAlarm.cpp b/Core/HLE/sceKernelAlarm.cpp
index ea833860ec..baf4ddbf38 100644
--- a/Core/HLE/sceKernelAlarm.cpp
+++ b/Core/HLE/sceKernelAlarm.cpp
@@ -111,6 +111,13 @@ void __KernelAlarmInit()
 	alarmTimer = CoreTiming::RegisterEvent("Alarm", __KernelTriggerAlarm);
 }
 
+void __KernelAlarmDoState(PointerWrap &p)
+{
+	p.Do(alarmTimer);
+	CoreTiming::RestoreRegisterEvent(alarmTimer, "Alarm", __KernelTriggerAlarm);
+	p.DoMarker("sceKernelAlarm");
+}
+
 KernelObject *__KernelAlarmObject()
 {
 	// Default object to load from state.
diff --git a/Core/HLE/sceKernelAlarm.h b/Core/HLE/sceKernelAlarm.h
index 24cc866e37..4b286eb87a 100644
--- a/Core/HLE/sceKernelAlarm.h
+++ b/Core/HLE/sceKernelAlarm.h
@@ -23,4 +23,5 @@ int sceKernelCancelAlarm(SceUID uid);
 int sceKernelReferAlarmStatus(SceUID uid, u32 infoPtr);
 
 void __KernelAlarmInit();
+void __KernelAlarmDoState(PointerWrap &p);
 KernelObject *__KernelAlarmObject();
diff --git a/Core/HLE/sceKernelEventFlag.cpp b/Core/HLE/sceKernelEventFlag.cpp
index f0e5e16034..80471c4c4d 100644
--- a/Core/HLE/sceKernelEventFlag.cpp
+++ b/Core/HLE/sceKernelEventFlag.cpp
@@ -101,7 +101,14 @@ int eventFlagWaitTimer = 0;
 
 void __KernelEventFlagInit()
 {
-	eventFlagWaitTimer = CoreTiming::RegisterEvent("EventFlagTimeout", &__KernelEventFlagTimeout);
+	eventFlagWaitTimer = CoreTiming::RegisterEvent("EventFlagTimeout", __KernelEventFlagTimeout);
+}
+
+void __KernelEventFlagDoState(PointerWrap &p)
+{
+	p.Do(eventFlagWaitTimer);
+	CoreTiming::RestoreRegisterEvent(eventFlagWaitTimer, "EventFlagTimeout", __KernelEventFlagTimeout);
+	p.DoMarker("sceKernelEventFlag");
 }
 
 KernelObject *__KernelEventFlagObject()
diff --git a/Core/HLE/sceKernelEventFlag.h b/Core/HLE/sceKernelEventFlag.h
index 2eb1c659ba..151efa25f7 100644
--- a/Core/HLE/sceKernelEventFlag.h
+++ b/Core/HLE/sceKernelEventFlag.h
@@ -28,4 +28,5 @@ u32 sceKernelReferEventFlagStatus(SceUID id, u32 statusPtr);
 u32 sceKernelCancelEventFlag(SceUID uid, u32 pattern, u32 numWaitThreadsPtr);
 
 void __KernelEventFlagInit();
+void __KernelEventFlagDoState(PointerWrap &p);
 KernelObject *__KernelEventFlagObject();
diff --git a/Core/HLE/sceKernelMbx.cpp b/Core/HLE/sceKernelMbx.cpp
index 3ae6ae4f04..34aea59532 100644
--- a/Core/HLE/sceKernelMbx.cpp
+++ b/Core/HLE/sceKernelMbx.cpp
@@ -167,7 +167,14 @@ struct Mbx : public KernelObject
 
 void __KernelMbxInit()
 {
-	mbxWaitTimer = CoreTiming::RegisterEvent("MbxTimeout", &__KernelMbxTimeout);
+	mbxWaitTimer = CoreTiming::RegisterEvent("MbxTimeout", __KernelMbxTimeout);
+}
+
+void __KernelMbxDoState(PointerWrap &p)
+{
+	p.Do(mbxWaitTimer);
+	CoreTiming::RestoreRegisterEvent(mbxWaitTimer, "MbxTimeout", __KernelMbxTimeout);
+	p.DoMarker("sceKernelMbx");
 }
 
 KernelObject *__KernelMbxObject()
diff --git a/Core/HLE/sceKernelMbx.h b/Core/HLE/sceKernelMbx.h
index b0fb25e952..c171461a8f 100644
--- a/Core/HLE/sceKernelMbx.h
+++ b/Core/HLE/sceKernelMbx.h
@@ -34,4 +34,5 @@ int sceKernelCancelReceiveMbx(SceUID id, u32 numWaitingThreadsAddr);
 int sceKernelReferMbxStatus(SceUID id, u32 infoAddr);
 
 void __KernelMbxInit();
+void __KernelMbxDoState(PointerWrap &p);
 KernelObject *__KernelMbxObject();
diff --git a/Core/HLE/sceKernelMemory.cpp b/Core/HLE/sceKernelMemory.cpp
index 807e74a2e1..97ce91136b 100644
--- a/Core/HLE/sceKernelMemory.cpp
+++ b/Core/HLE/sceKernelMemory.cpp
@@ -135,6 +135,13 @@ void __KernelMemoryInit()
 	INFO_LOG(HLE, "Kernel and user memory pools initialized");
 }
 
+void __KernelMemoryDoState(PointerWrap &p)
+{
+	kernelMemory.DoState(p);
+	userMemory.DoState(p);
+	p.DoMarker("sceKernelMemory");
+}
+
 void __KernelMemoryShutdown()
 {
 	INFO_LOG(HLE,"Shutting down user memory pool: ");
diff --git a/Core/HLE/sceKernelMemory.h b/Core/HLE/sceKernelMemory.h
index cc5334ae89..0b6602d756 100644
--- a/Core/HLE/sceKernelMemory.h
+++ b/Core/HLE/sceKernelMemory.h
@@ -30,6 +30,7 @@ extern BlockAllocator userMemory;
 extern BlockAllocator kernelMemory;
 
 void __KernelMemoryInit();
+void __KernelMemoryDoState(PointerWrap &p);
 void __KernelMemoryShutdown();
 KernelObject *__KernelMemoryFPLObject();
 KernelObject *__KernelMemoryVPLObject();
diff --git a/Core/HLE/sceKernelModule.cpp b/Core/HLE/sceKernelModule.cpp
index 1f7b0c050c..d35e5d5138 100644
--- a/Core/HLE/sceKernelModule.cpp
+++ b/Core/HLE/sceKernelModule.cpp
@@ -172,6 +172,12 @@ static SceUID mainModuleID;	// hack
 // STATE END
 //////////////////////////////////////////////////////////////////////////
 
+void __KernelModuleDoState(PointerWrap &p)
+{
+	p.Do(mainModuleID);
+	p.DoMarker("sceKernelModule");
+}
+
 Module *__KernelLoadELFFromPtr(const u8 *ptr, u32 loadAddress, std::string *error_string)
 {
 	Module *module = new Module;
diff --git a/Core/HLE/sceKernelModule.h b/Core/HLE/sceKernelModule.h
index 18e3d5f036..732bd43173 100644
--- a/Core/HLE/sceKernelModule.h
+++ b/Core/HLE/sceKernelModule.h
@@ -21,6 +21,7 @@
 #include "HLE.h"
 
 KernelObject *__KernelModuleObject();
+void __KernelModuleDoState(PointerWrap &p);
 
 u32 __KernelGetModuleGP(SceUID module);
 bool __KernelLoadExec(const char *filename, SceKernelLoadExecParam *param, std::string *error_string);
diff --git a/Core/HLE/sceKernelMutex.cpp b/Core/HLE/sceKernelMutex.cpp
index c0778031c7..a6243fff08 100644
--- a/Core/HLE/sceKernelMutex.cpp
+++ b/Core/HLE/sceKernelMutex.cpp
@@ -131,12 +131,22 @@ static MutexMap mutexHeldLocks;
 
 void __KernelMutexInit()
 {
-	mutexWaitTimer = CoreTiming::RegisterEvent("MutexTimeout", &__KernelMutexTimeout);
-	lwMutexWaitTimer = CoreTiming::RegisterEvent("LwMutexTimeout", &__KernelLwMutexTimeout);
+	mutexWaitTimer = CoreTiming::RegisterEvent("MutexTimeout", __KernelMutexTimeout);
+	lwMutexWaitTimer = CoreTiming::RegisterEvent("LwMutexTimeout", __KernelLwMutexTimeout);
 
 	__KernelListenThreadEnd(&__KernelMutexThreadEnd);
 }
 
+void __KernelMutexDoState(PointerWrap &p)
+{
+	p.Do(mutexWaitTimer);
+	CoreTiming::RestoreRegisterEvent(mutexWaitTimer, "MutexTimeout", __KernelMutexTimeout);
+	p.Do(lwMutexWaitTimer);
+	CoreTiming::RestoreRegisterEvent(lwMutexWaitTimer, "LwMutexTimeout", __KernelLwMutexTimeout);
+	p.Do(mutexHeldLocks);
+	p.DoMarker("sceKernelMutex");
+}
+
 KernelObject *__KernelMutexObject()
 {
 	return new Mutex;
diff --git a/Core/HLE/sceKernelMutex.h b/Core/HLE/sceKernelMutex.h
index 5db1f3b4d5..18eeb4fafb 100644
--- a/Core/HLE/sceKernelMutex.h
+++ b/Core/HLE/sceKernelMutex.h
@@ -37,6 +37,7 @@ void __KernelLwMutexTimeout(u64 userdata, int cyclesLate);
 void __KernelMutexThreadEnd(SceUID thread);
 
 void __KernelMutexInit();
+void __KernelMutexDoState(PointerWrap &p);
 void __KernelMutexShutdown();
 KernelObject *__KernelMutexObject();
 KernelObject *__KernelLwMutexObject();
diff --git a/Core/HLE/sceKernelSemaphore.cpp b/Core/HLE/sceKernelSemaphore.cpp
index 0572a8d70d..6e213ff31d 100644
--- a/Core/HLE/sceKernelSemaphore.cpp
+++ b/Core/HLE/sceKernelSemaphore.cpp
@@ -72,7 +72,14 @@ static int semaWaitTimer = 0;
 
 void __KernelSemaInit()
 {
-	semaWaitTimer = CoreTiming::RegisterEvent("SemaphoreTimeout", &__KernelSemaTimeout);
+	semaWaitTimer = CoreTiming::RegisterEvent("SemaphoreTimeout", __KernelSemaTimeout);
+}
+
+void __KernelSemaDoState(PointerWrap &p)
+{
+	p.Do(semaWaitTimer);
+	CoreTiming::RestoreRegisterEvent(semaWaitTimer, "SemaphoreTimeout", __KernelSemaTimeout);
+	p.DoMarker("sceKernelSema");
 }
 
 KernelObject *__KernelSemaphoreObject()
diff --git a/Core/HLE/sceKernelSemaphore.h b/Core/HLE/sceKernelSemaphore.h
index f816f97e41..14df34cbed 100644
--- a/Core/HLE/sceKernelSemaphore.h
+++ b/Core/HLE/sceKernelSemaphore.h
@@ -29,4 +29,5 @@ int sceKernelWaitSemaCB(SceUID semaid, int signal, u32 timeoutPtr);
 void __KernelSemaTimeout(u64 userdata, int cycleslate);
 
 void __KernelSemaInit();
+void __KernelSemaDoState(PointerWrap &p);
 KernelObject *__KernelSemaphoreObject();