a41f6a27662d20e6b73673438cc9bca880de20eb
[tpg/acess2.git] / KernelLand / Modules / Storage / LVM / main.c
1 /*
2  * Acess2 Logical Volume Manager
3  * - By John Hodge (thePowersGang)
4  *
5  * lvm.h
6  * - LVM Core definitions
7  */
8 #define DEBUG   0
9 #define VERSION VER2(0,1)
10 #include "lvm_int.h"
11 #include <fs_devfs.h>
12 #include <modules.h>
13 #include <api_drv_disk.h>
14
15 // === PROTOTYPES ===
16 // ---
17  int    LVM_Initialise(char **Arguments);
18  int    LVM_Cleanup(void);
19 // ---
20  int    LVM_Root_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX]);
21 tVFS_Node       *LVM_Root_FindDir(tVFS_Node *Node, const char *Name);
22  int    LVM_Vol_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX]);
23 tVFS_Node       *LVM_Vol_FindDir(tVFS_Node *Node, const char *Name);
24 size_t  LVM_Vol_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer);
25 size_t  LVM_Vol_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer);
26 size_t  LVM_SubVol_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer);
27 size_t  LVM_SubVol_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer);
28 void    LVM_CloseNode(tVFS_Node *Node);
29
30 Uint    LVM_int_DrvUtil_ReadBlock(Uint64 Address, Uint Count, void *Buffer, void *Argument);
31 Uint    LVM_int_DrvUtil_WriteBlock(Uint64 Address, Uint Count, const void *Buffer, void *Argument);
32
33 // === GLOBALS ===
34 MODULE_DEFINE(0, VERSION, LVM, LVM_Initialise, LVM_Cleanup, NULL);
35 tVFS_NodeType   gLVM_RootNodeType = {
36         .ReadDir = LVM_Root_ReadDir,
37         .FindDir = LVM_Root_FindDir
38 };
39 tVFS_NodeType   gLVM_VolNodeType = {
40         .ReadDir = LVM_Vol_ReadDir,
41         .FindDir = LVM_Vol_FindDir,
42         .Read = LVM_Vol_Read,
43         .Write = LVM_Vol_Write,
44         .Close = LVM_CloseNode
45 };
46 tVFS_NodeType   gLVM_SubVolNodeType = {
47         .Read = LVM_SubVol_Read,
48         .Write = LVM_SubVol_Write,
49         .Close = LVM_CloseNode
50 };
51 tDevFS_Driver   gLVM_DevFS = {
52         NULL, "LVM",
53         {.Flags = VFS_FFLAG_DIRECTORY, .Type = &gLVM_RootNodeType, .Size = -1}
54 };
55
56 tLVM_Vol        *gpLVM_FirstVolume;
57 tLVM_Vol        *gpLVM_LastVolume = (void*)&gpLVM_FirstVolume;
58
59 // === CODE ===
60 int LVM_Initialise(char **Arguments)
61 {
62         DevFS_AddDevice( &gLVM_DevFS );
63         return 0;
64 }
65
66 int LVM_Cleanup(void)
67 {
68         // Attempt to destroy all volumes
69         tLVM_Vol        *vol, *prev = NULL, *next;
70         
71         // TODO: Locks?
72         for( vol = gpLVM_FirstVolume; vol; prev = vol, vol = next )
73         {
74                 next = vol->Next;
75                  int    nFree = 0;
76                 
77                 for( int i = 0; i < vol->nSubVolumes; i ++ )
78                 {
79                         tLVM_SubVolume  *sv;
80                         sv = vol->SubVolumes[i];
81                         if( sv == NULL ) {
82                                 nFree ++;
83                                 continue;
84                         }
85
86                         Mutex_Acquire(&sv->Node.Lock);
87                         if(sv->Node.ReferenceCount == 0) {
88                                 nFree ++;
89                                 vol->SubVolumes[i] = NULL;
90                                 Mutex_Release(&sv->Node.Lock);
91                         }
92                         else {
93                                 Mutex_Release(&sv->Node.Lock);
94                                 continue ;
95                         }
96
97                         Mutex_Acquire(&sv->Node.Lock);
98                         LOG("Removed subvolume %s:%s", vol->Name, sv->Name);
99                         free(sv);
100                 }
101                 
102                 if( nFree != vol->nSubVolumes )
103                         continue ;
104
105                 if(prev)
106                         prev->Next = next;
107                 else
108                         gpLVM_FirstVolume = next;
109
110                 Mutex_Acquire(&vol->DirNode.Lock);
111                 Mutex_Acquire(&vol->VolNode.Lock);
112                 if( vol->Type->Cleanup )
113                         vol->Type->Cleanup( vol->Ptr );
114                 LOG("Removed volume %s", vol->Name);
115                 free(vol);
116         }
117
118         if( gpLVM_FirstVolume ) 
119                 return EBUSY;
120         
121         return EOK;
122 }
123
124 // --------------------------------------------------------------------
125 // VFS Inteface
126 // --------------------------------------------------------------------
127 int LVM_Root_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX])
128 {
129         tLVM_Vol        *vol;
130         
131         if( ID < 0 )    return -EINVAL;
132
133         // TODO: Sub-dirs for 'by-uuid', 'by-label' etc
134
135         for( vol = gpLVM_FirstVolume; vol && ID --; vol = vol->Next );
136         
137         if(vol) {
138                 strncpy(Dest, vol->Name, FILENAME_MAX);
139                 return 0;
140         }
141         else
142                 return -ENOENT;
143 }
144 tVFS_Node *LVM_Root_FindDir(tVFS_Node *Node, const char *Name)
145 {
146         tLVM_Vol        *vol;
147         for( vol = gpLVM_FirstVolume; vol; vol = vol->Next )
148         {
149                 if( strcmp(vol->Name, Name) == 0 )
150                 {
151                         vol->DirNode.ReferenceCount ++;
152                         return &vol->DirNode;
153                 }
154         }
155         return NULL;
156 }
157
158 int LVM_Vol_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX])
159 {
160         tLVM_Vol        *vol = Node->ImplPtr;
161         const char *src;
162         
163         if( ID < 0 || ID >= vol->nSubVolumes+1 )
164                 return -EINVAL;
165
166         if( ID == 0 ) {
167                 src = "ROOT";
168         }
169         else {
170                 src = vol->SubVolumes[ID-1]->Name;
171         }
172         strncpy(Dest, src, FILENAME_MAX);
173         return 0;
174 }
175 tVFS_Node *LVM_Vol_FindDir(tVFS_Node *Node, const char *Name)
176 {
177         tLVM_Vol        *vol = Node->ImplPtr;
178
179         if( strcmp("ROOT", Name) == 0 )
180                 return &vol->VolNode;
181         
182         for( int i = 0; i < vol->nSubVolumes; i ++ )
183         {
184                 if( strcmp(vol->SubVolumes[i]->Name, Name) == 0 )
185                 {
186                         vol->SubVolumes[i]->Node.ReferenceCount ++;
187                         return &vol->SubVolumes[i]->Node;
188                 }
189         }
190
191         return NULL;
192 }
193
194 size_t LVM_Vol_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
195 {
196         tLVM_Vol        *vol = Node->ImplPtr;
197         Uint64  byte_size = vol->BlockCount * vol->BlockSize;   
198
199         if( Offset > byte_size )
200                 return 0;
201         if( Length > byte_size )
202                 Length = byte_size;
203         if( Offset + Length > byte_size )
204                 Length = byte_size - Offset;
205
206         return DrvUtil_ReadBlock(
207                 Offset, Length, Buffer, 
208                 LVM_int_DrvUtil_ReadBlock, vol->BlockSize, vol
209                 );
210 }
211
212 size_t LVM_Vol_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer)
213 {
214         return 0;
215 }
216
217 size_t LVM_SubVol_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
218 {
219         tLVM_SubVolume  *sv = Node->ImplPtr;
220         Uint64  byte_size = sv->BlockCount * sv->Vol->BlockSize;
221
222         if( Offset > byte_size )
223                 return 0;
224         if( Length > byte_size )
225                 Length = byte_size;
226         if( Offset + Length > byte_size )
227                 Length = byte_size - Offset;
228
229         LOG("Reading (0x%llx+0x%llx)+0x%x to %p",
230                 (Uint64)(sv->FirstBlock * sv->Vol->BlockSize), Offset,
231                 Length, Buffer
232                 );
233         
234         Offset += sv->FirstBlock * sv->Vol->BlockSize;  
235
236         return DrvUtil_ReadBlock(
237                 Offset, Length, Buffer, 
238                 LVM_int_DrvUtil_ReadBlock, sv->Vol->BlockSize, sv->Vol
239                 );
240 }
241 size_t LVM_SubVol_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer)
242 {
243         tLVM_SubVolume  *sv = Node->ImplPtr;
244         Uint64  byte_size = sv->BlockCount * sv->Vol->BlockSize;
245
246         if( Offset > byte_size )
247                 return 0;
248         if( Length > byte_size )
249                 Length = byte_size;
250         if( Offset + Length > byte_size )
251                 Length = byte_size - Offset;
252
253         Offset += sv->FirstBlock * sv->Vol->BlockSize;  
254         
255         return DrvUtil_WriteBlock(
256                 Offset, Length, Buffer,
257                 LVM_int_DrvUtil_ReadBlock, LVM_int_DrvUtil_WriteBlock,
258                 sv->Vol->BlockSize, sv->Vol
259                 );
260 }
261
262 void LVM_CloseNode(tVFS_Node *Node)
263 {
264         Node->ReferenceCount --;
265 }
266
267 Uint LVM_int_DrvUtil_ReadBlock(Uint64 Address, Uint Count, void *Buffer, void *Argument)
268 {
269         return LVM_int_ReadVolume( Argument, Address, Count, Buffer );
270 }
271
272 Uint LVM_int_DrvUtil_WriteBlock(Uint64 Address, Uint Count, const void *Buffer, void *Argument)
273 {
274         return LVM_int_WriteVolume( Argument, Address, Count, Buffer );
275 }
276

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