Modules/USB - Slight commenting updates in HID
[tpg/acess2.git] / 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 }

UCC git Repository :: git.ucc.asn.au