Add Your Own Linux System Calls
Linux system calls -- we use them every day. But do you know how a system call is performed from user-space to the kernel? Explore the Linux system call interface (SCI), learn how to add new system calls (and alternatives for doing so), and discover utilities related to the SCI.
An Introduction to Process Migration and User Space Implementation for the Linux Environment
This .PDF article reviews the field of process migration by
summarizing the key concepts and giving an overview of high
level process migration algorithm and by providing a unique
alternative implementation of our own for the linux
environment. Design and implementation issues of process
migration are analyzed in general, and these are used as
pointers in describing our implementation. The primary aim of
this article is to build a user space process migration tool
which would obviate the need for kernel support. This paper
aims to provide an insight into the difficult task of actual
migration for performance gain.
Anatomy of Linux Synchronization Methods
In your Linux education, you may have learned about concurrency, critical sections, and locking, but how do you use these concepts within the kernel? This article reviews the locking mechanisms available within the Linux Kernel 2.6, including atomic operators, spinlocks, reader/writer locks, and kernel semaphores. Also try the Linux Kernal tutorial to learn how to compile, and customize a Linux kernelto suit your needs.
Anatomy of the Linux Kernel
The Linux kernel is the core of a large and complex operating system, and while it's huge, it is well organized in terms of subsystems and layers. In this article, you explore the general structure of the Linux kernel</a> and get to know its major subsystems and core interfaces.
Anatomy of the Linux Slab Allocator
Minimize the time required to manage memory and maximize available memory for general usage with the slab allocator. This article explores the ideas behind the slab allocator and examines its interfaces and their use. It uses the Linux kernel method that originated in Solaris of allocating memory of objects based on their size.
Concurrency for grown-ups
This article introduces the basic concurrency concepts you need to conduct your business in the server closets safely. Concurrency labels situations where more than one "application" is running at a time. Linux hosts always fill their process tables with more-or-less simultaneous programs. Linux is a multi-tasking operating system and it's built for this.
Explore the Linux Memory Model
Memory management is a large, complex, and time-consuming set of tasks, one that is difficult to achieve because crafting a model how systems behave in real-world, multi-programmed environments is a tough job. Components like scheduling, paging behavior, and multiple-process interactions presents a considerable challenge. This article will help you decipher the basic knowledge required to engage the challenge of Linux memory management, providing you with a start.
Go Inside the Linux Scheduler
The Linux kernel continues to evolve, incorporating new technologies and gaining in reliability, scalability, and performance. One of the most important features of the 2.6 kernel is a scheduler implemented by Ingo Molnar. This scheduler is dynamic, supports load-balancing, and operates in constant time -- O(1). This article explores these attributes of the Linux 2.6 scheduler, and more.
Improvements in kernel development from 2.4 to 2.6
The long-awaited 2.6 kernel is finally here. The author takes a look behind the scenes at the tools, tests, and techniques -- from revision control and regression testing to bugtracking and list keeping -- that helped make <a href=http://www-106.ibm.com/developerworks/linux/library/l-dev26/index.html?ca=dgr-lnxw961KernCompDev>2.6 a better kernel</a> than any that have come before it. Some interesting changes took place in the way the Linux kernel is developed and tested. Several key changes have improved overall stability as well as quality.
Improving Linux kernel performance and scalability
The first step in improving Linux performance is quantifying it. But how exactly do you quantify performance for Linux or for comparable systems? In this article, members of the IBM Linux Technology Center share their expertise as they describe how they ran several benchmark tests on the Linux 2.4 and 2.5 kernels late last year.
Improving Linux kernel performance and scalability
This article describes the strategy and methodology used by the team for measuring, analyzing, and improving the performance and scalability of the Linux kernel, focusing on platform-independent issues. A suite of benchmarks is used to accomplish this task. The benchmarks provide coverage for a diverse set of workloads, including Web serving, database, and file serving. In addition, we show the various components of the kernel (disk I/O subsystem, for example) that are stressed by each benchmark.
Inside the Linux kernel debugger
When debugging kernel problems, being able to trace the kernel
execution and examine its memory and data structures is very
useful. The built-in kernel debugger in Linux, KDB, provides
this facility. In this article you'll learn how to use the
features provided by KDB and how to install and set up KDB on a
Linux machine. You'll also get acquainted with the commands and
the setup and display options available to you in KDB.
Kernel 2.6: Linux More Enterprise-Ready Than Ever Before
The 2.6 Linux kernel employs a number of techniques to improve
the use of large amounts of memory, making Linux more
enterprise-ready than ever before. This article outlines a few
of the more important changes, including reverse mapping, the
use of larger memory pages, storage of page-table entries in
high memory, and greater stability of the memory manager.
Kernel comparison: Web serving on 2.4 and 2.6
Many improvements have been made in the Linux 2.6 kernel to
favor enterprise applications. This article presents results
from the IBM Linux Technology Center's Web serving testing
efforts, comparing the Linux 2.4 and 2.6 kernels from various
aspects. The highlights here are the key enhancements in the
2.6 kernel, the test methodologies, and the results of the
tests themselves. Bottom line: the 2.6 kernel is much faster
than 2.4 for serving Web pages, with no loss in reliability.
Kernel Compilation & Avoiding ‘Unresolved Symbol’
Many of the kernel newbies are not aware of certain important concepts which are essential for proper compilation and insertion of the modules into the kernel This HOWTO is all about kernel compilation, how to avoid the annoying 'unresolved symbols' errors while Insmoding the modules.
KernelAnalysis-HOWTO
This document tries to explain some things about the Linux Kernel, such as the most important components, how they work, and so on. This HOWTO should help prevent the reader from needing to browse all the kernel source files searching for the"right function," declaration, and definition, and then linking each to the other.
Key Porting Differences from LinuxThreads to NPTL
The LinuxThreads project originally brought multithreading to Linux, but didn't conform to POSIX threading standards. The introduction of Native POSIX Thread Library (NPTL) however, overcame many of these disadvantages. This article describes some of the differences between these two Linux threading models for developers who may need to port their applications or who simply want to understand where the differences lie.
Linux kerneld mini-HOWTO
This document explains how to install and use the automatic kernel module loader "kerneld".The kerneld feature was introduced during the 1.3 development kernels by Bjorn Ekwall. It allows kernel modules such as device drivers, network drivers and filesystems to be loaded automatically when they are needed, rather than having to do it manually with modprobe or insmod.
Linux Scheduler Latency
Back in early November 2001, I started following a discussion between two factions of the Linux kernel community. The gist of the discussion was over what was the best solution to the Linux scheduler latency problem, that is the delay between the occurrence of an interrupt and the running of the process that services the interrupt. There were two main factions, the preemption patch faction and the low-latency patch faction. Both groups were very passionate (i.e. vocal) about the superiority of their solution. Since one of my jobs at Red Hat is to evaluate and recommend new techniques for embedded Linux solutions and since scheduler latency is one of the biggest complaints that hard realtime champions have about Linux, I decided to evaluate both patches and see which one came out on top.
Networking improvements in the 2.6 kernel
The new Linux kernel includes support for and improvements in
many areas of networking: from tunneling and better file
security to encryption and privacy protection. This article
covers how these improvements affect users even as they make
Linux more secure and more enterprise-ready.
POSIX threads explained
POSIX (Portable Operating System Interface) threads are a great way to increase the responsiveness and performance of your code. In this series, Daniel Robbins shows you exactly how to use threads in your code. A lot of behind-the-scenes details are covered, so by the end of this series you'll really be ready to create your own multithreaded programs.
POSIX threads explained, Part 2
POSIX threads are a great way to increase the responsiveness and performance of your code. In this second article of a three-part series, Daniel Robbins shows you how to protect the integrity of shared data structures in your threaded code by using nifty little things called mutexes.
POSIX threads explained, Part 3
In this article, the last of a three-part series on POSIX threads, Daniel takes a good look at how to use condition variables. Condition variables are POSIX thread structures that allow you to "wake up" threads when certain conditions are met. You can think of them as a thread-safe form of signalling. Daniel wraps up the article by using all that you've learned so far to implement a multi-threaded work crew application.
Simulate devices using DSF
Device Simulator Framework (DSF) provides an easy-to-use ioctl
interface to all your devices, real or imagined. Intended for
experienced kernel and device driver software developers, DSF
makes it easier to debug and test device code that would
otherwise be difficult to simulate or recreate.
Take Charge of Processor Affinity
Knowing a little bit about how the Linux 2.6 scheduler treats CPU affinity can help you design better userspace applications. Soft affinity means that processes do not frequently migrate between processors, whereas hard affinity means that processes run on processors you specify.
The Linux Kernel
This book is for Linux enthusiasts who want to know how the Linux kernel works. It is not an internals manual. Rather it describes the principles and mechanisms that Linux uses; how and why the Linux kernel works the way that it does.
Upgrading To The Linux 2.4 Kernel
This article shows how to (carefully) upgrade to the Linux 2.4 Kernel, and also considers the new breed of distributions and the challenges of the post-dot-com environment.
Using DEVFS
The role of the kernel is mostly related to hardware control, as user-space programs need a way of referring to hardware devices that they wish to use. Some hardware devices are used implicitly, through interfaces such as sockets or filesystems. However, it is often necessary to refer to a hardware device directly -- such as a particular serial port or hard-disk partition. This is accomplished through the use of special device files that are usually found in the /dev directory. This article introduces devfs.
Using Test Suites to Validate the Linux Kernel
You can use test suites to make sure that a new Linux kernel behaves properly. This article links to software that can test the basic functioning of your machine, suites that are dedicated specifically to kernel testing, and application test suites that test the kernel indirectly by checking the behaviour of the applications.
Enterprise Open Source Journal Enterprise Open Source Journal is the first magazine designed solely to focus on open source strategies in the enterprise.
subscribe now
