Added BochsGA to build

[tpg/acess2.git] / Kernel / drv / fifo.c

diff --git a/Kernel/drv/fifo.c b/Kernel/drv/fifo.c
index cbbd107..b27c678 100644 (file)
--- a/Kernel/drv/fifo.c
+++ b/Kernel/drv/fifo.c
@@ -4,6 +4,7 @@
 #include <acess.h>
 #include <modules.h>
 #include <fs_devfs.h>
+#include <semaphore.h>
 
 // === CONSTANTS ===
 #define DEFAULT_RING_SIZE      2048
@@ -31,7 +32,7 @@ void  FIFO_Close(tVFS_Node *Node);
  int   FIFO_Relink(tVFS_Node *Node, const char *OldName, const char *NewName);
 Uint64 FIFO_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
 Uint64 FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
-tPipe  *FIFO_Int_NewPipe(int Size, char *Name);
+tPipe  *FIFO_Int_NewPipe(int Size, const char *Name);
 
 // === GLOBALS ===
 MODULE_DEFINE(0, 0x0032, FIFO, FIFO_Install, NULL, NULL);
@@ -218,28 +219,37 @@ Uint64 FIFO_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
        while(remaining)
        {
                // Wait for buffer to fill
-               if(pipe->Flags & PF_BLOCKING) {
-                       while(pipe->ReadPos == pipe->WritePos) {
-                               Threads_Yield();
-                               //MAGIC_BREAK();
-                       }
+               if(pipe->Flags & PF_BLOCKING)
+               {
+                       #if 0
+                       len = Semaphore_Wait( &pipe->Semaphore, remaining );
+                       #else
+                       VFS_SelectNode(Node, VFS_SELECT_READ, NULL, "FIFO_Read");
+                       // Read buffer
+                       // TODO: Rethink this, it might not work on buffer overflow
+                       if(pipe->WritePos - pipe->ReadPos < remaining)
+                               len = pipe->WritePos - pipe->ReadPos;
+                       else
+                               len = remaining;
+                       #endif
                }
                else
+               {
                        if(pipe->ReadPos == pipe->WritePos)
                                return 0;
-               
-               // Read buffer
-               if(pipe->WritePos - pipe->ReadPos < remaining)
-                       len = pipe->WritePos - pipe->ReadPos;
-               else
-                       len = remaining;
+                       // Read buffer
+                       if(pipe->WritePos - pipe->ReadPos < remaining)
+                               len = pipe->WritePos - pipe->ReadPos;
+                       else
+                               len = remaining;
+               }
                
                // Check if read overflows buffer
                if(len > pipe->BufSize - pipe->ReadPos)
                {
                        int ofs = pipe->BufSize - pipe->ReadPos;
                        memcpy(Buffer, &pipe->Buffer[pipe->ReadPos], ofs);
-                       memcpy(Buffer + ofs, &pipe->Buffer, len-ofs);
+                       memcpy((Uint8*)Buffer + ofs, &pipe->Buffer, len-ofs);
                }
                else
                {
@@ -250,10 +260,16 @@ Uint64 FIFO_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
                pipe->ReadPos += len;
                pipe->ReadPos %= pipe->BufSize;
                
+               // Mark some flags
+               if( pipe->ReadPos == pipe->WritePos ) {
+                       VFS_MarkAvaliable(Node, 0);
+               }
+               VFS_MarkFull(Node, 0);  // Buffer can't still be full
+               
                // Decrement Remaining Bytes
                remaining -= len;
                // Increment Buffer address
-               Buffer += len;
+               Buffer = (Uint8*)Buffer + len;
        }
 
        return Length;
@@ -275,25 +291,34 @@ Uint64 FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
        while(remaining)
        {
                // Wait for buffer to empty
-               if(pipe->Flags & PF_BLOCKING)
-                       while(pipe->ReadPos == (pipe->WritePos+1)%pipe->BufSize)
-                               Threads_Yield();
+               if(pipe->Flags & PF_BLOCKING) {
+                       #if 0
+                       len = Semaphore_Signal( &pipe->Semaphore, remaining );
+                       #else
+                       VFS_SelectNode(Node, VFS_SELECT_WRITE, NULL, "FIFO_Write");
+                       if(pipe->ReadPos - pipe->WritePos < remaining)
+                               len = pipe->ReadPos - pipe->WritePos;
+                       else
+                               len = remaining;
+                       #endif
+               }
                else
+               {
                        if(pipe->ReadPos == (pipe->WritePos+1)%pipe->BufSize)
                                return 0;
-               
-               // Write buffer
-               if(pipe->ReadPos - pipe->WritePos < remaining)
-                       len = pipe->ReadPos - pipe->WritePos;
-               else
-                       len = remaining;
+                       // Write buffer
+                       if(pipe->ReadPos - pipe->WritePos < remaining)
+                               len = pipe->ReadPos - pipe->WritePos;
+                       else
+                               len = remaining;
+               }
                
                // Check if write overflows buffer
                if(len > pipe->BufSize - pipe->WritePos)
                {
                        int ofs = pipe->BufSize - pipe->WritePos;
                        memcpy(&pipe->Buffer[pipe->WritePos], Buffer, ofs);
-                       memcpy(&pipe->Buffer, Buffer + ofs, len-ofs);
+                       memcpy(&pipe->Buffer, (Uint8*)Buffer + ofs, len-ofs);
                }
                else
                {
@@ -304,10 +329,16 @@ Uint64 FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
                pipe->WritePos += len;
                pipe->WritePos %= pipe->BufSize;
                
+               // Mark some flags
+               if( pipe->ReadPos == pipe->WritePos ) {
+                       VFS_MarkFull(Node, 1);  // Buffer full
+               }
+               VFS_MarkAvaliable(Node, 1);
+               
                // Decrement Remaining Bytes
                remaining -= len;
                // Increment Buffer address
-               Buffer += len;
+               Buffer = (Uint8*)Buffer + len;
        }
 
        return Length;
@@ -315,30 +346,31 @@ Uint64 FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 
 // --- HELPERS ---
 /**
- * \fn tPipe *FIFO_Int_NewPipe(int Size, char *Name)
+ * \fn tPipe *FIFO_Int_NewPipe(int Size, const char *Name)
  * \brief Create a new pipe
  */
-tPipe *FIFO_Int_NewPipe(int Size, char *Name)
+tPipe *FIFO_Int_NewPipe(int Size, const char *Name)
 {
        tPipe   *ret;
-        int    allocsize = sizeof(tPipe) + sizeof(tVFS_ACL) + Size;
+        int    namelen = strlen(Name) + 1;
+        int    allocsize = sizeof(tPipe) + sizeof(tVFS_ACL) + Size + namelen;
        
        ret = malloc(allocsize);
        if(!ret)        return NULL;
        
        // Clear Return
        memset(ret, 0, allocsize);
-       
-       ret->Name = Name;
        ret->Flags = PF_BLOCKING;
        
        // Allocate Buffer
        ret->BufSize = Size;
        ret->Buffer = (void*)( (Uint)ret + sizeof(tPipe) + sizeof(tVFS_ACL) );
-       if(!ret->Buffer) {
-               free(ret);
-               return NULL;
-       }
+       
+       // Set name (and FIFO name)
+       ret->Name = ret->Buffer + Size;
+       strcpy(ret->Name, Name);
+       // - Start empty, max of `Size`
+       //Semaphore_Init( &ret->Semaphore, 0, Size, "FIFO", ret->Name );
        
        // Set Node
        ret->Node.Size = 0;