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

2. CSE-451 Processes2 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

3. CSE-451 Processes3 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

4. CSE-451 Processes4 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

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

6. CSE-451 Processes6 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:...

7. CSE-451 Processes7 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?

8. CSE-451 Processes8 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

9. CSE-451 Processes9 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

10. CSE-451 Processes10 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

11. CSE-451 Processes11 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

12. CSE-451 Processes12 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)

13. CSE-451 Processes13 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

14. CSE-451 Processes14 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

15. CSE-451 Processes15 Where do Processes Come From? Remember, 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

16. CSE-451 Processes16 Processes Under UNIX In Unix, the fork() system call is the only way to create a new process 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!

17. CSE-451 Processes17 Example main(int argc, char **argv) { char *myName = argv[1]; int cpid = fork(); 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?

18. CSE-451 Processes18 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

19. CSE-451 Processes19 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??

20. CSE-451 Processes20 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

21. CSE-451 Processes21 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); }

22. CSE-451 Processes22 Extra Credit for Friday 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