Book Image

Mastering Linux Kernel Development

By : CH Raghav Maruthi
Book Image

Mastering Linux Kernel Development

By: CH Raghav Maruthi

Overview of this book

Mastering Linux Kernel Development looks at the Linux kernel, its internal arrangement and design, and various core subsystems, helping you to gain significant understanding of this open source marvel. You will look at how the Linux kernel, which possesses a kind of collective intelligence thanks to its scores of contributors, remains so elegant owing to its great design. This book also looks at all the key kernel code, core data structures, functions, and macros, giving you a comprehensive foundation of the implementation details of the kernel’s core services and mechanisms. You will also look at the Linux kernel as well-designed software, which gives us insights into software design in general that are easily scalable yet fundamentally strong and safe. By the end of this book, you will have considerable understanding of and appreciation for the Linux kernel.

Related Content you might be interested in

Current Title:

Small book image
Mastering Linux Kernel Development
CH Raghav Maruthi
Oct, 2017 | 354 pages
Small book image
Linux Device Driver Development
John Madieu
Apr, 2022 | 708 pages
Small book image
Linux Device Drivers Development
John Madieu
Oct, 2017 | 586 pages
Small book image
Linux Kernel Programming Part 2 - Char Device Drivers and Kernel Synchronization
Kaiwan N Billimoria
Mar, 2021 | 452 pages
Table of Contents (19 chapters)
Title Page
Title Page
Credits
Credits
About the Author
About the Author
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
Comprehending Processes, Address Space, and Threads
Comprehending Processes, Address Space, and Threads
Processes
Process descriptors
Kernel stack
The issue of stack overflow
Process creation
Kernel threads
Process status and termination
Namespaces and cgroups
Summary
2
Deciphering the Process Scheduler
Deciphering the Process Scheduler
Process schedulers
Linux process scheduler design
Runqueue
The scheduler's entry point
Process priorities
Scheduler classes
Completely Fair Scheduling class (CFS)
Real-time scheduling class
Scheduler related system calls
Process preemption
Summary
3
Signal Management
Signal Management
Signals
Signal-management APIs
Signal data structures
Signal generation and delivery
Restarting interrupted system calls
Summary
4
Memory Management and Allocators
Memory Management and Allocators
Initialization operations
Zones and nodes
Memory allocators
Summary
5
Filesystems and File I/O
Filesystems and File I/O
Filesystem - high-level view
Filesystems in the Linux kernel
Common filesystem interface
Special filesystems
Summary
6
Interprocess Communication
Interprocess Communication
Pipes and FIFOs
Message queues
Shared memory
Semaphores
Summary
7
Virtual Memory Management
Virtual Memory Management
Process address space
Summary
8
Kernel Synchronization and Locking
Kernel Synchronization and Locking
Atomic operations
Introducing exclusion locks
Summary
9
Interrupts and Deferred Work
Interrupts and Deferred Work
Interrupt signals and vectors
Programmable interrupt controller
High-level interrupt-management interfaces
Deferred work
Summary
10
Clock and Time Management
Clock and Time Management
Time representation
Hardware abstraction
Linux timekeeping data structures, macros, and helper routines
Software timers and delay functions
POSIX clocks
Summary
11
Module Management
Module Management
Kernel modules
Summary
Index
Index

Scheduler related system calls

Linux provides an entire family of system calls that manage various scheduler parameters, policies, and priorities and retrieve a multitude of scheduling-related information for the calling threads. It also enables threads to yield CPU explicitly:

nice(int inc)

nice() takes an int parameter and adds it to the nice value of the calling thread. On success, it returns the new nice value of the thread. Nice values are within the range 19 (lowest priority) to -20 (highest priority). Nice values can be incremented only within this range:

getpriority(int which, id_t who)

This returns the nice value of the thread, group, user, or set of threads of a specified user as indicated by its parameters. It returns the highest priority held by any of the processes:

setpriority(int which, id_t who, int prio)

The scheduling priority of the thread, group, user, or set of threads of a specified user as indicated by its parameters is set bysetpriority.It returns zero on success:

sched_setscheduler...
Previous Section
End of Section 10
Next Section