Upload
norris
View
33
Download
0
Tags:
Embed Size (px)
DESCRIPTION
Applications, Address Spaces, and Processes. Separating Units of Computation. 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 - PowerPoint PPT Presentation
Citation preview
CSE-451 Processes 1
Applications, Address Spaces, and Processes
Separating Units of Computation
CSE-451 Processes 2
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 3
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 4
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 5
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 6
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 7
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 8
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 9
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 10
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 11
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 12
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 13
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 14
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 15
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
CSE-451 Processes 16
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!
CSE-451 Processes 17
Examplemain(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?
CSE-451 Processes 18
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 19
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 20
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 21
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 22
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/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