TDC561 Network Programming

1. TDC561 Network Programming Review UNIX Architecture and Programming Camelia Zlatea, PhD Email: czlatea@cs.depaul.edu

2. References • W. Richard Stevens, Network Programming, Vol, I, 2nd Ed, Prentice Hall PTR, NJ, 1998. • W. Richard Stevens, Advanced UNIX Programming, Vol, I, 2nd Ed, Prentice Hall PTR, NJ, 1998. • Links to Richard Stevens books; http://www.kohala.com/start/ • John Shapley Gray, Interprocess Communications in UNIX -- The Nooks and Crannies Prentice Hall PTR, NJ, 1998. • Web Other resources about UNIX programming: • Brief tutorial on C and UNIX programming http://www.strath.ac.uk/IT/Docs/Ccourse/ • Source code from textbook (Network Programming - Stevens) http://www.kohala.com/start/unpv12e.html • link to Stevens - UNIX programming book; http://www.kohala.com/start/apue.html • UNIX Files Systems and I/O programming – guide; http://www.nd.edu/~lemmon/courses/UNIX/l3/l3.html • HP-UX man pages http://docs.hp.com/hpux/onlinedocs/B2355-90682/B2355-90682.html (system calls)

3. Overview UNIX Architecture UNIX processes, threads UNIX program development System calls – fork, exec, etc.

4. Portability Multi-process architecture (multitasking) Multi-user capability Ability to initiate asynchronous processes A hierarchical file system Device independent I/O operations User interface: Shell; selectable per user basis UNIX Features

5. System V Interface Definition (SVID), AT&T Portable Operating System Interface for Computer Environments (POSIX), based on SVID, IEEE ANSI C, American National Standard Institute ANSI/ISO C++ Standard (draft) UNIX Standards

6. Solaris - Sun Microsystems SunOS (later called Solaris), Solaris 2.x based on SVR4 HP-UX, Hewlett-Packard, SVR2 Linux, Linus Torvalds, free distribution, PC-based AIX, IBM, similar to SVR4 IRIX, Silicon Graphics, SVR4 UNIX Implementations

7. Multi-process/Multi-user architecture • Virtual Machine • timesharing OS • process, process quantum, process states • Kernel, base OS • manages all HW dependent functions • users have no direct access to it • System Calls Interface • service routine performing user requests

8. UNIX Architectural Overview Applications Network Applications DBMS Utilities Shell’s Executable Programs Commands pipe, filters System Calls Interface Kernel UNIX Hardware Architecture

9. UNIX Kernel - model User Space User Processes System Call Interface (Library Routines) Kernel Space Scheduler Device Drivers I/O Buffers Hardware Process Memory File System I/O Services Mgmt. Mgmt. Process Memory File System I/O Services Mgmt. Mgmt.

10. Kernel - low level functions Process representation, scheduling, dispatching Memory allocation and de-allocation Interrupt handling Low level device control Disk Mgmt., data buffering Process synchronization and IPC (Inter-Process Communication) Kernel - services level Maps user-level requests with device driver actions A user system call is translated to a call of the kernel routine, providing that requested service Type of Services: process creation and termination I/O services UNIX file system services terminal handling services System Call Interface level A user mode process is translated into a protected kernel mode process Now, program can call kernel routines UNIX Kernel

11. User processes running: shells Unix commands utilities application programs User Processes level

12. UNIX and POSIX API • UNIX API - system calls • UNIX API are called by • C library functions and • C++ standard classes Example: iostream class • API set to perform: • determine system configuration and user information • file management • process creation and management • inter-process communication • network communication

13. UNIX and POSIX API User Process (User Mode of Execution) an API is invoked UNIX API’s level Kernel mode of execution API executed in protected mode • Context Switch from user to kernel mode • more overhead than library functions, for the same task • I/O lib.functions are buffered API execution completed

14. A process may create sub-processes fork(); A process may terminate exit(); A process may put itself to sleep temporarily sleep(20); pause(); wait(); Processes synchronization mechanisms communication mechanisms UNIX Processes – APIs

