Blocking read() implementation sketch

In a scenario where we do not have a shared DMA buffer and async IO notification, but instead rely on a traditional read() system call, the implementation would be significantly different. This method involves more traditional, synchronous IO operations, where the userland process blocks while waiting for data to be read from the device.

Userland Implementation with read()

The userland code would be simpler, as it just involves calling read() and blocking until the data is available.

Pseudocode for Userland

function main():
    fd = open("/dev/ethernet", O_RDONLY)  // Open the Ethernet device
    if fd < 0:
        print("Failed to open device")
        return -1

    buffer = allocate_buffer(BUFFER_SIZE)  // Allocate a buffer for reading

    while true:
        bytes_read = read(fd, buffer, BUFFER_SIZE)  // Block until data is read
        if bytes_read < 0:
            print("Error reading data")

        process_data(buffer, bytes_read)  // Process the received data


In this setup, the read() function call blocks the process until the Ethernet card has data available. The process remains idle during this time, potentially leading to less efficient CPU usage compared to asynchronous methods.

Kernel Implementation with read()

On the kernel side, the implementation would involve handling the read() system call, managing the Ethernet card's interrupts, and a basic scheduler to handle multiple processes and IO operations.

Pseudocode for Kernel

Ethernet Card Interrupt Handler

function ethernet_interrupt_handler():
    data = read_data_from_ethernet_card()
    if there_is_a_blocked_read_operation:

When the Ethernet card receives data, it triggers an interrupt. The kernel's interrupt handler reads this data and stores it in a kernel buffer. If a read() operation is waiting for data, it unblocks it.

Read System Call Implementation

function sys_read(fd, buffer, count):
    if fd is not associated with Ethernet card:
        return ERROR_INVALID_FD

    if no_data_available_in_kernel_buffer:
        block_current_process()  // Block the process until data is available

    data = retrieve_data_from_kernel_buffer(count)
    copy_data_to_user_space(buffer, data)
    return number_of_bytes_copied

The read() system call implementation involves checking if data is available in the kernel buffer. If not, it blocks the current process. Once data becomes available (signaled by the interrupt handler), it copies the data to the user space buffer.

Basic Scheduler

function scheduler():
    while true:
        process = select_next_process_to_run()
        if process is blocked:
        else if process completed:

The scheduler is responsible for managing processes, including those blocked on read() operations. It selects the next process to run and handles transitioning processes between ready, blocked, and completed states.


Using read() in combination with a traditional interrupt-driven approach is a more conventional method for handling IO in userland. It's simpler in terms of userland implementation but potentially less efficient due to the blocking nature of IO operations. This approach stands in contrast to the more efficient DMA and async IO notification method, where the CPU can continue processing other tasks while waiting for IO operations to complete, but where the code is split across a callback function and a mainloop.