1. Practical Session 1 System Calls
Operating Systems
Practical Session 1 System Calls

2. A few administrative notes…
Course homepage:
Assignments:
Extending xv6 (a pedagogical OS)
Submission in pairs.
Frontal checking:
Assume the grader may ask anything.
Must register to exactly one checking session.

3. Operating System
An operating system (OS) is system software that manages computer hardware and software resources and provides common services for computer programs.

4. Main Components for today
Process
Describes an execution of a program and all of its requirements
Kernel
The Heart of the OS, manages processes and other resources
System Calls
Means of communications between the process and the kernel

5. Process Process Kernel Space User Space Run Kernel code Has: Stack
Heap
System wide view
Direct Hardware access
Run user code
System calls

6. System Calls
A System Call is an interface between a user application and a service provided by the operating system (or kernel).
These can be roughly grouped into five major categories:
Process control (e.g. create/terminate process)
File Management (e.g. read, write)
Device Management (e.g. logically attach a device)
Information Maintenance (e.g. set time or date)
Communications (e.g. send messages)

7. System Calls - motivation
A process is not supposed to have a direct access the hardware/kernel. It can’t access the kernel memory or functions.
This is strictly enforced (‘protected mode’) for good reasons:
Can jeopardize other processes running.
Cause physical damage to devices.
Alter system behavior.
The system call mechanism provides a safe mechanism to request specific kernel operations.

8. Jumping from user space to kernel space
A process running in user space cannot run code/access data structures in the kernel space
In x86 arch, in order to jump to kernel space, it is common that the process will use interrupts
When jumping to kernel space, the process (kernel) must store a “backup” for its current execution state (so that the kernel will be able to resume the execution later), this backup is referred to as a trapframe.

9. System Calls - interface
Calls are usually made with C/C++ library functions:
User Application
C - Library
Kernel
System Call
getpid()
Load arguments, eax ← _NR_getpid, kernel mode (int 80)
Call Sys_Call_table[eax]
sys_getpid()
return
syscall_exit
_NR_getpid – the number of the system call getpid
0x80 – interrupt on Intel’s CPUs
resume_userspace
return
User-Space
Kernel-Space
Remark: Invoking int 0x80 is common although newer techniques for “faster” control transfer (SYSCALL/SYSRET) are provided by both AMD’s and Intel’s architecture.

10. XV6 CODE

11. System Calls - interface
syscall.h
// System call numbers #define SYS_fork 1 #define SYS_exit 2 #define SYS_wait 3 #define SYS_pipe 4 #define SYS_read 5 #define SYS_kill 6 #define SYS_exec 7 #define SYS_fstat 8 #define SYS_chdir 9 #define SYS_dup 10 #define SYS_getpid 11 #define SYS_sbrk 12 #define SYS_sleep 13 #define SYS_uptime 14 #define SYS_open 15 #define SYS_write 16 #define SYS_mknod 17 #define SYS_unlink 18 #define SYS_link 19 #define SYS_mkdir 20 #define SYS_close 21
Calls are usually made with C/C++ library functions:
User Application
C - Library
Kernel
System Call
getpid()
Load arguments, eax ← _NR_getpid, kernel mode (int 80)
Call Sys_Call_table[eax]
sys_getpid()
return
syscall_exit
_NR_getpid – the number of the system call getpid
0x80 – interrupt on Intel’s CPUs
resume_userspace
return
User-Space
Kernel-Space
Remark: Invoking int 0x80 is common although newer techniques for “faster” control transfer are provided by both AMD’s and Intel’s architecture.

12. System Calls - interface
usys.S
#include "syscall.h" #include "traps.h"
#define SYSCALL(name) \ .globl name; \
name: \
movl $SYS_ ## name, %eax; \ int $T_SYSCALL; \
ret
SYSCALL(fork)
SYSCALL(exit)
SYSCALL(wait)
SYSCALL(pipe)
SYSCALL(read) SYSCALL(write) SYSCALL(close) SYSCALL(kill)
SYSCALL(exec)
SYSCALL(open) SYSCALL(mknod) SYSCALL(unlink) SYSCALL(fstat) SYSCALL(link) SYSCALL(mkdir) SYSCALL(chdir)
SYSCALL(dup) SYSCALL(getpid) SYSCALL(sbrk) SYSCALL(sleep) SYSCALL(uptime)
System Calls - interface
.globl fork; \
fork : \
movl $SYS_fork, %eax; \
int $T_SYSCALL; \
ret
Calls are usually made with C/C++ library functions:
User Application
C - Library
Kernel
System Call
getpid()
Load arguments, eax ← _NR_getpid, kernel mode (int 80)
Call Sys_Call_table[eax]
.globl fork; \
fork : \
movl $1, %eax; \
int $64; \
ret
sys_getpid()
return
syscall_exit
_NR_getpid – the number of the system call getpid
0x80 – interrupt on Intel’s CPUs
resume_userspace
return
User-Space
Kernel-Space
Remark: Invoking int 0x80 is common although newer techniques for “faster” control transfer are provided by both AMD’s and Intel’s architecture.

