Process Creation in UNIX

Transcription

1 Process Creation in UNIX int fork() create a child process identical to parent Child process has a copy of the address space of the parent process On success: Both parent and child continue execution at the instruction after fork For parent: return code is the process ID (PID) of child For child: return code is 0 On failure: Child not created Return code is 1 for parent 1 fork example 1: #include <sys/types.h> int x=5; int pid = fork(); if (pid < 0) return 1; cout << "I am running\n"; if (pid) cout << "I am the parent\n"; x *= 2; else cout << "I am the child\n"; x += 2; cout << "x is " << x << "\n"; 2 1

2 fork example 2: Suppose we want a parent process to create 3 children to do tasks void child1()... void child2()... void child3()... int p1, p2, p3; p1 = fork(); if (p1 == 0) child1(); p2 = fork(); (p2 == 0) child2(); p3 = fork(); (p3 == 0) child3(); 3 Waiting for Process Termination in UNIX int wait(int *status) wait for any child to terminate int waitpid(int pid, int *status, int options) wait for the specified child to terminate If status is not NULL, status information of child is stored in the location pointed to by status. Options: 0 : wait until child has exited WNOHANG : return immediately if no child has exited Return value: the process ID of the child which exited, or zero if WNOHANG was used and no child was available, or 1 on error If a child terminates before parent calls wait: When parent calls wait, it returns immediately and child s PCB is de allocated. 4 2

3 Loading Programs in UNIX int execl(const char *path, const char *arg,...) int execlp(const char *file, const char *arg,...) int execv(const char *path, char *const argv[]) int execvp(const char *file, char *const argv[]) Used after a fork to replace a process memory space with a new program. Do not return on success, return 1 on error Second parameter: l list of arguments v array of arguments Both list and array must be terminated by a NULL pointer First parameter: Without p full path of executable With p name of executable, will search the search path for executable 5 #include <sys/types.h> #include <sys/wait.h> /* This program will 1) Create a process 2) Have the new process execute "ls a l S" 3) Wait until the new process terminates */ int pid = fork(); if (pid < 0) cerr << "Couldn't create process\n"; exit( 1); if (0==pid) // I'm the child execlp("ls", "ls", " a", " l", " S", NULL); // still here? Problem... cout << "Exec error!\n"; exit( 1); // Still here? Must be the parent. waitpid(pid, NULL, 0); cout << "Child has terminated, so will I\n"; 6 3

4 Open() System Call int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); Convert a pathname into a file descriptor (a non negative negative integer for use in subsequent I/O). If successful, return the new file descriptor. If error, return 1. Example: open( file.txt, O_WRONLY O_CREATE O_TRUNC, S_IRWXU) O_WRONLY: write only O_CREATE: create if not exist O_TRUNC: if file already exists and the open mode allows writing, it will be truncated to length 0 S_IRWXU: user (file owner) has read, write and execute permission Mode must be specified when O_CREAT is in the flags, and is ignored otherwise. 7 Read(), Write(), Close() System Calls int read(int fd, void *buffer, int n) read from a file descriptor Read up to n bytes from file descriptor fd into the buffer. Return the number of bytes read on success and 1 on error. int write(int fd, const void *buffer, int n) write to a file descriptor Write up to n bytes to the file descriptor fd from the buffer Return the number of bytes written on success and 1 on error. int close(int fd) close a file descriptor Close the file descriptor so that it no longer refers to any file and may be reused. Return zero on success and 1 on error. 8 4

5 Pipes: Simple IPC in UNIX A pipe is a queue of data: sender puts data to one end, receiver gets data from the other end Unidirectional int pipe(int fd[2]) create a pipe On success fd[0] is a read only file descriptor fd[1] is a write only file descriptor Returns 0 On failure: returns 1 9 Pipes To setup pipe communication between processes: Sender needs fd[1] Receiver needs fd[0] Sender and receiver must have common ancestor who called pipe Using pipes: Send: write to write end of pipe write(fd[1], buf, len) Receive: read from read end of pipe read(fd[0], buf, len) 10 5

6 /* * This program: * * Creates two children processes and a pipe. * * Child 1 sends a message to child 2 via a pipe. * */ #include <sys/types.h> y/yp #include <sys/wait.h> #include <string.h> void Child1(int fd) // PRE: fd is the file descriptor to write the message to char *message = "Hello, child2!"; int bytes = strlen(message)+1; cout << "Child1 sending " << bytes << " byte message "; cout << message << " to child2\n"; write(fd, message, bytes); cout << "Child1 exiting\n"; void Child2(int fd) // PRE: fd is the file descriptor to read from char buffer[256]; cout << "Child2 waiting for message from child1\n"; int sent = read(fd, buffer, 256); cout << "Child2 got " << sent << " byte message "; cout << buffer << " from child1\n"; cout << "Child2 exiting\n"; int pipefd[2]; if (pipe(pipefd) < 0) cerr << "Pipe error!\n"; return 1; int pid2 = fork(); if (0==pid2) // Child 2 close(pipefd[1]); // we don''t write to the pipe Child2(pipefd[0]); // read end of pipe int pid1 = fork(); if (0==pid1) // Child 1 close(pipefd[0]); // we don't read from the pipe Child1(pipefd[1]); // write end of pipe // Parent... close pipe and wait for children close(pipefd[0]); close(pipefd[1]); waitpid(pid1, NULL, 0); waitpid(pid2, NULL, 0); cout << "Everyone is done\n"; 11 Redirection of Standard Input and Output int dup2(int oldfd, int newfd) duplicate a file descriptor Make newfd be the copy of oldfd Return the new descriptor, or 1 if an error occurred UNIX file descriptors: 0 = standard input, 1 = standard output Redirect standard input: int fd = open ( input.txt, O_RDONLY); dup2(fd, 0); //whenever your program reads from stdin, it will read from fd Redirect standard output: int fd = open ( output.txt, O_WRONLY O_TRUNC); dup2(fd, 1); //whenever your program writes to stdout, it will write to fd 12 6

7 /* * This program: * Creates two children processes and a pipe. * Re directs standard output of child1 to the pipe. * Re directs standard input of child2 to the pipe. * Runs "yes no" in child1 * Runs "head 10" in child2 * Waits for all to finish */ #include <sys/types.h> #include <sys/wait.h> #include <string.h> void Child1(int fd) // PRE: fd is the file descriptor to write to dup2(fd, 1); close(fd); execlp("yes", "yes", "no", NULL); cout << "Child 1 error!\n"; void Child2(int fd) // PRE: fd is the file descriptor to read from dup2(fd, 0); close(fd); execlp("head", "head", " 10", NULL); cout << "Child 2 error!\n"; int pipefd[2]; if (pipe(pipefd) < 0) cerr << "Pipe error!\n"; return 1; int pid2 = fork(); if (0==pid2) // Child 2 close(pipefd[1]); // we don't write to the pipe Child2(pipefd[0]); // read end of pipe int pid1 = fork(); if (0==pid1) // Child 1 close(pipefd[0]); // we don't read from the pipe Child1(pipefd[1]); // write end of pipe // Parent... close pipe and wait for children close(pipefd[0]); // if you take this out, we will hang! close(pipefd[1]); waitpid(pid1, NULL, 0); waitpid(pid2, NULL, 0); cout << "Everyone is done\n"; 13 7