OPERATING SYSTEM MODULE ANSWERS (SEC-G)

1….A. Linux File System Structure and Directory Creation

Benefit of Linux File System Structure

The Linux file system structure helps organize data in a hierarchical manner, allowing for easier management of files and resources. Some
key advantages for Tech Solutions' IT team:

1. Separation of System Files and User Files:

o System files are typically under / (root), /bin, /sbin, /lib, while user-specific data is in /home.

o This helps prevent accidental overwriting of important system files by regular users.

2. Security and Permissions:

o Linux uses file permissions (read, write, execute) and user/group ownership to ensure only authorized personnel can
access sensitive files.

3. Consistency:

o The standard structure ensures that admins can easily locate files and directories across different servers.

Process to Create the projects Directory and project.txt File

1. Navigate to the desired location:

o For example, /home/username/.

o cd /home/username/

2. Create the projects directory:

mkdir projects

3. Navigate to the projects directory:

cd projects

4. Create the project.txt file:

touch project.txt

5.Set appropriate permissions:

 For example, allowing only the user to write and read, but others to only read:

chmod 644 project.txt

6. Setting the ownership (if needed):

 Assuming username is the user and groupname is the group:

chown username:groupname project.txt

B. Deleting the "Completed Project" Directory and Application Crash Diagnosis

Command to Safely Delete a Directory

To safely delete the directory named "completed project" and all its contents, use the following command:

rm -rf "completed project"

 Explanation:

o rm: Remove files.

o -r: Recursively delete all files and subdirectories.

o -f: Force the deletion without asking for confirmation.

Diagnosing Application Crashes

In case of an application crash, the IT team should first check:

1. Log Files:

o Common locations:

 /var/log/syslog (system logs)

 /var/log/messages (general logs)

 /var/log/apache2/ (if using Apache)

 /var/log/nginx/ (if using Nginx)

o These logs may contain error messages or other details about why the crash occurred.

2. Application-specific Logs:

o Many applications create their own log files (e.g., in /var/log/ or within their own directories). Check these for any
unusual activity or error codes.

3. System Resource Usage:

o Check top, htop, or free to ensure there is no excessive CPU, memory, or disk usage that might have caused the crash.

C. Directory Structure for a Software Project and Backup Script

Directory Structure for Project-related Files

For a new software project, the directory structure can be designed as follows:

/projects

└── /project_name

├── /docs # Documentation files

├── /src # Source code files

├── /bin # Compiled binaries or executables

├── /tests # Unit and integration tests

├── /config # Configuration files

├── /assets # Media, graphics, or other static assets

└── /logs # Log files

Script to Backup Critical Directories

This bash script will back up the critical directories (/etc, /home, /var/www) to a secure location (e.g., /backups):

#!/bin/bash

# Define source and backup directory

SOURCE_DIRECTORIES=("/etc" "/home" "/var/www")

BACKUP_DIR="/backups"

DATE=$(date +%F)

BACKUP_FILE="backup_$DATE.tar.gz"

# Create backup directory if it doesn't exist

mkdir -p $BACKUP_DIR

# Perform the backup using tar

tar -czf $BACKUP_DIR/$BACKUP_FILE ${SOURCE_DIRECTORIES[@]}

# Check if the backup was successful

if [ $? -eq 0 ]; then

echo "Backup completed successfully!"

else

echo "Backup failed."

Fi

Explanation:

 This script creates a backup of /etc, /home, and /var/www in a compressed .tar.gz file.

 The backup file is stored with a date-based filename to ensure uniqueness.

 It checks for errors in the backup process by verifying the exit status

2….A. Counting Files and Subdirectories and Checking Ownership

1. Counting the Number of Files and Subdirectories

To count files and subdirectories in a directory:

Count all files:

find /path/to/directory -type f | wc -l

 -type f: Finds only files.

 wc -l: Counts the number of lines (one for each file).

Count all subdirectories:

find /path/to/directory -type d | wc -l


o -type d: Finds only directories.

2. Finding the Owner and Group of a File or Directory

Use the ls -l command to find the owner and group:

ls -l /path/to/file_or_directory

-rw-r--r-- 1 username groupname 1234 Jan 22 12:00 file.txt

 username: Owner.

 groupname: Group.

