1. CSE-451 Processes1 Applications, Address Spaces, and Processes Separating Units of Computation

2. CSE-451 Processes2 Understanding Processes A Computer System has lots of nasty details in it. –CPU, Memory, Stack, Address space, Privileged execution, Exceptions, System calls, I/O Control & Interrupts A PROCESS is the operating system’s ABSTRACTION for all of this junk. Programs execute using the PROCESS abstraction. Basis for –memory management –sharing & isolation –concurrency –scheduling

3. CSE-451 Processes3 Definitions User mode –when the system is executing with the privileged bit off Kernel mode –when the system is executing with the privileged bit on Address space –the range of addresses available for a program to use Legal address space –the range of addresses that a program can use right now

4. CSE-451 Processes4 User and Kernel Memory When the mode bit is set to PRIVILEGED, the kernel can see all of memory –user program, arguments, etc –User memory is like a big data structure for the kernel But, when the mode bit is off, the user program can only see its own memory –the kernel’s address space is OFF LIMITS –what happens if the user tries? Good for the OS, and good for the user program

5. CSE-451 Processes5 OS/User Protection User Program The Operating System 0x00000000 0x7fffffff 0xffffffff main() { int fd = open(“/tmp/foo”); close(fd); } Syscall dispatch File system VM system /* Syscall Dispatcher */ // determine requested routine // transfer control to requested routine // return result Address Space 0x80000000

6. CSE-451 Processes6 Privileged Memory Protection Address low bits high bits Mode bit Protection Fault To memory C = AB

7. CSE-451 Processes7 Inside the User Program User Program The code we wrote Some code we didn’t write _open: load $v0, #SyscallOpen syscall cmp $v0, 0 jneError move $a0, $v0 ret Error: …. Syscall dispatch syscall_ent: cmp $v0, #0// check if good system call jlt Error cmp $v0, #MaxSysCall jgt Error jsr SaveAllNonLinkRegisters load $v0, $v0(SyscallTable) // if so, get api entry point jsr $v0 // go there move $v0, $a0 // result in $a0 load $v0, #0 RestoreAllNonLinkRegisters retsys Error:...

8. CSE-451 Processes8 What Happens on Syscall? Automatic –Hardware MODE bit flips (go from nonpriv to priv) –Minimal save and restore of context SP <- Kernel Syscall SP PC <- Kernel Syscall PC *SP++ <- User SP *SP++ <- User PC –What happens on retsys?

9. CSE-451 Processes9 And then we pick it up... Sycall handler checks to make sure we’re asking for a good service Control is transferred to the service Result is passed back

10. CSE-451 Processes10 The Stack Push down record of execution state maintained as a series of frames typedef struct StackFrame { int registers[NUM_REGS]; int pc; StackFrame *prev; };

11. CSE-451 Processes11 The Stack Push down record of execution state r1r2sp... 100 200 300 P1 P2 P3 Program Registers 2345 110 15 1 Stack (array of words) Older Newer 23,45,100,- 11,0,200,600 600 616 620 15,1,300,616

12. CSE-451 Processes12 Understanding the Stack User stack main int fd main+12 SP Kernel stack 0x40040 USP=0x40040 UPC=_open+12 SPstack at syscall $a0 $a1 $a2… syscall_ent+24 SP stack at entry to open New stuff Old stuff 0x83000000

13. CSE-451 Processes13 Concepts So Far User programs operate out of a different portion of the address space than the kernel There is a context switch that occurs every time we enter the kernel Inside the kernel we have expanded privileges A combination of hardware and software is responsible for this behavior

14. CSE-451 Processes14 Multiple Address Spaces Nearly all operating systems support the abstraction of multiple address spaces EmacsMail Kernel mode User mode 0x80000000 0xffffffff CC 0x00000000 0x7fffffff 0x00000000 0x7fffffff 0x00000000 0x7fffffff

15. CSE-451 Processes15 A Process Each address space contains a process –a bunch of text & data –a “thread” in execution A thread represents the flow of control that is active inside a program –deterministic change of state prescribed by the current state and the PC (which is actually part of the current state)

16. CSE-451 Processes16 A Process is a Program in Execution static int z = 5; main(int argc, char **argv) { int x = foo(); printf(“%d\n”, x); } int foo() { return z=23;} Source Code File Executable File (Program) a.out cc text header: “size, start PC” Create Process text start PC z=5 static data heap stack 0x00000000 0x7fffffff Process In Memory 1st instruction thread

