SystemCalls
In the view of user programs, the kernel is a transparent system layer — it is always present but
never really noticed. Processes don’t know whether the kernel is running or not. Neither do they
know which virtual memory contents are currently in RAM or which contents have been swapped
out or perhaps not even read in. Nevertheless, processes are engaged in permanent interaction with
the kernel to request system resources, access peripherals, communicate with other processes, read
in files, and much more. For these purposes, they use standard library routines that, in turn, invoke
kernel functions — ultimately, the kernel is responsible for sharing resources and services fairly
and, above all, smoothly between requesting processes.
Applications therefore see the kernel as a large collection of routines that perform a wide variety
of system functions. The standard library is an intermediate layer to standardize and simplify the
management of kernel routines across different architectures and systems.
In the view of the kernel, the situation is, of course, a bit more complicated especially as there
are several major differences between user and kernel mode, some of which were discussed in
earlier chapters. Of particular note are the different virtual address spaces of the two modes and the
different ways of exploiting various processor features. Also of interest is how control is transferred
backward and forward between applications and the kernel, and how parameters and return values
are passed. This chapter discusses such questions.
As described in previous chapters,system callsare used to invoke kernel routines from within user
applications in order to exploit the special capabilities of the kernel. We have already examined the
implementation of a number of system callsfrom a wide range of kernel subsystems.
First, let’s take a brief look at system programming to distinguish clearly between library routines of
the standard library and the corresponding system calls. We then closely examine the kernel sources
in order to describe the mechanism for switching from userspace to kernel space. The infrastructure
used to implement system calls is described, and special implementation features are discussed.