🖥️ Operating System Notes

// Example of system calls in C
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    // Process control system calls
    pid_t pid = fork();  
    // Create new process
    
    if (pid == 0) {
        // Child process
        printf("Child process executing\n");
        exit(0);
    } else if (pid > 0) {
        // Parent process
        wait(NULL);  
        // Wait for child to complete
        printf("Child process completed\n");
    }
    
    // File manipulation system calls
    int fd = open("file.txt", O_RDONLY);  
    // Open file for reading
    
    if (fd == -1) {
        perror("Error opening file");
        return 1;
    }
    
    char buffer[1024];
    int bytes_read = read(fd, buffer, 1024);  
    // Read from file
    
    if (bytes_read > 0) {
        printf("Read %d bytes\n", bytes_read);
    }
    
    close(fd);  
    // Close file descriptor
    
    // Device management system calls
    int device_fd = open("/dev/device", O_RDWR);
    if (device_fd != -1) {
        ioctl(device_fd, command, arg);  
        // Device control operation
        close(device_fd);
    }
    
    return 0;
}

// Structure of Process Control Block
struct PCB {
    // Process identification
    int process_id;           
    // Unique process identifier
    int parent_id;            
    // Parent process ID
    
    // Process state information
    char process_state;        
    // New, Ready, Running, Waiting, Terminated
    int priority;              
    // Process priority level
    
    // CPU state information
    int program_counter;       
    // Address of next instruction
    int cpu_registers[16];    
    // General purpose registers
    int stack_pointer;         
    // Current stack pointer
    int base_pointer;          
    // Current base pointer
    
    // Memory management information
    int memory_limits;         
    // Memory allocation limits
    int page_table_ptr;        
    // Pointer to page table
    int memory_usage;          
    // Current memory usage
    
    // File management information
    int list_of_open_files;    
    // List of open file descriptors
    int working_directory;     
    // Current working directory
    
    // CPU scheduling information
    int cpu_usage;             
    // Total CPU time used
    int waiting_time;          
    // Time spent in waiting queue
    int arrival_time;          
    // Time when process arrived
    int burst_time;            
    // Estimated CPU burst time
    
    // Process communication information
    int message_queue;         
    // Message queue for IPC
    int semaphores;            
    // Associated semaphores
    
    // Process hierarchy information
    int child_processes[10]; 
    // Array of child process IDs
    int num_children;          
    // Number of child processes
};

// FCFS Scheduling Algorithm
void fcfs_scheduling(struct Process processes[], int n) {
    int current_time = 0;
    float total_waiting_time = 0;
    
    for(int i = 0; i < n; i++) {
        // Process arrives at current_time
        if(current_time < processes[i].arrival_time) {
            current_time = processes[i].arrival_time;
        }
        
        // Calculate waiting time
        processes[i].waiting_time = current_time - processes[i].arrival_time;
        total_waiting_time += processes[i].waiting_time;
        
        // Execute process
        current_time += processes[i].burst_time;
        processes[i].completion_time = current_time;
    }
    
    float avg_waiting_time = total_waiting_time / n;
    printf("Average Waiting Time: %.2f\n", avg_waiting_time);
}

// SJF Scheduling Algorithm (Non-preemptive)
void sjf_scheduling(struct Process processes[], int n) {
    int current_time = 0;
    int completed = 0;
    
    while(completed < n) {
        int shortest_job = -1;
        int min_burst = INT_MAX;
        
        // Find shortest job that has arrived
        for(int i = 0; i < n; i++) {
            if(processes[i].arrival_time <= current_time && 
               processes[i].remaining_time > 0 && 
               processes[i].burst_time < min_burst) {
                shortest_job = i;
                min_burst = processes[i].burst_time;
            }
        }
        
        if(shortest_job == -1) {
            current_time++;
            continue;
        }
        
        // Execute the shortest job
        processes[shortest_job].waiting_time = current_time - processes[shortest_job].arrival_time;
        current_time += processes[shortest_job].burst_time;
        processes[shortest_job].completion_time = current_time;
        processes[shortest_job].remaining_time = 0;
        completed++;
    }
}

// Round Robin Scheduling Algorithm
void round_robin(struct Process processes[], int n, int quantum) {
    int current_time = 0;
    int completed = 0;
    
    while(completed < n) {
        for(int i = 0; i < n; i++) {
            if(processes[i].remaining_time > 0 && 
               processes[i].arrival_time <= current_time) {
                
                if(processes[i].remaining_time > quantum) {
                    current_time += quantum;
                    processes[i].remaining_time -= quantum;
                } else {
                    current_time += processes[i].remaining_time;
                    processes[i].waiting_time = current_time - processes[i].arrival_time - processes[i].burst_time;
                    processes[i].remaining_time = 0;
                    completed++;
                }
            }
        }
    }
}

