Kernel: Implement SYS_SYNC and add sync executable to userspace

You can (and have to) manually sync disk after writes to it.

kernel/kernel/FS/DevFS/FileSystem.cpp

@@ -44,6 +44,7 @@ namespace Kernel
 						{
 							if (inode->is_device())
 								((Device*)inode.ptr())->update();
+							return BAN::Iteration::Continue;
 						}
 					);
 					s_instance->m_device_lock.unlock();
@@ -60,8 +61,22 @@ namespace Kernel
 		MUST(reinterpret_cast<RamDirectoryInode*>(root_inode().ptr())->add_inode(path, device));
 	}
 
+	void DevFileSystem::for_each_device(const BAN::Function<BAN::Iteration(Device*)>& callback)
+	{
+		LockGuard _(m_device_lock);
+		for_each_inode(
+			[&](BAN::RefPtr<Kernel::RamInode> inode)
+			{
+				if (!inode->is_device())
+					return BAN::Iteration::Continue;
+				return callback((Device*)inode.ptr());
+			}
+		);
+	}
+
 	dev_t DevFileSystem::get_next_dev()
 	{
+		LockGuard _(m_device_lock);
 		static dev_t next_dev = 1;
 		return next_dev++;
 	}

kernel/kernel/FS/RamFS/FileSystem.cpp

@@ -48,11 +48,18 @@ namespace Kernel
 		return m_inodes[ino];
 	}
 
-	void RamFileSystem::for_each_inode(void (*callback)(BAN::RefPtr<RamInode>))
+	void RamFileSystem::for_each_inode(const BAN::Function<BAN::Iteration(BAN::RefPtr<RamInode>)>& callback)
 	{
 		LockGuard _(m_lock);
 		for (auto& [_, inode] : m_inodes)
-			callback(inode);
+		{
+			auto decision = callback(inode);
+			if (decision == BAN::Iteration::Break)
+				break;
+			if (decision == BAN::Iteration::Continue)
+				continue;
+			ASSERT_NOT_REACHED();
+		}
 	}
 
 }

kernel/kernel/Process.cpp

@@ -1,6 +1,7 @@
 #include <BAN/ScopeGuard.h>
 #include <BAN/StringView.h>
 #include <kernel/CriticalScope.h>
+#include <kernel/FS/DevFS/FileSystem.h>
 #include <kernel/FS/VirtualFileSystem.h>
 #include <kernel/InterruptController.h>
 #include <kernel/LockGuard.h>
@@ -8,6 +9,7 @@
 #include <kernel/Memory/PageTableScope.h>
 #include <kernel/Process.h>
 #include <kernel/Scheduler.h>
+#include <kernel/Storage/StorageDevice.h>
 #include <kernel/Timer/Timer.h>
 #include <LibELF/ELF.h>
 #include <LibELF/Values.h>
@@ -752,6 +754,24 @@ namespace Kernel
 		return 0;
 	}
 
+	BAN::ErrorOr<long> Process::sys_sync()
+	{
+		BAN::ErrorOr<long> ret = 0;
+		DevFileSystem::get().for_each_device(
+			[&](Device* device)
+			{
+				if (device->is_storage_device())
+				{
+					auto success = ((StorageDevice*)device)->sync_disk_cache();
+					if (success.is_error())
+						ret = success.release_error();
+				}
+				return BAN::Iteration::Continue;
+			}
+		);
+		return ret;
+	}
+
 	BAN::ErrorOr<long> Process::sys_read_dir_entries(int fd, DirectoryEntryList* list, size_t list_size)
 	{
 		LockGuard _(m_lock);

kernel/kernel/Syscall.cpp

@@ -191,6 +191,9 @@ namespace Kernel
 		case SYS_STAT:
 			ret = Process::current().sys_stat((const char*)arg1, (struct stat*)arg2, (int)arg3);
 			break;
+		case SYS_SYNC:
+			ret = Process::current().sys_sync();
+			break;
 		default:
 			dwarnln("Unknown syscall {}", syscall);
 			break;