KernelLand/Kernel/drv/proc.c

   1 /*
   2  * Acess2
   3  * - Kernel Status Driver
   4  */
   5 #define DEBUG   1
   6 #include <acess.h>
   7 #include <modules.h>
   8 #include <fs_devfs.h>
   9 #include <fs_sysfs.h>
  10
  11 // === CONSTANTS ===
  12 #define VERSION ((0 << 8) | (1))        // 0.01
  13
  14 // === TYPES ===
  15 typedef struct sSysFS_Ent
  16 {
  17         struct sSysFS_Ent       *Next;
  18         struct sSysFS_Ent       *ListNext;
  19         struct sSysFS_Ent       *Parent;
  20         tVFS_Node       Node;
  21         char    Name[];
  22 } tSysFS_Ent;
  23
  24 // === PROTOTYPES ===
  25  int    SysFS_Install(char **Arguments);
  26  int    SysFS_IOCtl(tVFS_Node *Node, int Id, void *Data);
  27
  28 #if 0
  29  int    SysFS_RegisterFile(const char *Path, const char *Data, int Length);
  30  int    SysFS_UpdateFile(int ID, const char *Data, int Length);
  31  int    SysFS_RemoveFile(int ID);
  32 #endif
  33
  34  int    SysFS_Comm_ReadDir(tVFS_Node *Node, int Id, char Dest[FILENAME_MAX]);
  35 tVFS_Node       *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename);
  36 size_t  SysFS_Comm_ReadFile(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer);
  37 void    SysFS_Comm_CloseFile(tVFS_Node *Node);
  38
  39 // === GLOBALS ===
  40 extern tSysFS_Ent       gSysFS_Version; // Defined Later
  41 extern tSysFS_Ent       gSysFS_Root;    // Defined Later
  42 MODULE_DEFINE(0, VERSION, SysFS, SysFS_Install, NULL, NULL);
  43 tVFS_NodeType   gSysFS_FileNodeType = {
  44         .TypeName = "SysFS File",
  45         .Read = SysFS_Comm_ReadFile
  46         };
  47 tVFS_NodeType   gSysFS_DirNodeType = {
  48         .TypeName = "SysFS Dir",
  49         .ReadDir = SysFS_Comm_ReadDir,
  50         .FindDir = SysFS_Comm_FindDir
  51         };
  52 tSysFS_Ent      gSysFS_Version_Kernel = {
  53         NULL, NULL,     // Nexts
  54         &gSysFS_Version,        // Parent
  55         {
  56                 .Inode = 1,     // File #1
  57                 .ImplPtr = NULL,
  58                 .ImplInt = (Uint)&gSysFS_Version_Kernel,        // Self-Link
  59                 .Size = 0,
  60                 .NumACLs = 1,
  61                 .ACLs = &gVFS_ACL_EveryoneRO,
  62                 .Type = &gSysFS_FileNodeType
  63         },
  64         "Kernel"
  65 };
  66 tSysFS_Ent      gSysFS_Version = {
  67         NULL, NULL,
  68         &gSysFS_Root,
  69         {
  70                 .Size = 1,
  71                 .ImplPtr = &gSysFS_Version_Kernel,
  72                 .ImplInt = (Uint)&gSysFS_Version,       // Self-Link
  73                 .NumACLs = 1,
  74                 .ACLs = &gVFS_ACL_EveryoneRX,
  75                 .Flags = VFS_FFLAG_DIRECTORY,
  76                 .Type = &gSysFS_DirNodeType
  77         },
  78         "Version"
  79 };
  80 // Root of the SysFS tree (just used to keep the code clean)
  81 tSysFS_Ent      gSysFS_Root = {
  82         NULL, NULL,
  83         NULL,
  84         {
  85                 .Size = 1,
  86                 .ImplPtr = &gSysFS_Version,
  87                 .ImplInt = (Uint)&gSysFS_Root   // Self-Link
  88         },
  89         "/"
  90 };
  91 tDevFS_Driver   gSysFS_DriverInfo = {
  92         NULL, "system",
  93         {
  94         .NumACLs = 1,
  95         .ACLs = &gVFS_ACL_EveryoneRX,
  96         .Flags = VFS_FFLAG_DIRECTORY,
  97         .ImplPtr = &gSysFS_Version,
  98         .Size = sizeof(gSysFS_Root)/sizeof(tSysFS_Ent),
  99         .Type = &gSysFS_DirNodeType
 100         }
 101 };
 102  int    giSysFS_NextFileID = 2;
 103 tSysFS_Ent      *gSysFS_FileList;
 104
 105 // === CODE ===
 106 /**
 107  * \fn int SysFS_Install(char **Options)
 108  * \brief Installs the SysFS Driver
 109  */
 110 int SysFS_Install(char **Options)
 111 {
 112         gSysFS_Version_Kernel.Node.Size = strlen(gsBuildInfo);
 113         gSysFS_Version_Kernel.Node.ImplPtr = (void*)gsBuildInfo;
 114
 115         DevFS_AddDevice( &gSysFS_DriverInfo );
 116         return MODULE_ERR_OK;
 117 }
 118
 119 /**
 120  * \fn int SysFS_RegisterFile(char *Path, char *Data, int Length)
 121  * \brief Registers a file (buffer) for the user to be able to read from
 122  * \param Path  Path for the file to be accessable from (relative to SysFS root)
 123  * \param Data  Pointer to the data buffer (must be non-volatile)
 124  * \param Length        Length of the data buffer
 125  * \return The file's identifier
 126  */
 127 int SysFS_RegisterFile(const char *Path, const char *Data, int Length)
 128 {
 129          int    start = 0;
 130          int    tmp;
 131         tSysFS_Ent      *ent = NULL;
 132         tSysFS_Ent      *child, *prev;
 133
 134         // Find parent directory
 135         while( (tmp = strpos(&Path[start], '/')) != -1 )
 136         {
 137                 prev = NULL;
 138
 139                 if(ent)
 140                         child = ent->Node.ImplPtr;
 141                 else
 142                         child = gSysFS_DriverInfo.RootNode.ImplPtr;
 143                 for( ; child; prev = child, child = child->Next )
 144                 {
 145                         if( strncmp( &Path[start], child->Name, tmp+1 ) == '/' )
 146                                 break;
 147                 }
 148
 149                 // Need a new directory?
 150                 if( !child )
 151                 {
 152                         child = calloc( 1, sizeof(tSysFS_Ent)+tmp+1 );
 153                         child->Next = NULL;
 154                         memcpy(child->Name, &Path[start], tmp);
 155                         child->Name[tmp] = '\0';
 156                         child->Parent = ent;
 157                         child->Node.Inode = 0;
 158                         child->Node.ImplPtr = NULL;
 159                         child->Node.ImplInt = (Uint)child;      // Uplink
 160                         child->Node.NumACLs = 1;
 161                         child->Node.ACLs = &gVFS_ACL_EveryoneRX;
 162                         child->Node.Flags = VFS_FFLAG_DIRECTORY;
 163                         child->Node.Type = &gSysFS_DirNodeType;
 164                         if( !prev ) {
 165                                 if(ent)
 166                                         ent->Node.ImplPtr = child;
 167                                 else
 168                                         gSysFS_DriverInfo.RootNode.ImplPtr = child;
 169                                 // ^^^ Impossible (There is already /Version)
 170                         }
 171                         else
 172                                 prev->Next = child;
 173                         if(ent)
 174                                 ent->Node.Size ++;
 175                         else
 176                                 gSysFS_DriverInfo.RootNode.Size ++;
 177                         Log_Log("SysFS", "Added directory '%s'", child->Name);
 178                 }
 179
 180                 ent = child;
 181
 182                 start = tmp+1;
 183         }
 184
 185         // ent: Parent tSysFS_Ent or NULL
 186         // start: beginning of last path element
 187
 188         // Check if the name is taken
 189         prev = NULL;
 190         if(ent)
 191                 child = ent->Node.ImplPtr;
 192         else
 193                 child = gSysFS_DriverInfo.RootNode.ImplPtr;
 194         for( ; child; child = child->Next )
 195         {
 196                 if( strcmp( &Path[start], child->Name ) == 0 )
 197                         break;
 198         }
 199         if( child ) {
 200                 Log_Warning("SysFS", "'%s' is taken (in '%s')\n", &Path[start], Path);
 201                 return 0;
 202         }
 203
 204         // Create new node
 205         child = calloc( 1, sizeof(tSysFS_Ent)+strlen(&Path[start])+1 );
 206         child->Next = NULL;
 207         strcpy(child->Name, &Path[start]);
 208         child->Parent = ent;
 209
 210         child->Node.Inode = giSysFS_NextFileID++;
 211         child->Node.ImplPtr = (void*)Data;
 212         child->Node.ImplInt = (Uint)child;      // Uplink
 213         child->Node.Size = Length;
 214         child->Node.NumACLs = 1;
 215         child->Node.ACLs = &gVFS_ACL_EveryoneRO;
 216         child->Node.Type = &gSysFS_FileNodeType;
 217
 218         // Add to parent's child list
 219         if(ent) {
 220                 ent->Node.Size ++;
 221                 child->Next = ent->Node.ImplPtr;
 222                 ent->Node.ImplPtr = child;
 223         }
 224         else {
 225                 gSysFS_DriverInfo.RootNode.Size ++;
 226                 child->Next = gSysFS_DriverInfo.RootNode.ImplPtr;
 227                 gSysFS_DriverInfo.RootNode.ImplPtr = child;
 228         }
 229         // Add to global file list
 230         child->ListNext = gSysFS_FileList;
 231         gSysFS_FileList = child;
 232
 233         Log_Log("SysFS", "Added '%s' (%p)", Path, Data);
 234
 235         return child->Node.Inode;
 236 }
 237
 238 /**
 239  * \fn int SysFS_UpdateFile(int ID, char *Data, int Length)
 240  * \brief Updates a file
 241  * \param ID    Identifier returned by ::SysFS_RegisterFile
 242  * \param Data  Pointer to the data buffer
 243  * \param Length        Length of the data buffer
 244  * \return Boolean Success
 245  */
 246 int SysFS_UpdateFile(int ID, const char *Data, int Length)
 247 {
 248         tSysFS_Ent      *ent;
 249
 250         for( ent = gSysFS_FileList; ent; ent = ent->Next )
 251         {
 252                 // It's a reverse sorted list
 253                 if(ent->Node.Inode < (Uint64)ID)
 254                         return 0;
 255                 if(ent->Node.Inode == (Uint64)ID)
 256                 {
 257                         ent->Node.ImplPtr = (void*)Data;
 258                         ent->Node.Size = Length;
 259                         return 1;
 260                 }
 261         }
 262
 263         return 0;
 264 }
 265
 266 /**
 267  * \fn int SysFS_RemoveFile(int ID)
 268  * \brief Removes a file from user access
 269  * \param ID    Identifier returned by ::SysFS_RegisterFile
 270  * \return Boolean Success
 271  * \note If a handle is still open to the file, it will be invalidated
 272  */
 273 int SysFS_RemoveFile(int ID)
 274 {
 275         tSysFS_Ent      *file;
 276         tSysFS_Ent      *ent, *parent, *prev;
 277
 278         prev = NULL;
 279         for( ent = gSysFS_FileList; ent; prev = ent, ent = ent->Next )
 280         {
 281                 // It's a reverse sorted list
 282                 if(ent->Node.Inode < (Uint64)ID)        return 0;
 283                 if(ent->Node.Inode == (Uint64)ID)       break;
 284         }
 285
 286         if(!ent)        return 0;
 287
 288         // Set up for next part
 289         file = ent;
 290         parent = file->Parent;
 291
 292         // Remove from file list
 293         if(prev)
 294                 prev->ListNext = file->ListNext;
 295         else
 296                 gSysFS_FileList = file->ListNext;
 297         file->Node.Size = 0;
 298         file->Node.ImplPtr = NULL;
 299
 300         // Search parent directory
 301         for( ent = parent->Node.ImplPtr; ent; prev = ent, ent = ent->Next )
 302         {
 303                 if( ent == file )       break;
 304         }
 305         if(!ent) {
 306                 Log_Warning("SysFS", "Bookkeeping Error: File in list, but not in directory");
 307                 return 0;
 308         }
 309
 310         // Remove from parent directory
 311         if(prev)
 312                 prev->Next = ent->Next;
 313         else
 314                 parent->Node.ImplPtr = ent->Next;
 315
 316         // Free if not in use
 317         if(file->Node.ReferenceCount == 0)
 318                 free(file);
 319
 320         return 1;
 321 }
 322
 323 /**
 324  * \fn char *SysFS_Comm_ReadDir(tVFS_Node *Node, int Pos)
 325  * \brief Reads from a SysFS directory
 326  */
 327 int SysFS_Comm_ReadDir(tVFS_Node *Node, int Pos, char Dest[FILENAME_MAX])
 328 {
 329         tSysFS_Ent      *child = (tSysFS_Ent*)Node->ImplPtr;
 330         if(Pos < 0 || (Uint64)Pos >= Node->Size)
 331                 return -EINVAL;
 332
 333         for( ; child; child = child->Next, Pos-- )
 334         {
 335                 if( Pos == 0 ) {
 336                         strncpy(Dest, child->Name, FILENAME_MAX);
 337                         return 0;
 338                 }
 339         }
 340         return -ENOENT;
 341 }
 342
 343 /**
 344  * \fn tVFS_Node *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename)
 345  * \brief Find a file in a SysFS directory
 346  */
 347 tVFS_Node *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename)
 348 {
 349         tSysFS_Ent      *child = (tSysFS_Ent*)Node->ImplPtr;
 350
 351         for( ; child; child = child->Next )
 352         {
 353                 if( strcmp(child->Name, Filename) == 0 )
 354                         return &child->Node;
 355         }
 356
 357         return NULL;
 358 }
 359
 360 /**
 361  * \brief Read from an exposed buffer
 362  */
 363 size_t SysFS_Comm_ReadFile(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
 364 {
 365         if( Offset > Node->Size )       return -1;
 366         if( Length > Node->Size )       Length = Node->Size;
 367         if( Offset + Length > Node->Size)       Length = Node->Size - Offset;
 368
 369         if( Node->ImplPtr )
 370                 memcpy(Buffer, (void*)((Uint)Node->ImplPtr+(Uint)Offset), Length);
 371         else
 372                 return -1;
 373
 374         return Length;
 375 }
 376
 377 /**
 378  * \fn void SysFS_Comm_CloseFile(tVFS_Node *Node)
 379  * \brief Closes an open file
 380  * \param Node  Node to close
 381  */
 382 void SysFS_Comm_CloseFile(tVFS_Node *Node)
 383 {
 384         // Dereference
 385         Node->ReferenceCount --;
 386         if( Node->ReferenceCount > 0 )  return;
 387
 388         // Check if it is still valid
 389         if( Node->ImplPtr )     return;
 390
 391         // Delete
 392         free( (void*)Node->ImplInt );
 393 }