// Priority Scheduling Algorithm
void priority_scheduling(struct Process processes[], int n) {
    int current_time = 0;
    int completed = 0;
    
    while(completed < n) {
        int highest_priority = -1;
        int min_priority = INT_MAX;
        
        // Find highest priority job that has arrived
        for(int i = 0; i < n; i++) {
            if(processes[i].arrival_time <= current_time && 
               processes[i].remaining_time > 0 && 
               processes[i].priority < min_priority) {
                highest_priority = i;
                min_priority = processes[i].priority;
            }
        }
        
        if(highest_priority == -1) {
            current_time++;
            continue;
        }
        
        // Execute the highest priority job
        processes[highest_priority].waiting_time = current_time - processes[highest_priority].arrival_time;
        current_time += processes[highest_priority].burst_time;
        processes[highest_priority].completion_time = current_time;
        processes[highest_priority].remaining_time = 0;
        completed++;
    }
}

// User Thread Implementation in C
#include <pthread.h>

void* thread_function(void* arg) {
    int thread_id = *(int*)arg;
    printf("Thread %d is running\n", thread_id);
    return NULL;
}

int main() {
    pthread_t threads[5];
    int thread_ids[5];
    
    // Create threads
    for(int i = 0; i < 5; i++) {
        thread_ids[i] = i;
        pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]);
    }
    
    // Wait for threads to complete
    for(int i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("All threads completed\n");
    return 0;
}

// Peterson's Algorithm for Two Processes
int turn = 0;
int flag[2] = {0, 0};

void enter_critical_section(int process_id) {
    int other = 1 - process_id;
    
    flag[process_id] = 1;  
    // Show interest
    turn = other;        
    // Give turn to other process
    
    // Wait until other process is not interested or it's our turn
    while(flag[other] == 1 && turn == other) {
        // Busy wait
    }
}

void exit_critical_section(int process_id) {
    flag[process_id] = 0;  
    // No longer interested
}

// Semaphore Implementation
#include <semaphore.h>

sem_t mutex;  
// Binary semaphore for mutual exclusion
sem_t empty;  
// Counting semaphore for empty slots
sem_t full;   
// Counting semaphore for full slots

void producer() {
    while(1) {
        // Produce item
        sem_wait(&empty);  
        // Wait for empty slot
        sem_wait(&mutex);  
        // Enter critical section
        
        // Add item to buffer
        
        sem_post(&mutex);  
        // Exit critical section
        sem_post(&full);   
        // Signal that buffer is full
    }
}

void consumer() {
    while(1) {
        sem_wait(&full);   
        // Wait for full slot
        sem_wait(&mutex);  
        // Enter critical section
        
        // Remove item from buffer
        
        sem_post(&mutex);  
        // Exit critical section
        sem_post(&empty);  
        // Signal that buffer is empty
    }
}

// Mutex Implementation
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_function(void* arg) {
    pthread_mutex_lock(&mutex);  
    // Acquire lock
    
    // Critical section
    printf("Thread %d in critical section\n", *(int*)arg);
    
    pthread_mutex_unlock(&mutex);  
    // Release lock
    return NULL;
}

// Dining Philosophers Problem Solution
#include <pthread.h>
#include <semaphore.h>

#define N 5  
// Number of philosophers

sem_t chopsticks[N];
sem_t mutex;

void* philosopher(void* arg) {
    int id = *(int*)arg;
    int left = id;
    int right = (id + 1) % N;
    
    while(1) {
        // Think
        printf("Philosopher %d is thinking\n", id);
        
        // Pick up chopsticks
        sem_wait(&mutex);
        sem_wait(&chopsticks[left]);
        sem_wait(&chopsticks[right]);
        sem_post(&mutex);
        
        // Eat
        printf("Philosopher %d is eating\n", id);
        
        // Put down chopsticks
        sem_post(&chopsticks[left]);
        sem_post(&chopsticks[right]);
    }
    
    return NULL;
}

// Readers-Writers Problem Solution
#include <pthread.h>
#include <semaphore.h>

sem_t mutex;      
// Protects read_count
sem_t write_lock; 
// Protects the shared resource
int read_count = 0;

