Kernel: Deallocate memory in RingBuffer on destruction, more changes to

how messages are stored. Delete unused scripts

Kernel/include/objects/message.h

@@ -81,7 +81,11 @@ class MessageEndpoint final : public KernelObject{
 
     void Watch(KernelObjectWatcher& watcher, int events){
         acquireLock(&waitingLock);
-        waiting.add_back(&watcher);
+        if(queue.Empty()){
+            waiting.add_back(&watcher);
+        } else {
+            watcher.Signal();
+        }
         releaseLock(&waitingLock)
     }
 
@@ -101,14 +105,27 @@ class MessageEndpoint final : public KernelObject{
         uint8_t** buffer;
     };
 
+    struct Message{
+        uint64_t id;
+        uint16_t size;
+        uint8_t data[];
+    };
+
+    inline Message* AllocateMessage(){
+        void* m = kmalloc(sizeof(Message) + maxMessageSize);
+
+        return reinterpret_cast<Message*>(m);
+    }
+
     friend Pair<FancyRefPtr<MessageEndpoint>,FancyRefPtr<MessageEndpoint>> CreatePair();
     uint16_t maxMessageSize = 8;
     uint16_t messageQueueLimit = 128;
     lock_t queueLock = 0;
 
     Semaphore queueAvailablilitySemaphore = Semaphore(messageQueueLimit);
 
-    RawRingBuffer queue;
+    RingBuffer<Message*> queue;
+    RingBuffer<Message*> cache;
 
     FancyRefPtr<MessageEndpoint> peer;
 

Kernel/include/ringbuffer.h

@@ -26,18 +26,23 @@ class RingBuffer{
         dequeuePointer = buffer;
     }
 
-    void Enqueue(const T* data){
+    virtual ~RingBuffer(){
+        delete buffer;
+    }
+
+    void Enqueue(const T& data){
         acquireLock(&enqueueLock);
         acquireLock(&dequeueLock);
 
-        memcpy(enqueuePointer++, data, sizeof(T));
+        *enqueuePointer++ = data;
 
         if(enqueuePointer >= bufferEnd){
-            enqueuePointer = buffer;
+            enqueuePointer = buffer; // Wrap around to start
         }
 
         if(enqueuePointer == dequeuePointer){
             Resize((bufferSize + 2) << 1);
+            // If after increasing the enqueue pointer it is equal to dequeue pointer then the queue is full
         }
 
         releaseLock(&enqueueLock);
@@ -57,14 +62,12 @@ class RingBuffer{
             if(buffer + wrappedCount >= dequeuePointer){
                 Resize((bufferSize << 1) + count); // Ring buffer is full
             }
+
+            memcpy(buffer, data + contiguousCount, sizeof(T) * wrappedCount);
         } 
 
         memcpy(enqueuePointer, data, sizeof(T) * contiguousCount);
 
-        if(wrappedCount > 0){
-            memcpy(buffer, data + contiguousCount, sizeof(T) * wrappedCount);
-        }
-
         size += count;
         enqueuePointer = buffer + ((enqueuePointer + count - buffer) % bufferSize); // Calculate new enqueuePointer
     }
@@ -116,6 +119,24 @@ class RingBuffer{
         return contiguous + wrapped;
     }
 
+    int Dequeue(T& data){
+        acquireLock(&dequeueLock);
+
+        if(dequeuePointer == enqueuePointer){
+            releaseLock(&dequeueLock);
+            return 0;
+        }
+
+        data = *dequeuePointer++;
+
+        if(dequeuePointer >= bufferEnd){
+            dequeuePointer = buffer;
+        }
+
+        releaseLock(&dequeueLock);
+        return 1;
+    }
+
     void Drain() {
         acquireLock(&enqueueLock);
         acquireLock(&dequeueLock);
@@ -162,13 +183,15 @@ class RingBuffer{
         bufferEnd = &buffer[bufferSize];
 
         memcpy(bufferEnd - (oldBufferEnd - dequeuePointer), dequeuePointer, (oldBufferEnd - dequeuePointer) * sizeof(T));
+        dequeuePointer = bufferEnd - (oldBufferEnd - dequeuePointer);
+
         if(dequeuePointer > enqueuePointer){
             memcpy(buffer, oldBuffer, (enqueuePointer - oldBuffer) * sizeof(T));
+            enqueuePointer = buffer + (enqueuePointer - oldBuffer);
+        } else {
+            enqueuePointer = bufferEnd - (oldBufferEnd - enqueuePointer);
         }
 
-        dequeuePointer = bufferEnd - (oldBufferEnd - dequeuePointer);
-        enqueuePointer = buffer + (enqueuePointer - oldBuffer);
-
         kfree(oldBuffer);
     }
 

Kernel/src/arch/x86_64/syscalls.cpp

@@ -805,10 +805,12 @@ long SysGetVideoMode(RegisterContext* r){
 }
 
 long SysUName(RegisterContext* r){
-	char* str = (char*)SC_ARG0(r);
-	strcpy(str, Lemon::versionString);
+	if(Memory::CheckUsermodePointer(SC_ARG0(r), strlen(Lemon::versionString), Scheduler::GetCurrentProcess()->addressSpace)) {
+		strcpy((char*) SC_ARG0(r), Lemon::versionString);
+		return 0;
+	}
 
-	return 0;
+	return -EFAULT;
 }
 
 long SysReadDir(RegisterContext* r){

Kernel/src/objects/message.cpp

@@ -44,23 +44,16 @@ int64_t MessageEndpoint::Read(uint64_t* id, uint16_t* size, uint8_t* data){
 
     acquireLock(&queueLock);
 
-    queue.Dequeue(reinterpret_cast<uint8_t*>(id), sizeof(uint64_t));
-    queue.Dequeue(reinterpret_cast<uint8_t*>(size), sizeof(uint16_t));
+    Message* m;
+    if(queue.Dequeue(m) <= 0){
+        return 0;
+    }
 
-    if(*size){
-        size_t read = queue.Dequeue(data, *size);
-        if(read < *size){
-            Log::Warning("[MessageEndpoint] Draining message queue (expected %u bytes, only got %u) (id: %u size:, %hu)!", *size, read, *id, *size);
-            queue.Drain(); // Not all data has been written, drain the buffer
+    memcpy(data, m->data, m->size);
+    *size = m->size;
+    *id = m->id;
 
-            releaseLock(&queueLock);
-
-            if(!peer.get()){
-                return -ENOTCONN;
-            }
-            return 0;
-        }
-    }
+    cache.Enqueue(m);
 
     releaseLock(&queueLock);
 
@@ -154,12 +147,22 @@ int64_t MessageEndpoint::Write(uint64_t id, uint16_t size, uint64_t data){
     }
 
     acquireLock(&peer->queueLock);
-    if(size) {
-        peer->queue.EnqueueObjects(id, size, Pair((uint8_t*)data, size));
+
+    Message* m;
+    if(peer->cache.Dequeue(m)){ // Check for a cached message allocaiton
+        m->size = size;
+        m->id = id;
+        memcpy(m->data, (uint8_t*)data, size);
     } else {
-        peer->queue.EnqueueObjects(id, size);
+        m = AllocateMessage(); // Nothing left in cache, allocate a new message
+
+        m->size = size;
+        m->id = id;
+        memcpy(m->data, (uint8_t*)data, size);
     }
 
+    peer->queue.Enqueue(m);
+
     acquireLock(&peer->waitingLock);
     while(peer->waiting.get_length() > 0){
         peer->waiting.remove_at(0)->Signal();