KernelLand/Kernel/vfs/fs/root.c

   1 /*
   2  * AcessMicro VFS
   3  * - Root Filesystem Driver
   4  */
   5 #define DEBUG   0
   6 #include <acess.h>
   7 #include <vfs.h>
   8 #include <vfs_ramfs.h>
   9
  10 // === CONSTANTS ===
  11 #define MAX_FILES       64
  12 #define MAX_FILE_SIZE   1024
  13
  14 // === PROTOTYPES ===
  15 tVFS_Node       *Root_InitDevice(const char *Device, const char **Options);
  16  int    Root_MkNod(tVFS_Node *Node, const char *Name, Uint Flags);
  17 tVFS_Node       *Root_FindDir(tVFS_Node *Node, const char *Name);
  18 char    *Root_ReadDir(tVFS_Node *Node, int Pos);
  19 Uint64  Root_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  20 Uint64  Root_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, const void *Buffer);
  21 tRamFS_File     *Root_int_AllocFile(void);
  22
  23 // === GLOBALS ===
  24 tVFS_Driver     gRootFS_Info = {
  25         "rootfs", 0, Root_InitDevice, NULL, NULL
  26         };
  27 tRamFS_File     RootFS_Files[MAX_FILES];
  28 tVFS_ACL        RootFS_DirACLs[3] = {
  29         {{0,0}, {0,VFS_PERM_ALL}},      // Owner (Root)
  30         {{1,0}, {0,VFS_PERM_ALL}},      // Group (Root)
  31         {{0,-1}, {0,VFS_PERM_ALL^VFS_PERM_WRITE}}       // World (Nobody)
  32 };
  33 tVFS_ACL        RootFS_FileACLs[3] = {
  34         {{0,0}, {0,VFS_PERM_ALL^VFS_PERM_EXECUTE}},     // Owner (Root)
  35         {{1,0}, {0,VFS_PERM_ALL^VFS_PERM_EXECUTE}},     // Group (Root)
  36         {{0,-1}, {0,VFS_PERM_READ}}     // World (Nobody)
  37 };
  38 tVFS_NodeType   gRootFS_DirType = {
  39         .TypeName = "RootFS-Dir",
  40         .ReadDir = Root_ReadDir,
  41         .FindDir = Root_FindDir,
  42         .MkNod = Root_MkNod
  43 };
  44 tVFS_NodeType   gRootFS_FileType = {
  45         .TypeName = "RootFS-File",
  46         .Read = Root_Read,
  47         .Write = Root_Write,
  48 };
  49
  50 // === CODE ===
  51 /**
  52  * \brief Initialise the root filesystem
  53  */
  54 tVFS_Node *Root_InitDevice(const char *Device, const char **Options)
  55 {
  56         tRamFS_File     *root;
  57         if(strcmp(Device, "root") != 0) {
  58                 return NULL;
  59         }
  60
  61         // Create Root Node
  62         root = &RootFS_Files[0];
  63
  64         root->Node.ImplPtr = root;
  65
  66         root->Node.CTime
  67                 = root->Node.MTime
  68                 = root->Node.ATime = now();
  69         root->Node.NumACLs = 3;
  70         root->Node.ACLs = RootFS_DirACLs;
  71
  72         root->Node.Type = &gRootFS_DirType;
  73
  74         return &root->Node;
  75 }
  76
  77 /**
  78  * \fn int Root_MkNod(tVFS_Node *Node, const char *Name, Uint Flags)
  79  * \brief Create an entry in the root directory
  80  */
  81 int Root_MkNod(tVFS_Node *Node, const char *Name, Uint Flags)
  82 {
  83         tRamFS_File     *parent = Node->ImplPtr;
  84         tRamFS_File     *child;
  85         tRamFS_File     *prev = (tRamFS_File *) &parent->Data.FirstChild;
  86
  87         ENTER("pNode sName xFlags", Node, Name, Flags);
  88
  89         LOG("%i > %i", strlen(Name)+1, sizeof(child->Name));
  90         if(strlen(Name) + 1 > sizeof(child->Name))
  91                 LEAVE_RET('i', 0);
  92
  93         // Find last child, while we're at it, check for duplication
  94         for( child = parent->Data.FirstChild; child; prev = child, child = child->Next )
  95         {
  96                 if(strcmp(child->Name, Name) == 0) {
  97                         LEAVE('i', 0);
  98                         return 0;
  99                 }
 100         }
 101
 102         child = Root_int_AllocFile();
 103         memset(child, 0, sizeof(tRamFS_File));
 104
 105         strcpy(child->Name, Name);
 106
 107         child->Parent = parent;
 108         child->Next = NULL;
 109         child->Data.FirstChild = NULL;
 110
 111         child->Node.ImplPtr = child;
 112         child->Node.Flags = Flags;
 113         child->Node.NumACLs = 3;
 114         child->Node.Size = 0;
 115
 116         if(Flags & VFS_FFLAG_DIRECTORY)
 117         {
 118                 child->Node.ACLs = RootFS_DirACLs;
 119                 child->Node.Type = &gRootFS_DirType;
 120         } else {
 121                 if(Flags & VFS_FFLAG_SYMLINK)
 122                         child->Node.ACLs = RootFS_DirACLs;
 123                 else
 124                         child->Node.ACLs = RootFS_FileACLs;
 125                 child->Node.Type = &gRootFS_FileType;
 126         }
 127
 128         prev->Next = child;
 129
 130         parent->Node.Size ++;
 131
 132         LEAVE('i', 1);
 133         return 1;
 134 }
 135
 136 /**
 137  * \fn tVFS_Node *Root_FindDir(tVFS_Node *Node, const char *Name)
 138  * \brief Find an entry in the filesystem
 139  */
 140 tVFS_Node *Root_FindDir(tVFS_Node *Node, const char *Name)
 141 {
 142         tRamFS_File     *parent = Node->ImplPtr;
 143         tRamFS_File     *child = parent->Data.FirstChild;
 144
 145         ENTER("pNode sName", Node, Name);
 146         //Log("Root_FindDir: (Node=%p, Name='%s')", Node, Name);
 147
 148         for(;child;child = child->Next)
 149         {
 150                 //Log(" Root_FindDir: strcmp('%s', '%s')", child->Node.Name, Name);
 151                 LOG("child->Name = '%s'", child->Name);
 152                 if(strcmp(child->Name, Name) == 0) {
 153                         LEAVE('p', &child->Node);
 154                         return &child->Node;
 155                 }
 156         }
 157
 158         LEAVE('n');
 159         return NULL;
 160 }
 161
 162 /**
 163  * \fn char *Root_ReadDir(tVFS_Node *Node, int Pos)
 164  * \brief Get an entry from the filesystem
 165  */
 166 char *Root_ReadDir(tVFS_Node *Node, int Pos)
 167 {
 168         tRamFS_File     *parent = Node->ImplPtr;
 169         tRamFS_File     *child = parent->Data.FirstChild;
 170
 171         for( ; child && Pos--; child = child->Next ) ;
 172
 173         if(child)       return strdup(child->Name);
 174
 175         return NULL;
 176 }
 177
 178 /**
 179  * \fn Uint64 Root_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 180  * \brief Read from a file in the root directory
 181  */
 182 Uint64 Root_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 183 {
 184         tRamFS_File     *file = Node->ImplPtr;
 185         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 186
 187         if(Offset > Node->Size) {
 188                 LEAVE('i', 0);
 189                 return 0;
 190         }
 191         if(Length > Node->Size) Length = Node->Size;
 192
 193         if(Offset+Length > Node->Size)
 194                 Length = Node->Size - Offset;
 195
 196         memcpy(Buffer, file->Data.Bytes+Offset, Length);
 197         LOG("Buffer = '%.*s'", (int)Length, Buffer);
 198
 199         LEAVE('i', Length);
 200         return Length;
 201 }
 202
 203 /**
 204  * \fn Uint64 Root_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 205  * \brief Write to a file in the root directory
 206  */
 207 Uint64 Root_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, const void *Buffer)
 208 {
 209         tRamFS_File     *file = Node->ImplPtr;
 210
 211         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 212
 213         if(Offset > Node->Size) {
 214                 LEAVE('i', -1);
 215                 return -1;
 216         }
 217
 218         if(Offset + Length > MAX_FILE_SIZE)
 219         {
 220                 Length = MAX_FILE_SIZE - Offset;
 221         }
 222
 223         LOG("Buffer = '%.*s'", (int)Length, Buffer);
 224
 225         // Check if buffer needs to be expanded
 226         if(Offset + Length > Node->Size)
 227         {
 228                 void *tmp = realloc( file->Data.Bytes, Offset + Length );
 229                 if(tmp == NULL) {
 230                         Warning("Root_Write - Increasing buffer size failed");
 231                         LEAVE('i', -1);
 232                         return -1;
 233                 }
 234                 file->Data.Bytes = tmp;
 235                 Node->Size = Offset + Length;
 236                 LOG("Expanded buffer to %i bytes", (int)Node->Size);
 237         }
 238
 239         memcpy(file->Data.Bytes+Offset, Buffer, Length);
 240         LOG("File - '%.*s'", Node->Size, file->Data.Bytes);
 241
 242         LEAVE('i', Length);
 243         return Length;
 244 }
 245
 246 /**
 247  * \fn tRamFS_File *Root_int_AllocFile(void)
 248  * \brief Allocates a file from the pool
 249  */
 250 tRamFS_File *Root_int_AllocFile(void)
 251 {
 252          int    i;
 253         for( i = 0; i < MAX_FILES; i ++ )
 254         {
 255                 if( RootFS_Files[i].Name[0] == '\0' )
 256                 {
 257                         return &RootFS_Files[i];
 258                 }
 259         }
 260         return NULL;
 261 }