15. Multiple Processes - concurrency at OS level Multiple Threads - concurrency at process level thread = flow of control in a process multiple threads (stream of instructions) are executed within the same process threads share code & data (address space) threads have their own execution stack, PC, register set and states context switches are avoided efficient mapping on multi-processor machines UNIX Threads

16. Process - a program in execution process - active entity program - passive entity (binary file) Address Space - list of memory locations from where a process reads/writes (code/data/stack) Set of registers (PC, SP, ...) Process Table - linked list of structures associates w/ processes System Calls - interface between OS and User process Processes

17. Process State new, ready, running, blocked, terminated Process Image Map Pointer Process ID assigned at process creation Program Counter (PC) address of next instruction to be executed CPU Registers (saved process context) List of Open File Descriptors I/O Devices Attached CPU Scheduling Info (priority) Process Control Block (process attributes)

18. Process Image Map (simplified) Process Table Process Image Proc. n Proc. 1 Text/Code Segment Data Segment Stack Segment Process Control Block

20. Example: /* Display Segment Address Information */ #include <stdio.h> extern int etext,edata,end; void main(void) { printf(“etext: %6X\t edata: %6X \t end: %6X \n”, &etext, &edata, &end); }

21. New - process created ( Ex: fork(); ) Ready - process is waiting to be assigned to processor (inserted in ready queue) Running - instructions are being executed Blocked - wait for events to occur (inserted in queue) Ex: wait(); pause(); Terminated - normal/abnormal termination (exit();) Process States

22. Process Model New created wakeup Ready Quantum Expired dispatch Blocked/ Suspended Running User Mode sleep exit System Call Interrupt Return Running Kernel Mode Terminated Interrupt Interrupt return

23. Context of a Process process state (defined by it’s code) value of u-area values of registers the process uses contents of user and kernel stacks is associated with process image map Context Switching system executes a process in the context of the process when the kernel decides to execute another process, it does context switching kernel saves enough information such that it can later switch back to the first process and resumes its execution Mode Switching moving from user to kernel mode kernel save information to return to user mode

24. User mode processes in use mode can access their own instructions and data; NOT kernel or other process’s code or data Kernel mode process can access system(kernel) code and data and user addresses Kernel is part of each process Kernel executes on behalf of the process P1 P2 P3 P4 OS HW Kernel Mode User Mode K K U U

25. Context Switching P2 P1 OS Save state in PCB1 Reload state from PCB2 Save state in PCB2 Reload state from PCB1

26. Switching the CPU to another process by saving the state of the old process (PCB) and load the state of the new process (PCB) Pure Overhead Performance Bottleneck Avoid Overhead of Context Switching by introducing new structures: THREADS Context Switching

27. Compilation (ANSI C) cc -o file file.c file Man Pages man cc man <sys_call> , example: man socket man <shell_cmd>, example: man ps

28. Process - system support Fork system call Process states Exec system call Exit function Background processes Parent-Child Synchronization (wait) More about UNIX Processes

29. A fork system call: pid_t pid; pid = fork(); if (pid ==-1) { /* fork failure, no more entries in process table*/ } else if (pid==0){ /*child process*/ } else { /* parent process */ }

30. The user process calls fork(); Store system call parameters arguments, return address, local variables) into the user stack. Call corresponding kernel service execution of a trap instruction In kernel space save: parameters, return address and local variables for kernel routine Execute kernel routine Normal Return cleans-up kernel stack switch from kernel to user mode Fork - System Call

31. Successful return from system call: parent and child processes: share same text segment identical data segments identical user & kernel stack segments same user structure parent normal return restores return address from user stack child “pseudo return” restores same return address as the parent from its user stack Fork - System Call

32. Parent Process Child Process File Table text data stack i-node Table Open Files Current Directory text data stack Open Files Current Directory

33. #include <sys/types.h> #include <unistd.h> pid_t getpid(void); /* get current process ID */ pid_t getppid(void); /* get ID of the parent of the process */ Process information

34. pid_t pid; static int x; x=1; pid = fork(); if (pid < 0 ) { perror(“fork failure”); } else if (pid==0) x++; else x--; printf(“process %d: x=%d\n”, getpid(), x); What value(s) are printed for variable x? Race Conditions Race Condition • cannot predict if parent or child will run first after fork()