B. Checking Disk Space and Safe File Deletions

1. Checking Available Disk Space

Use the df command to check disk space:

df -h
  -h: Displays sizes in a human-readable format (e.g., GB, MB).

 Output includes:

o Filesystem.

o Total size.

o  Used space.

o  Available space.

o  Mounted directory.

2. Why is rm -rf Dangerous?

The rm -rf command is dangerous because:

 No Confirmation: It deletes all files and directories recursively without asking for confirmation.
 Irrecoverable Deletions: Once executed, data cannot be recovered without backups.
 Risk of Typos: A small typo can lead to deleting unintended directories (e.g., / or /home).

3. Preventing Accidental Deletions

 Use Interactive Mode:

rm -ri /path/to/directory

o Prompts for confirmation before deletion.

o Use --preserve-root:

rm -rf --preserve-root /

  Prevents accidental deletion of the root directory.

 Enable Aliases: Add this alias to ~/.bashrc to make rm safer:

alias rm='rm -i'

Prompts for confirmation before deleting.

C. Shell Script to Safely Identify and Delete Unnecessary Files

Here is a script to find and delete empty files or temporary files (e.g., files ending with .tmp or .bak) safely:

#!/bin/bash

# Define the directory to search

TARGET_DIR="/path/to/project"

# Log file for recording deletions

LOG_FILE="/var/log/cleanup.log"

DATE=$(date +%F)

# Create or clear the log file

echo "Cleanup started on $DATE" > $LOG_FILE

# Find and delete empty files

echo "Finding and deleting empty files..." >> $LOG_FILE

find $TARGET_DIR -type f -empty -print -delete >> $LOG_FILE

# Find and delete temporary files (.tmp, .bak)

echo "Finding and deleting temporary files (.tmp, .bak)..." >> $LOG_FILE

find $TARGET_DIR -type f \( -name "*.tmp" -o -name "*.bak" \) -print -delete >> $LOG_FILE

# Log completion

echo "Cleanup completed on $(date)" >> $LOG_FILE

# Print message to console

echo "Cleanup completed. Details logged in $LOG_FILE."

How It Works

1. Defines the target directory: Replace /path/to/project with the directory to clean.

2. Logs deletions: Creates a log file (/var/log/cleanup.log) to record what was deleted.

3. Deletes empty files: Finds and deletes files with zero size (-empty).

4. Deletes temporary files: Deletes files with .tmp or .bak extensions.

5. Safety: Logs all actions for review.

Running the Script

Save the script as cleanup.sh, make it executable, and run it:

chmod +x cleanup.sh

./cleanup.sh

This ensures unnecessary files are removed systematically and with a record for auditing purposes. Let me know if you need further details!

3…..A. Input Validation Importance and Handling Negative Numbers

Importance of Input Validation

Input validation ensures that the program:

1. Processes valid data: Prevents errors and undefined behavior caused by invalid inputs.

2. Improves security: Reduces vulnerabilities like crashes or code injection.

3. Maintains functionality: Ensures the program operates as intended with meaningful results.

4. Guides users: Helps users provide correct inputs through clear feedback.

Illustration for Negative Number Input

If the system accepts only positive numbers and a negative number is entered, it should:

1. Detect the negative input.

2. Display an error message.

3. Re-prompt the user to input a valid number.

B. Code to Handle Division by Zero and Multiple Operations

Handling Division by Zero

#!/bin/bash

# Function to perform division