void* reader(void* arg) {
    int id = *(int*)arg;
    
    while(1) {
        sem_wait(&mutex);
        read_count++;
        if(read_count == 1) {
            sem_wait(&write_lock);  
            // First reader blocks writers
        }
        sem_post(&mutex);
        
        // Read the shared resource
        printf("Reader %d is reading\n", id);
        
        sem_wait(&mutex);
        read_count--;
        if(read_count == 0) {
            sem_post(&write_lock);  
            // Last reader allows writers
        }
        sem_post(&mutex);
    }
    
    return NULL;
}

void* writer(void* arg) {
    int id = *(int*)arg;
    
    while(1) {
        sem_wait(&write_lock);
        
        // Write to the shared resource
        printf("Writer %d is writing\n", id);
        
        sem_post(&write_lock);
    }
    
    return NULL;
}

// Banker's Algorithm Implementation
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3

int available[MAX_RESOURCES];
int maximum[MAX_PROCESSES][MAX_RESOURCES];
int allocation[MAX_PROCESSES][MAX_RESOURCES];
int need[MAX_PROCESSES][MAX_RESOURCES];
int finish[MAX_PROCESSES] = {0};

int is_safe_state() {
    int work[MAX_RESOURCES];
    int safe_sequence[MAX_PROCESSES];
    int count = 0;
    
    // Initialize work array
    for(int i = 0; i < MAX_RESOURCES; i++) {
        work[i] = available[i];
    }
    
    // Find a process that can be allocated resources
    while(count < MAX_PROCESSES) {
        int found = 0;
        
        for(int i = 0; i < MAX_PROCESSES; i++) {
            if(!finish[i]) {
                int can_allocate = 1;
                
                for(int j = 0; j < MAX_RESOURCES; j++) {
                    if(need[i][j] > work[j]) {
                        can_allocate = 0;
                        break;
                    }
                }
                
                if(can_allocate) {
                    for(int j = 0; j < MAX_RESOURCES; j++) {
                        work[j] += allocation[i][j];
                    }
                    safe_sequence[count] = i;
                    finish[i] = 1;
                    count++;
                    found = 1;
                }
            }
        }
        
        if(!found) {
            return 0; 
            // Deadlock detected
        }
    }
    
    return 1; 
    // Safe state
}

// Page Table Entry Structure
struct page_table_entry {
    int frame_number;     
    // Physical frame number
    int valid_bit;        
    // 1 if page is in memory
    int dirty_bit;        
    // 1 if page has been modified
    int reference_bit;    
    // 1 if page has been accessed
    int protection;       
    // Read/write permissions
};

// Directory Entry Structure
struct directory_entry {
    char filename[32];
    int inode_number;
    char file_type;        
    // 'f' for file, 'd' for directory
    long file_size;
    time_t creation_time;
    time_t modification_time;
};

// Disk Scheduling Algorithms

// First Come First Serve (FCFS)
int fcfs(int requests[], int n, int head) {
    int total_seek = 0;
    
    for(int i = 0; i < n; i++) {
        total_seek += abs(requests[i] - head);
        head = requests[i];
    }
    
    return total_seek;
}

// Shortest Seek Time First (SSTF)
int sstf(int requests[], int n, int head) {
    int total_seek = 0;
    int visited[1000] = {0};
    
    for(int i = 0; i < n; i++) {
        int min_distance = INT_MAX;
        int min_index = -1;
        
        for(int j = 0; j < n; j++) {
            if(!visited[j]) {
                int distance = abs(requests[j] - head);
                if(distance < min_distance) {
                    min_distance = distance;
                    min_index = j;
                }
            }
        }
        
        total_seek += min_distance;
        head = requests[min_index];
        visited[min_index] = 1;
    }
    
    return total_seek;
}

// SCAN (Elevator) Algorithm
int scan(int requests[], int n, int head, int direction) {
    int total_seek = 0;
    int visited[1000] = {0};
    
    // Sort requests for efficient processing
    for(int i = 0; i < n-1; i++) {
        for(int j = 0; j < n-i-1; j++) {
            if(requests[j] > requests[j+1]) {
                int temp = requests[j];
                requests[j] = requests[j+1];
                requests[j+1] = temp;
            }
        }
    }
    
    // Process requests based on direction
    if(direction == 1) { // Moving towards higher tracks
        for(int i = 0; i < n; i++) {
            if(requests[i] >= head) {
                total_seek += abs(requests[i] - head);
                head = requests[i];
            }
        }
        // Reverse direction and process remaining requests
        for(int i = n-1; i >= 0; i--) {
            if(requests[i] < head) {
                total_seek += abs(requests[i] - head);
                head = requests[i];
            }
        }
    } else { // Moving towards lower tracks
        for(int i = n-1; i >= 0; i--) {
            if(requests[i] <= head) {
                total_seek += abs(requests[i] - head);
                head = requests[i];
            }
        }
        // Reverse direction and process remaining requests
        for(int i = 0; i < n; i++) {
            if(requests[i] > head) {
                total_seek += abs(requests[i] - head);
                head = requests[i];
            }
        }
    }
    
    return total_seek;
}

