Ch 2 getting started with the kernel
This presentation is the property of its rightful owner.
Sponsored Links
1 / 16

Ch 2. Getting Started with the Kernel PowerPoint PPT Presentation

Ch 2. Getting Started with the Kernel. A Beast of a Different Nature (1) . The kernel has several differences compared to normal user-space applications. The kernel does not have access to the C library. The kernel is coded in GNU C. The kernel lacks memory protection like user-space.

Related searches for Ch 2. Getting Started with the Kernel

Download Presentation

Ch 2. Getting Started with the Kernel

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Ch 2 getting started with the kernel

Ch 2. Getting Started with the Kernel


A beast of a different nature 1

A Beast of a Different Nature (1)

  • The kernel has several differences compared to normal user-space applications.

    • The kernel does not have access to the C library.

    • The kernel is coded in GNU C.

    • The kernel lacks memory protection like user-space.

    • The kernel cannot easily use floating point.

    • The kernel has a small fixed-size stack.

    • Because the kernel has asynchronous interrupts, it is preemptive.

    • Synchronization and concurrency are major concerns within the kernel.

    • Portability is important.


A beast of a different nature 2

A Beast of a Different Nature (2)

  • No libc

    • Unlike a user-space application, the kernel is not linked against the standard C library.

    • The full C library, or even a decent subset of it, is too large and too inefficient for the kernel.

    • Many of the usual libc functions have been implemented inside the kernel.

      • For example, the common string manipulation functions are in lib/string.c. Just include <linux/string.h>.

    • Of the missing functions, the most familiar is printf().


A beast of a different nature 3

A Beast of a Different Nature (3)

  • The kernel does not have access to printf(), but it does have access to printk().

  • The printk() function copies the formatted string into the kernel log buffer, which is normally read by the syslog program.

  • Usage is similar to printf():

    printk("Hello world! A string: %s and an integer: %d\n", a_string, an_integer);

  • printk() allows you to specify a priority flag.

  • This flag is used by syslogd to decide where to display kernel messages.

    • As an example

      printk(KERN_ERR "this is an error!\n").


A beast of a different nature 4

A Beast of a Different Nature (4)

  • GNU C

    • Like any self-respecting Unix kernel, the Linux kernel is programmed in C.

    • The kernel is not programmed in strict ANSI C.

    • The kernel developers make use of various language extensions available in gcc.

    • The kernel developers use both ISO C99 and GNU C extensions to the C language.

  • Look at some of the more interesting extensions that may show up in kernel code.


A beast of a different nature 5

A Beast of a Different Nature (5)

  • Inline Functions

    • GNU C supports inline functions.

    • Inserted inline into each function call site.

    • This eliminates the overhead of function invocation and return (register saving and restore).

    • Allows for potentially more optimization because the compiler can optimize the caller and the called function together.

    • Code size increases because the contents of the function are copied to all the callers, which increases memory consumption.

    • Kernel developers use inline functions for small time-critical functions.


A beast of a different nature 6

A Beast of a Different Nature (6)

  • Making large functions inline, especially those that are used more than once or are not time critical, is frowned upon by the kernel developers.

  • An inline function is declared when the keywords static and inline are used as part of the function definition.

    static inline void dog(unsigned long tail_size)

  • The function declaration must precede any usage, or else the compiler cannot make the function inline.

  • Common practice is to place inline functions in header files.


A beast of a different nature 7

A Beast of a Different Nature (7)

  • Inline Assembly

    • The gcc C compiler enables the embedding of assembly instructions in normal C functions.

    • This feature is used in only those parts of the kernel that are unique to a given system architecture.

    • The asm() compiler directive is used to inline assembly code.

    • The Linux kernel is programmed in a mixture of C and assembly, with assembly relegated to low-level architecture and fast path code.

    • The vast majority of kernel code is programmed in straight C.


A beast of a different nature 8

