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

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