CSE-451 Processes1 Applications, Address Spaces, and Processes Separating Units of Computation.
-
date post
21-Dec-2015 -
Category
Documents
-
view
217 -
download
0
Transcript of CSE-451 Processes1 Applications, Address Spaces, and Processes Separating Units of Computation.
CSE-451 Processes 1
Applications, Address Spaces, and Processes
Separating Units of Computation
CSE-451 Processes 2
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
CSE-451 Processes 3
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
CSE-451 Processes 4
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
CSE-451 Processes 5
OS/User Protection
User Program
The OperatingSystem
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
CSE-451 Processes 6
Privileged Memory Protection
ModeA
High BitB
Fault?C
0 0 0
0 1 1
1 0 0
1 1 0
Address
low bitshigh bits
Mode bit
Protection Fault
Tomemory
C = AB
CSE-451 Processes 7
Inside the User ProgramUser Program
The codewe wrote
Some codewe didn’t write
_open:load $v0, #SyscallOpensyscallcmp $v0, 0jne Errormove $a0, $v0ret
Error:….
Syscall dispatch
syscall_ent:cmp $v0, #0 // check if good system calljlt Errorcmp $v0, #MaxSysCalljgt Errorjsr SaveAllNonLinkRegistersload $v0, $v0(SyscallTable) // if so, get api entry pointjsr $v0 // go theremove $v0, $a0 // result in $a0load $v0, #0RestoreAllNonLinkRegistersretsys
Error:...
CSE-451 Processes 8
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?
CSE-451 Processes 9
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
CSE-451 Processes 10
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;
};
CSE-451 Processes 11
The Stack
• Push down record of execution stater1 r2 sp...
100
200
300
P1
P2
P3
Program Registers
23 45
11 0
15 1
Stack (array ofwords)
Older
Newer
23,45,100,-
11,0,200,600
600616
620 15,1,300,616
CSE-451 Processes 12
Understanding the StackUser stack
mainint fdmain+12SP
Kernel stack
0x40040
USP=0x40040UPC=_open+12
SPstack at syscall$a0$a1$a2…syscall_ent+24SPstack at entry to open
New stuff
Old stuff
0x83000000
CSE-451 Processes 13
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
CSE-451 Processes 14
Multiple Address Spaces
• Nearly all operating systems support the abstraction of multiple address spaces
Emacs Mail
Kernel mode
User mode
0x80000000
0xffffffff
CC
0x00000000
0x7fffffff
0x00000000
0x7fffffff
0x00000000
0x7fffffff
CSE-451 Processes 15
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)
CSE-451 Processes 16
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;}
SourceCodeFile
ExecutableFile (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
CSE-451 Processes 17
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 stackcall main
call fooset z to 23return 23
set x to 23push xpush “%d\n”call printfreturn
argcargv_exit
main+423
stack
argcargv_exit2323
“%d\n”main+16 Thread
CSE-451 Processes 18
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
CSE-451 Processes 19
Process Creation: The Directed Approach
Operating System
1. h = CreateAddressSpace()
new address space
CSE-451 Processes 20
Process Creation: The Directed Approach (2)
Operating System
1. h = CreateAddressSpace();2. WriteAddressSpace(h, programImage);
new address space
CSE-451 Processes 21
Process Creation: The Directed Approach (3)
ProcessTable Operating System
1. h = CreateAddressSpace()2. WriteAddressSpace(h, programImage)3. StartThreadInAddressSpace(h,0);
new address space
CSE-451 Processes 22
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?
CSE-451 Processes 23
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!
CSE-451 Processes 24
Examplemain(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?
CSE-451 Processes 25
Bizarre But Real
lace:tmp<15> cc a.clace:tmp<16> ./a.out foobarThe child of foobar is 23874My child is 23874
Parent
Child
Operating System
fork()
retsys
v0=0v0=23874
CSE-451 Processes 26
Even More Bizarre
lace:tmp<15> cc a.clace:tmp<16> ./a.out foobarThe child of foobar is 23874My child is 23874lace:tmp<17> ./a.out foobarMy child is 24266The child of foobar is 24266lace:tmp<18>
Parent
Child
Operating System
fork()
retsys
v0=0v0=24266Why do we get a different answer??
CSE-451 Processes 27
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
CSE-451 Processes 28
Starting a new programmain(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); }}
CSE-451 Processes 29
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/motdDEC 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 memoryintensive jobs elsewhere.
CSE451Shell% /bin/dateSun Apr 5 22:51:50 PDT 1998