Kernel/Userspace: Replace my custom SHM system with SysV shm

This allows xbanan to use shm!

kernel/arch/i686/Signal.S

@@ -59,7 +59,7 @@ signal_trampoline:
 	addl $24, %esp
 
 	// restore sigmask
-	movl $78, %eax      // SYS_SIGPROCMASK
+	movl $79, %eax      // SYS_SIGPROCMASK
 	movl $3,  %ebx      // SIG_SETMASK
 	leal 72(%esp), %ecx // set
 	xorl %edx, %edx     // oset

kernel/arch/x86_64/Signal.S

@@ -61,7 +61,7 @@ signal_trampoline:
 	addq $40, %rsp
 
 	// restore sigmask
-	movq $78, %rdi       // SYS_SIGPROCMASK
+	movq $79, %rdi       // SYS_SIGPROCMASK
 	movq $3,  %rsi       // SIG_SETMASK
 	leaq 192(%rsp), %rdx // set
 	xorq %r10, %r10      // oset

kernel/include/kernel/Memory/SharedMemoryObject.h

@@ -6,25 +6,20 @@
 #include <kernel/Lock/SpinLock.h>
 #include <kernel/Memory/MemoryRegion.h>
 
-#include <fcntl.h>
+#include <sys/shm.h>
 
 namespace Kernel
 {
 
-	class SharedMemoryObject;
-
 	class SharedMemoryObjectManager
 	{
-	public:
-		using Key = size_t;
-
 	public:
 		static BAN::ErrorOr<void> initialize();
 		static SharedMemoryObjectManager& get();
 
-		BAN::ErrorOr<Key> create_object(size_t size, PageTable::flags_t);
-		BAN::ErrorOr<void> delete_object(Key);
-		BAN::ErrorOr<BAN::UniqPtr<SharedMemoryObject>> map_object(Key, PageTable&, AddressRange);
+		BAN::ErrorOr<int> shmget(key_t key, size_t size, int shmflg);
+		BAN::ErrorOr<void> shmctl(int shmid, int cmd, struct shmid_ds* user_buf);
+		BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> shmat(int shmid, const void* shmaddr, int shmflg);
 
 	private:
 		SharedMemoryObjectManager() {}
@@ -32,49 +27,29 @@ namespace Kernel
 	private:
 		struct Object : public BAN::RefCounted<Object>
 		{
+			Object(key_t key, shmid_ds info)
+				: key(key)
+				, info(info)
+			{ }
 			~Object();
 
-			Key key;
-			size_t size;
-			PageTable::flags_t flags;
+			bool can_current_process_access(int flags) const;
+
+			const key_t key;
+			shmid_ds info;
+
+			Mutex mutex;
 			BAN::Vector<paddr_t> paddrs;
-			SpinLock spin_lock;
+			bool marked_for_deletion { false };
 		};
 
 	private:
 		Mutex m_mutex;
-		BAN::HashMap<Key, BAN::RefPtr<Object>> m_objects;
+		BAN::HashMap<key_t, int> m_ids;
+		BAN::HashMap<int, BAN::RefPtr<Object>> m_objects;
 
 		friend class SharedMemoryObject;
 		friend class BAN::UniqPtr<SharedMemoryObjectManager>;
 	};
 
-	class SharedMemoryObject : public MemoryRegion
-	{
-		BAN_NON_COPYABLE(SharedMemoryObject);
-		BAN_NON_MOVABLE(SharedMemoryObject);
-
-	public:
-		static BAN::ErrorOr<BAN::UniqPtr<SharedMemoryObject>> create(BAN::RefPtr<SharedMemoryObjectManager::Object>, PageTable&, AddressRange);
-
-		BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> clone(PageTable& new_page_table) override;
-		BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> split(size_t offset) override;
-
-		BAN::ErrorOr<void> msync(vaddr_t, size_t, int) override { return {}; }
-
-	protected:
-		BAN::ErrorOr<bool> allocate_page_containing_impl(vaddr_t vaddr, bool wants_write) override;
-
-	private:
-		SharedMemoryObject(BAN::RefPtr<SharedMemoryObjectManager::Object> object, PageTable& page_table)
-			: MemoryRegion(page_table, object->size, MemoryRegion::Type::SHARED, object->flags, O_EXEC | O_RDWR)
-			, m_object(object)
-		{ }
-
-	private:
-		BAN::RefPtr<SharedMemoryObjectManager::Object> m_object;
-
-		friend class BAN::UniqPtr<SharedMemoryObject>;
-	};
-
 }