// RAID 5 Parity Calculation
unsigned char calculate_parity(unsigned char data[], int size) {
    unsigned char parity = 0;
    
    for(int i = 0; i < size; i++) {
        parity ^= data[i]; // XOR operation for parity
    }
    
    return parity;
}

// RAID 5 Data Recovery
unsigned char recover_data(unsigned char data[], int size, 
                           unsigned char parity, int failed_index) {
    unsigned char recovered = parity;
    
    for(int i = 0; i < size; i++) {
        if(i != failed_index) {
            recovered ^= data[i];
        }
    }
    
    return recovered;
}

// Access Control Matrix Implementation
struct access_control_entry {
    char subject[32];    // User or process identifier
    char object[32];     // File or resource identifier
    int permissions;        // Read, Write, Execute permissions
};

// Access Control Matrix
struct access_control_matrix {
    struct access_control_entry entries[1000];
    int entry_count;
};

// Check access permissions
int check_access(char* subject, char* object, int permission) {
    for(int i = 0; i < matrix.entry_count; i++) {
        if(strcmp(matrix.entries[i].subject, subject) == 0 && 
           strcmp(matrix.entries[i].object, object) == 0) {
            return (matrix.entries[i].permissions & permission) == permission;
        }
    }
    return 0; // Access denied
}

// Role-Based Access Control Implementation
struct role {
    char role_name[32];
    int permissions;
};

struct user {
    char username[32];
    char roles[10][32];
    int role_count;
};

int check_rbac_access(struct user* user, char* resource, int permission) {
    for(int i = 0; i < user->role_count; i++) {
        if(has_role_permission(user->roles[i], resource, permission)) {
            return 1;
        }
    }
    return 0;
}

// Password Authentication System
#include <stdio.h>
#include <string.h>
#include <openssl/sha.h>

struct user_account {
    char username[32];
    char password_hash[64];
    char salt[16];
    int failed_attempts;
    time_t lockout_time;
};

// Hash password with salt
void hash_password(const char* password, const char* salt, char* hash) {
    char salted_password[256];
    sprintf(salted_password, "%s%s", password, salt);
    
    SHA256_CTX ctx;
    SHA256_Init(&ctx);
    SHA256_Update(&ctx, salted_password, strlen(salted_password));
    SHA256_Final((unsigned char*)hash, &ctx);
}

// Verify password
int verify_password(struct user_account* account, const char* password) {
    char computed_hash[64];
    hash_password(password, account->salt, computed_hash);
    
    return strcmp(account->password_hash, computed_hash) == 0;
}

// Two-Factor Authentication with TOTP
int verify_totp(const char* secret, int code) {
    time_t current_time = time(NULL);
    int time_step = 30; // 30-second window
    int counter = current_time / time_step;
    
    // Generate TOTP code (simplified)
    int expected_code = generate_totp(secret, counter);
    
    // Check current and adjacent windows for clock skew
    return (code == expected_code || 
            code == generate_totp(secret, counter - 1) || 
            code == generate_totp(secret, counter + 1));
}

// Producer-Consumer Problem Implementation
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>

#define BUFFER_SIZE 5
#define MAX_ITEMS 10

// Shared buffer and synchronization variables
int buffer[BUFFER_SIZE];
int in = 0, out = 0;
sem_t empty, full, mutex;

// Producer thread function
void* producer(void* arg) {
    int item;
    
    for(int i = 0; i < MAX_ITEMS; i++) {
        item = i;
        
        // Wait for empty slot in buffer
        sem_wait(&empty);
        
        // Acquire mutex for critical section
        sem_wait(&mutex);
        
        // Add item to buffer
        buffer[in] = item;
        printf("Producer: Produced item %d at position %d\n", item, in);
        in = (in + 1) % BUFFER_SIZE;
        
        // Release mutex and signal full slot
        sem_post(&mutex);
        sem_post(&full);
        
        // Simulate production time
        usleep(100000);
    }
    
    return NULL;
}

// Consumer thread function
void* consumer(void* arg) {
    int item;
    
    for(int i = 0; i < MAX_ITEMS; i++) {
        // Wait for item in buffer
        sem_wait(&full);
        
        // Acquire mutex for critical section
        sem_wait(&mutex);
        
        // Remove item from buffer
        item = buffer[out];
        printf("Consumer: Consumed item %d from position %d\n", item, out);
        out = (out + 1) % BUFFER_SIZE;
        
        // Release mutex and signal empty slot
        sem_post(&mutex);
        sem_post(&empty);
        
        // Simulate consumption time
        usleep(150000);
    }
    
    return NULL;
}

