3 * - By thePowersGang (John Hodge)
6 * - Implements the select() system call (and supporting code)
8 * TODO: Remove malloc for read/write queues
15 #include <semaphore.h>
21 #define NUM_THREADS_PER_ALLOC 4
24 typedef struct sVFS_SelectListEnt tVFS_SelectListEnt;
27 struct sVFS_SelectListEnt
29 tVFS_SelectListEnt *Next;
30 tThread *Threads[NUM_THREADS_PER_ALLOC];
33 // NOTE: Typedef is in vfs.h
34 struct sVFS_SelectList
37 tVFS_SelectListEnt FirstEnt;
41 // int VFS_SelectNode(tVFS_Node *Node, enum eVFS_SelectTypes Type, tTime *Timeout);
42 // int VFS_Select(int MaxHandle, fd_set *ReadHandles, fd_set *WriteHandles, fd_set *ErrHandles, tTime *Timeout, Uint32 ExtraEvents, BOOL IsKernel);
43 // int VFS_MarkFull(tVFS_Node *Node, BOOL IsBufferFull);
44 // int VFS_MarkAvaliable(tVFS_Node *Node, BOOL IsDataAvaliable);
45 // int VFS_MarkError(tVFS_Node *Node, BOOL IsErrorState);
46 int VFS_int_Select_GetType(int Type, tVFS_Node *Node, tVFS_SelectList ***List, int **Flag, int *WantedFlag, int *MaxAllowed);
47 int VFS_int_Select_Register(tThread *Thread, int MaxHandle, fd_set *Handles, int Type, BOOL IsKernel);
48 int VFS_int_Select_Deregister(tThread *Thread, int MaxHandle, fd_set *Handles, int Type, BOOL IsKernel);
49 int VFS_int_Select_AddThread(tVFS_SelectList *List, tThread *Thread, int MaxAllowed);
50 void VFS_int_Select_RemThread(tVFS_SelectList *List, tThread *Thread);
51 void VFS_int_Select_SignalAll(tVFS_SelectList *List);
56 int VFS_SelectNode(tVFS_Node *Node, int TypeFlags, tTime *Timeout, const char *Name)
58 tThread *thisthread = Proc_GetCurThread();
61 ENTER("pNode iTypeFlags pTimeout sName", Node, TypeFlags, Timeout, Name);
64 for( type = 0; type < 3; type ++ )
66 tVFS_SelectList **list;
67 int *flag, wanted, maxAllowed;
68 if( !(TypeFlags & (1 << type)) ) continue;
69 if( VFS_int_Select_GetType(type, Node, &list, &flag, &wanted, &maxAllowed) ) {
75 if( !*list ) *list = calloc(1, sizeof(tVFS_SelectList));
77 VFS_int_Select_AddThread(*list, thisthread, maxAllowed);
80 VFS_int_Select_RemThread(*list, thisthread);
89 LOG("Semaphore_Wait()");
90 // TODO: Actual timeout
91 Threads_WaitEvents( THREAD_EVENT_VFS|THREAD_EVENT_SIGNAL );
93 else if( *Timeout > 0 )
95 tTimer *t = Time_AllocateTimer(NULL, NULL);
97 Threads_ClearEvent( THREAD_EVENT_TIMER );
98 // TODO: Convert *Timeout?
99 LOG("Timeout %lli ms", *Timeout);
100 Time_ScheduleTimer( t, *Timeout );
101 // Wait for the timer or a VFS event
102 Threads_WaitEvents( THREAD_EVENT_VFS|THREAD_EVENT_TIMER|THREAD_EVENT_SIGNAL );
108 for( type = 0; type < 3; type ++ )
110 tVFS_SelectList **list;
111 int *flag, wanted, maxAllowed;
112 if( !(TypeFlags & (1 << type)) ) continue;
113 VFS_int_Select_GetType(type, Node, &list, &flag, &wanted, &maxAllowed);
114 LOG("VFS_int_Select_RemThread()");
116 VFS_int_Select_RemThread(*list, thisthread);
117 ret = ret || *flag == wanted;
120 Threads_ClearEvent( THREAD_EVENT_VFS );
121 Threads_ClearEvent( THREAD_EVENT_TIMER );
127 int VFS_Select(int MaxHandle, fd_set *ReadHandles, fd_set *WriteHandles, fd_set *ErrHandles, tTime *Timeout, Uint32 ExtraEvents, BOOL IsKernel)
129 tThread *thisthread = Proc_GetCurThread();
132 ENTER("iMaxHandle pReadHandles pWriteHandles pErrHandles pTimeout xExtraEvents bIsKernel",
133 MaxHandle, ReadHandles, WriteHandles, ErrHandles, Timeout, ExtraEvents, IsKernel);
135 // Notes: The idea is to make sure we only enter wait (Threads_WaitEvents)
136 // if we are going to be woken up (either by an event at a later time,
137 // or by an event that happened while or before we were registering).
138 // Hence, register must happen _before_ we check the state flag
139 // (See VFS_int_Select_Register), that way either we pick up the flag,
140 // or the semaphore is incremeneted (or both, but never none)
142 // Register with nodes
144 LOG(" - ReadHandles[0] = %x", ReadHandles->flags[0]);
145 ret = VFS_int_Select_Register(thisthread, MaxHandle, ReadHandles, 0, IsKernel);
146 ret += VFS_int_Select_Register(thisthread, MaxHandle, WriteHandles, 1, IsKernel);
147 ret += VFS_int_Select_Register(thisthread, MaxHandle, ErrHandles, 2, IsKernel);
149 LOG("Register ret = %i", ret);
151 // If there were events waiting, de-register and return
154 LOG(" - ReadHandles[0] = %x", ReadHandles->flags[0]);
155 ret = VFS_int_Select_Deregister(thisthread, MaxHandle, ReadHandles, 0, IsKernel);
156 ret += VFS_int_Select_Deregister(thisthread, MaxHandle, WriteHandles, 1, IsKernel);
157 ret += VFS_int_Select_Deregister(thisthread, MaxHandle, ErrHandles, 2, IsKernel);
158 LOG(" - ReadHandles[0] = %x", ReadHandles->flags[0]);
166 LOG("Waiting for VFS/SIGNAL events (Plus 0x%x)", ExtraEvents);
167 // TODO: Actual timeout
168 Threads_WaitEvents( THREAD_EVENT_VFS|THREAD_EVENT_SIGNAL|ExtraEvents );
170 else if( *Timeout > 0 )
172 tTimer *t = Time_AllocateTimer(NULL, NULL);
174 Threads_ClearEvent( THREAD_EVENT_TIMER );
175 // TODO: Convert *Timeout?
176 LOG("Timeout %lli ms", *Timeout);
177 Time_ScheduleTimer( t, *Timeout );
178 // Wait for the timer or a VFS event
179 Threads_WaitEvents( THREAD_EVENT_VFS|THREAD_EVENT_TIMER|ExtraEvents );
182 // Fill output (modify *Handles)
183 LOG("De-registering");
184 // - Also, de-register
185 ret = VFS_int_Select_Deregister(thisthread, MaxHandle, ReadHandles, 0, IsKernel);
186 ret += VFS_int_Select_Deregister(thisthread, MaxHandle, WriteHandles, 1, IsKernel);
187 ret += VFS_int_Select_Deregister(thisthread, MaxHandle, ErrHandles, 2, IsKernel);
189 Threads_ClearEvent( THREAD_EVENT_VFS );
190 Threads_ClearEvent( THREAD_EVENT_TIMER );
196 // Mark a node as having data ready for reading
197 int VFS_MarkAvaliable(tVFS_Node *Node, BOOL IsDataAvaliable)
200 ENTER("pNode bIsDataAvaliable", Node, IsDataAvaliable);
201 Node->DataAvaliable = !!IsDataAvaliable;
202 if( Node->DataAvaliable )
203 VFS_int_Select_SignalAll(Node->ReadThreads);
208 // Mark a node as having a full buffer
209 int VFS_MarkFull(tVFS_Node *Node, BOOL IsBufferFull)
212 ENTER("pNode bIsBufferFull", Node, IsBufferFull);
213 Node->BufferFull = !!IsBufferFull;
214 if( !Node->BufferFull )
215 VFS_int_Select_SignalAll(Node->WriteThreads);
220 // Mark a node as errored
221 int VFS_MarkError(tVFS_Node *Node, BOOL IsErrorState)
224 ENTER("pNode bIsErrorState", Node, IsErrorState);
225 Node->ErrorOccurred = !!IsErrorState;
226 if( Node->ErrorOccurred )
227 VFS_int_Select_SignalAll(Node->ErrorThreads);
233 int VFS_int_Select_GetType(int Type, tVFS_Node *Node, tVFS_SelectList ***List, int **Flag, int *WantedFlag, int *MaxAllowed)
235 // Get the type of the listen
239 if(List) *List = &Node->ReadThreads;
240 if(Flag) *Flag = &Node->DataAvaliable;
241 if(WantedFlag) *WantedFlag = 1;
242 if(MaxAllowed) *MaxAllowed = 1; // Max of 1 for read
245 if(List) *List = &Node->WriteThreads;
246 if(Flag) *Flag = &Node->BufferFull;
247 if(WantedFlag) *WantedFlag = 0;
248 if(MaxAllowed) *MaxAllowed = 1; // Max of 1 for write
251 if(List) *List = &Node->ErrorThreads;
252 if(Flag) *Flag = &Node->ErrorOccurred;
253 if(WantedFlag) *WantedFlag = 1;
254 if(MaxAllowed) *MaxAllowed = -1; // No max for error listeners
257 Log_Error("VFS", "VFS_int_Select_GetType: BUG CHECK, Unknown Type %i", Type);
264 * \return Number of files with an action
266 int VFS_int_Select_Register(tThread *Thread, int MaxHandle, fd_set *Handles, int Type, BOOL IsKernel)
268 int i, numFlagged = 0;
269 tVFS_SelectList **list;
270 int *flag, wantedFlagValue;
273 if( !Handles ) return 0;
275 ENTER("pThread iMaxHandle pHandles iType iIsKernel", Thread, MaxHandle, Handles, Type, IsKernel);
277 for( i = 0; i < MaxHandle; i ++ )
281 // Is the descriptor set
282 if( !FD_ISSET(i, Handles) ) continue;
285 handle = VFS_GetHandle( i | (IsKernel?VFS_KERNEL_FLAG:0) );
286 // Is the handle valid?
287 if( !handle || !handle->Node )
289 if( Type == 2 ) { // Bad FD counts as an error
298 // Get the type of the listen
299 if( VFS_int_Select_GetType(Type, handle->Node, &list, &flag, &wantedFlagValue, &maxAllowed) ) {
306 *list = calloc(1, sizeof(tVFS_SelectList));
310 if( VFS_int_Select_AddThread(*list, Thread, maxAllowed ) )
312 // Oops, error (or just no space)
316 // Check for the flag
317 if( !!*flag == !!wantedFlagValue ) {
318 LOG(" %i == want %i", !!*flag, !!wantedFlagValue);
323 LEAVE('i', numFlagged);
328 * \return Number of files with an action
330 int VFS_int_Select_Deregister(tThread *Thread, int MaxHandle, fd_set *Handles, int Type, BOOL IsKernel)
332 int i, numFlagged = 0;
333 tVFS_SelectList **list;
334 int *flag, wantedFlagValue;
336 if( !Handles ) return 0;
338 ENTER("pThread iMaxHandle pHandles iType iIsKernel", Thread, MaxHandle, Handles, Type, IsKernel);
340 for( i = 0; i < MaxHandle; i ++ )
344 // Is the descriptor set
345 if( !FD_ISSET(i, Handles) ) continue;
348 handle = VFS_GetHandle( i | (IsKernel?VFS_KERNEL_FLAG:0) );
349 // Is the handle valid?
350 if( !handle || !handle->Node )
352 if( Type == 2 ) { // Bad FD counts as an error
361 // Get the type of the listen
362 if( VFS_int_Select_GetType(Type, handle->Node, &list, &flag, &wantedFlagValue, NULL) ) {
368 VFS_int_Select_RemThread(*list, Thread );
370 // Check for the flag
371 if( !!*flag == !!wantedFlagValue ) {
373 LOG(" %i == want %i", !!*flag, !!wantedFlagValue);
381 LEAVE('i', numFlagged);
387 * \return Boolean failure
389 int VFS_int_Select_AddThread(tVFS_SelectList *List, tThread *Thread, int MaxAllowed)
392 tVFS_SelectListEnt *block, *prev;
394 ENTER("pList pThread iMaxAllowed", List, Thread, MaxAllowed);
396 // Lock to avoid concurrency issues
397 Mutex_Acquire(&List->Lock);
399 block = &List->FirstEnt;
401 // Look for free space
404 for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
406 if( block->Threads[i] == NULL )
408 block->Threads[i] = Thread;
409 Mutex_Release(&List->Lock);
414 if( MaxAllowed && count >= MaxAllowed ) {
415 Mutex_Release(&List->Lock);
428 block = malloc( sizeof(tVFS_SelectListEnt) );
430 Log_Warning("VFS", "VFS_int_Select_AddThread: malloc() failed");
431 Mutex_Release(&List->Lock);
435 block->Threads[0] = Thread;
436 for( i = 1; i < NUM_THREADS_PER_ALLOC; i ++ )
438 block->Threads[i] = NULL;
445 Mutex_Release(&List->Lock);
451 void VFS_int_Select_RemThread(tVFS_SelectList *List, tThread *Thread)
453 tVFS_SelectListEnt *block, *prev = NULL;
455 ENTER("pList pThread", List, Thread);
457 // Lock to avoid concurrency issues
458 Mutex_Acquire(&List->Lock);
460 block = &List->FirstEnt;
462 // Look for the thread
465 for( int i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
467 if( block->Threads[i] == Thread )
469 block->Threads[i] = NULL;
471 // Check if this block is empty
472 if( block != &List->FirstEnt )
474 for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
475 if( block->Threads[i] )
478 if( i == NUM_THREADS_PER_ALLOC ) {
479 LOG("Deleting block");
480 prev->Next = block->Next;
483 //TODO: If not empty, check if it can be merged downwards
486 Mutex_Release(&List->Lock);
496 // Not on list, is this an error?
498 Mutex_Release(&List->Lock);
505 * \brief Signal all threads on a list
507 void VFS_int_Select_SignalAll(tVFS_SelectList *List)
510 tVFS_SelectListEnt *block;
514 ENTER("pList", List);
516 // Lock to avoid concurrency issues
517 Mutex_Acquire(&List->Lock);
519 block = &List->FirstEnt;
521 // Look for the thread
524 for( i = 0; i < NUM_THREADS_PER_ALLOC; i ++ )
526 if( block->Threads[i] )
528 LOG("block(%p)->Threads[%i] = %p", block, i, block->Threads[i]);
529 Threads_PostEvent( block->Threads[i], THREAD_EVENT_VFS );
536 Mutex_Release(&List->Lock);