kernel/include/kernel/Process.h

@@ -179,9 +179,10 @@ namespace Kernel
 		BAN::ErrorOr<long> sys_mprotect(void* addr, size_t len, int prot);
 		BAN::ErrorOr<long> sys_msync(void* addr, size_t len, int flags);
 
-		BAN::ErrorOr<long> sys_smo_create(size_t len, int prot);
-		BAN::ErrorOr<long> sys_smo_delete(SharedMemoryObjectManager::Key);
-		BAN::ErrorOr<long> sys_smo_map(SharedMemoryObjectManager::Key);
+		BAN::ErrorOr<long> sys_shmget(key_t key, size_t size, int shmflg);
+		BAN::ErrorOr<long> sys_shmctl(int shmid, int cmd, struct shmid_ds* buf);
+		BAN::ErrorOr<long> sys_shmat(int shmid, const void* shmaddr, int shmflg);
+		BAN::ErrorOr<long> sys_shmdt(const void* shmaddr);
 
 		BAN::ErrorOr<long> sys_ttyname(int fildes, char* name, size_t namesize);
 		BAN::ErrorOr<long> sys_posix_openpt(int flags);
@@ -255,6 +256,8 @@ namespace Kernel
 		const VirtualFileSystem::File& working_directory() const { return m_working_directory; }
 		const VirtualFileSystem::File& root_file() const { return m_root_file; }
 
+		BAN::ErrorOr<AddressRange> find_free_address_range(size_t size);
+
 	private:
 		Process(const Credentials&, pid_t pid, pid_t parent, pid_t sid, pid_t pgrp);
 		static Process* create_process(const Credentials&, pid_t parent, pid_t sid = 0, pid_t pgrp = 0);
@@ -280,8 +283,6 @@ namespace Kernel
 		// You must hold reader end of m_mapped_region_lock when calling this.
 		size_t find_mapped_region(vaddr_t) const;
 
-		BAN::ErrorOr<AddressRange> find_free_address_range(size_t size);
-
 		BAN::ErrorOr<VirtualFileSystem::File> find_file(int fd, const char* path, int flags) const;
 		BAN::ErrorOr<FileParent> find_parent_file(int fd, const char* path, int flags) const;
 		BAN::ErrorOr<VirtualFileSystem::File> find_relative_parent(int fd, const char* path) const;

kernel/kernel/Memory/SharedMemoryObject.cpp

@@ -1,13 +1,44 @@
 #include <kernel/Lock/LockGuard.h>
 #include <kernel/Memory/Heap.h>
 #include <kernel/Memory/SharedMemoryObject.h>
+#include <kernel/Process.h>
 #include <kernel/Random.h>
