Modules/USB - Slight commenting updates in HID
[tpg/acess2.git] / KernelLand / Kernel / drv / fifo.c
1 /* AcessOS
2  * FIFO Pipe Driver
3  */
4 #define DEBUG   0
5 #include <acess.h>
6 #include <modules.h>
7 #include <fs_devfs.h>
8 #include <semaphore.h>
9
10 // === CONSTANTS ===
11 #define DEFAULT_RING_SIZE       2048
12 #define PF_BLOCKING             1
13
14 // === TYPES ===
15 typedef struct sPipe {
16         struct sPipe    *Next;
17         char    *Name;
18         tVFS_Node       Node;
19         Uint    Flags;
20          int    ReadPos;
21          int    WritePos;
22          int    BufSize;
23         char    *Buffer;
24 } tPipe;
25
26 // === PROTOTYPES ===
27  int    FIFO_Install(char **Arguments);
28  int    FIFO_IOCtl(tVFS_Node *Node, int Id, void *Data);
29 char    *FIFO_ReadDir(tVFS_Node *Node, int Id);
30 tVFS_Node       *FIFO_FindDir(tVFS_Node *Node, const char *Filename);
31  int    FIFO_MkNod(tVFS_Node *Node, const char *Name, Uint Flags);
32 void    FIFO_Reference(tVFS_Node *Node);
33 void    FIFO_Close(tVFS_Node *Node);
34  int    FIFO_Relink(tVFS_Node *Node, const char *OldName, const char *NewName);
35 Uint64  FIFO_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
36 Uint64  FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, const void *Buffer);
37 tPipe   *FIFO_Int_NewPipe(int Size, const char *Name);
38
39 // === GLOBALS ===
40 MODULE_DEFINE(0, 0x0032, FIFO, FIFO_Install, NULL, NULL);
41 tVFS_NodeType   gFIFO_DirNodeType = {
42         .TypeName = "FIFO Dir Node",
43         .ReadDir = FIFO_ReadDir,
44         .FindDir = FIFO_FindDir,
45         .MkNod = FIFO_MkNod,
46         .Relink = FIFO_Relink,
47         .IOCtl = FIFO_IOCtl
48 };
49 tVFS_NodeType   gFIFO_PipeNodeType = {
50         .TypeName = "FIFO Pipe Node",
51         .Read = FIFO_Read,
52         .Write = FIFO_Write,
53         .Close = FIFO_Close,
54         .Reference = FIFO_Reference
55 };
56 tDevFS_Driver   gFIFO_DriverInfo = {
57         NULL, "fifo",
58         {
59         .Size = 1,
60         .NumACLs = 1,
61         .ACLs = &gVFS_ACL_EveryoneRW,
62         .Flags = VFS_FFLAG_DIRECTORY,
63         .Type = &gFIFO_DirNodeType
64         }
65 };
66 tVFS_Node       gFIFO_AnonNode = {
67         .NumACLs = 1,
68         .ACLs = &gVFS_ACL_EveryoneRW,
69         };
70 tPipe   *gFIFO_NamedPipes = NULL;
71
72 // === CODE ===
73 /**
74  * \fn int FIFO_Install(char **Options)
75  * \brief Installs the FIFO Driver
76  */
77 int FIFO_Install(char **Options)
78 {
79         DevFS_AddDevice( &gFIFO_DriverInfo );
80         return MODULE_ERR_OK;
81 }
82
83 /**
84  * \fn int FIFO_IOCtl(tVFS_Node *Node, int Id, void *Data)
85  */
86 int FIFO_IOCtl(tVFS_Node *Node, int Id, void *Data)
87 {
88         return 0;
89 }
90
91 /**
92  * \fn char *FIFO_ReadDir(tVFS_Node *Node, int Id)
93  * \brief Reads from the FIFO root
94  */
95 char *FIFO_ReadDir(tVFS_Node *Node, int Id)
96 {
97         tPipe   *tmp = gFIFO_NamedPipes;
98         
99         // Entry 0 is Anon Pipes
100         if(Id == 0)     return strdup("anon");
101         
102         // Find the id'th node
103         while(--Id && tmp)      tmp = tmp->Next;
104         // If node found, return it
105         if(tmp) return strdup(tmp->Name);
106         // else error return
107         return NULL;
108 }
109
110 /**
111  * \fn tVFS_Node *FIFO_FindDir(tVFS_Node *Node, const char *Filename)
112  * \brief Find a file in the FIFO root
113  * \note Creates an anon pipe if anon is requested
114  */
115 tVFS_Node *FIFO_FindDir(tVFS_Node *Node, const char *Filename)
116 {
117         tPipe   *tmp;
118         if(!Filename)   return NULL;
119         
120         // NULL String Check
121         if(Filename[0] == '\0') return NULL;
122         
123         // Anon Pipe
124         if(Filename[0] == 'a' && Filename[1] == 'n'
125         && Filename[2] == 'o' && Filename[3] == 'n'
126         && Filename[4] == '\0') {
127                 tmp = FIFO_Int_NewPipe(DEFAULT_RING_SIZE, "anon");
128                 return &tmp->Node;
129         }
130         
131         // Check Named List
132         tmp = gFIFO_NamedPipes;
133         while(tmp)
134         {
135                 if(strcmp(tmp->Name, Filename) == 0)
136                         return &tmp->Node;
137                 tmp = tmp->Next;
138         }
139         return NULL;
140 }
141
142 /**
143  * \fn int FIFO_MkNod(tVFS_Node *Node, const char *Name, Uint Flags)
144  */
145 int FIFO_MkNod(tVFS_Node *Node, const char *Name, Uint Flags)
146 {
147         return 0;
148 }
149
150 void FIFO_Reference(tVFS_Node *Node)
151 {
152         if(!Node->ImplPtr)      return ;
153         
154         Node->ReferenceCount ++;
155 }
156
157 /**
158  * \fn void FIFO_Close(tVFS_Node *Node)
159  * \brief Close a FIFO end
160  */
161 void FIFO_Close(tVFS_Node *Node)
162 {
163         tPipe   *pipe;
164         if(!Node->ImplPtr)      return ;
165         
166         Node->ReferenceCount --;
167         if(Node->ReferenceCount)        return ;
168         
169         pipe = Node->ImplPtr;
170         
171         if(strcmp(pipe->Name, "anon") == 0) {
172                 Log_Debug("FIFO", "Pipe %p closed", Node->ImplPtr);
173                 free(Node->ImplPtr);
174                 return ;
175         }
176         
177         return ;
178 }
179
180 /**
181  * \fn int FIFO_Relink(tVFS_Node *Node, const char *OldName, const char *NewName)
182  * \brief Relink a file (Deletes named pipes)
183  */
184 int FIFO_Relink(tVFS_Node *Node, const char *OldName, const char *NewName)
185 {
186         tPipe   *pipe, *tmp;
187         
188         if(Node != &gFIFO_DriverInfo.RootNode)  return 0;
189         
190         // Can't relink anon
191         if(strcmp(OldName, "anon"))     return 0;
192         
193         // Find node
194         for(pipe = gFIFO_NamedPipes;
195                 pipe;
196                 pipe = pipe->Next)
197         {
198                 if(strcmp(pipe->Name, OldName) == 0)
199                         break;
200         }
201         if(!pipe)       return 0;
202         
203         // Relink a named pipe
204         if(NewName) {
205                 // Check new name
206                 for(tmp = gFIFO_NamedPipes;
207                         tmp;
208                         tmp = tmp->Next)
209                 {
210                         if(strcmp(tmp->Name, NewName) == 0)     return 0;
211                 }
212                 // Create new name
213                 free(pipe->Name);
214                 pipe->Name = malloc(strlen(NewName)+1);
215                 strcpy(pipe->Name, NewName);
216                 return 1;
217         }
218         
219         // Unlink the pipe
220         if(Node->ImplPtr) {
221                 free(Node->ImplPtr);
222                 return 1;
223         }
224         
225         return 0;
226 }
227
228 /**
229  * \fn Uint64 FIFO_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
230  * \brief Read from a fifo pipe
231  */
232 Uint64 FIFO_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
233 {
234         tPipe   *pipe = Node->ImplPtr;
235         Uint    len;
236         Uint    remaining = Length;
237
238         if(!pipe)       return 0;
239         
240         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
241         
242         while(remaining)
243         {
244                 // Wait for buffer to fill
245                 if(pipe->Flags & PF_BLOCKING)
246                 {
247                         if( pipe->ReadPos == pipe->WritePos )
248                                 VFS_SelectNode(Node, VFS_SELECT_READ, NULL, "FIFO_Read");
249                         
250                 }
251                 else
252                 {
253                         if(pipe->ReadPos == pipe->WritePos)
254                         {
255                                 VFS_MarkAvaliable(Node, 0);
256                                 LEAVE('i', 0);
257                                 return 0;
258                         }
259                 }
260         
261                 len = remaining;
262                 if( pipe->ReadPos < pipe->WritePos )
263                 {
264                          int    avail_bytes = pipe->WritePos - pipe->ReadPos;
265                         if( avail_bytes < remaining )   len = avail_bytes;
266                 }
267                 else
268                 {
269                          int    avail_bytes = pipe->WritePos + pipe->BufSize - pipe->ReadPos;
270                         if( avail_bytes < remaining )   len = avail_bytes;
271                 }
272
273                 LOG("len = %i, remaining = %i", len, remaining);                
274
275                 // Check if read overflows buffer
276                 if(len > pipe->BufSize - pipe->ReadPos)
277                 {
278                         int ofs = pipe->BufSize - pipe->ReadPos;
279                         memcpy(Buffer, &pipe->Buffer[pipe->ReadPos], ofs);
280                         memcpy((Uint8*)Buffer + ofs, &pipe->Buffer, len-ofs);
281                 }
282                 else
283                 {
284                         memcpy(Buffer, &pipe->Buffer[pipe->ReadPos], len);
285                 }
286                 
287                 // Increment read position
288                 pipe->ReadPos += len;
289                 pipe->ReadPos %= pipe->BufSize;
290                 
291                 // Mark some flags
292                 if( pipe->ReadPos == pipe->WritePos ) {
293                         VFS_MarkAvaliable(Node, 0);
294                 }
295                 VFS_MarkFull(Node, 0);  // Buffer can't still be full
296                 
297                 // Decrement Remaining Bytes
298                 remaining -= len;
299                 // Increment Buffer address
300                 Buffer = (Uint8*)Buffer + len;
301                 
302                 // TODO: Option to read differently
303                 LEAVE('i', len);
304                 return len;
305         }
306
307         LEAVE('i', Length);
308         return Length;
309
310 }
311
312 /**
313  * \fn Uint64 FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
314  * \brief Write to a fifo pipe
315  */
316 Uint64 FIFO_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, const void *Buffer)
317 {
318         tPipe   *pipe = Node->ImplPtr;
319         Uint    len;
320         Uint    remaining = Length;
321         
322         if(!pipe)       return 0;
323
324         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
325         
326         while(remaining)
327         {
328                 // Wait for buffer to empty
329                 if(pipe->Flags & PF_BLOCKING) {
330                         if( pipe->ReadPos == (pipe->WritePos+1)%pipe->BufSize )
331                                 VFS_SelectNode(Node, VFS_SELECT_WRITE, NULL, "FIFO_Write");
332
333                         len = remaining;
334                         if( pipe->ReadPos > pipe->WritePos )
335                         {
336                                  int    rem_space = pipe->ReadPos - pipe->WritePos;
337                                 if(rem_space < remaining)       len = rem_space;
338                         }
339                         else
340                         {
341                                  int    rem_space = pipe->ReadPos + pipe->BufSize - pipe->WritePos;
342                                 if(rem_space < remaining)       len = rem_space;
343                         }
344                 }
345                 else
346                 {
347                         if(pipe->ReadPos == (pipe->WritePos+1)%pipe->BufSize)
348                         {
349                                 LEAVE('i', 0);
350                                 return 0;
351                         }
352                         // Write buffer
353                         if(pipe->ReadPos - pipe->WritePos < remaining)
354                                 len = pipe->ReadPos - pipe->WritePos;
355                         else
356                                 len = remaining;
357                 }
358                 
359                 // Check if write overflows buffer
360                 if(len > pipe->BufSize - pipe->WritePos)
361                 {
362                         int ofs = pipe->BufSize - pipe->WritePos;
363                         memcpy(&pipe->Buffer[pipe->WritePos], Buffer, ofs);
364                         memcpy(&pipe->Buffer, (Uint8*)Buffer + ofs, len-ofs);
365                 }
366                 else
367                 {
368                         memcpy(&pipe->Buffer[pipe->WritePos], Buffer, len);
369                 }
370                 
371                 // Increment read position
372                 pipe->WritePos += len;
373                 pipe->WritePos %= pipe->BufSize;
374                 
375                 // Mark some flags
376                 if( pipe->ReadPos == pipe->WritePos ) {
377                         VFS_MarkFull(Node, 1);  // Buffer full
378                 }
379                 VFS_MarkAvaliable(Node, 1);
380                 
381                 // Decrement Remaining Bytes
382                 remaining -= len;
383                 // Increment Buffer address
384                 Buffer = (Uint8*)Buffer + len;
385         }
386
387         LEAVE('i', Length);
388         return Length;
389 }
390
391 // --- HELPERS ---
392 /**
393  * \fn tPipe *FIFO_Int_NewPipe(int Size, const char *Name)
394  * \brief Create a new pipe
395  */
396 tPipe *FIFO_Int_NewPipe(int Size, const char *Name)
397 {
398         tPipe   *ret;
399          int    namelen = strlen(Name) + 1;
400          int    allocsize = sizeof(tPipe) + sizeof(tVFS_ACL) + Size + namelen;
401         
402         ret = calloc(1, allocsize);
403         if(!ret)        return NULL;
404         
405         // Clear Return
406         ret->Flags = PF_BLOCKING;
407         
408         // Allocate Buffer
409         ret->BufSize = Size;
410         ret->Buffer = (void*)( (Uint)ret + sizeof(tPipe) + sizeof(tVFS_ACL) );
411         
412         // Set name (and FIFO name)
413         ret->Name = ret->Buffer + Size;
414         strcpy(ret->Name, Name);
415         // - Start empty, max of `Size`
416         //Semaphore_Init( &ret->Semaphore, 0, Size, "FIFO", ret->Name );
417         
418         // Set Node
419         ret->Node.ReferenceCount = 1;
420         ret->Node.Size = 0;
421         ret->Node.ImplPtr = ret;
422         ret->Node.UID = Threads_GetUID();
423         ret->Node.GID = Threads_GetGID();
424         ret->Node.NumACLs = 1;
425         ret->Node.ACLs = (void*)( (Uint)ret + sizeof(tPipe) );
426                 ret->Node.ACLs->Group = 0;
427                 ret->Node.ACLs->ID = ret->Node.UID;
428                 ret->Node.ACLs->Inv = 0;
429                 ret->Node.ACLs->Perms = -1;
430         ret->Node.CTime
431                 = ret->Node.MTime
432                 = ret->Node.ATime = now();
433         ret->Node.Type = &gFIFO_PipeNodeType;
434         
435         return ret;
436 }

UCC git Repository :: git.ucc.asn.au