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