+#include <kernel/Timer/Timer.h>
+#include <kernel/UserCopy.h>
+
+#include <fcntl.h>
 
 namespace Kernel
 {
 
 	static BAN::UniqPtr<SharedMemoryObjectManager> s_instance;
 
+	class SharedMemoryObject : public MemoryRegion
+	{
+		BAN_NON_COPYABLE(SharedMemoryObject);
+		BAN_NON_MOVABLE(SharedMemoryObject);
+
+	public:
+		static BAN::ErrorOr<BAN::UniqPtr<SharedMemoryObject>> create(BAN::RefPtr<SharedMemoryObjectManager::Object>, PageTable&, AddressRange, int status_flags);
+		~SharedMemoryObject();
+
+		BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> clone(PageTable& new_page_table) override;
+		BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> split(size_t offset) override;
+
+		BAN::ErrorOr<void> msync(vaddr_t, size_t, int) override { return {}; }
+
+	protected:
+		BAN::ErrorOr<bool> allocate_page_containing_impl(vaddr_t vaddr, bool wants_write) override;
+
+	private:
+		SharedMemoryObject(BAN::RefPtr<SharedMemoryObjectManager::Object>, PageTable& page_table, int status_flags);
+
+	private:
+		BAN::RefPtr<SharedMemoryObjectManager::Object> m_object;
+
+		friend class BAN::UniqPtr<SharedMemoryObject>;
+	};
+
 	BAN::ErrorOr<void> SharedMemoryObjectManager::initialize()
 	{
 		ASSERT(!s_instance);
@@ -28,70 +59,189 @@ namespace Kernel
 				Heap::get().release_page(paddr);
 	}
 
-	BAN::ErrorOr<SharedMemoryObjectManager::Key> SharedMemoryObjectManager::create_object(size_t size, PageTable::flags_t flags)
+	BAN::ErrorOr<int> SharedMemoryObjectManager::shmget(key_t key, size_t size, int shmflg)
 	{
-		ASSERT(size % PAGE_SIZE == 0);
-
-		auto object = TRY(BAN::RefPtr<Object>::create());
-		object->size = size;
-		object->flags = flags;
-		TRY(object->paddrs.resize(size / PAGE_SIZE, 0));
-
 		LockGuard _(m_mutex);
 
-		// NOTE: don't set the top bit so cast to signed is not negative
-		auto generate_key = []() { return Random::get<Key>() & (~(Key)0 >> 1); };
+		if (key != IPC_PRIVATE)
+		{
+			if (auto it = m_ids.find(key); it != m_ids.end())
+			{
+				if (shmflg & IPC_EXCL)
+					return BAN::Error::from_errno(EEXIST);
 
-		Key key = generate_key();
-		while (m_objects.contains(key))
-			key = generate_key();
-		object->key = key;
+				const auto& object = m_objects[it->value];
+				if (object->info.shm_segsz < size)
+					return BAN::Error::from_errno(EINVAL);
 
-		TRY(m_objects.insert(key, object));
-		return key;
+				const int flags =
+					(shmflg & S_IRUSR ? O_RDONLY : 0) |
+					(shmflg & S_IWUSR ? O_WRONLY : 0);
+				if (!object->can_current_process_access(flags))
+					return BAN::Error::from_errno(EACCES);
+
+				return it->value;
+			}
+
+			if (!(shmflg & IPC_CREAT))
+				return BAN::Error::from_errno(ENOENT);
+		}
+
+		const auto& process = Process::current();
+		const uid_t uid = process.credentials().euid();
+		const gid_t gid = process.credentials().egid();
+		const pid_t pid = process.pid();
+		const mode_t mode = shmflg & 0777;
+
+		auto object = TRY(BAN::RefPtr<Object>::create(key, shmid_ds {
+				.shm_perm = {
+					.uid = uid,
+					.gid = gid,
+					.cuid = uid,
+					.cgid = uid,
+					.mode = mode,
+				},
+				.shm_segsz = size,
+				.shm_lpid = 0,
+				.shm_cpid = pid,
+				.shm_nattch = 0,
+				.shm_atime = 0,
+				.shm_dtime = 0,
+				.shm_ctime = SystemTimer::get().real_time().tv_sec,
+		}));
+		TRY(object->paddrs.resize(BAN::Math::div_round_up(size, PAGE_SIZE), 0));
+
+		auto generate_id = []() { return Random::get<unsigned>() & BAN::numeric_limits<int>::max(); };
+
+		int shmid = generate_id();
+		while (m_ids.contains(shmid))
+			shmid = generate_id();
+
+		if (key != IPC_PRIVATE)
+			TRY(m_ids.insert(key, shmid));
+
+		if (auto ret = m_objects.insert(shmid, object); ret.is_error())
+		{
+			if (key != IPC_PRIVATE)
+				m_ids.remove(key);
+			return ret.release_error();
+		}
+
+		return shmid;
 	}
 
-	BAN::ErrorOr<void> SharedMemoryObjectManager::delete_object(Key key)
+	BAN::ErrorOr<void> SharedMemoryObjectManager::shmctl(int shmid, int cmd, struct shmid_ds* user_buf)
 	{
-		LockGuard _(m_mutex);
+		LockGuard _0(m_mutex);
 
-		auto it = m_objects.find(key);
+		auto it = m_objects.find(shmid);
 		if (it == m_objects.end())
-			return BAN::Error::from_errno(ENOENT);
+			return BAN::Error::from_errno(EINVAL);
+
+		LockGuard _1(it->value->mutex);
+
+		switch (cmd)
+		{
+			case IPC_RMID:
+				if (!it->value->can_current_process_access(O_WRONLY))
+					return BAN::Error::from_errno(EACCES);
+				if (it->key != IPC_PRIVATE)
+					m_ids.remove(it->key);
+				if (it->value->info.shm_nattch == 0)
+					m_objects.remove(it);
+				else
+					it->value->marked_for_deletion = true;
+				break;
+			case IPC_STAT:
+				TRY(write_to_user(user_buf, &it->value->info, sizeof(shmid_ds)));
+				break;
+			case IPC_SET:
+			{
+				if (!it->value->can_current_process_access(O_WRONLY))
+					return BAN::Error::from_errno(EACCES);
+				shmid_ds buf;
+				TRY(read_from_user(user_buf, &buf, sizeof(shmid_ds)));
+				it->value->info.shm_perm.uid  = buf.shm_perm.uid;
+				it->value->info.shm_perm.gid  = buf.shm_perm.gid;
+				it->value->info.shm_perm.mode = buf.shm_perm.mode & 0777;
+				break;
+			}
+			default:
+				return BAN::Error::from_errno(EINVAL);
+		}
 
-		m_objects.remove(it);
 		return {};
 	}
 
-	BAN::ErrorOr<BAN::UniqPtr<SharedMemoryObject>> SharedMemoryObjectManager::map_object(Key key, PageTable& page_table, AddressRange address_range)
+	BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> SharedMemoryObjectManager::shmat(int shmid, const void* shmaddr, int shmflg)
 	{
 		LockGuard _(m_mutex);
 
-		auto it = m_objects.find(key);
+		auto it = m_objects.find(shmid);
 		if (it == m_objects.end())
 			return BAN::Error::from_errno(ENOENT);
 
-		return TRY(SharedMemoryObject::create(it->value, page_table, address_range));
+		const int status_flags = (shmflg & SHM_RDONLY) ? O_RDONLY : O_RDWR;
+		if (!it->value->can_current_process_access(status_flags))
+			return BAN::Error::from_errno(EACCES);
+
+		const AddressRange address_range = (shmaddr == nullptr)
+			? AddressRange { .start = 0x400000, .end = USERSPACE_END }
+			: TRY(Process::current().find_free_address_range(it->value->info.shm_segsz));
+
+		auto region = TRY(SharedMemoryObject::create(it->value, Process::current().page_table(), address_range, status_flags));
+		return BAN::UniqPtr<MemoryRegion>(BAN::move(region));
 	}
 
-	BAN::ErrorOr<BAN::UniqPtr<SharedMemoryObject>> SharedMemoryObject::create(BAN::RefPtr<SharedMemoryObjectManager::Object> object, PageTable& page_table, AddressRange address_range)
+	bool SharedMemoryObjectManager::Object::can_current_process_access(int flags) const
 	{
-		auto smo = TRY(BAN::UniqPtr<SharedMemoryObject>::create(object, page_table));
-		TRY(smo->initialize(address_range));
-		return BAN::move(smo);
+		const auto& creds = Process::current().credentials();
+		if (Inode::can_access(info.shm_perm.uid,  info.shm_perm.gid,  info.shm_perm.mode, creds, flags))
+			return true;
+		if (Inode::can_access(info.shm_perm.cuid, info.shm_perm.cgid, info.shm_perm.mode, creds, flags))
+			return true;
+		return false;
+	}
+
+	BAN::ErrorOr<BAN::UniqPtr<SharedMemoryObject>> SharedMemoryObject::create(BAN::RefPtr<SharedMemoryObjectManager::Object> object, PageTable& page_table, AddressRange address_range, int status_flags)
+	{
+		auto shared_memory_object = TRY(BAN::UniqPtr<SharedMemoryObject>::create(object, page_table, status_flags));
+		TRY(shared_memory_object->initialize(address_range));
+		return shared_memory_object;
+	}
+
+	SharedMemoryObject::SharedMemoryObject(BAN::RefPtr<SharedMemoryObjectManager::Object> object, PageTable& page_table, int status_flags)
+		: MemoryRegion(
+			page_table,
+			object->info.shm_segsz,
+			MemoryRegion::Type::SHARED,
+			PageTable::UserSupervisor | ((status_flags & O_WRONLY) ? PageTable::ReadWrite : 0) | PageTable::Present,
+			status_flags
+		), m_object(object)
+	{
+		LockGuard _(m_object->mutex);
+		m_object->info.shm_nattch++;
+		m_object->info.shm_atime = SystemTimer::get().real_time().tv_sec;
+	}
+
+	SharedMemoryObject::~SharedMemoryObject()
+	{
+		LockGuard _(m_object->mutex);
+		if (--m_object->info.shm_nattch == 0 && m_object->marked_for_deletion)
+			SharedMemoryObjectManager::get().m_objects.remove(m_object->key);
+		m_object->info.shm_dtime = SystemTimer::get().real_time().tv_sec;
 	}
 
 	BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> SharedMemoryObject::clone(PageTable& new_page_table)
 	{
-		auto region = TRY(SharedMemoryObject::create(m_object, new_page_table, { .start = vaddr(), .end = vaddr() + size() }));
+		auto region = TRY(SharedMemoryObject::create(m_object, new_page_table, { .start = vaddr(), .end = vaddr() + size() }, m_status_flags));
 		return BAN::UniqPtr<MemoryRegion>(BAN::move(region));
 	}
 
-	BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> SharedMemoryObject::split(size_t offset)
+	BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> SharedMemoryObject::split(size_t)
 	{
-		(void)offset;
-		dwarnln("TODO: SharedMemoryObject::split");
-		return BAN::Error::from_errno(ENOTSUP);
+		derrorln("SharedMemoryObjects are not splittable");
+		return BAN::Error::from_errno(EINVAL);
 	}
 
 	BAN::ErrorOr<bool> SharedMemoryObject::allocate_page_containing_impl(vaddr_t address, bool wants_write)
@@ -99,12 +249,11 @@ namespace Kernel
 		ASSERT(contains(address));
 		(void)wants_write;
 
-		// Check if address is already mapped
-		vaddr_t vaddr = address & PAGE_ADDR_MASK;
+		const vaddr_t vaddr = address & PAGE_ADDR_MASK;
 		if (m_page_table.physical_address_of(vaddr) != 0)
 			return false;
 
-		SpinLockGuard _(m_object->spin_lock);
+		LockGuard _(m_object->mutex);
 
 		paddr_t paddr = m_object->paddrs[(vaddr - m_vaddr) / PAGE_SIZE];
 		if (paddr == 0)
@@ -117,6 +266,7 @@ namespace Kernel
 			});
 			m_object->paddrs[(vaddr - m_vaddr) / PAGE_SIZE] = paddr;
 		}
