📄️ Overview
We know that a compute system is a collection of hardware and software that modifies data.
📄️ File Handlers
You've most likely had to deal with files in the past.
📄️ File Descriptors
After running the code in the "File Handlers" section, you saw that open() returns a number.
📄️ Redirections
In the File Descriptors section, we mentioned redirections such as ls > file.txt.
📄️ Pipes
When it comes to inter-process communication, so far we know that 2 different processes can mmap() the same file and use that as some sort of shared memory, but this requires writing data to the disk which is slow.
📄️ Local IO in Action
Most of the time, file handling is a simple operation from the perspective of the application.
📄️ Remote IO
In the previous sections, we started looking into how applications interact with the outside world.
📄️ Networking 101
In this section, we will briefly explore how networking works in general, from the perspective of the application.
📄️ Client-Server Model
Up to now, we've avoided code snippets using TCP.
📄️ Beyond Network Sockets
Up until this point, we first learned how to use the Berkeley Sockets API, then we learned about the client-server model, based on this API.
📄️ File Mappings
Mapping a file to the VAS of a process is similar to how shared libraries are loaded into the same VAS.
📄️ IO Internals
Now, we will take a short look at how the file descriptors you've just learnt about are handled in libc.
📄️ Zero-Copy
Imagine a server that responds with files that it stores locally.
📄️ Asynchronous IO
When doing I/O, the major issue we are facing is that I/O operations are typically much slower than CPU operations.
📄️ IO Multiplexing
I/O multiplexing is the ability to serve multiple I/O channels (or anything that can be referenced via a file descriptor / handle) simultaneously.
📄️ Arena
Open File Structure in the Kernel