// Main function to demonstrate producer-consumer
int main() {
    pthread_t producer_thread, consumer_thread;
    
    // Initialize semaphores
    sem_init(&empty, 0, BUFFER_SIZE); // Buffer starts empty
    sem_init(&full, 0, 0);        // No items initially
    sem_init(&mutex, 0, 1);       // Binary semaphore for mutual exclusion
    
    // Create producer and consumer threads
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);
    
    // Wait for threads to complete
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    
    // Clean up semaphores
    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);
    
    printf("Producer-Consumer demonstration completed.\n");
    return 0;
}

// Advanced File Copy Program with Error Handling
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define BUFFER_SIZE 4096
#define MAX_PATH 256

// Function to copy file with progress tracking
int copy_file(char* source, char* destination) {
    FILE *src, *dst;
    char buffer[BUFFER_SIZE];
    size_t bytes_read, bytes_written;
    long total_bytes = 0;
    long file_size;
    
    // Validate input parameters
    if(source == NULL || destination == NULL) {
        fprintf(stderr, "Error: Invalid file paths\n");
        return -1;
    }
    
    // Check if source and destination are the same
    if(strcmp(source, destination) == 0) {
        fprintf(stderr, "Error: Source and destination are the same\n");
        return -1;
    }
    
    // Open source file for reading
    src = fopen(source, "rb");
    if(src == NULL) {
        fprintf(stderr, "Error opening source file '%s': %s\n", source, strerror(errno));
        return -1;
    }
    
    // Get file size for progress tracking
    fseek(src, 0, SEEK_END);
    file_size = ftell(src);
    fseek(src, 0, SEEK_SET);
    
    // Open destination file for writing
    dst = fopen(destination, "wb");
    if(dst == NULL) {
        fprintf(stderr, "Error opening destination file '%s': %s\n", destination, strerror(errno));
        fclose(src);
        return -1;
    }
    
    printf("Starting file copy: %s -> %s\n", source, destination);
    printf("File size: %ld bytes\n", file_size);
    
    // Copy file content in chunks
    while((bytes_read = fread(buffer, 1, BUFFER_SIZE, src)) > 0) {
        bytes_written = fwrite(buffer, 1, bytes_read, dst);
        
        if(bytes_written != bytes_read) {
            fprintf(stderr, "Error writing to destination file: %s\n", strerror(errno));
            fclose(src);
            fclose(dst);
            return -1;
        }
        
        total_bytes += bytes_written;
        
        // Show progress
        if(file_size > 0) {
            int progress = (int)((total_bytes * 100) / file_size);
            printf("\rProgress: %d%% (%ld/%ld bytes)", progress, total_bytes, file_size);
            fflush(stdout);
        }
    }
    
    // Check for read errors
    if(ferror(src)) {
        fprintf(stderr, "\nError reading source file: %s\n", strerror(errno));
        fclose(src);
        fclose(dst);
        return -1;
    }
    
    // Close files
    fclose(src);
    fclose(dst);
    
    printf("\nFile copied successfully: %ld bytes\n", total_bytes);
    return 0;
}

// Function to create directory if it doesn't exist
int ensure_directory(char* path) {
    char temp_path[MAX_PATH];
    char *token;
    
    strcpy(temp_path, path);
    token = strtok(temp_path, "/");
    
    while(token != NULL) {
        if(mkdir(token, 0755) != 0 && errno != EEXIST) {
            fprintf(stderr, "Error creating directory '%s': %s\n", token, strerror(errno));
            return -1;
        }
        token = strtok(NULL, "/");
    }
    
    return 0;
}

// Main function demonstrating file operations
int main(int argc, char* argv[]) {
    if(argc != 3) {
        printf("Usage: %s <source_file> <destination_file>\n", argv[0]);
        return 1;
    }
    
    // Ensure destination directory exists
    char *last_slash = strrchr(argv[2], '/');
    if(last_slash != NULL) {
        *last_slash = '\0';
        if(ensure_directory(argv[2]) != 0) {
            return 1;
        }
        *last_slash = '/';
    }
    
    // Perform file copy
    if(copy_file(argv[1], argv[2]) == 0) {
        printf("File copy operation completed successfully.\n");
        return 0;
    } else {
        printf("File copy operation failed.\n");
        return 1;
    }
}