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         for( vol = gpLVM_FirstVolume; vol && ID --; vol = vol->Next );
 134
 135         if(vol) {
 136                 strncpy(Dest, vol->Name, FILENAME_MAX);
 137                 return 0;
 138         }
 139         else
 140                 return -ENOENT;
 141 }
 142 tVFS_Node *LVM_Root_FindDir(tVFS_Node *Node, const char *Name)
 143 {
 144         tLVM_Vol        *vol;
 145         for( vol = gpLVM_FirstVolume; vol; vol = vol->Next )
 146         {
 147                 if( strcmp(vol->Name, Name) == 0 )
 148                 {
 149                         vol->DirNode.ReferenceCount ++;
 150                         return &vol->DirNode;
 151                 }
 152         }
 153         return NULL;
 154 }
 155
 156 int LVM_Vol_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX])
 157 {
 158         tLVM_Vol        *vol = Node->ImplPtr;
 159         const char *src;
 160
 161         if( ID < 0 || ID >= vol->nSubVolumes+1 )
 162                 return -EINVAL;
 163
 164         if( ID == 0 ) {
 165                 src = "ROOT";
 166         }
 167         else {
 168                 src = vol->SubVolumes[ID-1]->Name;
 169         }
 170         strncpy(Dest, src, FILENAME_MAX);
 171         return 0;
 172 }
 173 tVFS_Node *LVM_Vol_FindDir(tVFS_Node *Node, const char *Name)
 174 {
 175         tLVM_Vol        *vol = Node->ImplPtr;
 176
 177         if( strcmp("ROOT", Name) == 0 )
 178                 return &vol->VolNode;
 179
 180         for( int i = 0; i < vol->nSubVolumes; i ++ )
 181         {
 182                 if( strcmp(vol->SubVolumes[i]->Name, Name) == 0 )
 183                 {
 184                         vol->SubVolumes[i]->Node.ReferenceCount ++;
 185                         return &vol->SubVolumes[i]->Node;
 186                 }
 187         }
 188
 189         return NULL;
 190 }
 191
 192 size_t LVM_Vol_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
 193 {
 194         tLVM_Vol        *vol = Node->ImplPtr;
 195         Uint64  byte_size = vol->BlockCount * vol->BlockSize;
 196
 197         if( Offset > byte_size )
 198                 return 0;
 199         if( Length > byte_size )
 200                 Length = byte_size;
 201         if( Offset + Length > byte_size )
 202                 Length = byte_size - Offset;
 203
 204         return DrvUtil_ReadBlock(
 205                 Offset, Length, Buffer,
 206                 LVM_int_DrvUtil_ReadBlock, vol->BlockSize, vol
 207                 );
 208 }
 209
 210 size_t LVM_Vol_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer)
 211 {
 212         return 0;
 213 }
 214
 215 size_t LVM_SubVol_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
 216 {
 217         tLVM_SubVolume  *sv = Node->ImplPtr;
 218         Uint64  byte_size = sv->BlockCount * sv->Vol->BlockSize;
 219
 220         if( Offset > byte_size )
 221                 return 0;
 222         if( Length > byte_size )
 223                 Length = byte_size;
 224         if( Offset + Length > byte_size )
 225                 Length = byte_size - Offset;
 226
 227         LOG("Reading (0x%llx+0x%llx)+0x%x to %p",
 228                 (Uint64)(sv->FirstBlock * sv->Vol->BlockSize), Offset,
 229                 Length, Buffer
 230                 );
 231
 232         Offset += sv->FirstBlock * sv->Vol->BlockSize;
 233
 234         return DrvUtil_ReadBlock(
 235                 Offset, Length, Buffer,
 236                 LVM_int_DrvUtil_ReadBlock, sv->Vol->BlockSize, sv->Vol
 237                 );
 238 }
 239 size_t LVM_SubVol_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer)
 240 {
 241         tLVM_SubVolume  *sv = Node->ImplPtr;
 242         Uint64  byte_size = sv->BlockCount * sv->Vol->BlockSize;
 243
 244         if( Offset > byte_size )
 245                 return 0;
 246         if( Length > byte_size )
 247                 Length = byte_size;
 248         if( Offset + Length > byte_size )
 249                 Length = byte_size - Offset;
 250
 251         Offset += sv->FirstBlock * sv->Vol->BlockSize;
 252
 253         return DrvUtil_WriteBlock(
 254                 Offset, Length, Buffer,
 255                 LVM_int_DrvUtil_ReadBlock, LVM_int_DrvUtil_WriteBlock,
 256                 sv->Vol->BlockSize, sv->Vol
 257                 );
 258 }
 259
 260 void LVM_CloseNode(tVFS_Node *Node)
 261 {
 262         Node->ReferenceCount --;
 263 }
 264
 265 Uint LVM_int_DrvUtil_ReadBlock(Uint64 Address, Uint Count, void *Buffer, void *Argument)
 266 {
 267         return LVM_int_ReadVolume( Argument, Address, Count, Buffer );
 268 }
 269
 270 Uint LVM_int_DrvUtil_WriteBlock(Uint64 Address, Uint Count, const void *Buffer, void *Argument)
 271 {
 272         return LVM_int_WriteVolume( Argument, Address, Count, Buffer );
 273 }
 274