35. #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { fork(); printf(“A\n”); fork(); printf(“B\n”); fork(); printf(“C\n”); } Comment on the above program output. Race Conditions Race Condition • cannot predict if parent or child will run first after fork()

36. #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { int i; for (i=1; i<=3; i++) { fork(); printf(“PID=%d i=%d\n”, getpid(), i); } printf(“PID=%d i=%d\n”, getpid(), i); } Comment on the above program output. Race Conditions Race Condition • cannot predict if parent or child will run first after fork()

37. #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { int i; for (i=1; i<=3; i++) { if (fork()==0) break; printf(“PID=%d i=%d\n”, getpid(), i); } printf(“PID=%d i=%d\n”, getpid(), i); } Comment on the above program output. Race Conditions Race Condition • cannot predict if parent or child will run first after fork()

38. #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { int i; for (i=1; i<==3; i++) { if (fork()>0) break; printf(“PID=%d i=%d\n”, getpid(), i); } printf(“PID=%d i=%d\n”, getpid(), i); } Comment on the above program output. Race Conditions Race Condition • cannot predict if parent or child will run first after fork()

39. Initiated - fork() Ready-to-Run in ready queue for CPU access Running process quantum Blocked sleep(n); /* deterministic delay */ pause(); /* non-deterministic delay */ Terminated exit(int status); Shell command: ps [options] Process States

40. #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <string.h> void main(void) { static char buf[2]; if (fork()==0) strcpy(buf,”A\n”); else strcpy(buf,”B\n”); sleep(10); write(1,buf,sizeof(buf)); } Comment on the above program execution Race Condition • cannot predict if parent or child will run first after fork()

41. #include <unistd.h> int execl(const char *file, const char arg0, .. , const argn); int execv(const char *file, char *argv[]); the process executes the the binary code from file if failure return -1 if success does not return Exec - System Call

42. File test1.c #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { int i; for (i=1; i<=3;i++) if (fork()==0) { /* process child */ execv(“/bin/ps”,”ps -el”); } else { /* process partent */ printf(“Parent: %d\n”,getpid()); } } cc -o test1 test1.c test1

43. File test2.c #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { int i; for (i=1; i<=3;i++) if (fork()==0) { /* process child */ execv(“child”,”child”); } else { /* process partent */ printf(“Parent: %d\n”,getpid()); } } cc -o test2 test2.c

44. File child.c #include <stdio.h> #include <sys/types.h> #include <unistd.h> void main(void) { pid_t pid; printf(“Parent: %d\n”,getpid()); sleep(30); } cc -o test2 test2.c cc -o child child.c test2

45. #include <stdlib.h> void exit(int status); status - parameter returned to parent process status=0 - normal termination status# - abnormal termination Effects: close all open file descriptors notifies the parent (by signal) return status info to parent if parent no longer exists then PPD:=1 (is adopted by process init) Exit - Function Call

46. #include <unistd.h> void _exit(int status); status - process exit status code status=0 - normal termination status#0 - abnormal termination Effects: terminates a process closes all open file descriptors deallocates all process data and stack segment process becomes a zombie (it is no longer scheduled to run) init process clean up process table slot _exit - System Call

47. #include <iostream.h> #include <unistd.h> int main() { cout << "Test for _exit" << endl; _exit(0); return 0; } % g++ -o test test.c; test Test for _exit % echo $status 0 _exit - System Call

48. #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *status); returns -,1 if failure (check errno) no unwaited-for child process interrupt signal returns the child PID, is success synchronization: parent waits for a child to terminate if more child-processes, waits for any wait - System Call

49. #include <sys/types.h> #include <sys/wait.h> pid_t waitpid(pid_t p, int *status, int opt); Return value - a child process ID or -1 Argument pid_t p - a child PID -1 waits for any child (same as wait) 0 waits for any child in same group w/ parent >0 waits for child process with this PID=p <-1 waits for any child with GID = |p| waitpid - System Call

50. #include <sys/types.h> #include <sys/wait.h> pid_t waitpid(pid_t p, int *status, int opt); Options values WNOHANG - do not block if status cannot be obtained WNOWAIT - keep process in wait status WUNTRACED - wait any stopped child process waitpid - System Call