From 3afa165ef34db9bd4343c673ee2c01bc5c5780c7 Mon Sep 17 00:00:00 2001 From: user Date: Tue, 2 Dec 2025 16:56:38 +0100 Subject: [PATCH] =?UTF-8?q?musst=20semaphore.counter=20public=20machen,=20?= =?UTF-8?q?hasse=20alles.=20init=20l=C3=A4uft=20nun?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- kernel/interrupt/guard.h | 2 ++ kernel/sync/semaphore.h | 2 +- kernel/syscall/handler.cc | 20 ++++++++++++++++---- kernel/syscall/skeleton.cc | 9 +++++---- kernel/syscall/stub.h | 26 +++++++++++++++++++++++++- 5 files changed, 49 insertions(+), 10 deletions(-) diff --git a/kernel/interrupt/guard.h b/kernel/interrupt/guard.h index 16c20fc..021b737 100644 --- a/kernel/interrupt/guard.h +++ b/kernel/interrupt/guard.h @@ -20,7 +20,9 @@ struct Vault { Bellringer bellringer; BBuffer keys; Semaphore keys_sem; +static constexpr int MAX_SEMS =32; + Semaphore sems[MAX_SEMS]; // Ignore this for now, this is for a bonus task Graphics graphics; diff --git a/kernel/sync/semaphore.h b/kernel/sync/semaphore.h index cb0a9bd..9355ee1 100644 --- a/kernel/sync/semaphore.h +++ b/kernel/sync/semaphore.h @@ -25,7 +25,6 @@ class Semaphore { // Prevent copies and assignments Semaphore(const Semaphore&) = delete; Semaphore& operator=(const Semaphore&) = delete; - unsigned counter; Queue waiting; public: @@ -33,6 +32,7 @@ class Semaphore { * \param c Initial counter value */ explicit Semaphore(unsigned c = 0) : counter(c) {} + unsigned counter; /*! \brief Wait for access to the critical area. * diff --git a/kernel/syscall/handler.cc b/kernel/syscall/handler.cc index e71e46b..ac90758 100644 --- a/kernel/syscall/handler.cc +++ b/kernel/syscall/handler.cc @@ -44,11 +44,23 @@ extern "C" size_t syscall_handler(size_t sysnum, size_t p1, size_t p2, Syscall::Skeleton::test(Guard::enter().vault(), p1, p2, p3, p4, p5); break; case Syscall::ID::WRITE: - Guarded g = Guard::enter(); - g.vault().kout.setPos((int)p4, (int)p5); - Syscall::Skeleton::write(g.vault(), p1, (char*)p2, p3); + Guard::enter().vault().kout.setPos((int)p4, (int)p5); + Syscall::Skeleton::write(Guard::enter().vault(), p1, (char*)p2, p3); break; - } + case Syscall::ID::SEM_INIT: + Syscall::Skeleton::sem_init(Guard::enter().vault(), p1, p2); + break; + case Syscall::ID::SEM_DESTROY: + Syscall::Skeleton::sem_destroy(Guard::enter().vault(), p1); + break; + case Syscall::ID::SEM_WAIT: + Syscall::Skeleton::sem_wait(Guard::enter().vault(), p1); + break; + case Syscall::ID::SEM_SIGNAL: + Syscall::Skeleton::sem_signal(Guard::enter().vault(), p1); + break; + + } return static_cast(-1); } diff --git a/kernel/syscall/skeleton.cc b/kernel/syscall/skeleton.cc index 5f7acf8..1f780a0 100644 --- a/kernel/syscall/skeleton.cc +++ b/kernel/syscall/skeleton.cc @@ -46,10 +46,11 @@ void sleep(Vault &vault, size_t ms) { } bool sem_init(Vault &vault, size_t id, uint32_t value) { - (void)vault; - (void)id; - (void)value; - return false; + if (id >= vault.MAX_SEMS) { + return false; // out‐of‐range id + } + vault.sems[id].counter=value; + return true; } void sem_destroy(Vault &vault, size_t id) { diff --git a/kernel/syscall/stub.h b/kernel/syscall/stub.h index 18e433e..f1e0f5c 100644 --- a/kernel/syscall/stub.h +++ b/kernel/syscall/stub.h @@ -8,6 +8,15 @@ namespace Syscall { enum class ID : size_t { TEST = 0, WRITE = 1, + //READ = 2, + //SLEEP =3, + SEM_INIT=4, + SEM_DESTROY=5, + SEM_WAIT=6, + SEM_SIGNAL=7, + //SYS_GETPID=8, + //SYS_EXIT= 9, + //SYS_KILL=10 }; } // namespace Syscall @@ -25,5 +34,20 @@ extern "C" ssize_t sys_safe_call(Syscall::ID id, size_t p1, size_t p2, } [[gnu::always_inline]] static inline int write(int fd, const void *buf, size_t len, int x = -1, int y = -1) { - return sys_call(Syscall::ID::WRITE, fd, (size_t)buf, len, x, y); + return sys_call(Syscall::ID::WRITE, fd, (size_t)buf, len, x, y); +} + + +[[gnu::always_inline]] static inline int sem_init(int fd, int semid, int value) { + return sys_call(Syscall::ID::SEM_INIT, fd, semid, value, 0,0); +} +[[gnu::always_inline]] static inline int sem_destroy(int fd, int semid) { + return sys_call(Syscall::ID::SEM_DESTROY, fd, semid,0,0,0); +} +[[gnu::always_inline]] static inline int sem_wait(int fd, int semid) { + return sys_call(Syscall::ID::SEM_WAIT, fd, semid,0,0,0); +} + +[[gnu::always_inline]] static inline int sem_signal(int fd, int semid) { + return sys_call(Syscall::ID::SEM_SIGNAL, fd, semid,0,0,0); }