Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 07 Template
07 - System Calls
Outline
Syscalls Recap
Syscall Implementation
Example: gettimeofday
Memory Access
Adding a Syscall to Linux
Comments
Syscall Mechanism
Examples
Announcements
Reading: MOS 1.6
Syscalls Recap
Syscall Mechanism
Syscall Implementation
Quiz 1 will be on Friday, first 10 min of class.
10 MCQ online, no cheat sheet.
Don't be late!
It will include content from today!
Rest of PA2 released. If I'm quick, we'll get
through almost everything you need today.
System calls are the kernel's API for user-mode
programs to interact with hardware and system-
critical functions.
User-mode programs
- see syscalls as normal functions
- cannot access kernel stuff
System Call requires CPU context switch
System Calls are OS-dependent, often not portable
Hardware invocation mechanism is arch dependent
2 general approaches:
Syscall parameters are passed via registers.
For example, in x86 assembly:
On the syscall instruction, the CPU:
Hardware saves program counter
Hardware jumps to entry in kernel-mode
Kernel assembly procedure saves registers
kernel initializes new stack and dispatches
System call code runs
Scheduler decides which process to return to
Kernel assembly restores process context
Kernel restores PC and leaves kernel mode
Then the kernel entry code takes over.
Kernel entry code determines which syscall to
invoke by looking up the syscall number in a table.
Internal prototypes:
Arch-specific:
Syscall Table:
Macro SYSCALL_DEFINE2 declares a syscall with
2 arguments. For each argument, the macro takes
the type and name as separate fields.
Return value will be returned to user process.
copy_{to/from}_user copies data between kernel
and process address space.
Important:
Kernel should never trust the user!
Kernel should not abuse its powers!
Kernel should copy user data to kernel space
before manipulating it, then copy it back to user
space.
User Space Memory Access API:
Write your syscall function
To add your syscall to the build system:
Pros:
- Adding syscalls is "easy"
Cons:
- Need official syscall number
- Interface changes are permanent
- Must be registered for every architecture
- Not always necessary
Alternative:
- Device or virtual file (kernel modules)
- Can alter behavior of existing syscalls
(e.g. read, write, ioctl)
- Add a file:
- Modify top-level Makefile:
- contents:
- contents:
(Assume syscall code @ )
Add syscall to syscall table (arch-specific)
Add syscall prototype to header file
Rebuild and reinstall kernel
Test with libc syscall function from user code
- In an existing file (not for PA 2)
- x86:
- Use tabs between fields
- common:
- or arch-specific equivalent
- Recompile kernel
- Reinstall modules
- Reinstall kernel
- Reboot with new kernel
- In an new file if self-contained
- Add file to build system
- User-space cannot access kernel-space memory
- Kernel-space can access user-space memory
- Kernel must check user-provided pointers
- Kernel must never execute user-space memory
- Minimize access to user-space memory
the table is used by the Linux build system
Trap Model
column 1:
column 2:
column 3:
column 4:
syscall number
architecture availability
syscall name
internal function name
- Similar to hardware interrupt mechanism
Interrupt Instruction
Special Instruction
Idea: fake an interrupt (hardware interrupts trigger kernel-mode)
Idea: special hardware logic to perform mode and context switch
Ex. Intel & AMD originally had sysenter/syscall, with different
hardware mechanisms. Now, both use syscall in 64-bit systems
e.g. UNIX calls completely different from Windows
Kernel code only executes under 2 conditions:
(See also MOS Figure 1-18)
Process Management
File System
Miscellaneous
- hardware access
- read/write/manage files in storage devices
- read/write to I/O devices
- create processes
- change security permissions
- interrupt
- system call
1)
2)
3)
pid = fork()
pid = waitpid(pid, &statloc, options)
s = execve(name, argv, environp)
exit(status)
create a child process identical to parent
wait for child to terminate
replace a process's core image
terminate process execution and return status
fd = open(file, mode, ...)
s = close(fd)
n = read(fd, buffer, len)
n = write(fd, buffer, len)
pos = lseek(fd, offset, whence)
s = stat(name, &buf)
s = mkdir(name, mode)
s = rmdir(name)
s = link(name1, name2)
s = unlink(name)
s = mount(special, name, flag)
s = unmount(special)
open a file
close an open file
read data from file to buffer
write data from buffer to file
move the file pointer
get file status information
create directory
remove empty directory
create an entry name2 that points to name1
remove an entry
mount a file system
unmount a file system
s = chdir(dirname)
s = chmod(name, mode)
s = kill(pid, signal)
sec = time(&seconds)
change working directory
change file's protection bits
send signal to process
get seconds since 1/1/1970
User Mode Process
User Mode Process
Kernel Mode Execution
syscall invoked
syscall returns
time
- Enters kernel code, different address range
> Kernel checks calling process permissions
- Changes execution mode (user -> kernel)
> Recall the CPU status/control register
(1):
>
1)
1)
2)
3)
4)
5)
2)
3)
4)
5)
6)
7)
8)
>
>
(2):
.text
ENTRY (syscall)
movq %rdi, %rax /* Syscall number -> rax. */
movq %rsi, %rdi /* shift arg1 - arg5. */
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %r10
movq %r9, %r8
movq 8(%rsp),%r9 /* arg6 is on the stack. */
syscall /* Do the system call. */
cmpq $-4095, %rax /* Check %rax for error. */
jae SYSCALL_ERROR_LABEL /* Jump to error handler if error. */
ret /* Return to caller. */
PSEUDO_END (syscall)
(from glibc source)
Saves the process's next instruction address
Jumps to fixed kernel entry point
Updates ctrl/stat register to kernel-mode
arch/x86/entry/entry_64.S
arch/x86/entry/syscalls/syscall_64.tbl
do_syscall_64
see
see
see
similar to interrupts in MOS Figure 2-5
Resume a user-mode process
Steps 6-8:
Step 5:
Executes system call proper
Steps 1-4:
Hardware & assembly save context
MOS Figure 1-17
include/linux/syscalls.h
include/linux/syscalls.h
arch/x86/include/asm/syscalls.h
kernel/time/time.c
uaccess.h
get_user
Gets a simple variable from user space
Puts a simple variable to user space
Clears a block in user space
Copies a block from kernel to user space
Copies a block from user to kernel space
Gets length of a string buffer in user space
Copies a string from user to kernel space
put_user
clear_user
copy_to_user
copy_from_user
strnlen_user
strncpy_from_user
arch/x86/entry/syscalls/syscall_64.tbl
arch/x86/entry/syscalls/syscall_64.tbl
include/linux/syscalls.h
see
Kernel
Space
User
Space
Forbidden
Dangerous
my_syscall/my_syscall.c
my_syscall/Makefile
obj-y += my_syscall.o
core-y :=
my_syscall/