Process creation (fork and exec) in Operating Systems - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding fork() behavior

What happens immediately after a fork() system call in a Unix-like operating system?

A The child process starts executing a different program automatically.

B The parent process is replaced by a new program.

C The operating system terminates the parent process.

D A new child process is created as a copy of the parent process.

💡 Hint

Think about whether the parent process continues to run after fork().

After fork(), the operating system creates a new child process that is an exact copy of the parent process. Both processes continue running independently.

📋 Factual

intermediate

Role of exec() in process creation

What is the primary purpose of the exec() family of system calls in process creation?

A To create a new process by duplicating the current one.

B To terminate the current process and all its children.

C To replace the current process's memory space with a new program.

D To pause the current process until a child finishes execution.

💡 Hint

Consider what happens to the program code when exec() is called.

The exec() system call replaces the current process's code and data with a new program, without creating a new process.

🔍 Analysis

advanced

Output of combined fork() and exec() code

Consider the following code snippet in a Unix-like system:

pid = fork()
if pid == 0:
    exec("/bin/ls")
else:
    wait()

What is the expected behavior of this code?

A The code causes a runtime error because exec() is called incorrectly.

B The child process lists directory contents, parent waits for child to finish.

C Both parent and child list directory contents simultaneously.

D The parent process lists directory contents, child waits.

💡 Hint

Remember what fork() returns in parent and child, and what exec() does.

The child process replaces its code with /bin/ls and runs it. The parent waits for the child to finish before continuing.

❓ Comparison

advanced

Difference between fork() and exec()

Which statement best describes the difference between fork() and exec() system calls?

A <code>fork()</code> creates a new process; <code>exec()</code> replaces the current process's program.

B <code>fork()</code> replaces the current process's program; <code>exec()</code> creates a new process.

C Both <code>fork()</code> and <code>exec()</code> create new processes but in different ways.

D <code>fork()</code> terminates the current process; <code>exec()</code> pauses it.

💡 Hint

Think about whether each call creates a new process or changes the current one.

fork() duplicates the current process creating a child; exec() replaces the current process's code with a new program.

❓ Reasoning

expert

Why use fork() before exec()?

Why do most Unix-like programs use fork() followed by exec() to run a new program instead of just calling exec() directly?

A To create a new process so the original program can continue running separately.

B Because <code>fork()</code> cleans up memory before <code>exec()</code> runs.

C Because <code>exec()</code> cannot be called without <code>fork()</code> first.

D To ensure the new program runs with higher priority than the original.

💡 Hint

Consider what happens if exec() is called without fork().

Calling exec() replaces the current program, so fork() is used first to create a new process that runs the new program, allowing the original to continue.

Practice

1. What does the fork() system call do in an operating system?

easy

A. Replaces the current process with a new program

B. Creates a new process by copying the current process

C. Terminates the current process immediately

D. Pauses the current process temporarily

Solution

1. Step 1: Understand the role of fork()

   The fork() call creates a new process by duplicating the current one, including its code and data.

2. Step 2: Differentiate from exec()

   Unlike exec(), which replaces the process, fork() makes a copy, so both processes continue running.

3. Final Answer:

   Creates a new process by copying the current process -> Option B

4. Quick Check:

   fork() = process copy [OK]

Hint: Remember: fork copies, exec replaces [OK]

Common Mistakes:

• Confusing fork() with exec()
• Thinking fork() replaces the process
• Believing fork() pauses the process

2. Which of the following is the correct way to use exec() in a program?

easy

A. exec("ls -l")

B. exec("/bin/ls", "-l")

C. exec("/bin/ls", ["ls", "-l"])

D. exec("ls", "-l")

Solution

1. Step 1: Recall exec() syntax

   The exec() family requires the program path and an argument list, where the first argument is the program name.

2. Step 2: Identify correct argument format

   exec("/bin/ls", ["ls", "-l"]) correctly passes the path and an array with the program name and its argument.

3. Final Answer:

   exec("/bin/ls", ["ls", "-l"]) -> Option C

4. Quick Check:

   exec() needs path + argument list [OK]

Hint: exec() needs program path and argument array [OK]

Common Mistakes:

• Passing arguments as separate strings instead of array
• Using command line string instead of path
• Omitting the program name in argument list

3. Consider this code snippet in a Unix-like system:

pid = fork()
if pid == 0:
    exec("/bin/echo", ["echo", "Hello"])
else:
    print("Parent process")

What will be printed when this code runs?

medium

A. Parent process
Hello

B. Parent process

C. Hello

D. Hello
Parent process

Solution

1. Step 1: Understand fork() behavior

   The fork() creates a child process. The child runs the exec() replacing itself with the echo program.

2. Step 2: Analyze output from parent and child

   The parent (pid > 0) prints "Parent process". The child (pid == 0) calls exec(), loading /bin/echo which prints "Hello". Both outputs appear on stdout, typically with parent first.

3. Final Answer:

   Parent process Hello -> Option A

4. Quick Check:

   fork() + child exec() = both print [OK]

Hint: fork() child exec(): both print, parent first [OK]

Common Mistakes:

• Thinking only parent prints
• Reversing the output order
• Believing exec() prevents child output

4. What is wrong with this code snippet?

pid = fork()
if pid == 0:
    exec("ls", ["ls", "-l"])
else:
    print("Parent")

medium

A. The exec call is missing the full path to the program

B. fork() should be replaced with exec()

C. The parent process should call exec() instead

D. The argument list to exec() should be a string, not a list

Solution

1. Step 1: Check exec() usage

   The exec() call requires the full path to the executable, not just the command name.

2. Step 2: Identify the missing full path

   Using "ls" without "/bin/ls" will cause exec to fail because it won't find the program.

3. Final Answer:

   The exec call is missing the full path to the program -> Option A

4. Quick Check:

   exec() needs full path [OK]

Hint: Always use full path in exec() [OK]

Common Mistakes:

• Using command name without path in exec()
• Confusing fork() and exec() roles
• Passing wrong argument types to exec()

5. A program wants to run another program safely without stopping itself. Which sequence of system calls should it use?

hard

A. Call exec() first, then fork()

B. Call exec() directly to run the new program

C. Call fork() twice, then the parent calls exec()

D. Call fork() to create a child, then the child calls exec()

Solution

1. Step 1: Understand process creation and replacement

   Calling exec() replaces the current process, so calling it directly stops the original program.

2. Step 2: Use fork() then exec() in child

   By calling fork(), the program creates a child process. The child can then call exec() to run the new program, leaving the parent running.

3. Final Answer:

   Call fork() to create a child, then the child calls exec() -> Option D

4. Quick Check:

   fork() then exec() = safe new program run [OK]

Hint: fork first, then exec in child to keep parent alive [OK]

Common Mistakes:

• Calling exec() directly and losing original process
• Calling fork() twice unnecessarily
• Calling exec() before fork()