I/O and IPC βββ
I/O and IPC βββ¶
Overview¶
This chapter covers operating system I/O systems and Inter-Process Communication (IPC) mechanisms. Topics range from hardware control to high-level communication methods.
Table of Contents¶
- I/O Hardware
- I/O Methods
- Device Drivers
- Buffering Strategies
- IPC Overview
- Pipes
- Shared Memory
- Message Queues and Sockets
- Practice Problems
1. I/O Hardware¶
1.1 I/O Device Classification¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β I/O Device Classification β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β ββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββββββββββββββ β
β β Classification β Examples β β
β ββββββββββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββ€ β
β β Block Device β Hard disk, SSD, USB storage β β
β β β - Fixed-size block access β β
β β β - Random access possible β β
β ββββββββββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββ€ β
β β Character Device β Keyboard, mouse, printer, serial port β β
β β β - Byte stream access β β
β β β - Sequential access β β
β ββββββββββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββ€ β
β β Network Device β Ethernet, WiFi, Bluetooth β β
β β β - Packet-based β β
β β β - Socket interface β β
β ββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββββββββββββββ β
β β
β Linux device files: β
β /dev/sda - First SCSI/SATA disk (block) β
β /dev/tty1 - First terminal (character) β
β /dev/null - Null device (character) β
β /dev/random - Random number generator (character) β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
1.2 I/O Hardware Architecture¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β I/O Hardware Architecture β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β CPU β β
β βββββββββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββββββββ β
β β β
β βΌ β
β ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β System Bus β β
β ββββββββ¬ββββββββββββββ¬ββββββββββββββ¬ββββββββββββββ¬βββββββββββββββββ β
β β β β β β
β βΌ βΌ βΌ βΌ β
β ββββββββββββββ ββββββββββββββ ββββββββββββββ ββββββββββββββ β
β β Memory β β Disk β β Graphics β β Network β β
β β Controller β β Controller β β Controller β β Controller β β
β ββββββββββββββ βββββββ¬βββββββ βββββββ¬βββββββ βββββββ¬βββββββ β
β β β β β
β βΌ βΌ βΌ β
β βββββββββββ βββββββββββ βββββββββββ β
β β HDD β β GPU β β NIC β β
β β SSD β β β β β β
β βββββββββββ βββββββββββ βββββββββββ β
β β
β Device Controller Components: β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β Status Register β Command Register β Data Register β β
β β (Status) β (Command) β (Data) β β
β β - Ready/complete β - Read/write β - I/O data buffer β β
β β - Error β - Control cmds β β β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
2. I/O Methods¶
2.1 Polling (Programmed I/O)¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Polling Method β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β CPU repeatedly checks device status β
β β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β CPU Device Controller β β
β β β β
β β 1. Send command βββββββββββββββββββΆ Command register β β
β β β β
β β 2. while (status == busy) { βββ Status register β β
β β // Keep checking (CPU waste!) β β
β β } β β
β β β β
β β 3. Data transfer βββββββββββββββΆ/βββ Data register β β
β β β β
β β 4. Check completion βββ Status register β β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β
β Advantages: β
β - Simple implementation β
β - Low overhead for fast devices β
β β
β Disadvantages: β
β - CPU time waste (Busy Waiting) β
β - Inefficient for slow devices β
β β
β Use case: Fast network devices (high throughput) β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
2.2 Interrupt-Driven I/O¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Interrupt Method β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Time βββββββββββββββββββββββββββββββββββββββββββββββββββΆ β
β β
β CPU: [Other work] [Interrupt handler] [Other work] β
β β β² β
β β I/O request β Interrupt β
β βΌ β Complete signal β
β Device: [I/O operation executing.......] β β
β β β
β β
β Interrupt handling process: β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β β β
β β 1. Device generates interrupt signal β β
β β β β
β β 2. CPU suspends current work β β
β β - Save registers β β
β β - Save PC (Program Counter) β β
β β β β
β β 3. Look up interrupt vector table β β
β β Interrupt number β Handler address β β
β β β β
β β 4. Execute interrupt handler (ISR) β β
β β - Check device status β β
β β - Transfer data β β
β β - Wake waiting process β β
β β β β
β β 5. Restore registers/PC, resume original work β β
β β β β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β
β Advantages: CPU can do other work while waiting for I/O β
β Disadvantages: Interrupt overhead, inefficient for frequent I/O β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
2.3 DMA (Direct Memory Access)¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β DMA Method β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Direct data transfer between device and memory without CPU β
β β
β ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β β β
β β ββββββββ βββββββββββββββββββ β β
β β β CPU βββ(1) SetupβββββββββΆβ DMA Controller β β β
β β β βββ(4) Interruptββββββ β β β
β β ββββββββ β - Source addr β β β
β β β β - Dest addr β β β
β β β (Do other work) β - Byte count β β β
β β β β - Direction β β β
β β β ββββββββββ¬βββββββββ β β
β β β β β β
β β β (2)(3) Direct transfer β β
β β βΌ β β β
β β ββββββββββββ β β β
β β β Memory βββββββββββββββββββββββββββββ β β
β β β β β β β
β β ββββββββββββ β β β
β β β β β
β β βββββββββββββΌββββββββββββ β β
β β β Disk Device β β β
β β βββββββββββββββββββββββββ β β
β β β β
β ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β
β DMA transfer process: β
β 1. CPU sets transfer information in DMA controller β
β 2. DMA uses bus to transfer data (Cycle Stealing) β
β 3. CPU performs cache/register operations during transfer β
β 4. DMA generates interrupt when transfer complete β
β β
β Advantages: Minimal CPU load for large data transfers β
β Disadvantages: DMA controller cost, bus contention β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
3. Device Drivers¶
3.1 Driver Structure¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Device Driver Layers β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β User Applications β β
β β (open, read, write, ioctl) β β
β ββββββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββββββββββ β
β β System calls β
β βΌ β
β βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β VFS Layer β β
β β (Virtual File System) β β
β β Device-independent abstraction interface β β
β ββββββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββββββββββ β
β β β
β βββββββββββββββββββββββΌββββββββββββββββββββββ β
β βΌ βΌ βΌ β
β βββββββββββββββ βββββββββββββββ βββββββββββββββ β
β βBlock Driver β β Char Driver β β Network β β
β β (Block) β β (Character) β β Driver β β
β ββββββββ¬βββββββ ββββββββ¬βββββββ ββββββββ¬βββββββ β
β β β β β
β βΌ βΌ βΌ β
β βββββββββββββββ βββββββββββββββ βββββββββββββββ β
β β SCSI/SATA β β TTY/Serial β β Ethernet β β
β β Driver β β Driver β β Driver β β
β ββββββββ¬βββββββ ββββββββ¬βββββββ ββββββββ¬βββββββ β
β β β β β
β βΌ βΌ βΌ β
β βββββββββββββββ βββββββββββββββ βββββββββββββββ β
β β Hardware β β Hardware β β Hardware β β
β βββββββββββββββ βββββββββββββββ βββββββββββββββ β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
3.2 Linux Driver Example¶
// Simple character device driver structure
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#define DEVICE_NAME "mydevice"
static int major_number;
static char device_buffer[1024];
static int open_count = 0;
// Open device
static int device_open(struct inode *inode, struct file *file) {
open_count++;
printk(KERN_INFO "mydevice: opened %d time(s)\n", open_count);
return 0;
}
// Close device
static int device_release(struct inode *inode, struct file *file) {
printk(KERN_INFO "mydevice: closed\n");
return 0;
}
// Read from device
static ssize_t device_read(struct file *file, char __user *buffer,
size_t length, loff_t *offset) {
int bytes_to_read = min(length, sizeof(device_buffer) - (size_t)*offset);
if (*offset >= sizeof(device_buffer)) return 0;
if (copy_to_user(buffer, device_buffer + *offset, bytes_to_read)) {
return -EFAULT;
}
*offset += bytes_to_read;
return bytes_to_read;
}
// Write to device
static ssize_t device_write(struct file *file, const char __user *buffer,
size_t length, loff_t *offset) {
int bytes_to_write = min(length, sizeof(device_buffer) - 1);
if (copy_from_user(device_buffer, buffer, bytes_to_write)) {
return -EFAULT;
}
device_buffer[bytes_to_write] = '\0';
return bytes_to_write;
}
// File operations structure
static struct file_operations fops = {
.owner = THIS_MODULE,
.open = device_open,
.release = device_release,
.read = device_read,
.write = device_write,
};
// Module initialization
static int __init mydevice_init(void) {
major_number = register_chrdev(0, DEVICE_NAME, &fops);
if (major_number < 0) {
printk(KERN_ALERT "Failed to register device\n");
return major_number;
}
printk(KERN_INFO "mydevice: registered with major number %d\n",
major_number);
return 0;
}
// Module cleanup
static void __exit mydevice_exit(void) {
unregister_chrdev(major_number, DEVICE_NAME);
printk(KERN_INFO "mydevice: unregistered\n");
}
module_init(mydevice_init);
module_exit(mydevice_exit);
MODULE_LICENSE("GPL");
4. Buffering Strategies¶
4.1 Buffering Types¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Buffering Types β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β 1. Single Buffering β
β βββββββββββ βββββββββββ βββββββββββ β
β β Device β ββββΆ β Buffer β ββββΆ β Process β β
β βββββββββββ βββββββββββ βββββββββββ β
β β
β Problem: Device waits while buffer being processed β
β β
β 2. Double Buffering β
β βββββββββββ βββββββββββ βββββββββββ β
β β Device β ββββΆ β Buffer Aβ ββββΆ β Process β β
β β β βββββββββββ€ β β β
β β β ββββΆ β Buffer Bβ ββββΆ β β β
β βββββββββββ βββββββββββ βββββββββββ β
β β
β Device writes to A while process reads from B (parallel processing) β
β β
β 3. Circular Buffering β
β β
β βββββββββββββββββββββββββββββββββββββββββ β
β β Circular Buffer Queue β β
β β βββββ¬ββββ¬ββββ¬ββββ¬ββββ¬ββββ¬ββββ β β
β β β 0 β 1 β 2 β 3 β 4 β 5 β 6 β β β
β β βββββ΄ββββ΄ββββ΄ββββ΄ββββ΄ββββ΄ββββ β β
β β β β β β
β β head tail β β
β β (consume pos) (produce pos) β β
β βββββββββββββββββββββββββββββββββββββββββ β
β β
β Efficient for producer-consumer pattern β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
4.2 Spooling¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Spooling β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Simultaneous Peripheral Operations On-Line β
β β
β Printer spooling example: β
β β
β βββββββββββ β
β βProcess 1βββββ β
β βββββββββββ β βββββββββββββββββββ βββββββββββββββ β
β β β β β β β
β βββββββββββ βββββΆβ Spool Dir βββββΆβ Printer β β
β βProcess 2βββββ€ β (Disk Queue) β β Daemon βββββΆ Printerβ
β βββββββββββ β β β β(Sequential) β β
β β β job1.spl β βββββββββββββββ β
β βββββββββββ β β job2.spl β β
β βProcess 3βββββ β job3.spl β β
β βββββββββββ βββββββββββββββββββ β
β β
β Features: β
β - Virtualizes slow device (printer) β
β - Multiple processes can "print" simultaneously β
β - Actual printing happens sequentially β
β - Process returns immediately (asynchronous) β
β β
β Other examples: Mail spool, batch job queue β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
5. IPC Overview¶
5.1 IPC Methods Comparison¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β IPC Methods Comparison β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β βββββββββββββββββββ¬βββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β Method β Features β β
β βββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββββββββββββ€ β
β β Pipe β - Unidirectional (anonymous), bidirectional(named)β β
β β β - Parent-child process communication β β
β β β - Byte stream β β
β βββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββββββββββββ€ β
β β Shared Memory β - Fastest (minimal kernel involvement) β β
β β β - Requires synchronization (semaphores, etc) β β
β β β - Suitable for large data β β
β βββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββββββββββββ€ β
β β Message Queue β - Structured messages β β
β β β - Asynchronous communication β β
β β β - Priority support β β
β βββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββββββββββββ€ β
β β Signal β - Asynchronous notification β β
β β β - Limited information transfer β β
β β β - Similar to interrupt β β
β βββββββββββββββββββΌβββββββββββββββββββββββββββββββββββββββββββββββββββ€ β
β β Socket β - Network communication β β
β β β - Cross-system communication possible β β
β β β - TCP/UDP protocols β β
β βββββββββββββββββββ΄βββββββββββββββββββββββββββββββββββββββββββββββββββ β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
6. Pipes¶
6.1 Anonymous Pipe¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Anonymous Pipe β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Unidirectional communication between parent-child processes β
β β
β βββββββββββββββ βββββββββββββββ β
β β Parent β Pipe β Child β β
β β Process β β Process β β
β β β βββββββββββββββββ β β β
β β write(fd[1])βββΆβ===============βββΆβ read(fd[0]) β β
β β β βββββββββββββββββ β β β
β β close(fd[0]) β close(fd[1])β β
β βββββββββββββββ βββββββββββββββ β
β β
β fd[0]: Read end β
β fd[1]: Write end β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// Anonymous pipe example
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main() {
int pipefd[2];
pid_t pid;
char buffer[1024];
// Create pipe
if (pipe(pipefd) == -1) {
perror("pipe");
exit(1);
}
pid = fork();
if (pid == -1) {
perror("fork");
exit(1);
}
if (pid == 0) {
// Child process: read from pipe
close(pipefd[1]); // Close write end
ssize_t n = read(pipefd[0], buffer, sizeof(buffer));
printf("Child received: %.*s\n", (int)n, buffer);
close(pipefd[0]);
exit(0);
} else {
// Parent process: write to pipe
close(pipefd[0]); // Close read end
const char* message = "Hello from parent!";
write(pipefd[1], message, strlen(message));
printf("Parent sent: %s\n", message);
close(pipefd[1]);
wait(NULL);
}
return 0;
}
6.2 Named Pipe (FIFO)¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Named Pipe (FIFO) β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Pipe with name in file system β
β Communication between unrelated processes possible β
β β
β βββββββββββββββ /tmp/myfifo βββββββββββββββ β
β β Process A β β Process B β β
β β β ββββββββββββββ β β β
β β write() ββββΌββΆβ FIFO File ββββΆβ read() β β
β β β ββββββββββββββ β β β
β βββββββββββββββ βββββββββββββββ β
β β
β $ mkfifo /tmp/myfifo # Create β
β $ ls -l /tmp/myfifo β
β prw-r--r-- 1 user group 0 Jan 15 10:00 /tmp/myfifo β
β # 'p' indicates pipe type β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// FIFO creation and usage
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#define FIFO_PATH "/tmp/myfifo"
// Writer process
void writer() {
mkfifo(FIFO_PATH, 0666);
int fd = open(FIFO_PATH, O_WRONLY);
const char* message = "Hello via FIFO!";
write(fd, message, strlen(message));
close(fd);
}
// Reader process
void reader() {
int fd = open(FIFO_PATH, O_RDONLY);
char buffer[1024];
ssize_t n = read(fd, buffer, sizeof(buffer));
buffer[n] = '\0';
printf("Received: %s\n", buffer);
close(fd);
}
7. Shared Memory¶
7.1 POSIX Shared Memory¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Shared Memory Structure β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Process A Process B β
β βββββββββββββββββββ βββββββββββββββββββ β
β βVirtual Addr Spaceβ βVirtual Addr Spaceβ β
β β β β β β
β β βββββββββββββββ β β βββββββββββββββ β β
β β β Code β β β β Code β β β
β β βββββββββββββββ€ β β βββββββββββββββ€ β β
β β β Data β β β β Data β β β
β β βββββββββββββββ€ β β βββββββββββββββ€ β β
β β βShared MemoryβββΌββββββββββββββββΌβΆβShared Memoryβ β β
β β β (0x7000) β β β β β (0x9000) β β β
β β βββββββββββββββ€ β β β βββββββββββββββ€ β β
β β β Heap β β β β β Heap β β β
β β βββββββββββββββ β β β βββββββββββββββ β β
β βββββββββββββββββββ β βββββββββββββββββββ β
β β β
β βΌ β
β βββββββββββββββββββββββ β
β β Physical Memory β β
β β β β
β β [Shared Region] β β
β β Frames 100-110 β β
β βββββββββββββββββββββββ β
β β
β Same physical memory mapped to different virtual addresses β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// POSIX shared memory example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
#define SHM_NAME "/my_shm"
#define SHM_SIZE 4096
typedef struct {
int counter;
char message[256];
} SharedData;
int main() {
// Create shared memory
int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
ftruncate(fd, SHM_SIZE);
// Map memory
SharedData* shared = mmap(NULL, SHM_SIZE,
PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
// Initialize
shared->counter = 0;
strcpy(shared->message, "Hello!");
pid_t pid = fork();
if (pid == 0) {
// Child: read/modify shared memory
printf("Child reads: counter=%d, message=%s\n",
shared->counter, shared->message);
shared->counter = 100;
strcpy(shared->message, "Modified by child");
munmap(shared, SHM_SIZE);
exit(0);
} else {
// Parent: wait then check
wait(NULL);
printf("Parent reads: counter=%d, message=%s\n",
shared->counter, shared->message);
// Cleanup
munmap(shared, SHM_SIZE);
shm_unlink(SHM_NAME);
}
return 0;
}
7.2 Synchronization Need¶
// Shared memory with semaphore synchronization
#include <semaphore.h>
typedef struct {
sem_t mutex; // Mutual exclusion
sem_t items; // Item count
sem_t spaces; // Empty space count
int buffer[10];
int in, out;
} SharedBuffer;
// Producer
void producer(SharedBuffer* sb, int item) {
sem_wait(&sb->spaces); // Wait for empty space
sem_wait(&sb->mutex); // Critical section
sb->buffer[sb->in] = item;
sb->in = (sb->in + 1) % 10;
sem_post(&sb->mutex); // Release critical section
sem_post(&sb->items); // Signal item added
}
// Consumer
int consumer(SharedBuffer* sb) {
sem_wait(&sb->items); // Wait for item
sem_wait(&sb->mutex); // Critical section
int item = sb->buffer[sb->out];
sb->out = (sb->out + 1) % 10;
sem_post(&sb->mutex); // Release critical section
sem_post(&sb->spaces); // Signal empty space added
return item;
}
8. Message Queues and Sockets¶
8.1 POSIX Message Queue¶
// Message queue example
#include <mqueue.h>
#include <stdio.h>
#include <string.h>
#define QUEUE_NAME "/my_queue"
typedef struct {
long type;
char text[256];
} Message;
// Sender
void sender() {
struct mq_attr attr = {
.mq_maxmsg = 10,
.mq_msgsize = sizeof(Message)
};
mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_WRONLY, 0666, &attr);
Message msg;
msg.type = 1;
strcpy(msg.text, "Hello via Message Queue!");
mq_send(mq, (char*)&msg, sizeof(msg), 0);
mq_close(mq);
}
// Receiver
void receiver() {
mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY);
Message msg;
mq_receive(mq, (char*)&msg, sizeof(msg), NULL);
printf("Received: %s\n", msg.text);
mq_close(mq);
mq_unlink(QUEUE_NAME);
}
8.2 Socket Communication¶
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Socket Communication β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β β
β Server Client β
β β
β socket() βββββββββββββββββββββββββββββββ socket() β
β β β β
β βΌ β β
β bind() β β
β β β β
β βΌ β β
β listen() β β
β β β β
β βΌ βΌ β
β accept() ββββββββββ Connection req ββββββββ connect() β
β β β β
β β ββββββββββββββββββββββββββββ β β
β βΌ β Data Exchange β βΌ β
β read() βββββββββββββββββββββββββββββββΆββββwrite() β
β write()βββββββββββββββββββββββββββββββΆββββread() β
β β ββββββββββββββββββββββββββββ β β
β βΌ βΌ β
β close() βββββββββββββββββββββββββββββββ close() β
β β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// TCP server example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
int main() {
int server_fd, client_fd;
struct sockaddr_in address;
socklen_t addrlen = sizeof(address);
char buffer[1024] = {0};
// Create socket
server_fd = socket(AF_INET, SOCK_STREAM, 0);
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
// Bind
bind(server_fd, (struct sockaddr*)&address, sizeof(address));
// Listen
listen(server_fd, 3);
printf("Server listening on port %d\n", PORT);
// Accept client connection
client_fd = accept(server_fd, (struct sockaddr*)&address, &addrlen);
// Receive data
read(client_fd, buffer, sizeof(buffer));
printf("Received: %s\n", buffer);
// Send response
send(client_fd, "Hello from server", 17, 0);
close(client_fd);
close(server_fd);
return 0;
}
Practice Problems¶
Problem 1: I/O Method Comparison¶
Suggest appropriate use cases for polling, interrupts, and DMA.
Show Answer
1. Polling:
- Very fast devices (high-speed network cards)
- Very short response time
- When avoiding interrupt overhead
Example: 10Gbps network, low-latency trading systems
2. Interrupts:
- Slow devices (keyboard, mouse)
- Infrequent I/O
- When CPU needs to do other work
Example: General input devices, low-speed serial ports
3. DMA (Direct Memory Access):
- Large data transfers
- Block devices (disk, SSD)
- High throughput required
Example: Disk I/O, video capture, large network transfers
Problem 2: Pipe Communication¶
Explain the internal operation of the following shell command from a pipe perspective.
$ cat file.txt | grep "error" | wc -l
Show Answer
1. Shell creates two pipes:
pipe1: cat β grep
pipe2: grep β wc
2. Creates three child processes:
Process 1 (cat):
- Redirect stdout to pipe1[1]
- exec("cat", "file.txt")
- Write file content to pipe1
Process 2 (grep):
- Redirect stdin to pipe1[0]
- Redirect stdout to pipe2[1]
- exec("grep", "error")
- Read from pipe1, filter "error", write to pipe2
Process 3 (wc):
- Redirect stdin to pipe2[0]
- exec("wc", "-l")
- Read from pipe2, count lines
3. Data flow:
file.txt β cat β pipe1 β grep β pipe2 β wc β stdout
Problem 3: Shared Memory vs Message Passing¶
Compare advantages and disadvantages of shared memory and message queues when implementing producer-consumer problem.
Show Answer
Shared Memory:
Advantages:
- Fastest IPC (no kernel involvement)
- Efficient for large data
- Flexible data structures
Disadvantages:
- Must implement synchronization directly (semaphores, mutexes)
- Must handle data race conditions
- Single system only
- Complex memory management
Message Queue:
Advantages:
- Built-in synchronization (OS handles)
- Structured message passing
- Priority support
- Clear message boundaries
Disadvantages:
- Data copy overhead
- Message size limits
- Slower than shared memory
Selection criteria:
- Large/high-speed: Shared memory
- Simplicity/safety: Message queue
- Distributed system: Sockets or network message queue
Problem 4: DMA Calculation¶
Compare CPU usage time for DMA vs PIO (Programmed I/O) when reading 1MB file from disk.
- Block size: 512 bytes
- PIO: 100 CPU cycles per block
- DMA: 1000 cycles setup, 500 cycles interrupt
- CPU clock: 1GHz
Show Answer
File size: 1MB = 1,048,576 bytes
Block count: 1,048,576 / 512 = 2,048 blocks
PIO method:
- CPU cycles = 2,048 Γ 100 = 204,800 cycles
- CPU time = 204,800 / 1,000,000,000 = 0.2048 ms
DMA method:
- Setup: 1,000 cycles
- Completion interrupt: 500 cycles
- Total CPU cycles = 1,000 + 500 = 1,500 cycles
- CPU time = 1,500 / 1,000,000,000 = 0.0015 ms
Comparison:
- PIO: 0.2048 ms
- DMA: 0.0015 ms
- DMA is ~136Γ more efficient
Additional consideration:
- DMA has setup overhead, inefficient for very small transfers
- Break-even point: 1500 / 100 = 15 blocks = 7.5 KB
- DMA advantageous for transfers > 7.5 KB
Problem 5: Socket Programming¶
Explain differences between TCP and UDP sockets and suggest suitable applications for each.
Show Answer
TCP (Transmission Control Protocol):
Features:
- Connection-oriented (3-way handshake)
- Reliability guaranteed (ordering, retransmission)
- Flow control, congestion control
- Byte stream
Suitable applications:
- Web (HTTP/HTTPS)
- Email (SMTP, IMAP)
- File transfer (FTP, SCP)
- Database connections
- SSH
UDP (User Datagram Protocol):
Features:
- Connectionless
- No reliability (loss possible)
- No ordering guarantee
- Datagram-based
- Low overhead
Suitable applications:
- Real-time streaming (video, audio)
- Online games
- DNS queries
- VoIP
- IoT sensor data
Selection criteria:
- Reliability required: TCP
- Speed/low latency priority: UDP
- Some loss acceptable: UDP
- Accurate delivery needed: TCP
Next Steps¶
You've completed the OS Theory learning materials! Recommended next learning paths:
Advanced Learning¶
- Linux: Apply learned concepts in actual OS
- Process management:
ps,top,kill - File systems:
mount,df,du - Networking:
netstat,ss,iptables
Related Fields¶
- Computer_Architecture: Hardware perspective
- Memory hierarchy
- Cache memory
- I/O systems
Practical Projects¶
- Mini shell implementation (process creation, pipes)
- Memory allocator implementation
- File system simulator
- Scheduler simulator
References¶
- Silberschatz, "Operating System Concepts" Chapters 12-13
- Stevens, "Advanced Programming in the UNIX Environment"
- Linux man pages:
pipe(2),mmap(2),socket(2),shm_open(3) - Linux kernel documentation: https://www.kernel.org/doc/html/latest/
- Tanenbaum, "Modern Operating Systems" Chapters 5-6