A Beast of a Different Nature (8)

  • Branch Annotation

    • The gcc C compiler has a built-in directive that optimizes conditional branches as either very likely taken or very unlikely taken.

      • For example, consider an if statement such as the following

        • if (foo) { /* ... */ }

        • To mark this branch as very unlikely taken, i.e. we predict foo is nearly always zero:

          if (unlikely(foo)) { /* ... */ }

        • Conversely, to mark a branch as very likely taken:, i.e. we predict foo is nearly always nonzero:

          if (likely(foo)) { /* ... */ }


A beast of a different nature 9

A Beast of a Different Nature (9)

  • You should only use these directives when the branch direction is overwhelmingly a known priori or when you want to optimize a specific case at the cost of the other case.

    • These directives result in a performance boost when the branch is correctly predicted, but a performance loss when the branch is mispredicted.

  • A very common usage for unlikely() and likely() is error conditions.

  • unlikely() finds much more use in the kernel because if statements tend to indicate a special case.


A beast of a different nature 10

A Beast of a Different Nature (10)

  • No Memory Protection

    • When a user-space application attempts an illegal memory access, the kernel can trap the error, send SIGSEGV, and kill the process.

    • If the kernel attempts an illegal memory access, the results are less controlled.

    • Memory violations in the kernel result in a major kernel error.

      • You must not illegally access memory, such as dereferencing a NULL pointer.

    • Kernel memory is not pageable.

      • Every byte of memory you consume is one less byte of available physical memory.


A beast of a different nature 11

A Beast of a Different Nature (11)

  • No (Easy) Use of Floating Point

    • When a user-space process uses floating-point instructions, the kernel manages the transition from integer to floating point mode.

    • What the kernel has to do when using floating-point instructions normally catches a trap and does something in response.

    • Unlike user-space, the kernel does not have the seamless support for floating point because it cannot trap itself.

    • Using floating point inside the kernel requires manually saving and restoring the floating point registers, among possible other chores.


A beast of a different nature 12

A Beast of a Different Nature (12)

  • Small, Fixed-Size Stack

    • User-space can statically allocate tons of variables on the stack, including huge structures and many-element arrays.

    • This behavior is legal because user-space has a large stack that can grow in size dynamically.

    • The kernel stack is neither large nor dynamic; it is small and fixed in size.

    • The exact size of the kernel's stack varies by architecture.

    • On x86, the stack size is configurable at compile-time and can be either 4 or 8KB.

    • The kernel stack is two pages, which generally implies that it is 8KB on 32-bit architectures and 16KB on 64-bit architectures. This size is fixed and absolute.

    • Each process receives its own stack.


A beast of a different nature 13

A Beast of a Different Nature (13)

  • Synchronization and Concurrency

    • The kernel is susceptible to race conditions.

    • Unlike a single-threaded user-space application, a number of properties of the kernel allow for concurrent access of shared resources and thus require synchronization to prevent races.

    • Linux is a preemptive multi-tasking operating system. Processes are scheduled and rescheduled at the whim of the kernel's process scheduler.

    • The kernel must synchronize between these tasks.


A beast of a different nature 14

A Beast of a Different Nature (14)

  • The Linux kernel supports multiprocessing.

    • Without proper protection, kernel code executing on two or more processors can access the same resource.

  • Interrupts occur asynchronously with respect to the currently executing code.

    • Without proper protection, an interrupt can occur in the midst of accessing a shared resource and the interrupt handler can then access the same resource.

  • The Linux kernel is preemptive.

    • Without protection, kernel code can be preempted in favor of different code that then accesses the same resource.

  • Typical solutions to race conditions include spinlocks and semaphores.


A beast of a different nature 15

A Beast of a Different Nature (15)

  • Portability Is Important

    • Linux is a portable operating system and should remain one.

    • Architecture-independent C code must correctly compile and run on a wide range of systems.

    • Architecture-dependent code must be properly segregated in system-specific directories in the kernel source tree.

    • A handful of rules such as remain endian neutral, be 64-bit clean, do not assume the word or page size, and so on, go a long way.


  • Login