17. CSE-451 Processes17 The Thread Of Control static int z = 5; main(int argc, char **argv) { int x = foo(); printf(“%d\n”, x); } int foo() { return z=23;} argc, argv are on the stack call main call foo set z to 23 return 23 set x to 23 push x push “%d\n” call printf return argc argv _exit main+4 23 stack argc argv _exit 23 “%d\n” main+16 Thread

18. CSE-451 Processes18 Where do Processes Come From? A process is an address space with some stuff in it and a thread of control All operating systems have facilities for creating new processes Some of them (eg, NT) are quite simple: –CreateAddressSpace, WriteAddressSpace, CreateThreadInAddressSpace, StartThread Others (eg, UNIX) are more subtle, but quite elegant

19. CSE-451 Processes19 Process Creation: The Directed Approach Operating System 1. h = CreateAddressSpace() new address space

20. CSE-451 Processes20 Process Creation: The Directed Approach (2) Operating System 1. h = CreateAddressSpace(); 2. WriteAddressSpace(h, programImage); new address space

21. CSE-451 Processes21 Process Creation: The Directed Approach (3) ProcessTable Operating System 1. h = CreateAddressSpace() 2. WriteAddressSpace(h, programImage) 3. StartThreadInAddressSpace(h,0); new address space

22. CSE-451 Processes22 Tying it Together with a User Level Routine spawn(char *programName); { AddressSpace a; char *programImage; int fd = open(programName); programImage = (char*)malloc(filesize(fd)); read(fd, programImage, filesize(fd)); a = CreateAddressSpace(); WriteAddressSpace(a, programImage, filesize(fd)); StartThreadInAddressSpace(a, 0); } What’s the significance of this being a user level routine?

23. CSE-451 Processes23 Processes Under UNIX In Unix, the fork() system call is the only way to create a new process –attractive when new and old process share a lot (the original Unix model) int fork() does many things at once: –creates a new address space (called the child) –copies the parent’s address space into the child’s –starts a new thread of control in the child’s address space –parent and child are equivalent -- almost in parent, fork() returns a non-zero integer in child, fork() returns a zero. difference allows parent and child to distinguish int fork() returns TWICE!

24. CSE-451 Processes24 Example main(int argc, char **argv) { char *myName = argv[1]; int cpid = fork(); // cpid is a handle. if (cpid == 0) { printf(“The child of %s is %d\n”, myName, getpid()); exit(0); } else { printf(“My child is %d\n”, cpid); exit(0); } What does this program print?

25. CSE-451 Processes25 Bizarre But Real lace:tmp cc a.c lace:tmp./a.out foobar The child of foobar is 23874 My child is 23874 Parent Child Operating System fork() retsys v0=0v0=23874

26. CSE-451 Processes26 Even More Bizarre lace:tmp cc a.c lace:tmp./a.out foobar The child of foobar is 23874 My child is 23874 lace:tmp./a.out foobar My child is 24266 The child of foobar is 24266 lace:tmp Parent Child Operating System fork() retsys v0=0v0=24266 Why do we get a different answer??

27. CSE-451 Processes27 Fork is half the story Fork() gets us a new address space, but not one that’s all that different. –parent and child share EVERYTHING memory, operating system state int exec(char *programName) completes the picture –throws away the contents of the calling address space –replaces it with the program named by programName –starts executing at header.startPC

28. CSE-451 Processes28 Starting a new program main(int argc, char **argv) { char *myName = argv[1]; char *progName = argv[2]; int cpid = fork(); if (cpid == 0) { printf(“The child of %s is %d\n”, myName, getpid()); execl(progName, // executable name progName, 0); // null terminated argv printf(“OH NO. THEY LIED TO ME!!!\n”); } else { printf(“My child is %d\n”, cpid); exit(0); }

29. CSE-451 Processes29 HW 1 Write a simple UNIX program to simulate the UNIX shell in a “read/fork/exec” loop –don’t bother with path searches. All commands can be fully qualified CSE451Shell% /bin/cat /etc/motd DEC OSF/1 V3.2 (Rev. 214); Thu Feb 22 08:48:40 PST 1996 DEC OSF/1 V3.2 Worksystem Software (Rev. 214) This is an AFS fileserver. Please run long running jobs (hours) or memory intensive jobs elsewhere. CSE451Shell% /bin/date Sun Apr 5 22:51:50 PDT 1998