Usermode/ld-acess - Added two more ARM relocation types
[tpg/acess2.git] / Kernel / vfs / nodecache.c
1 /*
2  * AcessMicro VFS
3  * - File IO Passthru's
4  */
5 #include <acess.h>
6 #include "vfs.h"
7 #include "vfs_int.h"
8
9 // === TYPES ===
10 typedef struct sCachedInode {
11         struct sCachedInode     *Next;
12         tVFS_Node       Node;
13 } tCachedInode;
14 typedef struct sInodeCache {
15         struct sInodeCache      *Next;
16          int    Handle;
17         tCachedInode    *FirstNode;     // Sorted List
18         Uint64  MaxCached;              // Speeds up Searching
19 } tInodeCache;
20
21 // === PROTOTYPES ===
22 tInodeCache     *Inode_int_GetFSCache(int Handle);
23
24 // === GLOBALS ===
25  int    gVFS_NextInodeHandle = 1;
26 tShortSpinlock  glVFS_InodeCache;
27 tInodeCache     *gVFS_InodeCache = NULL;
28
29 // === CODE ===
30 /**
31  * \fn int Inode_GetHandle()
32  */
33 int Inode_GetHandle()
34 {
35         tInodeCache     *ent;
36         
37         ent = malloc( sizeof(tInodeCache) );
38         ent->MaxCached = 0;
39         ent->Handle = gVFS_NextInodeHandle++;
40         ent->Next = NULL;       ent->FirstNode = NULL;
41         
42         // Add to list
43         SHORTLOCK( &glVFS_InodeCache );
44         ent->Next = gVFS_InodeCache;
45         gVFS_InodeCache = ent;
46         SHORTREL( &glVFS_InodeCache );
47         
48         return gVFS_NextInodeHandle-1;
49 }
50
51 /**
52  * \fn tVFS_Node *Inode_GetCache(int Handle, Uint64 Inode)
53  * \brief Gets a node from the cache
54  */
55 tVFS_Node *Inode_GetCache(int Handle, Uint64 Inode)
56 {
57         tInodeCache     *cache;
58         tCachedInode    *ent;
59         
60         cache = Inode_int_GetFSCache(Handle);
61         if(!cache)      return NULL;
62         
63         if(Inode > cache->MaxCached)    return NULL;
64         
65         // Search Cache
66         ent = cache->FirstNode;
67         for( ; ent; ent = ent->Next )
68         {
69                 if(ent->Node.Inode < Inode)     continue;
70                 if(ent->Node.Inode > Inode)     return NULL;
71                 ent->Node.ReferenceCount ++;
72                 return &ent->Node;
73         }
74         
75         return NULL;    // Should never be reached
76 }
77
78 /**
79  * \fn tVFS_Node *Inode_CacheNode(int Handle, tVFS_Node *Node)
80  */
81 tVFS_Node *Inode_CacheNode(int Handle, tVFS_Node *Node)
82 {
83         tInodeCache     *cache;
84         tCachedInode    *newEnt, *ent, *prev;
85         
86         cache = Inode_int_GetFSCache(Handle);
87         if(!cache)      return NULL;
88         
89         if(Node->Inode > cache->MaxCached)
90                 cache->MaxCached = Node->Inode;
91         
92         // Search Cache
93         ent = cache->FirstNode;
94         prev = (tCachedInode*) &cache->FirstNode;
95         for( ; ent; prev = ent, ent = ent->Next )
96         {
97                 if(ent->Node.Inode < Node->Inode)       continue;
98                 if(ent->Node.Inode == Node->Inode) {
99                         ent->Node.ReferenceCount ++;
100                         return &ent->Node;
101                 }
102                 break;
103         }
104         
105         // Create new entity
106         newEnt = malloc(sizeof(tCachedInode));
107         newEnt->Next = ent;
108         memcpy(&newEnt->Node, Node, sizeof(tVFS_Node));
109         prev->Next = newEnt;
110                 
111         return &newEnt->Node;
112 }
113
114 /**
115  * \fn void Inode_UncacheNode(int Handle, Uint64 Inode)
116  * \brief Dereferences/Removes a cached node
117  */
118 void Inode_UncacheNode(int Handle, Uint64 Inode)
119 {
120         tInodeCache     *cache;
121         tCachedInode    *ent, *prev;
122         
123         cache = Inode_int_GetFSCache(Handle);
124         if(!cache)      return ;
125         
126         if(Inode > cache->MaxCached)    return ;
127         
128         // Search Cache
129         ent = cache->FirstNode;
130         prev = (tCachedInode*) &cache->FirstNode;       // Special case removal
131         for( ; ent; prev = ent, ent = ent->Next )
132         {
133                 if(ent->Node.Inode < Inode)     continue;
134                 if(ent->Node.Inode > Inode)     return;
135                 ent->Node.ReferenceCount --;
136                 // Check if node needs to be freed
137                 if(ent->Node.ReferenceCount == 0)
138                 {
139                         prev->Next = ent->Next;
140                         if(ent->Node.Inode == cache->MaxCached)
141                         {
142                                 if(ent != cache->FirstNode)
143                                         cache->MaxCached = prev->Node.Inode;
144                                 else
145                                         cache->MaxCached = 0;
146                         }
147                                 
148                         free(ent);
149                 }
150                 return ;
151         }
152         
153         return ;
154 }
155
156 /**
157  * \fn void Inode_ClearCache(int Handle)
158  * \brief Removes a cache
159  */
160 void Inode_ClearCache(int Handle)
161 {
162         tInodeCache     *cache;
163         tInodeCache     *prev = NULL;
164         tCachedInode    *ent, *next;
165         
166         // Find the cache
167         for(
168                 cache = gVFS_InodeCache;
169                 cache && cache->Handle < Handle;
170                 prev = cache, cache = cache->Next
171                 );
172         if(!cache || cache->Handle != Handle)   return;
173         
174         // Search Cache
175         ent = cache->FirstNode;
176         while( ent )
177         {
178                 ent->Node.ReferenceCount = 1;
179                 next = ent->Next;
180                 
181                 if(ent->Node.Close)
182                         ent->Node.Close( &ent->Node );
183                 free(ent);
184                 
185                 ent = next;
186         }
187         
188         // Free Cache
189         if(prev == NULL)
190                 gVFS_InodeCache = cache->Next;
191         else
192                 prev->Next = cache->Next;
193         free(cache);
194 }
195
196 /**
197  * \fn tInodeCache *Inode_int_GetFSCache(int Handle)
198  * \brief Gets a cache given it's handle
199  */
200 tInodeCache *Inode_int_GetFSCache(int Handle)
201 {
202         tInodeCache     *cache = gVFS_InodeCache;
203         // Find Cache
204         for( ; cache; cache = cache->Next )
205         {
206                 if(cache->Handle > Handle)      continue;
207                 if(cache->Handle < Handle) {
208                         Warning("Inode_int_GetFSCache - Handle %i not in cache\n", Handle);
209                         return NULL;
210                 }
211                 break;
212         }
213         if(!cache) {
214                 Warning("Inode_int_GetFSCache - Handle %i not in cache [NULL]\n", Handle);
215                 return NULL;
216         }
217         
218         return cache;
219 }

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