OSDev.org

SoLDMG wrote:I do have one theory, which is to do IPC and tell the server process in question to do something, but I'd rather hear from someone who does know how this works.

SoLDMG wrote:I do have one theory, which is to do IPC and tell the server process in question to do something, but I'd rather hear from someone who does know how this works.

• there's some sort of communication system (e.g. messaging, where the kernel provides some functions to get and send messages)
• file IO is done using that communication system (e.g. by sending messages to the VFS and receiving messages from the VFS)
• the GUI (or teminal emulator or whatever) is also used via. that communication system (e.g. by sending messages to the GUI and receiving messages from the GUI)

• inside the POSIX library, various functions (e.g. printf(), puts(), fwrite(), gets(), fread(), etc) could all end up relying on tiny set of lower level functions (e.g. open(), read(), write() and close())
• those lower level functions would be implemented in the POSIX library using the OS's communication system, such that the file descriptor determines where the data is sent and how. For e.g. if the file descriptor for the "write()" is for a normal file then it may end up being messages sent to the VFS, if the file descriptor is stdout then it might end up being messages sent to GUI (or terminal emulator or something), etc.

File test("path/to/file.txt");
if(test.open()) {
    size_t bufSize = 1024;
    uint8_t buf[bufSize];
    int bytesRead = test.read(0, buf, bufSize); // first parameter is the offset
    // do something with the bytes
}

• A process wants to read the file with node id 25 (this id is acquired in the "open" method) and calls the File's read method
• File.read method allocates some shared memory & shares it with the VFS process
• File.read method calls the ghostapi::SystemCalls::sendMessage function to send a message to the VFS (containing the file id, the target buffer and the maximum number of bytes to read)
• ghostapi::SystemCalls::sendMessage function fills a SystemCall-struct and does a software interrupt, the kernel handles this call and dispatches the message
• In the VFS process, the ghostapi::SystemCalls::receiveMessage function is called
• ghostapi::SystemCalls::receiveMessage function again calls the kernel to receive the message
• Now the VFS has a request to handle and creates a new thread for handling
• This VFS thread does a lookup for the file, and does whatever is necessary to read the bytes into the buffer (this could now involve sending a message to a driver process to request it to read the bytes)
• Once the reading is done, the VFS sends a message to the requesting process with the number of bytes that were actually read
• The process now has the requested bytes in it's buffer