+
 		m_page_table.map_page_at(paddr, vaddr, m_flags);
 
 		return true;

kernel/kernel/Process.cpp

@@ -2928,48 +2928,46 @@ namespace Kernel
 		return 0;
 	}
 
-	BAN::ErrorOr<long> Process::sys_smo_create(size_t len, int prot)
+	BAN::ErrorOr<long> Process::sys_shmget(key_t key, size_t size, int shmflg)
 	{
-		if (len == 0)
-			return BAN::Error::from_errno(EINVAL);
-		if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC | PROT_NONE))
-			return BAN::Error::from_errno(EINVAL);
-
-		if (auto rem = len % PAGE_SIZE)
-			len += PAGE_SIZE - rem;
-
-		PageTable::flags_t page_flags = 0;
-		if (prot & PROT_READ)
-			page_flags |= PageTable::Flags::Present;
-		if (prot & PROT_WRITE)
-			page_flags |= PageTable::Flags::ReadWrite | PageTable::Flags::Present;
-		if (prot & PROT_EXEC)
-			page_flags |= PageTable::Flags::Execute | PageTable::Flags::Present;
-
-		if (page_flags == 0)
-			page_flags |= PageTable::Flags::Reserved;
-		else
-			page_flags |= PageTable::Flags::UserSupervisor;
-
-		return TRY(SharedMemoryObjectManager::get().create_object(len, page_flags));
+		return TRY(SharedMemoryObjectManager::get().shmget(key, size, shmflg));
 	}
 