divide() {

local num1=$1

local num2=$2

# Check for division by zero

if (( num2 == 0 )); then

echo "Error: Division by zero is not allowed."

return 1

fi

# Perform division

result=$(echo "scale=2; $num1 / $num2" | bc)

echo "Result: $result"

# Example Usage

read -p "Enter numerator: " numerator

read -p "Enter denominator: " denominator

divide "$numerator" "$denominator"

Handling Multiple Operations

#!/bin/bash

# Function to evaluate an expression

evaluate_expression() {

local expression="$1"

result=$(echo "$expression" | bc -l 2>/dev/null)

# Check if the expression is valid

if [[ $? -ne 0 ]]; then

echo "Error: Invalid mathematical expression."

return 1

fi
 echo "Result: $result"

# Example Usage

read -p "Enter a mathematical expression (e.g., 2 + 3 * 4): " expression

evaluate_expression "$expression"

C. Handling Non-Numeric Inputs and Limiting Retries

Handling Non-Numeric Inputs Indefinitely

#!/bin/bash

# Function to validate numeric input

get_numeric_input() {

while true; do

read -p "Enter a positive number: " input

if [[ "$input" =~ ^[0-9]+$ ]]; then

echo "Valid input: $input"

break

else

echo "Error: Please enter a valid positive number."

fi

done

# Example Usage

get_numeric_input

Limiting Retries to 5 Attempts

#!/bin/bash

# Function to validate numeric input with a retry limit

get_numeric_input_with_limit() {

local max_attempts=5

local attempts=0

while (( attempts < max_attempts )); do

read -p "Enter a positive number: " input

if [[ "$input" =~ ^[0-9]+$ ]]; then

echo "Valid input: $input"

return 0
 else

echo "Error: Please enter a valid positive number."

fi

(( attempts++ ))

echo "Attempt $attempts of $max_attempts"

done

echo "Maximum attempts reached. Exiting."

return 1

4…..A. Tasks Assigned to Each Processor and Role of Processor 4

Tasks Assigned to Each Processor

1. Processor 1: Collects and analyzes congestion data from traffic sensors.

2. Processor 2: Adjusts traffic signals based on real-time congestion data.

3. Processor 3: Clears routes for ambulances and other emergency vehicles.

4. Processor 4: Updates and maintains the traffic database with real-time information.

Role of Processor 4

Processor 4 plays a critical role in ensuring:

 Data Consistency: Maintains an up-to-date traffic database that is used by other processors.

 Real-Time Updates: Provides accurate traffic conditions for analysis and signal adjustments.

 Historical Analysis: Logs traffic data for future optimization and decision-making.

B. Why Locks/Semaphores Are Necessary in the Traffic Management System

Locks and semaphores are essential in the system to ensure:

1. Preventing Data Corruption: Shared resources like traffic maps and sensor data can be modified by multiple processors
simultaneously. Locks or semaphores prevent simultaneous write operations, ensuring consistency.

o Example: Processor 1 analyzing congestion and Processor 4 updating the database should not access the same
data concurrently.

2. Ensuring Resource Availability: Semaphores can control access to limited resources (e.g., signal controllers) so tasks are
queued rather than causing conflicts.

3. Avoiding Race Conditions: Locks ensure that tasks requiring the same resource are executed sequentially, avoiding
unpredictable outcomes.

4. Maintaining System Integrity: Prioritized tasks like clearing ambulance routes require guaranteed access to critical
resources, which semaphores facilitate by granting priority access.

C. Pseudo-Code for Dynamic Task Reallocation

Here’s a pseudo-code solution to reallocate tasks dynamically when one processor becomes overloaded during peak traffic
hours:
Dynamic Load Balancing with Task Reallocation

# Define processor states and tasks

processors = [Processor1, Processor2, Processor3, Processor4]

tasks = {

"Analyze Congestion": Processor1,

"Adjust Signals": Processor2,

"Clear Ambulance Routes": Processor3,

"Update Traffic Database": Processor4

# Function to check processor load

function check_processor_load(processor):

return processor.current_load # Returns the load percentage (0-100)

# Function to find idle or least-loaded processor

function find_idle_processor():

min_load = 100

idle_processor = null

for processor in processors:

load = check_processor_load(processor)

if load < min_load:

min_load = load

idle_processor = processor

return idle_processor

# Dynamic task reallocation logic

function reallocate_tasks():

for task, assigned_processor in tasks:

load = check_processor_load(assigned_processor)

# If the processor is overloaded (e.g., > 80% load), reassign the task

if load > 80:

idle_processor = find_idle_processor()

if idle_processor != null and idle_processor != assigned_processor:

print("Reassigning task:", task, "from", assigned_processor.name, "to", idle_processor.name)

# Reassign the task

 assigned_processor.remove_task(task)

idle_processor.assign_task(task)

else:

print("No idle processors available. Task", task, "remains on", assigned_processor.name)

# Main execution loop

while system_is_running:

reallocate_tasks()

wait(5) # Check and reallocate every 5 seconds

5…..A

B. CPU Allocation Sequence for Algorithms

Job Details

 Jobs: P, Q, R, S, T, U

 Burst Times: 10, 5, 7, 2, 4, 8

 Priorities: 8, 4, 6, 2, 5, 3 (lower value = higher priority)

i) Round Robin (Time Quantum = 2 minutes)

Logic:

1. Assign CPU to each process for up to 2 minutes.

2. If a process's burst time exceeds 2 minutes, add it to the end of the queue.

3. Continue until all processes complete.

Sequence:

P(2), Q(2), R(2), S(2), T(2), U(2), P(2), Q(2), R(2), T(2), U(2), P(2), R(1), U(2), P(2), U(2)

Completion Times:

 P: 22, Q: 8, R: 16, S: 2, T: 10, U: 24

ii) Priority Scheduling (Non-Preemptive)

Logic:

1. Sort processes by priority (lower value = higher priority).

2. Execute processes in order of their priorities.

Sequence:

S (2), Q (5), T (4), R (7), U (8), P (10)

iii) Shortest Job First (Non-Preemptive)

Logic:

1. Sort processes by burst time (ascending order).

2. Execute processes in that order.

Sequence:

S (2), T (4), Q (5), R (7), U (8), P (10)

C. Proposed Scheduling Algorithm for Multi-Core Processor System

Hybrid Scheduling Algorithm

Key Features:

1. Round Robin for Low-Priority Batch Tasks:

o Ensures fairness by providing time slices to all batch tasks.

o Balances throughput for low-priority tasks.

2. Priority Scheduling for High-Priority Real-Time Tasks:

o Guarantees low response times for real-time tasks based on priority.

3. Multilevel Queue Scheduling:

o Divides tasks into two queues:

 High-Priority Queue: For real-time tasks.

 Low-Priority Queue: For batch tasks.

4. Dynamic Time Slices:

o High-priority tasks get immediate execution.

o Low-priority tasks are executed in round-robin with adjustable time slices based on system load.

Algorithm Logic

1. Queue Assignment:

o Assign tasks to Queue 1 (High Priority) or Queue 2 (Low Priority) based on priority.
2. Queue Scheduling:

o Execute all tasks in Queue 1 using priority scheduling (preemptive).

o If Queue 1 is empty, execute tasks in Queue 2 using round-robin.

3. Dynamic Adjustments:

o Monitor system load.

o Increase or decrease time quantum for Queue 2 based on batch task load.

# Initialization

Queue1 = [] # High-priority real-time tasks

Queue2 = [] # Low-priority batch tasks

TimeQuantum = 2

# Task Assignment

for task in tasks:

if task.priority <= HIGH_PRIORITY_THRESHOLD:

Queue1.append(task)

else:

Queue2.append(task)

# Scheduling Loop

while Queue1 or Queue2:

# Process High-Priority Queue

while Queue1:

task = Queue1.pop(0)

execute_task(task)

# Process Low-Priority Queue with Round Robin

for task in Queue2:

if task.remaining_time <= TimeQuantum:

execute_task(task)

Queue2.remove(task)

else:

task.remaining_time -= TimeQuantum

move_to_end(Queue2, task)

# Dynamic Adjustment

if system_load_high():

TimeQuantum = increase_time_quantum()
 else:

TimeQuantum = decrease_time_quantum()

6…..A.Need for Multiprocessing in the University Server Scenario

Why Multiprocessing is Needed

In the given scenario where a university server runs multiple services (web server, database server, file-sharing service),
multiprocessing is crucial because:

1. Parallel Execution of Independent Services: Each service can be run as a separate process, which can independently execute
on separate CPU cores. This improves server performance, as tasks like handling web requests, managing database queries, and
processing file-sharing activities can all happen concurrently without waiting for each other.

2. Fault Isolation: If one service (e.g., the database server) crashes, it won’t affect the other services (e.g., web server or file-
sharing service). Each service runs in its own process, ensuring greater stability.

3. Better Resource Utilization: Multiprocessing allows each core of the CPU to handle separate tasks, which improves overall
system throughput and ensures that the server can scale well under heavy load.

Examples of Multiprocessing Systems

 Web Servers: Apache, Nginx (runs different processes to handle multiple web requests simultaneously).

 Database Servers: MySQL, PostgreSQL (handle multiple queries by running different processes for different client requests).

 Operating Systems: Unix, Linux (use multiprocessing to run multiple applications and services simultaneously).

 Parallel Computing Systems: Supercomputers, cloud-based systems (e.g., AWS EC2, Google Cloud Compute Engine) that use
multiprocessing to perform complex computations in parallel.

B. Code to Create Multiple Processes and Process Management

Code Example (Python) to Create Multiple Processes

import multiprocessing

import time

# Function to simulate a task

def task(name, duration):

print(f"Task {name} started.")

time.sleep(duration)

print(f"Task {name} completed.")

# Creating multiple processes

if __name__ == "__main__":

processes = []

tasks = [("Web Server", 2), ("Database Server", 3), ("File Sharing", 1)]

for task_name, task_duration in tasks:

p = multiprocessing.Process(target=task, args=(task_name, task_duration))

processes.append(p)

p.start() # Start the process

 for p in processes:

p.join() # Wait for all processes to complete

print("All tasks completed.")

C. Process and Thread Synchronization Issues

Synchronization Issues Leading to Data Corruption or Race Conditions

 Race Conditions occur when multiple threads or processes access shared resources simultaneously and the final outcome
depends on the order in which they access the resource. This can lead to unpredictable results or corruption of data.

o Example: Two processes (e.g., Web Server and Database Server) updating the same user record in a database
at the same time without synchronization can cause data inconsistency.

Methods to Prevent Race Conditions and Ensure Synchronization

1. Locks:

o A lock is a synchronization primitive used to ensure that only one process or thread can access a critical section
(shared resource) at a time.

2. Semaphores:

 A semaphore is a signaling mechanism used to control access to a shared resource by multiple processes or threads. It
allows a set number of processes to access the resource concurrently.

3. Mutex (Mutual Exclusion):

 A mutex ensures that only one thread or process can access the critical section at a time. It’s similar to a lock, but a mutex
can only be released by the process that acquired it.

4. Condition Variables:

 Condition variables are used for synchronization between threads or processes that need to wait for a specific condition to
be met before proceeding.

5. Atomic Operations:

o Atomic operations are indivisible operations that cannot be interrupted. Using atomic operations prevents data
corruption in shared resources.

o In some programming languages like Python, you can use built-in atomic operations for counters or variables
(e.g., atomic.add() in threading libraries).

7……A. Concept of Multi-Threading

What is Multi-Threading?

Multi-threading is a programming technique where a process is divided into multiple smaller tasks called threads, which can
run concurrently. Each thread represents a separate flow of control, allowing the program to perform multiple operations at
the same time. In the context of the bank system, multi-threading is useful for handling simultaneous deposit, withdrawal, and
balance check requests without blocking other operations.

Functions of pthread_create() and pthread_join()

 pthread_create():

o This function is used to create a new thread. It takes several parameters, including a thread identifier, thread
attributes, the function that the thread will execute, and its arguments.

o Syntax:

o int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

pthread_join():
  This function is used to wait for a thread to finish execution. It ensures that the main thread or calling thread will block until the
specified thread terminates.
 Syntax

int pthread_join(pthread_t thread, void **retval);

B. Code to Create an Online Banking System (Simulating Multiple Transactions)

Here’s an implementation of a simple banking system using multiple threads for deposit, withdrawal, and balance check operations:

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <unistd.h>

#define MAX_TRANSACTIONS 100

// Shared data (Account balance)

double balance = 0.0;

pthread_mutex_t lock;

void* deposit(void* amount) {

double deposit_amount = *((double*)amount);

pthread_mutex_lock(&lock); // Lock to avoid race conditions

balance += deposit_amount;

printf("Deposited: $%.2f, New Balance: $%.2f\n", deposit_amount, balance);

pthread_mutex_unlock(&lock); // Unlock after operation

return NULL;

void* withdraw(void* amount) {

double withdraw_amount = *((double*)amount);

pthread_mutex_lock(&lock);

if (balance >= withdraw_amount) {

balance -= withdraw_amount;

printf("Withdrew: $%.2f, New Balance: $%.2f\n", withdraw_amount, balance);

} else {

printf("Insufficient funds for withdrawal of $%.2f. Current Balance: $%.2f\n", withdraw_amount, balance);

pthread_mutex_unlock(&lock);

return NULL;

}
void* check_balance(void* arg) {

pthread_mutex_lock(&lock);

printf("Current Balance: $%.2f\n", balance);

pthread_mutex_unlock(&lock);

return NULL;

int main() {

pthread_t threads[MAX_TRANSACTIONS];

double amounts[MAX_TRANSACTIONS];

int transaction_count = 0;

// Initialize the mutex lock

pthread_mutex_init(&lock, NULL);

// Simulate various operations

for (transaction_count = 0; transaction_count < MAX_TRANSACTIONS; transaction_count++) {

if (transaction_count % 3 == 0) {

amounts[transaction_count] = 50.0; // Deposit $50

pthread_create(&threads[transaction_count], NULL, deposit, &amounts[transaction_count]);

} else if (transaction_count % 3 == 1) {

amounts[transaction_count] = 30.0; // Withdraw $30

pthread_create(&threads[transaction_count], NULL, withdraw, &amounts[transaction_count]);

} else {

pthread_create(&threads[transaction_count], NULL, check_balance, NULL); // Check balance

usleep(1000); // Simulate some delay between operations

// Wait for all threads to finish

for (int i = 0; i < transaction_count; i++) {

pthread_join(threads[i], NULL);

// Destroy the mutex lock

pthread_mutex_destroy(&lock);
 return 0;

C. Code for Banking Simulation to Detect Transaction Limit and Safely Terminate Threads

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <unistd.h>

#define MAX_TRANSACTIONS 100

#define TRANSACTION_LIMIT 100

// Shared data

double balance = 0.0;

pthread_mutex_t lock;

int transaction_count = 0;

void* deposit(void* amount) {

double deposit_amount = *((double*)amount);

pthread_mutex_lock(&lock);

balance += deposit_amount;

printf("Deposited: $%.2f, New Balance: $%.2f\n", deposit_amount, balance);

pthread_mutex_unlock(&lock);

return NULL;

void* withdraw(void* amount) {

double withdraw_amount = *((double*)amount);

pthread_mutex_lock(&lock);

if (balance >= withdraw_amount) {

balance -= withdraw_amount;

printf("Withdrew: $%.2f, New Balance: $%.2f\n", withdraw_amount, balance);

} else {

printf("Insufficient funds for withdrawal of $%.2f. Current Balance: $%.2f\n", withdraw_amount, balance);

pthread_mutex_unlock(&lock);

return NULL;

}
void* check_balance(void* arg) {

pthread_mutex_lock(&lock);

printf("Current Balance: $%.2f\n", balance);

pthread_mutex_unlock(&lock);

return NULL;

void* transaction_manager(void* arg) {

while (transaction_count < TRANSACTION_LIMIT) {

double amount = rand() % 100 + 1; // Random amount for simulation

if (transaction_count % 3 == 0) {

pthread_create(&threads[transaction_count], NULL, deposit, &amount);

} else if (transaction_count % 3 == 1) {

pthread_create(&threads[transaction_count], NULL, withdraw, &amount);

} else {

pthread_create(&threads[transaction_count], NULL, check_balance, NULL);

usleep(1000);

transaction_count++;

return NULL;

int main() {

pthread_t threads[MAX_TRANSACTIONS];

pthread_t manager_thread;

pthread_mutex_init(&lock, NULL);

// Create a manager thread to handle transactions

pthread_create(&manager_thread, NULL, transaction_manager, NULL);

// Wait for manager thread to finish

pthread_join(manager_thread, NULL);

// Wait for all threads to finish

 for (int i = 0; i < transaction_count; i++) {

pthread_join(threads[i], NULL);

pthread_mutex_destroy(&lock);

printf("Transaction limit reached, all threads terminated safely.\n");

return 0;

9….A. Metrics for Measuring Process Resource Consumption

To effectively measure and manage process resource consumption, the IT team can focus on the following key metrics:

1. CPU Usage:

o This metric measures the percentage of CPU time consumed by a process. It can help identify processes that
are CPU-intensive and could potentially affect the performance of other processes.

2. Memory Usage (RAM):

o This includes both the total memory used by the process and the breakdown of memory consumption (e.g.,
shared memory, heap memory, stack memory). High memory usage can lead to memory leaks and swapping,
which degrades system performance.

3. I/O Operations:

o This measures the amount of input and output the process performs (e.g., disk reads/writes, network activity).
Excessive I/O can lead to bottlenecks, especially in disk or network-bound applications.

4. Process Priority:

o This refers to the scheduling priority of a process. Lower-priority processes may delay high-priority ones,
especially when resources are constrained.

5. Process State:

o Monitoring the state of a process (e.g., running, sleeping, waiting for I/O) can help identify when processes are
idle or blocked, preventing the system from fully utilizing available resources.

6. Process Lifetime:

o This refers to the duration a process has been running. Long-running processes could lead to resource
contention and cause inefficiency in resource allocation.

7. Disk Usage (Disk Space):

o Tracking the amount of disk space used by a process or its data files can prevent issues such as disk exhaustion,
leading to performance degradation.

8. Context Switches:

o The number of times the CPU switches from one process to another. A high number of context switches can be
indicative of overhead due to frequent task switching.

9. Throughput:

o This measures the number of tasks or requests a process can complete in a given time period. For servers
handling requests, higher throughput is a key performance metric.

B. Prioritizing Processes (Database Server vs. Web Server)

In a scenario where both a database server and a web server are running concurrently, the IT team needs to prioritize the processes
to ensure optimal performance:

1. Database Server:

o Priority Justification: The database server often handles critical business logic and is directly tied to
application performance. For example, if the database server is slowed down, web applications that rely on
database queries will also be delayed, leading to slow page loads and poor user experience.

o Prioritization Approach: Assign higher priority to the database server to ensure quick access to database
resources. The database server may need to have a real-time or high-priority scheduling class to prevent delays
in database transactions and maintain data consistency.

2. Web Server:

o Priority Justification: While the web server is important, its performance depends heavily on the database
server. Requests that are not time-sensitive (such as static content requests) can be handled at a lower priority
to allow the database server to focus on time-sensitive operations (e.g., complex queries, transactions).

o Prioritization Approach: The web server should be assigned a lower priority than the database server, focusing
on handling user requests that can tolerate some delay (e.g., caching static content, queuing requests).

Common Inefficiencies in Process Management:

 Unbalanced Load: If one process consumes too many resources (e.g., CPU or memory), it can starve other processes,
leading to inefficiencies.

 Inefficient Scheduling Algorithms: Without proper prioritization, low-priority tasks may block high-priority tasks,
leading to delayed responses.

 Excessive Context Switching: Frequent switching between processes can result in overhead, reducing overall system
throughput.

 Memory Leaks: If processes don't properly release memory, they can consume all available memory, causing swapping
and system slowdown.

 High Disk I/O: Processes that continuously read and write to disk without caching or optimizations can degrade overall
system performance.

C. Process Scheduling Algorithm to Prioritize Real-Time Processes

To improve process scheduling, we need to prioritize real-time tasks while ensuring fair resource allocation for non-critical tasks.

Scheduling Algorithm: Hybrid Approach (Priority + Round-Robin)

1. Real-Time Process Prioritization:

o Real-time processes should be assigned the highest priority, ensuring they are given CPU time before non-
critical processes. These processes could include tasks like transaction processing or critical alerts.

2. Round-Robin for Non-Critical Processes:

o For non-real-time tasks, we use a round-robin scheduling algorithm. This ensures that each process gets a fair
share of CPU time, preventing any one process from hogging the CPU.

3. Dynamic Load Balancing:

o When the system load increases, the algorithm adjusts priorities dynamically to allocate more CPU time to
high-priority processes and less to lower-priority ones.

Algorithm Steps:

1. Step 1: Identify the real-time processes that must be given priority over others (e.g., database transactions, emergency
responses).

2. Step 2: Assign the highest priority to real-time processes, ensuring they execute first.
 3. Step 3: For non-real-time tasks (e.g., web server requests), use a round-robin scheduler to give each process a fixed time
slice.

4. Step 4: If a process exceeds its time slice, it’s placed at the end of the queue, and the next process is scheduled.

5. Step 5: Monitor system load and adjust priority dynamically. If the system becomes overloaded, lower the priority of non-
essential tasks to ensure critical tasks are not delayed.

10….A. Code for Fibonacci Series Using fork()

Here’s an implementation where the parent process creates a child process using the fork() system call. The child process computes
the Fibonacci sequence and prints it.

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/wait.h>

void generate_fibonacci(int n) {

int a = 0, b = 1, c;

printf("Fibonacci sequence for %d terms: \n", n);

for (int i = 0; i < n; i++) {

if (i <= 1) {

printf("%d ", i);

} else {

c = a + b;

a = b;

b = c;

printf("%d ", c);

printf("\n");

int main(int argc, char *argv[]) {

if (argc != 2) {

printf("Usage: %s <number_of_terms>\n", argv[0]);

exit(1);

int n = atoi(argv[1]);

pid_t pid = fork(); // Create child process

 if (pid == -1) {

// Fork failed

perror("Fork failed");

exit(1);

if (pid == 0) {

// Child process: generate Fibonacci sequence

generate_fibonacci(n);

exit(0); // End child process

} else {

// Parent process waits for child to finish

wait(NULL);

printf("Child process completed.\n");

return 0;

B. Why Do the Parent and Child Processes Have Different Copies of the value Variable After the fork() Call?

After a fork() call, the parent and child processes have separate memory spaces. The fork() system call creates a duplicate of the
parent's memory space for the child. Both processes will have their own copies of all variables, including value, and any changes
made to a variable in one process will not affect the other process.

 Parent Process: After the fork(), the parent can continue its execution. It has its own copy of the memory, including the
variables.

 Child Process: The child gets its own copy of the memory, which includes a duplicate of all the parent's variables.
Changes made in the child process (e.g., modifying value) do not affect the parent process’s value, as they reside in
different memory spaces.

This is a result of copy-on-write semantics: both processes initially share the same physical memory pages, but as soon as either
process modifies the memory, a copy of that page is created for that process.

C. Using Shared Memory for Fibonacci Sequence

To allow both the parent and child processes to share the Fibonacci sequence, we can use shared memory. Here is a modified version
of the program where the Fibonacci sequence is written to a shared memory segment.

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/wait.h>

#include <sys/shm.h>

#include <sys/ipc.h>

#define MAX_TERMS 100

void generate_fibonacci(int n, int *shm_ptr) {

int a = 0, b = 1, c;

for (int i = 0; i < n; i++) {

if (i <= 1) {

shm_ptr[i] = i;

} else {

c = a + b;

a = b;

b = c;

shm_ptr[i] = c;

int main(int argc, char *argv[]) {

if (argc != 2) {

printf("Usage: %s <number_of_terms>\n", argv[0]);

exit(1);

int n = atoi(argv[1]);

// Create shared memory segment

key_t key = ftok("shmfile", 65); // Unique key for shared memory

int shmid = shmget(key, sizeof(int) * MAX_TERMS, 0666 | IPC_CREAT);

if (shmid == -1) {

perror("shmget failed");

exit(1);

// Attach shared memory to this process

int *shm_ptr = (int*) shmat(shmid, NULL, 0);

if (shm_ptr == (int *)-1) {

perror("shmat failed");

exit(1);

}
 pid_t pid = fork(); // Create child process

if (pid == -1) {

// Fork failed

perror("Fork failed");

exit(1);

if (pid == 0) {

// Child process generates Fibonacci sequence

generate_fibonacci(n, shm_ptr);

printf("Child process completed Fibonacci sequence.\n");

exit(0);

} else {

// Parent process waits for child and then prints Fibonacci sequence

wait(NULL);

printf("Parent process printing Fibonacci sequence: \n");

for (int i = 0; i < n; i++) {

printf("%d ", shm_ptr[i]);

printf("\n");

// Detach and destroy shared memory

shmdt(shm_ptr);

shmctl(shmid, IPC_RMID, NULL);

return 0;

Which is More Efficient?

 Multi-threading is generally more efficient than fork() for tasks like generating the Fibonacci sequence because threads
share memory, leading to lower overhead and faster communication.

 fork() involves creating a completely separate process with its own memory space, which is more expensive in terms of
both time and system resources. In contrast, threads are lighter and can share the same memory, making them more
suitable for tasks that involve frequent data exchange, like computing Fibonacci numbers.

However, multi-threading requires careful synchronization to avoid race conditions, which is less of an issue with fork() since
processes are isolated.