A shell is a command line interpreter that reads user input and executes commands.
Chapter 5: Standard I/O Library
Opening a Stream:
- FILE *fopen(const char *pathname, const char *type);
- FILE *freopen(const char *pathname, const char *type, FILE *fp);
Reading and Writing a Stream:
- int getc(FILE *fp);
- int putc(FILE *fp);
- char *fgets(char *buf, int n, FILE *fp);
- int *fputs(const char *str, FILE *fp);
Example:
\#include "ourhdr.h"
int main(void) {
}
int main(void) {
}
Chapter 8: Process Control
The only way a new process is created by the Unix kernel is when an existing process calls the fork function.
The new process created by fork is called the child process. This function is called once but returns twice. The only difference in the returns is that the return value in the child is 0 while the return value in the parent is the process ID of the new child. The reason the child's process ID is returned to the parent is because a process can have more than one child, so there is no function that allows a process to obtain the process IDs of its children. The reason fork returns 0 to the child is because a process can have only a single parent, so the child can always call getppid to obtain the process ID of its parent. (Process ID 0 is always in use by the swapper, so it's not possible for 0 to be the process ID of a child.)
Both the child and parent continue executing with the instruction that follows the call to fork. The child is a copy of the parent. For example, the child gets a copy of the parent's data space, heap, and stack. Note that this is a copy for the child--the parent and child do not share these portion of memory. Often the parent and child share the text segment, if it's read only.
In general, we never know if the child starts executing before the parent of vice versa. This depends on the scheduling algorithm used by the kernel. If it's required that the child and parent synchronize with each other, some form of interprocess communication is required.
When we redirect the standard output of the parent, the child's standard output is also redirected.
Example:
\#include <sys/types.h>
\#include "ourhdr.h"
int glob = 6;
char buf[] = "a write to stdout\n";
int main(void) {
}
There are two uses for fork:
- When a process wants to duplicate itself so that the parent and child can each execute different sections of code at the same time. This is common for network servers--the parent waits for a service request from a client. When the request arrives, the parent calls fork and lets the child handle the request. The parent goes back to waiting for the next service request to arrive.
- When a process wants to execute a different program. This is common for shells. In this case, the child does and exec right after it returns from the fork.