-	BAN::ErrorOr<long> Process::sys_smo_delete(SharedMemoryObjectManager::Key key)
+	BAN::ErrorOr<long> Process::sys_shmctl(int shmid, int cmd, struct shmid_ds* user_buf)
 	{
-		TRY(SharedMemoryObjectManager::get().delete_object(key));
+		TRY(SharedMemoryObjectManager::get().shmctl(shmid, cmd, user_buf));
 		return 0;
 	}
 
-	BAN::ErrorOr<long> Process::sys_smo_map(SharedMemoryObjectManager::Key key)
+	BAN::ErrorOr<long> Process::sys_shmat(int shmid, const void* shmaddr, int shmflg)
 	{
-		auto region = TRY(SharedMemoryObjectManager::get().map_object(key, page_table(), { .start = 0x400000, .end = USERSPACE_END }));
+		RWLockWRGuard _(m_memory_region_lock);
+
+		auto region = TRY(SharedMemoryObjectManager::get().shmat(shmid, shmaddr, shmflg));
 
-		LockGuard _(m_process_lock);
 		const vaddr_t region_vaddr = region->vaddr();
+
 		TRY(add_mapped_region(BAN::move(region)));
+
 		return region_vaddr;
 	}
 
+	BAN::ErrorOr<long> Process::sys_shmdt(const void* shmaddr)
+	{
+		const vaddr_t vaddr = reinterpret_cast<vaddr_t>(shmaddr);
+
+		RWLockWRGuard _(m_memory_region_lock);
+
+		const size_t idx = find_mapped_region(vaddr);
+		if (idx >= m_mapped_regions.size() || m_mapped_regions[idx]->vaddr() != vaddr)
+			return BAN::Error::from_errno(ENOENT);
+
+		m_mapped_regions[idx]->wait_not_pinned();
+		m_mapped_regions.remove(idx);
+
+		return 0;
+	}
+
 	BAN::ErrorOr<long> Process::sys_ttyname(int fildes, char* user_buffer, size_t buffer_size)
 	{
 		auto inode = TRY(m_open_file_descriptors.inode_of(fildes));

kernel/kernel/Thread.cpp

@@ -15,7 +15,7 @@
 namespace Kernel
 {
 
-	static_assert(SYS_SIGPROCMASK == 78, "this is hard coded in arch/*/Signal.S");
+	static_assert(SYS_SIGPROCMASK == 79, "this is hard coded in arch/*/Signal.S");
 	static_assert(SIG_SETMASK     ==  3, "this is hard coded in arch/*/Signal.S");
 
 	extern "C" [[noreturn]] void start_kernel_thread();