Kernel - Debug to messages/select
[tpg/acess2.git] / KernelLand / Kernel / vfs / handle.c
1 /*
2  * Acess2 VFS
3  * - AllocHandle, GetHandle
4  */
5 #define SANITY  1
6 #define DEBUG   0
7 #include <acess.h>
8 #include <mm_virt.h>
9 #include "vfs.h"
10 #include "vfs_int.h"
11 #include "vfs_ext.h"
12 #include <threads.h>    // GetMaxFD
13 #include <vfs_threads.h>        // Handle maintainance
14
15 // === CONSTANTS ===
16 #define MAX_KERNEL_FILES        128
17
18 // === PROTOTYPES ===
19 #if 0
20 tVFS_Handle     *VFS_GetHandle(int FD);
21 #endif
22 inline void     _ReferenceNode(tVFS_Node *Node);
23  int    VFS_AllocHandle(int FD, tVFS_Node *Node, int Mode);
24
25 // === GLOBALS ===
26 tVFS_Handle     *gaUserHandles = (void*)MM_PPD_HANDLES;
27 tVFS_Handle     *gaKernelHandles = (void*)MM_KERNEL_VFS;
28
29 // === CODE ===
30 inline void _ReferenceNode(tVFS_Node *Node)
31 {
32         if( !MM_GetPhysAddr(Node->Type) ) {
33                 Log_Error("VFS", "Node %p's type is invalid (%p bad pointer) - %P corrupted",
34                         Node, Node->Type, MM_GetPhysAddr(&Node->Type));
35                 return ;
36         }
37         if( Node->Type && Node->Type->Reference )
38                 Node->Type->Reference( Node );
39         else
40                 Node->ReferenceCount ++;
41 }
42
43 /**
44  * \fn tVFS_Handle *VFS_GetHandle(int FD)
45  * \brief Gets a pointer to the handle information structure
46  */
47 tVFS_Handle *VFS_GetHandle(int FD)
48 {
49         tVFS_Handle     *h;
50         
51         //Log_Debug("VFS", "VFS_GetHandle: (FD=0x%x)", FD);
52         
53         if(FD < 0)      return NULL;
54         
55         if(FD & VFS_KERNEL_FLAG) {
56                 FD &= (VFS_KERNEL_FLAG - 1);
57                 if(FD >= MAX_KERNEL_FILES)      return NULL;
58                 h = &gaKernelHandles[ FD ];
59         } else {
60                 if(FD >= *Threads_GetMaxFD())   return NULL;
61                 h = &gaUserHandles[ FD ];
62         }
63         
64         if(h->Node == NULL)     return NULL;
65         //Log_Debug("VFS", "VFS_GetHandle: RETURN %p", h);
66         return h;
67 }
68
69 int VFS_AllocHandle(int bIsUser, tVFS_Node *Node, int Mode)
70 {
71          int    i;
72         
73         // Check for a user open
74         if(bIsUser)
75         {
76                  int    max_handles = *Threads_GetMaxFD();
77                 // Allocate Buffer
78                 if( MM_GetPhysAddr( gaUserHandles ) == 0 )
79                 {
80                         Uint    addr, size;
81                         size = max_handles * sizeof(tVFS_Handle);
82                         for(addr = 0; addr < size; addr += 0x1000)
83                         {
84                                 if( !MM_Allocate( (tVAddr)gaUserHandles + addr ) )
85                                 {
86                                         Warning("OOM - VFS_AllocHandle");
87                                         Threads_Exit(0, 0xFF);  // Terminate user
88                                 }
89                         }
90                         memset( gaUserHandles, 0, size );
91                 }
92                 // Get a handle
93                 for( i = 0; i < max_handles; i ++ )
94                 {
95                         if(gaUserHandles[i].Node)       continue;
96                         gaUserHandles[i].Node = Node;
97                         gaUserHandles[i].Position = 0;
98                         gaUserHandles[i].Mode = Mode;
99                         return i;
100                 }
101         }
102         else
103         {
104                 // Allocate space if not already
105                 if( MM_GetPhysAddr( gaKernelHandles ) == 0 )
106                 {
107                         Uint    addr, size;
108                         size = MAX_KERNEL_FILES * sizeof(tVFS_Handle);
109                         for(addr = 0; addr < size; addr += 0x1000)
110                         {
111                                 if( !MM_Allocate( (tVAddr)gaKernelHandles + addr ) )
112                                 {
113                                         Panic("OOM - VFS_AllocHandle");
114                                         Threads_Exit(0, 0xFF);  // Terminate application (get some space back)
115                                 }
116                         }
117                         memset( gaKernelHandles, 0, size );
118                 }
119                 // Get a handle
120                 for(i=0;i<MAX_KERNEL_FILES;i++)
121                 {
122                         if(gaKernelHandles[i].Node)     continue;
123                         gaKernelHandles[i].Node = Node;
124                         gaKernelHandles[i].Position = 0;
125                         gaKernelHandles[i].Mode = Mode;
126                         return i|VFS_KERNEL_FLAG;
127                 }
128         }
129         
130         return -1;
131 }
132
133 void VFS_ReferenceUserHandles(void)
134 {
135          int    i;
136          int    max_handles = *Threads_GetMaxFD();
137
138         // Check if this process has any handles
139         if( MM_GetPhysAddr( gaUserHandles ) == 0 )
140                 return ;
141         
142         for( i = 0; i < max_handles; i ++ )
143         {
144                 tVFS_Handle     *h;
145                 h = &gaUserHandles[i];
146                 if( !h->Node )
147                         continue ;
148                 _ReferenceNode(h->Node);
149                 h->Mount->OpenHandleCount ++;
150         }
151 }
152
153 void VFS_CloseAllUserHandles(void)
154 {
155          int    i;
156          int    max_handles = *Threads_GetMaxFD();
157
158         // Check if this process has any handles
159         if( MM_GetPhysAddr( gaUserHandles ) == 0 )
160                 return ;
161         
162         for( i = 0; i < max_handles; i ++ )
163         {
164                 tVFS_Handle     *h;
165                 h = &gaUserHandles[i];
166                 if( !h->Node )
167                         continue ;
168                 _CloseNode(h->Node);
169         }
170 }
171
172 /**
173  * \brief Take a backup of a set of file descriptors
174  */
175 void *VFS_SaveHandles(int NumFDs, int *FDs)
176 {
177         tVFS_Handle     *ret;
178          int    i;
179          int    max_handles = *Threads_GetMaxFD();
180         
181         // Check if this process has any handles
182         if( MM_GetPhysAddr( gaUserHandles ) == 0 )
183                 return NULL;
184
185         // Allocate
186         ret = malloc( NumFDs * sizeof(tVFS_Handle) );
187         if( !ret )
188                 return NULL;    
189
190         if( NumFDs > max_handles )
191                 NumFDs = max_handles;
192
193         // Take copies of the handles
194         for( i = 0; i < NumFDs; i ++ )
195         {
196                 tVFS_Handle     *h;
197                 if( FDs == NULL )
198                         h = &gaUserHandles[i];
199                 else {
200                         h = VFS_GetHandle(FDs[i] & (VFS_KERNEL_FLAG - 1));
201                         if(!h) {
202                                 Log_Warning("VFS", "VFS_SaveHandles - Invalid FD %i",
203                                         FDs[i] & (VFS_KERNEL_FLAG - 1) );
204                                 free(ret);
205                                 return NULL;
206                         }
207                 }
208                 memcpy( &ret[i], h, sizeof(tVFS_Handle) );
209                 
210                 // Reference node
211                 if( !h->Node )
212                         continue ;
213                 _ReferenceNode(h->Node);
214                 h->Mount->OpenHandleCount ++;
215         }       
216
217         return ret;
218 }
219
220 void VFS_RestoreHandles(int NumFDs, void *Handles)
221 {
222         tVFS_Handle     *handles = Handles;
223          int    i;
224
225         // NULL = nothing to do
226         if( !Handles )
227                 return ;        
228
229         // Check if there is already a set of handles
230         if( MM_GetPhysAddr( gaUserHandles ) != 0 )
231                 return ;
232         
233         
234         // Allocate user handle area
235         {
236                 Uint    addr, size;
237                  int    max_handles = *Threads_GetMaxFD();
238                 size = max_handles * sizeof(tVFS_Handle);
239                 for(addr = 0; addr < size; addr += 0x1000)
240                 {
241                         if( !MM_Allocate( (tVAddr)gaUserHandles + addr ) )
242                         {
243                                 Warning("OOM - VFS_AllocHandle");
244                                 Threads_Exit(0, 0xFF);  // Terminate user
245                         }
246                 }
247                 memset( gaUserHandles, 0, size );
248         }
249         
250         // Restore handles
251         memcpy( gaUserHandles, handles, NumFDs * sizeof(tVFS_Handle) );
252         // Reference when copied
253         for( i = 0; i < NumFDs; i ++ )
254         {
255                 tVFS_Handle     *h = &handles[i];
256         
257                 if( !h->Node )
258                         continue ;
259                 _ReferenceNode(h->Node);
260                 h->Mount->OpenHandleCount ++;
261         }
262 }
263
264 void VFS_FreeSavedHandles(int NumFDs, void *Handles)
265 {
266         tVFS_Handle     *handles = Handles;
267          int    i;
268
269         // NULL = nothing to do
270         if( !Handles )
271                 return ;        
272         
273         // Dereference all saved nodes
274         for( i = 0; i < NumFDs; i ++ )
275         {
276                 tVFS_Handle     *h = &handles[i];
277         
278                 if( !h->Node )
279                         continue ;
280                 _CloseNode(h->Node);
281                 
282                 ASSERT(h->Mount->OpenHandleCount > 0);
283                 LOG("dec. mntpt '%s' to %i", h->Mount->MountPoint, h->Mount->OpenHandleCount-1);
284                 h->Mount->OpenHandleCount --;
285         }
286         free( Handles );
287 }

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