[haiku-gsoc] Re: Xsi semaphorses: patch #1
- From: "Salvatore Benedetto" <emitrax@xxxxxxxxx>
- To: haiku-gsoc@xxxxxxxxxxxxx
- Date: Thu, 17 Jul 2008 13:44:06 +0000
2008/7/15 Ingo Weinhold <ingo_weinhold@xxxxxx>:
>> But what if some programs do share IPC keys for different kinds of IPC
>> subsystems?
>> Wouldn't that result in a bug from the application POV?
>
> I don't see what kind of potential bug you're thinking of.
>
If it's ok with you, I'd like to investigate a bit more on this before removing
the special case and use an ipc table for each subsystem, because although
the standard does not say explicitly to use the same ipc table for all
subsystems
it does provide an error code for the above situation
[ENOENT]
A semaphore identifier does not exist for the argument key and
(semflg &IPC_CREAT) is equal to 0.
and keys gets created on any {sem,msg,shm}get call.
Anyway, I've attached a patch that (hopefully) fix all previous issue, and also
(hopefully) add the rest of missing features without any other mistakes.
It's still not 100% complete though.
I'll look into a test application next.
Regards,
--
Salvatore Benedetto (a.k.a. emitrax)
Student of Computer Engineer
University of Pisa
www.haiku-os.it
Index: src/system/kernel/main.cpp
===================================================================
--- src/system/kernel/main.cpp (revision 26439)
+++ src/system/kernel/main.cpp (working copy)
@@ -36,6 +36,7 @@
#include <Notifications.h>
#include <port.h>
#include <posix/realtime_sem.h>
+#include <posix/xsi_semaphore.h>
#include <real_time_clock.h>
#include <sem.h>
#include <smp.h>
@@ -170,7 +171,9 @@
TRACE("init kernel daemons\n");
kernel_daemon_init();
arch_platform_init_post_thread(&sKernelArgs);
+ TRACE("init posix semaphores\n");
realtime_sem_init();
+ xsi_ipc_init();
TRACE("init VM threads\n");
vm_init_post_thread(&sKernelArgs);
Index: src/system/kernel/posix/Jamfile
===================================================================
--- src/system/kernel/posix/Jamfile (revision 26439)
+++ src/system/kernel/posix/Jamfile (working copy)
@@ -4,6 +4,7 @@
KernelMergeObject kernel_posix.o :
realtime_sem.cpp
+ xsi_semaphore.cpp
: $(TARGET_KERNEL_PIC_CCFLAGS)
;
Index: src/system/kernel/posix/xsi_semaphore.cpp
===================================================================
--- src/system/kernel/posix/xsi_semaphore.cpp (revision 0)
+++ src/system/kernel/posix/xsi_semaphore.cpp (revision 0)
@@ -0,0 +1,842 @@
+/*
+ * Copyright 2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Salvatore Benedetto <salvatore.benedetto@xxxxxxxxx>
+ */
+
+#include <posix/xsi_semaphore.h>
+
+#include <new>
+
+#include <sys/ipc.h>
+#include <sys/types.h>
+
+#include <OS.h>
+
+#include <kernel.h>
+#include <syscall_restart.h>
+
+#include <util/AutoLock.h>
+#include <util/DoublyLinkedList.h>
+#include <util/OpenHashTable.h>
+#include <util/Vector.h>
+
+
+//#define TRACE_XSI_SEM
+#ifdef TRACE_XSI_SEM
+# define TRACE(x) dprintf x
+# define TRACE_ERROR(x) dprintf x
+#else
+# define TRACE(x) /* nothing */
+# define TRACE_ERROR(x) dprintf x
+#endif
+
+//#define KTRACE_XSI_SEM
+#ifdef KTRACE_XSI_SEM
+# define KTRACE(x...) ktrace_printf(x)
+#else
+# define KTRACE(x...)
+#endif
+
+// Queue for holding blocked threads
+struct queued_thread : DoublyLinkedListLinkImpl<queued_thread> {
+ queued_thread(struct thread *thread, int32 count)
+ :
+ thread(thread),
+ count(count),
+ queued(false)
+ {
+ }
+
+ struct thread *thread;
+ int32 count;
+ bool queued;
+};
+
+typedef DoublyLinkedList<queued_thread> ThreadQueue;
+
+
+// Xsi semaphore definition
+class XsiSemaphore {
+public:
+ XsiSemaphore()
+ : fLastPidOperation(0),
+ fThreadsWaitingToIncrease(0),
+ fThreadsWaitingToBeZero(0),
+ fValue(0)
+ {
+ }
+
+ ~XsiSemaphore()
+ {
+ // For some reason the semaphore is getting destroyed.
+ // Wake up any remaing awaiting threads
+ InterruptsSpinLocker _(thread_spinlock);
+ while (queued_thread *entry =
fWaitingToIncreaseQueue.RemoveHead()) {
+ entry->queued = false;
+ thread_unblock_locked(entry->thread, EIDRM);
+ }
+ while (queued_thread *entry =
fWaitingToBeZeroQueue.RemoveHead()) {
+ entry->queued = false;
+ thread_unblock_locked(entry->thread, EIDRM);
+ }
+ }
+
+ // We return true in case the operation causes the
+ // caller to wait, so it can undo all the operations
+ // previously done
+ bool Add(short value)
+ {
+ if ((int)(fValue + value) < 0) {
+ TRACE(("XsiSemaphore::Add: going to sleep\n"));
+ return true;
+ } else {
+ fValue += value;
+ if (fValue == 0 && fThreadsWaitingToBeZero > 0)
+ WakeUpThread(true);
+ else if (fValue > 0 && fThreadsWaitingToIncrease > 0)
+ WakeUpThread(false);
+ return false;
+ }
+ }
+
+ pid_t LastPid() const
+ {
+ return fLastPidOperation;
+ }
+
+ void Revert(short value)
+ {
+ fValue -= value;
+ }
+
+ ushort ThreadsWaitingToIncrease() const
+ {
+ return fThreadsWaitingToIncrease;
+ }
+
+ ushort ThreadsWaitingToBeZero() const
+ {
+ return fThreadsWaitingToBeZero;
+ }
+
+ ushort Value() const
+ {
+ return fValue;
+ }
+
+ void SetPid(pid_t pid)
+ {
+ fLastPidOperation = pid;
+ }
+
+ void SetValue(ushort value)
+ {
+ // TODO: the semadj value corresponding to the
+ // specified semaphore in all processes is cleared
+ fValue = value;
+ }
+
+ status_t Wait(int32 count, bool waitForZero)
+ {
+ // enqueue the thread in the appropriate
+ // queue and get ready to wait
+ struct thread *thread = thread_get_current_thread();
+ queued_thread queueEntry(thread, count);
+ if (waitForZero) {
+ fWaitingToBeZeroQueue.Add(&queueEntry);
+ fThreadsWaitingToBeZero++;
+ } else {
+ fWaitingToIncreaseQueue.Add(&queueEntry);
+ fThreadsWaitingToIncrease++;
+ }
+ queueEntry.queued = true;
+
+ thread_prepare_to_block(thread, B_CAN_INTERRUPT,
+ THREAD_BLOCK_TYPE_OTHER, (void*)"xsi semaphore");
+
+ InterruptsSpinLocker _(thread_spinlock);
+ status_t result = thread_block_locked(thread);
+
+ return result;
+ }
+
+ void WakeUpThread(bool waitingForZero)
+ {
+ queued_thread *entry;
+ bool unblock = false;
+
+ InterruptsSpinLocker _(thread_spinlock);
+ if (waitingForZero) {
+ unblock = true;
+ entry = fWaitingToBeZeroQueue.RemoveHead();
+ } else {
+ entry = fWaitingToIncreaseQueue.Head();
+ if ((entry->count + fValue) >= 0) {
+ unblock = true;
+ entry = fWaitingToIncreaseQueue.RemoveHead();
+ }
+ }
+ if (unblock) {
+ entry->queued = false;
+ thread_unblock_locked(entry->thread, 0);
+ }
+ }
+
+private:
+ pid_t fLastPidOperation;
// sempid
+ ushort fThreadsWaitingToIncrease; //
semncnt
+ ushort fThreadsWaitingToBeZero; //
semzcnt
+ short fValue;
// semval
+
+ ThreadQueue fWaitingToIncreaseQueue;
+ ThreadQueue fWaitingToBeZeroQueue;
+};
+
+#define MAX_XSI_SEMS_PER_TEAM 128
+
+// Xsi semaphore set definition (semid_ds)
+class XsiSemaphoreSet {
+public:
+ XsiSemaphoreSet(int nsems, int flags)
+ : fLastSemctlTime((time_t)real_time_clock()),
+ fLastSemopTime(0),
+ fNumberOfSemaphores(nsems),
+ fSemaphores(0)
+ {
+ SetID();
+ SetIpcKey((key_t)-1);
+ SetPermissions(flags);
+ fSemaphores = new(std::nothrow) XsiSemaphore[nsems];
+
+ if (fSemaphores == NULL) {
+ TRACE_ERROR(("XsiSemaphoreSet::XsiSemaphore(): failed
to allocate "
+ "XsiSemaphore object\n"));
+ return;
+ }
+ }
+
+ ~XsiSemaphoreSet()
+ {
+ delete []fSemaphores;
+ }
+
+ void DoIpcSet(struct semid_ds *result)
+ {
+ fPermissions.uid = result->sem_perm.uid;
+ fPermissions.gid = result->sem_perm.gid;
+ fPermissions.mode = (fPermissions.mode & ~0x01ff)
+ | (result->sem_perm.mode & 0x01ff);
+ }
+
+ int ID() const
+ {
+ return fID;
+ }
+
+ key_t IpcKey() const
+ {
+ return fPermissions.key;
+ }
+
+ struct ipc_perm IpcPermission() const
+ {
+ return fPermissions;
+ }
+
+ time_t LastSemctlTime() const
+ {
+ return fLastSemctlTime;
+ }
+
+ time_t LastSemopTime() const
+ {
+ return fLastSemopTime;
+ }
+
+ ushort NumberOfSemaphores() const
+ {
+ return fNumberOfSemaphores;
+ }
+
+ XsiSemaphore* Semaphore(int nth) const
+ {
+ return &fSemaphores[nth];
+ }
+
+ // Implemented after sSemaphoreHashTable is declared
+ void SetID();
+
+ void SetIpcKey(key_t key)
+ {
+ fPermissions.key = key;
+ }
+
+ void SetLastSemctlTime()
+ {
+ fLastSemctlTime = real_time_clock();
+ }
+
+ void SetLastSemopTime()
+ {
+ fLastSemopTime = real_time_clock();
+ }
+
+ void SetPermissions(int flags)
+ {
+ fPermissions.uid = fPermissions.cuid = geteuid();
+ fPermissions.gid = fPermissions.cgid = getegid();
+ fPermissions.mode = (flags & 0x01ff);
+ }
+
+ bool HasPermission() const
+ {
+ if ((fPermissions.mode & S_IWOTH) != 0)
+ return true;
+
+ uid_t uid = geteuid();
+ if (uid == 0 || (uid == fPermissions.uid
+ && (fPermissions.mode & S_IWUSR) != 0))
+ return true;
+
+ gid_t gid = getegid();
+ if (gid == fPermissions.gid && (fPermissions.mode & S_IWGRP) !=
0)
+ return true;
+
+ return false;
+ }
+
+ bool HasReadPermission() const
+ {
+ // TODO: fix this
+ return HasPermission();
+ }
+
+ HashTableLink<XsiSemaphoreSet>* Link()
+ {
+ return &fLink;
+ }
+
+private:
+ int fID;
// semaphore set id
+ time_t fLastSemctlTime;
// sem_ctime
+ time_t fLastSemopTime;
// sem_otime
+ ushort fNumberOfSemaphores;
// sem_nsems
+ struct ipc_perm fPermissions;
// sem_perm
+ XsiSemaphore *fSemaphores;
+
+ ::HashTableLink<XsiSemaphoreSet> fLink;
+};
+
+// Xsi semaphore set hash table
+struct SemaphoreHashTableDefinition {
+ typedef int KeyType;
+ typedef XsiSemaphoreSet ValueType;
+
+ size_t HashKey (const int key) const
+ {
+ return (size_t)key;
+ }
+ size_t Hash(XsiSemaphoreSet *variable) const
+ {
+ return (size_t)variable->ID();
+ }
+ bool Compare(const int key, XsiSemaphoreSet *variable) const
+ {
+ return (int)key == (int)variable->ID();
+ }
+ HashTableLink<XsiSemaphoreSet>* GetLink(XsiSemaphoreSet *variable) const
+ {
+ return variable->Link();
+ }
+};
+
+
+// IPC class
+class Ipc {
+public:
+ Ipc(key_t key)
+ : fKey(key),
+ fSemaphoreSetId(-1)
+ {
+ }
+
+ key_t Key() const
+ {
+ return fKey;
+ }
+
+ int SemaphoreSetID() const
+ {
+ return fSemaphoreSetId;
+ }
+
+ void SetSemaphoreSetID(XsiSemaphoreSet *semaphoreSet)
+ {
+ fSemaphoreSetId = semaphoreSet->ID();
+ }
+
+ bool HasSemaphoreSet()
+ {
+ if (fSemaphoreSetId != -1)
+ return true;
+ return false;
+ }
+
+ HashTableLink<Ipc>* Link()
+ {
+ return &fLink;
+ }
+
+private:
+ key_t fKey;
+ int fSemaphoreSetId;
+ HashTableLink<Ipc> fLink;
+};
+
+
+struct IpcHashTableDefinition {
+ typedef key_t KeyType;
+ typedef Ipc ValueType;
+
+ size_t HashKey (const key_t key) const
+ {
+ return (size_t)(key);
+ }
+ size_t Hash(Ipc *variable) const
+ {
+ return (size_t)HashKey(variable->Key());
+ }
+ bool Compare(const key_t key, Ipc *variable) const
+ {
+ return (key_t)key == (key_t)variable->Key();
+ }
+ HashTableLink<Ipc>* GetLink(Ipc *variable) const
+ {
+ return variable->Link();
+ }
+};
+
+// Arbitrary limit
+#define MAX_XSI_SEMAPHORE 512
+static OpenHashTable<IpcHashTableDefinition> sIpcHashTable;
+static OpenHashTable<SemaphoreHashTableDefinition> sSemaphoreHashTable;
+
+static mutex sXsiSemaphoreSetLock;
+static mutex sIpcLock;
+static vint32 sNextAvailableID = 0;
+static vint32 sTotalNumberOfXsiSemaphores = 0;
+
+
+void
+XsiSemaphoreSet::SetID()
+{
+ // The lock is held upon creation of the object
+ while (true) {
+ if (sSemaphoreHashTable.Lookup(sNextAvailableID) == NULL)
+ break;
+ sNextAvailableID++;
+ }
+ fID = sNextAvailableID++;
+}
+
+
+void
+xsi_ipc_init()
+{
+ // Initialize hash tables
+ status_t status = sIpcHashTable.Init();
+ if (status != B_OK)
+ panic("xsi_ipc_init() failed to initialized ipc hash table\n");
+ status = sSemaphoreHashTable.Init();
+ if (status != B_OK)
+ panic("xsi_ipc_init() failed to initialized semaphore hash
table\n");
+
+ mutex_init(&sIpcLock, "global Posix IPC table");
+ mutex_init(&sXsiSemaphoreSetLock, "global Posix xsi sem table");
+}
+
+
+int
+_user_xsi_semget(key_t key, int numberOfSemaphores, int flags)
+{
+ XsiSemaphoreSet *semaphoreSet = NULL;
+ Ipc *ipcKey = NULL;
+ // Default assumptions
+ bool isPrivate = true;
+ bool create = true;
+
+ MutexLocker _(sIpcLock);
+ if (key != IPC_PRIVATE) {
+ isPrivate = false;
+ // Check if key already have a semaphore
+ // associated with it
+ ipcKey = sIpcHashTable.Lookup(key);
+ if (ipcKey == NULL) {
+ // The ipc key have probably just been created
+ // by the caller, add it to the system
+ ipcKey = new(std::nothrow) Ipc(key);
+ if (ipcKey == NULL) {
+ TRACE_ERROR(("xsi_semget: failed to create new
Ipc object "
+ "for key %d\n", (int)key));
+ return ENOMEM;
+ }
+ sIpcHashTable.Insert(ipcKey);
+ } else if (ipcKey->HasSemaphoreSet()) {
+ // The IPC key exist and it already has a semaphore
+ if ((flags & IPC_CREAT) && (flags & IPC_EXCL)) {
+ TRACE_ERROR(("xsi_semget: key %d already
exist\n", (int)key));
+ return EEXIST;
+ }
+ int semaphoreSetID = ipcKey->SemaphoreSetID();
+
+ MutexLocker _(sXsiSemaphoreSetLock);
+ semaphoreSet =
sSemaphoreHashTable.Lookup(semaphoreSetID);
+ if (!semaphoreSet->HasPermission()) {
+ TRACE_ERROR(("xsi_semget: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ if (semaphoreSet->NumberOfSemaphores() >=
numberOfSemaphores
+ && numberOfSemaphores != 0) {
+ TRACE_ERROR(("xsi_semget: nsems greater than
the one "
+ "associated with semaphore %d, key
%d\n",
+ semaphoreSet->ID(),
(int)semaphoreSet->IpcKey()));
+ return EINVAL;
+ }
+ create = false;
+ } else {
+ // The IPC key exist but it has not semaphore
associated with it
+ if (!(flags & IPC_CREAT)) {
+ TRACE_ERROR(("xsi_semget: key %d has not
semaphore associated "
+ "with it and caller did not ask for
creation\n",(int)key));
+ return ENOENT;
+ }
+ }
+ }
+
+ if (create) {
+ // Create a new sempahore for this key
+ if (numberOfSemaphores < 0
+ || numberOfSemaphores >= MAX_XSI_SEMS_PER_TEAM)
{
+ TRACE_ERROR(("xsi_semget: nsems out of range\n"));
+ return EINVAL;
+ }
+ if (sTotalNumberOfXsiSemaphores >= MAX_XSI_SEMAPHORE) {
+ TRACE_ERROR(("xsi_semget: reached limit of maximum
number of "
+ "semaphores allowed\n"));
+ return ENOSPC;
+ }
+ atomic_add(&sTotalNumberOfXsiSemaphores, 1);
+
+ MutexLocker _(sXsiSemaphoreSetLock);
+ semaphoreSet = new(std::nothrow)
XsiSemaphoreSet(numberOfSemaphores,
+ flags);
+ if (semaphoreSet == NULL) {
+ TRACE_ERROR(("xsi_semget: failed to allocate a new xsi "
+ "semaphore set\n"));
+ atomic_add(&sTotalNumberOfXsiSemaphores, -1);
+ return ENOMEM;
+ }
+ if (isPrivate)
+ semaphoreSet->SetIpcKey((key_t)-1);
+ else {
+ semaphoreSet->SetIpcKey(key);
+ ipcKey->SetSemaphoreSetID(semaphoreSet);
+ sSemaphoreHashTable.Insert(semaphoreSet);
+ }
+ }
+
+ return semaphoreSet->ID();
+}
+
+
+int
+_user_xsi_semctl(int semaphoreID, int semaphoreNumber, int command,
+ union semun *args)
+{
+ MutexLocker _(sXsiSemaphoreSetLock);
+ XsiSemaphoreSet *semaphoreSet = sSemaphoreHashTable.Lookup(semaphoreID);
+ if (semaphoreSet == NULL) {
+ TRACE_ERROR(("xsi_semctl: semaphore set id %d not valid\n",
+ semaphoreID));
+ return EINVAL;
+ }
+ if (semaphoreNumber < 0
+ || semaphoreNumber >= semaphoreSet->NumberOfSemaphores()) {
+ TRACE_ERROR(("xsi_semctl: semaphore number %d not valid for "
+ "semaphore %d\n", semaphoreNumber, semaphoreID));
+ return EINVAL;
+ }
+
+ if (args != 0 && !IS_USER_ADDRESS(args)) {
+ TRACE_ERROR(("xsi_semctl: semun address is not valid\n"));
+ return B_BAD_ADDRESS;
+ }
+
+ XsiSemaphore *semaphore = semaphoreSet->Semaphore(semaphoreNumber);
+ switch (command) {
+ case GETVAL:
+ if (!semaphoreSet->HasReadPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ return semaphore->Value();
+
+ case SETVAL:
+ if (!semaphoreSet->HasPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ int value;
+ if (user_memcpy(&value, &args->val, sizeof(int) <
B_OK)) {
+ TRACE_ERROR(("xsi_semctl: user_memcpy
failed\n"));
+ return B_BAD_ADDRESS;
+ }
+ if (value > USHRT_MAX) {
+ TRACE_ERROR(("xsi_semctl: value %d out of
range\n", value));
+ return ERANGE;
+ }
+ semaphore->SetValue(value);
+ return 0;
+
+ case GETPID:
+ if (!semaphoreSet->HasReadPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ return semaphore->LastPid();
+
+ case GETNCNT:
+ if (!semaphoreSet->HasReadPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ return semaphore->ThreadsWaitingToIncrease();
+
+ case GETZCNT:
+ if (!semaphoreSet->HasReadPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ return semaphore->ThreadsWaitingToBeZero();
+
+ case GETALL: {
+ if (!semaphoreSet->HasReadPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not read "
+ "permission on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ for (int i = 0; i < semaphoreSet->NumberOfSemaphores();
i++) {
+ semaphore = semaphoreSet->Semaphore(i);
+ unsigned short value = semaphore->Value();
+ if (user_memcpy(&args->array[i], &value,
sizeof(unsigned short))
+ < B_OK) {
+ TRACE_ERROR(("xsi_semctl: user_memcpy
failed\n"));
+ return B_BAD_ADDRESS;
+ }
+ }
+ return 0;
+ }
+
+ case SETALL: {
+ if (!semaphoreSet->HasPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not permission "
+ "on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ for (int i = 0; i < semaphoreSet->NumberOfSemaphores();
i++) {
+ semaphore = semaphoreSet->Semaphore(i);
+ unsigned short value;
+ if (user_memcpy(&value, &args->array[i],
sizeof(unsigned short))
+ < B_OK) {
+ TRACE_ERROR(("xsi_semctl: user_memcpy
failed\n"));
+ return B_BAD_ADDRESS;
+ }
+ semaphore->SetValue(value);
+ }
+ return 0;
+ }
+
+ case IPC_STAT: {
+ if (!semaphoreSet->HasReadPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not read "
+ "permission on semaphore %d, key %d\n",
semaphoreSet->ID(),
+ (int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ struct semid_ds result;
+ result.sem_perm = semaphoreSet->IpcPermission();
+ result.sem_nsems = semaphoreSet->NumberOfSemaphores();
+ result.sem_otime = semaphoreSet->LastSemopTime();
+ result.sem_ctime = semaphoreSet->LastSemctlTime();
+ if (user_memcpy(args->buf, &result, sizeof(struct
semid_ds))
+ < B_OK) {
+ TRACE_ERROR(("xsi_semctl: user_memcpy
failed\n"));
+ return B_BAD_ADDRESS;
+ }
+ return 0;
+ }
+
+ case IPC_SET: {
+ if (!semaphoreSet->HasPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling process has
not "
+ "permission on semaphore %d, key %d\n",
+ semaphoreSet->ID(),
(int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ struct semid_ds result;
+ if (user_memcpy(&result, args->buf, sizeof(struct
semid_ds))
+ < B_OK) {
+ TRACE_ERROR(("xsi_semctl: user_memcpy
failed\n"));
+ return B_BAD_ADDRESS;
+ }
+ semaphoreSet->DoIpcSet(&result);
+ return 0;
+ }
+
+ case IPC_RMID: {
+ if (!semaphoreSet->HasPermission()) {
+ TRACE_ERROR(("xsi_semctl: calling
process has not "
+ "permission on semaphore %d,
key %d\n",
+ semaphoreSet->ID(),
(int)semaphoreSet->IpcKey()));
+ return EACCES;
+ }
+ MutexLocker _(sIpcLock);
+ key_t key = semaphoreSet->IpcKey();
+ Ipc *ipcKey = sIpcHashTable.Lookup(key);
+ sSemaphoreHashTable.Remove(semaphoreSet);
+ sIpcHashTable.Remove(ipcKey);
+ atomic_add(&sTotalNumberOfXsiSemaphores,
+ semaphoreSet->NumberOfSemaphores());
+ // Wake up of threads waiting on this set
+ // happens in the destructor
+ delete semaphoreSet;
+ delete ipcKey;
+ return 0;
+ }
+
+ default:
+ TRACE_ERROR(("xsi_semctl: command %d not valid\n",
command));
+ return EINVAL;
+ }
+}
+
+
+status_t
+_user_xsi_semop(int semaphoreID, struct sembuf *sops, size_t nsops)
+{
+ XsiSemaphoreSet *semaphoreSet = sSemaphoreHashTable.Lookup(semaphoreID);
+ if (semaphoreSet == NULL) {
+ TRACE_ERROR(("xsi_semop: semaphore set id %d not valid\n",
semaphoreID));
+ return EINVAL;
+ }
+
+ if (!IS_USER_ADDRESS(sops)) {
+ TRACE_ERROR(("xsi_semop: sembuf address is not valid\n"));
+ return B_BAD_ADDRESS;
+ }
+
+ struct sembuf operations[nsops];
+ if (user_memcpy(&operations[0], sops,
+ (sizeof(struct sembuf) * nsops)) < B_OK) {
+ TRACE_ERROR(("xsi_semop: user_memcpy failed\n"));
+ return B_BAD_ADDRESS;
+ }
+
+ /*
+ * We won't do partial request. If we must wait on a
+ * semaphore, we undo all the operations already done
+ * and go to sleep.
+ */
+ bool notDone = true;
+ bool goToSleep = false;
+ status_t result = 0;
+ while (notDone) {
+ XsiSemaphore *semaphore = NULL;
+ short numberOfSemaphores = semaphoreSet->NumberOfSemaphores();
+
+ uint32 i = 0;
+ for (; i < nsops; i++) {
+ short semaphoreNumber = operations[i].sem_num;
+ if (semaphoreNumber >= numberOfSemaphores) {
+ TRACE_ERROR(("xsi_semop: %d invalid semaphore
number\n", i));
+ result = EINVAL;
+ break;
+ }
+ semaphore = semaphoreSet->Semaphore(semaphoreNumber);
+ unsigned short value = semaphore->Value();
+ short operation = operations[i].sem_op;
+ if (operation < 0) {
+ if (semaphore->Add(operation)) {
+ goToSleep = true;
+ break;
+ }
+ } else if (operation == 0) {
+ if (value == 0)
+ continue;
+ else if (operations[i].sem_flg & IPC_NOWAIT) {
+ result = EAGAIN;
+ break;
+ } else {
+ goToSleep = true;
+ break;
+ }
+ } else {
+ // Operation must be greater than zero,
+ // just add the value and continue
+ semaphore->Add(operation);
+ }
+ }
+
+ // Either we have to wait or an error occured
+ if (goToSleep || result != 0) {
+ // Undo all previosly done operations
+ for (int j = 0; j < i; j++) {
+ short semaphoreNumber = operations[j].sem_num;
+ semaphore =
semaphoreSet->Semaphore(semaphoreNumber);
+ short operation = operations[j].sem_op;
+ if (operation != 0)
+ semaphore->Revert(operation);
+ }
+ if (result != 0)
+ return result;
+
+ bool waitOnZero = true;
+ if (operations[i].sem_op != 0)
+ waitOnZero = false;
+
+ result = semaphore->Wait((int32)operations[i].sem_op,
waitOnZero);
+
+ // We are back to life.
+ // Find out why!
+ semaphoreSet = sSemaphoreHashTable.Lookup(semaphoreID);
+ if (semaphoreSet == NULL || result == EIDRM
+ || result == B_INTERRUPTED) {
+ TRACE_ERROR(("xsi_semop: semaphore set id %d
got destroyed\n",
+ semaphoreID));
+ result = EIDRM;
+ notDone = false;
+ }
+ } else
+ // everything worked like a charm
+ notDone = false;
+ // TODO: Handle SEM_UNDO requests
+ }
+ return result;
+}
Index: src/system/kernel/syscalls.cpp
===================================================================
--- src/system/kernel/syscalls.cpp (revision 26439)
+++ src/system/kernel/syscalls.cpp (working copy)
@@ -17,6 +17,7 @@
#include <vm.h>
#include <thread.h>
#include <posix/realtime_sem.h>
+#include <posix/xsi_semaphore.h>
#include <sem.h>
#include <port.h>
#include <cpu.h>
Index: src/system/libroot/posix/sys/ftok.c
===================================================================
--- src/system/libroot/posix/sys/ftok.c (revision 0)
+++ src/system/libroot/posix/sys/ftok.c (revision 0)
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Salvatore Benedetto <salvatore.benedetto@xxxxxxxxx>
+ */
+
+#include <sys/ipc.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+key_t
+ftok(const char *path, int id)
+{
+ struct stat st;
+
+ if (stat(path,&st) < 0)
+ return (key_t)-1;
+
+ return (key_t)(id << 24 | (st.st_dev & 0xff) << 16 | (st.st_ino &
0xffff));
+}
Index: src/system/libroot/posix/sys/xsi_sem.cpp
===================================================================
--- src/system/libroot/posix/sys/xsi_sem.cpp (revision 0)
+++ src/system/libroot/posix/sys/xsi_sem.cpp (revision 0)
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Salvatore Benedetto <salvatore.benedetto@xxxxxxxxx>
+ */
+
+#include <sys/sem.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include <OS.h>
+
+#include <posix/realtime_sem_defs.h>
+#include <syscall_utils.h>
+#include <syscalls.h>
+
+
+/*
+ * For the semctl option argument, the user
+ * should declare explicitly the following union
+ */
+union semun {
+ int val;
+ struct semid_ds *buf;
+ unsigned short *array;
+};
+
+
+int
+semget(key_t key, int num_sems, int sem_flags)
+{
+ RETURN_AND_SET_ERRNO(_kern_xsi_semget(key, num_sems, sem_flags));
+}
+
+
+int
+semctl(int semId, int sem_num, int command, ...)
+{
+ union semun arg;
+ va_list args;
+
+ switch (command) {
+ case GETVAL:
+ case GETPID:
+ case GETNCNT:
+ case GETZCNT:
+ case IPC_RMID:
+ RETURN_AND_SET_ERRNO(_kern_xsi_semctl(semId, sem_num,
command, 0));
+
+ case SETVAL:
+ case GETALL:
+ case SETALL:
+ case IPC_STAT:
+ case IPC_SET:
+ va_start(args, command);
+ arg = va_arg(args, union semun);
+ va_end(args);
+ RETURN_AND_SET_ERRNO(_kern_xsi_semctl(semId, sem_num,
command,
+ &arg));
+ default:
+ return EINVAL;
+ }
+}
+
+
+int
+semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops)
+{
+ RETURN_AND_SET_ERRNO(_kern_xsi_semop(sem_id, sem_ops, num_sem_ops));
+}
Index: src/system/libroot/posix/sys/Jamfile
===================================================================
--- src/system/libroot/posix/sys/Jamfile (revision 26439)
+++ src/system/libroot/posix/sys/Jamfile (working copy)
@@ -7,6 +7,7 @@
chmod.c
flock.c
ftime.c
+ ftok.c
getrusage.c
gettimeofday.c
itimer.c
@@ -23,4 +24,5 @@
uname.c
utimes.c
wait.c
+ xsi_sem.cpp
;
Index: headers/posix/sys/ipc.h
===================================================================
--- headers/posix/sys/ipc.h (revision 26439)
+++ headers/posix/sys/ipc.h (working copy)
@@ -6,8 +6,8 @@
#define _SYS_IPC_H
+#include <sys/cdefs.h>
#include <sys/types.h>
-#error functionality has not yet been implemented
/* Mode bits for msgget(), semget(), and shmget() */
@@ -17,15 +17,15 @@
/* Control commands for msgctl(), semctl(), and shmctl() */
#define IPC_RMID 0 /* remove identifier */
-#define IPC_SET 1
-#define IPC_STAT 2
+#define IPC_SET 1 /* set options */
+#define IPC_STAT 2 /* get options */
/* Private key */
-#define IPC_PRIVATE 0
+#define IPC_PRIVATE (key_t)0
struct ipc_perm {
- key_t key;
+ key_t key; /* IPC identifier */
uid_t uid; /* owner's user ID */
gid_t gid; /* owner's group ID */
uid_t cuid; /* creator's user ID */
@@ -34,14 +34,10 @@
};
-#ifdef __cplusplus
-extern "C" {
-#endif
+__BEGIN_DECLS
key_t ftok(const char *path, int id);
-#ifdef __cplusplus
-}
-#endif
+__END_DECLS
#endif /* _SYS_IPC_H */
Index: headers/posix/sys/sem.h
===================================================================
--- headers/posix/sys/sem.h (revision 0)
+++ headers/posix/sys/sem.h (revision 0)
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2008, Haiku Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _SYS_SEM_H
+#define _SYS_SEM_H
+
+#include <sys/cdefs.h>
+#include <sys/ipc.h>
+#include <sys/types.h>
+
+
+/* Semaphore operation flags */
+#define SEM_UNDO 10
+
+/* Command definition for semctl */
+#define GETPID 3 /* Get process ID of last element
manipulating */
+#define GETVAL 4 /* Get semval */
+#define GETALL 5 /* Get all semval */
+#define GETNCNT 6 /* Get semncnt */
+#define GETZCNT 7 /* Get semzcnt */
+#define SETVAL 8 /* Set semval */
+#define SETALL 9 /* Set all semval */
+
+struct semid_ds {
+ struct ipc_perm sem_perm; /* Operation permission
structure */
+ unsigned short sem_nsems; /* Number of semaphores in set
*/
+ time_t sem_otime; /* Last semop */
+ time_t sem_ctime; /* Last time changed by
semctl */
+};
+
+/* Structure passed as parameter to the semop function */
+struct sembuf {
+ unsigned short sem_num; /* Semaphore number */
+ short sem_op; /* Semaphore operation */
+ short sem_flg; /* Operation flags */
+};
+
+/*
+ * Semaphore info structure. Useful for the ipcs
+ * standard utily
+ */
+struct seminfo {
+ int semmni; /* Number of semaphore identifies */
+ int semmns; /* Number of semaphore in system */
+ int semmnu; /* Number of undo structures in system */
+ int semmsl; /* Max number of semaphores per id */
+ int semopm; /* Max number of operations per semop call */
+ int semume; /* Max number of undo entries per process */
+ int semusz; /* Size in bytes of undo structure */
+ int semvmx; /* Semaphore maximum valure */
+ int semaem; /* adjust on exit max value */
+};
+
+
+__BEGIN_DECLS
+
+int semctl(int sem_id, int sem_num, int command, ...);
+int semget(key_t key, int num_sems, int sem_flags);
+int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);
+
+__END_DECLS
+
+
+#endif /* _SYS_SEM_H */
Index: headers/private/kernel/posix/xsi_semaphore.h
===================================================================
--- headers/private/kernel/posix/xsi_semaphore.h (revision 0)
+++ headers/private/kernel/posix/xsi_semaphore.h (revision 0)
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef KERNEL_XSI_H
+#define KERNEL_XSI_H
+
+#include <sys/sem.h>
+#include <sys/cdefs.h>
+
+#include <OS.h>
+
+
+union semun {
+ int val;
+ struct semid_ds *buf;
+ unsigned short *array;
+};
+
+__BEGIN_DECLS
+
+extern void xsi_ipc_init();
+
+/* user calls */
+int _user_xsi_semget(key_t key, int numberOfSemaphores, int flags);
+int _user_xsi_semctl(int semaphoreID, int semaphoreNumber, int command,
+ union semun* args);
+status_t _user_xsi_semop(int semaphoreID, struct sembuf *sops, size_t nsops);
+
+__END_DECLS
+
+#endif /* KERNEL_XSI_H */
Index: headers/private/system/syscalls.h
===================================================================
--- headers/private/system/syscalls.h (revision 26439)
+++ headers/private/system/syscalls.h (working copy)
@@ -27,6 +27,7 @@
struct net_stat;
struct pollfd;
struct rlimit;
+struct sembuf;
struct sigaction;
struct stat;
struct _sem_t;
@@ -38,6 +39,8 @@
struct user_disk_device_job_info;
struct user_disk_system_info;
+union semun;
+
// This marks the beginning of the syscalls prototypes for gensyscallinfos.
// NOTE:
// * Nothing but those prototypes may live here.
@@ -89,6 +92,14 @@
extern status_t _kern_realtime_sem_post(sem_id semID);
extern status_t _kern_realtime_sem_wait(sem_id semID, bigtime_t
timeout);
+/* POSIX XSI sem syscalls */
+extern int _kern_xsi_semget(key_t key, int
numberOfSemaphores,
+ int flags);
+extern int _kern_xsi_semctl(int semaphoreID, int
semaphoreNumber,
+ int command, union semun* args);
+extern status_t _kern_xsi_semop(int semaphoreID, struct sembuf
*sops,
+ size_t nsops);
+
/* team & thread syscalls */
extern thread_id _kern_load_image(const char* const* flatArgs,
Other related posts:
