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