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