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 char    *SysFS_Comm_ReadDir(tVFS_Node *Node, int Id);
  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 < ID)        return 0;
 254                 if(ent->Node.Inode == ID)
 255                 {
 256                         ent->Node.ImplPtr = (void*)Data;
 257                         ent->Node.Size = Length;
 258                         return 1;
 259                 }
 260         }
 261
 262         return 0;
 263 }
 264
 265 /**
 266  * \fn int SysFS_RemoveFile(int ID)
 267  * \brief Removes a file from user access
 268  * \param ID    Identifier returned by ::SysFS_RegisterFile
 269  * \return Boolean Success
 270  * \note If a handle is still open to the file, it will be invalidated
 271  */
 272 int SysFS_RemoveFile(int ID)
 273 {
 274         tSysFS_Ent      *file;
 275         tSysFS_Ent      *ent, *parent, *prev;
 276
 277         prev = NULL;
 278         for( ent = gSysFS_FileList; ent; prev = ent, ent = ent->Next )
 279         {
 280                 // It's a reverse sorted list
 281                 if(ent->Node.Inode < ID)        return 0;
 282                 if(ent->Node.Inode == ID)       break;
 283         }
 284
 285         if(!ent)        return 0;
 286
 287         // Set up for next part
 288         file = ent;
 289         parent = file->Parent;
 290
 291         // Remove from file list
 292         if(prev)
 293                 prev->ListNext = file->ListNext;
 294         else
 295                 gSysFS_FileList = file->ListNext;
 296         file->Node.Size = 0;
 297         file->Node.ImplPtr = NULL;
 298
 299         // Search parent directory
 300         for( ent = parent->Node.ImplPtr; ent; prev = ent, ent = ent->Next )
 301         {
 302                 if( ent == file )       break;
 303         }
 304         if(!ent) {
 305                 Log_Warning("SysFS", "Bookkeeping Error: File in list, but not in directory");
 306                 return 0;
 307         }
 308
 309         // Remove from parent directory
 310         if(prev)
 311                 prev->Next = ent->Next;
 312         else
 313                 parent->Node.ImplPtr = ent->Next;
 314
 315         // Free if not in use
 316         if(file->Node.ReferenceCount == 0)
 317                 free(file);
 318
 319         return 1;
 320 }
 321
 322 /**
 323  * \fn char *SysFS_Comm_ReadDir(tVFS_Node *Node, int Pos)
 324  * \brief Reads from a SysFS directory
 325  */
 326 char *SysFS_Comm_ReadDir(tVFS_Node *Node, int Pos)
 327 {
 328         tSysFS_Ent      *child = (tSysFS_Ent*)Node->ImplPtr;
 329         if(Pos < 0 || Pos >= Node->Size)        return NULL;
 330
 331         for( ; child; child = child->Next, Pos-- )
 332         {
 333                 if( Pos == 0 )  return strdup(child->Name);
 334         }
 335         return NULL;
 336 }
 337
 338 /**
 339  * \fn tVFS_Node *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename)
 340  * \brief Find a file in a SysFS directory
 341  */
 342 tVFS_Node *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename)
 343 {
 344         tSysFS_Ent      *child = (tSysFS_Ent*)Node->ImplPtr;
 345
 346         for( ; child; child = child->Next )
 347         {
 348                 if( strcmp(child->Name, Filename) == 0 )
 349                         return &child->Node;
 350         }
 351
 352         return NULL;
 353 }
 354
 355 /**
 356  * \brief Read from an exposed buffer
 357  */
 358 size_t SysFS_Comm_ReadFile(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
 359 {
 360         if( Offset > Node->Size )       return -1;
 361         if( Length > Node->Size )       Length = Node->Size;
 362         if( Offset + Length > Node->Size)       Length = Node->Size - Offset;
 363
 364         if( Node->ImplPtr )
 365                 memcpy(Buffer, (void*)((Uint)Node->ImplPtr+(Uint)Offset), Length);
 366         else
 367                 return -1;
 368
 369         return Length;
 370 }
 371
 372 /**
 373  * \fn void SysFS_Comm_CloseFile(tVFS_Node *Node)
 374  * \brief Closes an open file
 375  * \param Node  Node to close
 376  */
 377 void SysFS_Comm_CloseFile(tVFS_Node *Node)
 378 {
 379         // Dereference
 380         Node->ReferenceCount --;
 381         if( Node->ReferenceCount > 0 )  return;
 382
 383         // Check if it is still valid
 384         if( Node->ImplPtr )     return;
 385
 386         // Delete
 387         free( (void*)Node->ImplInt );
 388 }