CS 550 Operating Systems Spring Process II

Transcription

1 CS 550 Operating Systems Spring 2018 Process II 1

2 Recap: Process Informal definition: A process is a program in execution. Process is not the same as a program. Program is a passive entity stored in the disk Process is an actively executing entity Program is just one component of a process. 2

3 So what else constitutes a process? Memory space (static, dynamic) Procedure call stack Registers and counters : Program counter, pointer, General purpose registers Open files, connections 3

4 Memory Layout of a typical process MAX Function Call Arguments, Return Address, Return Values Gap Heap Data Dynamically allocated memory (e.g. malloc()) Global variables, constants etc 0 Text Program Code and heap grow towards each other 4

5 Loading Executable Object Files OS functionality that (1) creates a process, (2) loads programs into memory, and (3) starts processes Places segments into memory Loads necessary dynamic libraries Allocated the initial stack frame Sets EIP (x86 instruction pointer register ) to the programs entry point ELF Program ELF Header.text.rodata.data.bss ESP EIP Memory Heap.bss.data.rodata.text 5

6 Multiple processes sharing main memory Two processes running different programs Two processes running the same program 6

7 Process Creation Always using fork() system call. When? User runs a program at command line OS creates a process to provide a service Check the directory /etc/init.d/ on Linux for scripts that start off different services at boot time. One process starts another process For example in servers 7

8 Creating a New Process - fork() Example code fork_ex.c int main() { pid_t pid; pid = fork(); if (pid == -1) { fprintf(stderr, "fork failed\n"); exit(1); } if (pid == 0) { printf("this is the child\n"); exit(0); } if (pid > 0) { printf("this is parent. The child is %d\n", pid); exit(0); } return 0; } 8

9 Points to Note fork() is called once But it returns twice!! Once in the parent and Once in the child The parent and the child are two different processes. Child is an exact copy of the parent. So how to make the child process do something different? Return value of fork in child = 0 Return value of fork in parent = [process ID of the child] By examining fork s return value, the parent and the child can take different code paths. 9

10 Parent process and child process The child process has its own address space, with the initial content be exactly the same as the parent process. 0xC xC Parent process address space Heap Child process address space Heap int g = 2; int g = 2; Data Data 0x Text (R/O) 0x Text (R/O) 10

11 Parent process and child process When a parent process uses fork() to create a child process, the two processes have the same program text. but separate copies of the data, stack, and heap segments. The child s stack, data, and heap segments are initially exact duplicates of the corresponding parts the parent s memory. After the fork(), each process can modify the variables in its data, stack, and heap segments without affecting the other process. 11

12 static int idata = 111; /* Allocated in data segment */ int main(int argc, char *argv[]) { int istack = 222; /* Allocated in stack segment */ pid_t childpid; childpid = fork(); if (childpid == -1) {exit(-1);} else if (childpid == 0) {idata *= 3; istack *= 3;} /* Child Process: modify data */ else {sleep(3)} /* Parent process: give child a chance to execute */ /* Both parent and child come here */ printf("pid=%ld %s idata=%d istack=%d\n", (long) getpid(), (childpid == 0)? "(child) " : "(parent)", idata, istack); } exit(0); 12

13 Memory semantics of fork() The parent and the child process have separate copies of the data, stack, and heap segments after forking. So each process can modify the variables in its data, stack, and heap segments without affecting the other process. A straightforward solution: creating copies of the parent s data, stack, and heap segments for the child process. (This was actually the implementation used by some early Unix systems). 13

14 0xC Parent process virtual memory Heap Page table virt-physical mapping Physical memory 0x Data Text (R/O) Text (R/O) 0xC Data Data copy Child process virtual memory 0x Heap Data Text (R/O) Direct copying also happens for heap and data segments. Any problems of this design? 14

15 Memory semantics of fork() Problems of direct copying parent s memory pages when forking. Slow process creation - the child process won t be ready until all the memory copying is done. Waste of resources and time Many resources could be shared between parent and child. fork() is usually immediately followed by an exec function to run a different program, which causes an replacement of the child process text segment, and re-initialization of the data, stack and heap segments, making the direct copying when forking a waste. 15