13. System Calls - interface
trapasm.S
.globl alltraps
alltraps:
# Build trap frame.
pushl %ds
pushl %es
pushl %fs
pushl %gs
pushal .
# Call trap(tf), where tf=%esp
pushl %esp
call trap
Calls are usually made with C/C++ library functions:
User Application
C - Library
Kernel
System Call
getpid()
Load arguments, eax ← _NR_getpid, kernel mode (int 80)
Call Sys_Call_table[eax]
sys_getpid()
return
syscall_exit
_NR_getpid – the number of the system call getpid
0x80 – interrupt on Intel’s CPUs
resume_userspace
return
User-Space
Kernel-Space
Remark: Invoking int 0x80 is common although newer techniques for “faster” control transfer are provided by both AMD’s and Intel’s architecture.

14. System Calls - interface
syscall.c
static int (*syscalls[])(void) = {
[SYS_fork] sys_fork,
[SYS_exit] sys_exit, .
[SYS_close] sys_close, };
void syscall(void) {
int num;
struct proc *curproc = myproc();
num = curproc->tf->eax;
if(num > 0 && num < NELEM(syscalls) &&
syscalls[num]) {
curproc->tf->eax = syscalls[num]();
} else {
cprintf("%d %s: unknown sys call %d\n",
curproc->pid, curproc->name, num);
curproc->tf->eax = -1; }
trap.c
Void trap(struct trapframe* tf) { .
if(tf->trapno == T_SYSCALL){
if(myproc()->killed)
exit();
myproc()->tf = tf;
syscall();
return; }
Calls are usually made with C/C++ library functions:
User Application
C - Library
Kernel
System Call
getpid()
Load arguments, eax ← _NR_getpid, kernel mode (int 80)
Call Sys_Call_table[eax]
sys_getpid()
return
syscall_exit
_NR_getpid – the number of the system call getpid
0x80 – interrupt on Intel’s CPUs
resume_userspace
return
User-Space
Kernel-Space
Remark: Invoking int 0x80 is common although newer techniques for “faster” control transfer are provided by both AMD’s and Intel’s architecture.

15. System Calls - interface
Calls are usually made with C/C++ library functions:
trapasm.S .
addl $4, %esp
# Return falls through to trapret...
.globl trapret
trapret:
popal
popl %gs
popl %fs
popl %es
popl %ds
addl $0x8, %esp # trapno and errcode
iret
User Application
C - Library
Kernel
System Call
getpid()
Load arguments, eax ← _NR_getpid, kernel mode (int 80)
Call Sys_Call_table[eax]
sys_getpid()
return
syscall_exit
_NR_getpid – the number of the system call getpid
0x80 – interrupt on Intel’s CPUs
resume_userspace
return
User-Space
Kernel-Space
Remark: Invoking int 0x80 is common although newer techniques for “faster” control transfer are provided by both AMD’s and Intel’s architecture.

16. System Calls – tips
Kernel behavior can be enhanced by altering the system calls themselves: imagine we wish to write a message (or add a log entry) whenever a specific user is opening a file. We can re-write the system call open with our new open function and load it to the kernel (need administrative rights). Now all “open” requests are passed through our function.
We can examine which system calls are made by a program by invoking strace<arguments>.
Strace –c <cmd> will give a summary of all sys calls

17. Process Control Kernel Space Proc 1 (running) Proc 2 (sleep) Proc 3
(ready)
Proc 4
(ready)

18. Process Control Block proc.h
enum procstate { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };
// Per-process state
struct proc {
uint sz; // Size of process memory (bytes)
pde_t* pgdir; // Page table
char *kstack; // Bottom of kernel stack for this process
enum procstate state; // Process state
int pid; // Process ID
struct proc *parent; // Parent process
struct trapframe *tf; // Trap frame for current syscall
struct context *context; // swtch() here to run process
void *chan; // If non-zero, sleeping on chan
int killed; // If non-zero, have been killed
struct file *ofile[NOFILE]; // Open files
struct inode *cwd; // Current directory
char name[16]; // Process name (debugging) };

19. THE KILL SYSTEM CALL (XV6)
/*** sysproc.c ***/
int
sys_kill(void) {
int pid;
if(argint(0, &pid) < 0)
return -1;
return kill(pid); }
/*** syscall.c ***/
static int (*syscalls[])(void) = {
[SYS_chdir] sys_chdir,
[SYS_close] sys_close,
[SYS_dup] sys_dup,
[SYS_exec] sys_exec,
[SYS_exit] sys_exit,
[SYS_fork] sys_fork,
[SYS_fstat] sys_fstat,
[SYS_getpid] sys_getpid,
[SYS_kill] sys_kill,
[SYS_link] sys_link,
[SYS_mkdir] sys_mkdir,
[SYS_mknod] sys_mknod,
[SYS_open] sys_open,
[SYS_pipe] sys_pipe,
[SYS_read] sys_read,
[SYS_sbrk] sys_sbrk,
[SYS_sleep] sys_sleep,
[SYS_unlink] sys_unlink,
[SYS_wait] sys_wait,
[SYS_write] sys_write,
[SYS_uptime] sys_uptime, };
/*** proc.c ***/
// Kill the process with the given pid.
// Process won't exit until it returns
// to user space (see trap in trap.c).
int
kill(int pid) {
struct proc *p;
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p->pid == pid){
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
p->state = RUNNABLE;
release(&ptable.lock);
return 0; }
return -1;
The collection of system calls that a kernel provides is the interface that user programs see. The xv6 kernel provides a subset of the services and system calls that Unix kernels traditionally offer.

20. Fork
pid_t fork(void);
Fork is used to create a new process. It creates a duplicate of the original process (including all file descriptors, registers, instruction pointer, etc’).
Once the call is finished, the process and its copy go their separate ways. Subsequent changes to one should not effect the other.
The fork call returns a different value to the original process (parent) and its copy (child): in the child process this value is zero, and in the parent process it is the PID of the child process.
When fork is invoked the parent’s information should be copied to its child – however, this can be wasteful if the child will not need this information (see exec()…). To avoid such situations, Copy On Write (COW) is used for the data section.
How do I find out the type of pid_t?
Simple:
Find out what’s needed: “man fork”
The man page specifies ‘unistd.h’,
Locate unistd by typing: “whereis unistd.h”
Open the file: /usr/include/unistd.h
pid_t is redefined with __pid_t
Check out all of its included headers
You will see that one of the included headers is ‘types.h’ --> sounds relevant ;)
Locate ‘types.h’ (/usr/include/bits/types.h) and see that pid_t is simply an int

21. Copy On Write (COW) How does Linux manage COW?
fork()
Parent Process DATA STRUCTURE (task_struct)
Child Process DATA STRUCTURE (task_struct)
write information RW RW RO
protection fault!
Copying is expensive. The child process will point to the parent’s pages
Well, no other choice but to allocate a new RW copy of each required page

22. Process control An example: Output: my process pid is 8864
int i = 3472;
printf("my process pid is %d\n",getpid());
fork_id=fork();
if (fork_id==0){
i= 6794;
printf(“child pid %d, i=%d\n",getpid(),i); }
else
printf(“parent pid %d, i=%d\n",getpid(),i);
return 0;
Output: my process pid is 8864
child pid 8865, i=6794
parent pid 8864, i=3472
Program flow:
PID = 8864
i = 3472
fork ()
PID = 8865
Answer – expects exec, will show next
fork_id=0 i = 6794
fork_id = 8865 i=3472

23. Process control
Exit
A process can terminate itself using the exit system call
The call for the exit can be either explicit or implicit
The exit system call receives a single integer argument that will be the exit status of the process
If the child already changed state than the call is returned immediately

24. Process control - zombies
When a process ends, the memory and resources associated with it are deallocated.
However, the entry for that process is not removed from the process table.
This allows the parent to collect the child’s exit status.
When this data is not collected by the parent the child is called a “zombie”. Such a leak is usually not worrisome in itself, however, it is a good indicator for problems to come.

25. Process control
Wait
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
The wait command is used for waiting on child processes whose state changed (the process terminated, for example).
The process calling wait will suspend execution until one of its children (or a specific one) terminates.
Waiting can be done for a specific process, a group of processes or on any arbitrary child with waitpid.
Once the status of a zombie process is collected that process is removed from the process table by the collecting process.
If the child already changed state than the call is returned immediately

26. Process control
exec*
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
exec….
The exec() family of function replaces current process image with a new process image (text, data, bss, stack, etc).
Since no new process is created, PID remains the same.
Exec functions do not return to the calling process unless an error occurred (in which case -1 is returned and errno is set with a special value).
The system call is execve(…)
With execv(), the first argument is a path to the executable. With execvp(), the first argument is a filename. It must be converted to a path before it can used. This involves looking for the filename in all of the directories in the PATH environment variable.
Bss – all uninitialized data such as static and global variables

27. Process control – simple shell
#define… …
int main(int argc, char **argv){
while(true){
type_prompt();
read_command(command, params);
pid=fork();
if (pid<0){
if (errno==EAGAIN)
printf(“ERROR cannot allocate sufficient memory\n”);
continue; }
if (pid>0)
wait(&status);
else
execvp(command,params);

28. Other system calls
File Management:
open
close
read
write
lseek
etc…