System Call Emulator Development

[rohankartha]

Does Atlas have a filesystem in AtlasState? I'm mapping out the implementation of some of the system calls (ex. sys_getcwd) and it seems like they would require access to some sort of filesystem.

[kathlenemagnus]

No, Atlas does not have a file system implemented yet. It will probably need its own class that can be included in the AtlasSystem class.

[rohankartha]

Okay I can work on a simple file system as I build out the emulator

[rohankartha]

What should the size of an address in Atlas's file system be?

[klingaard]

64-bit

[rohankartha]

Hello! I have added my progress below:

FileSystem.cpp

/* FileSystem class */

/* Members:
- Superblock (struct)
- Inodes (struct) - https://www.linuxjournal.com/content/understanding-linux-filesystems-inodes-block-sizes-and-data-structures#:~:text=A%20block%20is%20the%20smallest,4%20KB%2C%20and%208%20KB.
- Directory Entry (maps filenames to inodes, enforces hierarchical structure)
*/



/* Operations
- create inode (initialize inode, update directory entry)
- 
 */

FileSystem.hpp

#include <bitset>;
#include <string>;
#include <any>;
#include <unordered_map>;
#include <chrono>;

namespace atlas {
    class FileSystem {
        private:

            /********** type: SuperBlock **********/
            typedef struct {

                // File-system configuration
                int fileSystemSize;
                int blockSize;
                int numFreeBlocks;
                int numFreeInodes;

                // Bitmaps
                std::any* inodeBitmap;
                std::any* blockBitmap;

            } SuperBlock;

            /********** type: iNode **********/
            typedef struct {
    
                // ids
                std::string ownerId;
                std::string groupId;
                int fileSize;
            
                // Access and changes
                std::string permissions;
                std::unordered_map<std::string, 
                        std::chrono::system_clock::time_point> timestamps;
            
                // pointer to data block address (the actual file)
            
            } iNode;
            

    };
}

ProcessControlBlock.cpp

// (task_struct)
/* Members: 

- file descriptor table
- fs_struct
- ids
- stack pointer
- */

SystemCallEmulator.cpp

// Dependencies
#include "SystemCallEmulator.hpp"
#include "AtlasState.hpp"


namespace atlas
{

    // Constructor



    void SystemCallEmulator::handleSystemCall(AtlasState* state)
    {
        // Retrieve control and status register set
        atlas::RegisterSet* controlStatusRegisters = state->getCsrRegisterSet()

        // Read syscall number and arguments 
        controlStatusRegisters->readRegister();

        // Route to correct handler
        switch(syscall_code) {

            // sys_getcwd (current working directory)
            // sys_fcntl (file control)
            // sys_mkdirat (make directory)
            // sys_unlinkat (unlink)
            // sys_linkat (link)
            // sys_renameat (rename)
            // sys_ftruncate (file truncate)
            // sys_faccessat (file accessibility)
            // sys_chdir (change directory)
            // sys_openat (open file)
            // sys_close (close file descriptor)
            // sys_lseek (reposition file offset)
            // sys_read (read file)
            // sys_write (write to file)
            // sys_pread (read from file at specified offset)
            // sys_pwrite (write to file at specified offset)
            // sys_readlinkat (read target of symbolic link)
            // sys_fstatat (get file status)
            // sys_fstat (get file metadata for open file descriptor)
            // sys_exit (terminate process)
            // sys_statx (enhanced file metadata retrieval)
            // sys_lstat (retrieve file metadata w/o symlinks)
            // sys_getmainvars
        }

        // specific handlers


    }





    void handleGetCwd()
    {
        
    }


    
}

[klingaard]

Thanks, @rohankartha. Good layout for the intended design.