16 Copy-on-write for fork() Most modern Unix implementations apply the copy-on-write (COW) technique for data, stack, and heap segments. When fork() is performed, the child process for data, stack, and heap segments have the same mappings as its parent All the pages related to the data, stack, and heap segments are marked as read-only. 16

17 Copy-on-write for fork() Any attempt by either the child or the parent trying to modify the R/O pages will be trapped by the kernel, and a duplicate copy of the about-to-be-modified page is made and assigned to the faulting process, whose page table will be updated accordingly. Kernel marks the original and the duplicated pages as writable. Now the parent and the child can modify their own copies of pages without affecting each other s pages. 17

18 0xC Page table virt-physical mapping Parent process virtual memory 0x xC Heap Data Text (R/O) Physical memory Text (R/O) Data Child process virtual memory Heap Data 0x Text (R/O) 18

19 0xC Page table virt-physical mapping Parent process virtual memory Heap Physical memory 0x Data Text (R/O) Text (R/O) copy 0xC Data Child process virtual memory 0x Heap Data Text (R/O) When either the parent or the child change the stack frame. 19

20 Copy-on-write for fork() What is the overhead incurred by fork() with COW?? Only when a write happens In the common case that a process executes a new executable binary immediately after forking, this optimization prevents the wasted copying of large amounts of data. This is an important optimization because the Unix philosophy encourages quick process execution. 20

21 Race conditions after fork() After fork(), either the parent or the child can be scheduled to run. A test of executing fork() multiple times in Linux : 99.97% of a million executions have the parent first to run. In Linux 2.4, change was made to have the child to run first most of the time. But this change was later dropped from the 2.4 kernel series. In Linux 2.6, the change to have the child run first was adopted. 21

22 Race conditions after fork() What is the reasoning of the two policies? Child process to run first policy. If parent is first scheduled to run and parent makes changes to data, stack or heap segments, a copy of to-be-changed pages will be duplicated. If the child perform an exec right after it gains the CPU, the previous duplication will be a waste. Therefore by schedule the child first can avoid unnecessary copying. Parent process to run first policy. Cache locality: after a fork(), the parent s state is already active in the CPU and its memory-management information is already cached in the hardware memory management unit (e.g., translation look-aside buffer --- TLB). 22

23 Process Hierarchy Tree Parent of B and C Child of A Parent of D, E, F Leaf A created two child processes, B and C B created three child processes, D, E, and F 23

24 systemd(1) ModemManager(1331) {gdbus}(1413) {gmain}(1411) accounts-daemon(1346) {gdbus}(1387) {gmain}(1382) acpid(1336) at-spi-bus-laun(2856) dbus-daemon(2861) {dconf worker}(2857) {gdbus}(2860) {gmain}(2858) at-spi2-registr(2883) {gdbus}(2885) {gmain}(2884) atd(1356) avahi-daemon(1352) avahi-daemon(1367) cgmanager(1348) colord(3043) {gdbus}(3047) {gmain}(3045) cron(1324) cups-browsed(1383) {gdbus}(1457) {gmain}(1456) cupsd(1341) dbus(1455) dbus-daemon(1306) dbus-daemon(2841) dconf-service(2904) {gdbus}(2907) {gmain}(2906) dhclient(1554) dnsmasq(2920) dnsmasq(2921) dockerd(2400) docker-containe(2548) {docker-containe}(2561) {docker-containe}(2562) 24

25 Examining Processes in Unix/Linux ps command Standard process attributes /proc directory More interesting information if you are the root. If you don t what they mean, please use man proc top command Examining CPU and memory usage statistics. 25

26 Revisit: Loading Executable Object Files OS functionality that (1) creates a process, (2) loads programs into memory, and (3) starts processes Places segments into memory Loads necessary dynamic libraries Allocated the initial stack frame Sets EIP (x86 instruction pointer register ) to the programs entry point ELF Program ELF Header.text.rodata.data.bss ESP EIP Memory Heap.bss.data.rodata.text 26