M

M68k architecture (porting and), Platform Dependencies

MAC (medium access control) addresses, Initializing Each Device, Interface Information, The Device Methods, MAC Address Resolution–Non-Ethernet Headers

resolution of, MAC Address Resolution–Non-Ethernet Headers

set_mac_address method and, The Device Methods

macros, The Hello World Module, Version Dependency, The Kernel Symbol Table, The Internal Representation of Device Numbers, Quick Reference, printk, printk, printk, printk, printk, printk, printk, printk, Completions, Simple Sleeping, Manual sleeps, Quick Reference, Tasklets, Linked Lists, Linked Lists, Linked Lists, Configuration Registers and Initialization, Configuration Registers and Initialization, MODULE_DEVICE_TABLE, What Devices Does the Driver Support?, What Devices Does the Driver Support?, What Devices Does the Driver Support?, What Devices Does the Driver Support?, Bus attributes, Driver structure embedding, Physical Addresses and Pages, The Memory Map and Struct Page, Scatter/gather mappings, Scatter/gather mappings, set_termios

BUS_ATTR, Bus attributes

completion, Completions

DECLARE_TASKLET, Tasklets

DIVER_ATTR, Driver structure embedding

hello world module, The Hello World Module

INIT_LIST_HEAD, Linked Lists

internal representation of device numbers, The Internal Representation of Device Numbers

ioctl commands (creating), Quick Reference

KERN_ALERT, printk

KERN_CRIT, printk

KERN_DEBUG, printk

KERN_EMERG, printk

KERN_ERR, printk

KERN_INFO, printk

KERN_NOTICE, printk

KERN_WARNING, printk

list_entry, Linked Lists

list_for_each, Linked Lists

MINOR, Quick Reference

MODULE_DEVICE_TABLE, MODULE_DEVICE_TABLE

page_address, The Memory Map and Struct Page

PAGE_SHIFT, Physical Addresses and Pages

PCI_DEVICE, Configuration Registers and Initialization

PCI_DEVICE_CLASS, Configuration Registers and Initialization

RELEVANT_IFLAG, set_termios

sg_dma_address, Scatter/gather mappings

sg_dma_len, Scatter/gather mappings

symbols, The Kernel Symbol Table

UBS_DEVICE_VER, What Devices Does the Driver Support?

USB_DEVICE, What Devices Does the Driver Support?

USB_DEVICE_INFO, What Devices Does the Driver Support?

USB_INTERFACE_INFO, What Devices Does the Driver Support?

version dependency, Version Dependency

wait queues, Manual sleeps

wait-event, Simple Sleeping

magic SysRq key, System Hangs

mailing list, linux-kernel, Joining the Kernel Development Community

mainline kernels, installation of, Setting Up Your Test System

major device numbers, Major and Minor Numbers

MAJOR macro, Quick Reference

major numbers, Major and Minor Numbers–Dynamic Allocation of Major Numbers, Dynamic Allocation of Major Numbers

char drivers, Major and Minor Numbers–Dynamic Allocation of Major Numbers

dynamic allocation of, Dynamic Allocation of Major Numbers

make command, Compiling Modules

makefiles, Compiling Modules, Turning the Messages On and Off

printk function, Turning the Messages On and Off

management, Splitting the Kernel, Splitting the Kernel, Splitting the Kernel, Splitting the Kernel, Splitting the Kernel, Security Issues, scull's Memory Usage–scull's Memory Usage, Pitfalls in scull, Concurrency and Its Management–Concurrency and Its Management, Locking Traps–Fine- Versus Coarse-Grained Locking, Alternatives to Locking–Read-Copy-Update, Tasklets–Tasklets, The Size Argument, I/O Ports and I/O Memory–isa_readb and Friends, Quick Reference, The Linux Device Model, Managing classes, Memory Management in Linux–High and Low Memory, The Memory Map and Struct Page–The Memory Map and Struct Page, Page Tables, Virtual Memory Areas–The vm_area_struct structure, The Process Memory Map, The mmap Device Operation–Remapping Kernel Virtual Addresses, Performing Direct I/O–An asynchronous I/O example, Direct Memory Access–Talking to the DMA controller, Do-it-yourself allocation, Direct Memory Access

classes, Managing classes

concurrency, Concurrency and Its Management–Concurrency and Its Management, Locking Traps–Fine- Versus Coarse-Grained Locking, Alternatives to Locking–Read-Copy-Update

alternatives to locking, Alternatives to Locking–Read-Copy-Update

locking traps, Locking Traps–Fine- Versus Coarse-Grained Locking

fragmentation, Do-it-yourself allocation

hardware (I/O ports and I/O memory), I/O Ports and I/O Memory–isa_readb and Friends

interrupt handlers, Quick Reference

memory, Splitting the Kernel, scull's Memory Usage–scull's Memory Usage, Pitfalls in scull, Memory Management in Linux–High and Low Memory, The Memory Map and Struct Page–The Memory Map and Struct Page, Page Tables, Virtual Memory Areas–The vm_area_struct structure, The Process Memory Map, The mmap Device Operation–Remapping Kernel Virtual Addresses, Performing Direct I/O–An asynchronous I/O example, Direct Memory Access–Talking to the DMA controller, Direct Memory Access

direct I/O, Performing Direct I/O–An asynchronous I/O example

DMA, Direct Memory Access–Talking to the DMA controller, Direct Memory Access

mapping, The Memory Map and Struct Page–The Memory Map and Struct Page

mmap device operations, The mmap Device Operation–Remapping Kernel Virtual Addresses

page tables, Page Tables

process memory maps, The Process Memory Map

scull, scull's Memory Usage–scull's Memory Usage, Pitfalls in scull

VMAs, Virtual Memory Areas–The vm_area_struct structure

networks, Splitting the Kernel

physical memory, The Size Argument

power, The Linux Device Model

process, Splitting the Kernel, Splitting the Kernel

security, Security Issues

tasklets, Tasklets–Tasklets

manual sleeps, Manual sleeps

mapper program, Remapping RAM

mapping, I/O Memory Allocation and Mapping, I/O Memory Allocation and Mapping, Quick Reference, The Memory Map and Struct Page–The Memory Map and Struct Page, The Process Memory Map, The mmap Device Operation–Remapping Kernel Virtual Addresses, The mmap Device Operation, DMA mappings, DMA mappings, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Single-page streaming mappings, Scatter/gather mappings, Scatter/gather mappings, Scatter/gather mappings, PCI double-address cycle mappings

deleting, Setting up streaming DMA mappings

DMA, DMA mappings

I/O, I/O Memory Allocation and Mapping, Quick Reference

memory, The Memory Map and Struct Page–The Memory Map and Struct Page, The Process Memory Map, The mmap Device Operation–Remapping Kernel Virtual Addresses

mmap device operations, The mmap Device Operation–Remapping Kernel Virtual Addresses

process memory maps, The Process Memory Map

PCI double-address cycle, PCI double-address cycle mappings

registers, DMA mappings, Scatter/gather mappings

scatter-gather DMA, Scatter/gather mappings

scatterlists and, Scatter/gather mappings

single-page streaming, Single-page streaming mappings

software-mapped memory, I/O Memory Allocation and Mapping

streaming DMA configuration, Setting up streaming DMA mappings

video memory, The mmap Device Operation

match function (buses), Bus methods

MCA (Micro Channel Architecture), MCA

mdelay, Short Delays

measurement of time lapses, Measuring Time Lapses–Processor-Specific Registers

Media Independent Interface (MII), Media Independent Interface Support

media_changed method, Supporting Removable Media

memory, Splitting the Kernel, Loading and Unloading Modules, The Design of scull, The Design of scull, The Design of scull, scull's Memory Usage–scull's Memory Usage, Pitfalls in scull, Semaphores and Mutexes, Using the ioctl Argument, The Real Story of kmalloc–The Size Argument, The Flags Argument, Memory zones, Lookaside Caches–The alloc_pages Interface, Lookaside Caches, Memory Pools, get_free_page and Friends, get_free_page and Friends, vmalloc and Friends–A scull Using Virtual Addresses: scullv, Per-CPU Variables–Per-CPU Variables, Obtaining Large Buffers, Quick Reference, Quick Reference, Quick Reference, Quick Reference, I/O Ports and I/O Memory–isa_readb and Friends, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Memory Allocation and Mapping, I/O Memory Allocation and Mapping, ISA Memory Below 1 MB, Quick Reference, Quick Reference, Quick Reference, Page Size, PCI Addressing, Accessing the I/O and Memory Spaces, Memory Mapping and DMA, Memory Management in Linux–High and Low Memory, High and Low Memory, High and Low Memory, High and Low Memory, The Memory Map and Struct Page–The Memory Map and Struct Page, Page Tables, Virtual Memory Areas–The vm_area_struct structure, The Process Memory Map, The mmap Device Operation–Remapping Kernel Virtual Addresses, Remapping RAM, Performing Direct I/O–An asynchronous I/O example, Performing Direct I/O, Direct Memory Access–Talking to the DMA controller, Do-it-yourself allocation, Direct Memory Access, Initialization in sbull, Hardware Information

allocation, The Real Story of kmalloc–The Size Argument, The Flags Argument, Lookaside Caches–The alloc_pages Interface, Lookaside Caches, get_free_page and Friends, get_free_page and Friends, vmalloc and Friends–A scull Using Virtual Addresses: scullv, Per-CPU Variables–Per-CPU Variables, Obtaining Large Buffers, Quick Reference, Quick Reference, Quick Reference, I/O Memory Allocation and Mapping, Quick Reference

boot time, Obtaining Large Buffers, Quick Reference

flags, The Flags Argument, Lookaside Caches, Quick Reference

I/O, I/O Memory Allocation and Mapping, Quick Reference

kmalloc allocation engine, The Real Story of kmalloc–The Size Argument

lookaside caches, Lookaside Caches–The alloc_pages Interface, Quick Reference

by page, get_free_page and Friends

per-CPU variables, Per-CPU Variables–Per-CPU Variables

performance degradation issues, get_free_page and Friends

vmalloc allocation function, vmalloc and Friends–A scull Using Virtual Addresses: scullv

barriers, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, Quick Reference

block drivers, Initialization in sbull

DMA, Memory Mapping and DMA (see DMA)

global areas, The Design of scull

hardware, Hardware Information

high, High and Low Memory

I/O, I/O Ports and I/O Memory–isa_readb and Friends, Quick Reference

ISA, ISA Memory Below 1 MB

access, ISA Memory Below 1 MB

limitations on, High and Low Memory

locking, Semaphores and Mutexes

low, High and Low Memory

management, Splitting the Kernel, Memory Management in Linux–High and Low Memory, The Memory Map and Struct Page–The Memory Map and Struct Page, Page Tables, Virtual Memory Areas–The vm_area_struct structure, The Process Memory Map, The mmap Device Operation–Remapping Kernel Virtual Addresses, Performing Direct I/O–An asynchronous I/O example, Direct Memory Access–Talking to the DMA controller, Do-it-yourself allocation, Direct Memory Access

direct I/O, Performing Direct I/O–An asynchronous I/O example

DMA, Direct Memory Access–Talking to the DMA controller, Direct Memory Access

fragmentation, Do-it-yourself allocation

mapping, The Memory Map and Struct Page–The Memory Map and Struct Page

mmap device operations, The mmap Device Operation–Remapping Kernel Virtual Addresses

page tables, Page Tables

process memory maps, The Process Memory Map

VMAs, Virtual Memory Areas–The vm_area_struct structure

modules (loading), Loading and Unloading Modules

page size and portability, Page Size

PCI, PCI Addressing, Accessing the I/O and Memory Spaces

persistence, The Design of scull

pools, Memory Pools, Quick Reference

remapping RAM, Remapping RAM

scull, The Design of scull, scull's Memory Usage–scull's Memory Usage, Pitfalls in scull

design of, The Design of scull

troubleshooting, Pitfalls in scull

usage, scull's Memory Usage–scull's Memory Usage

software-mapped (and ioremap function), I/O Memory Allocation and Mapping

user space, Performing Direct I/O

verifying user-space addresses, Using the ioctl Argument

versus I/O registers, I/O Registers and Conventional Memory

zones, Memory zones

memory management, The Process Memory Map, The Process Memory Map

theory of, The Process Memory Map

VMAs, The Process Memory Map

messages, The Hello World Module, The Hello World Module, printk, Redirecting Console Messages, How Messages Get Logged, Turning the Messages On and Off, Turning the Messages On and Off, Rate Limiting, Oops Messages–Oops Messages

consoles, Redirecting Console Messages

debug, Turning the Messages On and Off, Rate Limiting

disabling, Turning the Messages On and Off

limitation of (printk function), Rate Limiting

globally enabling/disabling, Turning the Messages On and Off

kernels, The Hello World Module

logging, How Messages Get Logged

oops, Oops Messages–Oops Messages

priorities (loglevels) of, The Hello World Module, printk

methods, File Operations–File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, The file Structure, The file Structure, The file Structure, The open Method–The open Method, The release Method, The release Method, The release Method, The release Method, read and write, read and write, read and write, read and write, read and write, The read Method, The read Method, The write Method, The write Method, readv and writev, readv and writev, Implementing files in /proc, The seq_file interface, The seq_file interface, The seq_file interface, The seq_file interface, The ioctl Method, Debugging by Watching, Debugging by Watching, Oops Messages, Oops Messages, System Hangs, The Spinlock Functions, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, ioctl–Device Control Without ioctl, ioctl, Blocking and Nonblocking Operations, poll and select–The Underlying Data Structure, poll and select–The Underlying Data Structure, Reading data from the device, Writing to the device, Flushing pending output, Flushing pending output, Seeking a Device, Single-Open Devices, Restricting Access to a Single User at a Time, Blocking open as an Alternative to EBUSY, Blocking open as an Alternative to EBUSY, Cloning the Device on open, String Operations, Quick Reference, Release functions and kobject types, Default Attributes, Default Attributes, Hotplug Operations, Hotplug Operations, Bus methods, The vm_area_struct structure, The vm_area_struct structure, The vm_area_struct structure, The vm_area_struct structure, The mmap Device Operation–Remapping Kernel Virtual Addresses, Mapping Memory with nopage, Remapping RAM with the nopage method, Asynchronous I/O, Registering DMA usage, Talking to the DMA controller, Block device operations, The open and release Methods, The open and release Methods, Supporting Removable Media, Supporting Removable Media, The ioctl Method, The ioctl Method, Interface Information, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, The Device Methods, Packet Transmission, Packet Transmission, Using ARP with Ethernet, Custom ioctl Commands, Custom ioctl Commands, Statistical Information, Kernel Support for Multicasting, Netpoll

block_fsync, Flushing pending output

buses, Bus methods

change_mtu, The Device Methods

check_flags, File Operations

close, The release Method, The vm_area_struct structure

devices, The Device Methods

*dir_notify, File Operations

do_ioctl, The Device Methods, Custom ioctl Commands

fasync, File Operations

flush, File Operations, The release Method

fsync, File Operations, Flushing pending output

get_stats, The Device Methods, Statistical Information

hard_header, The Device Methods, Using ARP with Ethernet

hard_start_transmit, Packet Transmission

hard_start_xmit, The Device Methods, Packet Transmission

header_cache, The Device Methods

header_cache_update, The Device Methods

ioctl, File Operations, The ioctl Method, ioctl–Device Control Without ioctl, ioctl, The ioctl Method, Custom ioctl Commands

block drivers, The ioctl Method

customizing for networking, Custom ioctl Commands

debugging with, The ioctl Method

inode pointer in, ioctl

llseek, File Operations, Seeking a Device

lock, File Operations

media_changed, Supporting Removable Media

mmap, File Operations

next, The seq_file interface

nopage, The vm_area_struct structure, Mapping Memory with nopage, Remapping RAM with the nopage method

open, File Operations, The file Structure, The open Method–The open Method, Single-Open Devices, Restricting Access to a Single User at a Time, Blocking open as an Alternative to EBUSY, The vm_area_struct structure, Registering DMA usage, The open and release Methods, The Device Methods

block drivers, The open and release Methods

blocking, Blocking open as an Alternative to EBUSY

for network devices, The Device Methods

private_data and, The file Structure

requesting DMA channels, Registering DMA usage

restricting simultaneous users and, Restricting Access to a Single User at a Time

for single-open devices, Single-Open Devices

vm_operations_struct structure, The vm_area_struct structure

operations, File Operations–File Operations, File Operations, readv and writev, System Hangs, The Spinlock Functions, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Atomic Variables, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Bit Operations, Blocking and Nonblocking Operations, String Operations, Quick Reference, Hotplug Operations, Hotplug Operations, The mmap Device Operation–Remapping Kernel Virtual Addresses, Asynchronous I/O, Block device operations, The Device Methods

aio_fsync, Asynchronous I/O

atomic_add, Atomic Variables

atomic_dec, Atomic Variables

atomic_dec_and_test, Atomic Variables

atomic_inc, Atomic Variables

atomic_inc_and_test, Atomic Variables

atomic_read, Atomic Variables

atomic_set, Atomic Variables

atomic_sub, Atomic Variables

atomic_sub_and_test, Atomic Variables

bit, Bit Operations

block drivers, Block device operations

blocking/nonblocking, Blocking and Nonblocking Operations

change_bit, Bit Operations

clear_bit, Bit Operations

devices, The Device Methods

files, File Operations–File Operations

filter hotplug, Hotplug Operations

flush, File Operations

hotplugs, Hotplug Operations

mmap devices, The mmap Device Operation–Remapping Kernel Virtual Addresses

set_bit, Bit Operations

spinlocks, The Spinlock Functions

string, String Operations, Quick Reference

sysrq, System Hangs

test_and_change_bit, Bit Operations

test_and_clear_bit, Bit Operations

test_and_set_bit, Bit Operations

test_bit, Bit Operations

vector, readv and writev

poll, File Operations, poll and select–The Underlying Data Structure, The Device Methods

poll_controller, Netpoll

populate, The vm_area_struct structure

pread, read and write

proc_read, Implementing files in /proc

pwrite, read and write

read, File Operations, The file Structure, read and write, read and write, The read Method, The read Method, Debugging by Watching, Oops Messages, Reading data from the device, Talking to the DMA controller

arguments to, read and write

code for, The read Method

configuring DMA controllers, Talking to the DMA controller

f_pso field (file structure) and, The file Structure

oops messages, Oops Messages

poll method and, Reading data from the device

rules for interpreting return values, The read Method

strace command and, Debugging by Watching

readdir, File Operations

readv, File Operations

rebuild_header, The Device Methods

release, File Operations, The release Method, The release Method, Blocking open as an Alternative to EBUSY, Cloning the Device on open, Release functions and kobject types, The open and release Methods

block drivers, The open and release Methods

blocking, Blocking open as an Alternative to EBUSY

cloning devices, Cloning the Device on open

kobjects, Release functions and kobject types

revalidate, Supporting Removable Media

sbull ioctl, The ioctl Method

select, poll and select–The Underlying Data Structure

select, poll method and, File Operations

set_config, The Device Methods

set_mac_address, The Device Methods

set_multicast_list, Interface Information, The Device Methods, Kernel Support for Multicasting

show, The seq_file interface, Default Attributes

kobjects, Default Attributes

seq_file interface, The seq_file interface

start, The seq_file interface

stop, The Device Methods

store (kobjects), Default Attributes

strace command and, Debugging by Watching

struct module *owner, File Operations

tx_timeout, The Device Methods

unsigned long, File Operations

write, File Operations, The file Structure, read and write, The write Method, The write Method, Oops Messages, Writing to the device

code for, The write Method

f_pos field (file structure) and, The file Structure

interpreting rules for return values, The write Method

oops messages, Oops Messages

poll method and, Writing to the device

writev, File Operations, readv and writev

mice, Asynchronous Notification, Input

asynchronous notification, Asynchronous Notification

hotplugging, Input

Micro Channel Architecture (MCA), MCA

microsecond resolution, Knowing the Current Time

MII (Media Independent Interface), Media Independent Interface Support

minor device numbers, Major and Minor Numbers

MINOR macro, Quick Reference, Quick Reference

minor numbers, char drivers, Major and Minor Numbers–Dynamic Allocation of Major Numbers

MIPS processor, Processor-Specific Registers, Platform Dependencies

inline assembly code and, Processor-Specific Registers

porting and, Platform Dependencies

misc-progs directory, Redirecting Console Messages, Testing the Scullpipe Driver

mitigation of interrupts, Receive Interrupt Mitigation

MKDEV macro, Quick Reference

mlock system call, Doing It in User Space

mmap, Memory Management in Linux–High and Low Memory, The vm_area_struct structure, The mmap Device Operation–Remapping Kernel Virtual Addresses, Implementing mmap

(see also memory management)

device operations, The mmap Device Operation–Remapping Kernel Virtual Addresses

implementation, Memory Management in Linux–High and Low Memory, Implementing mmap

mmap method, File Operations, The vm_area_struct structure, Adding VMA Operations

usage count and, Adding VMA Operations

vm_area_struct structure and, The vm_area_struct structure

modalities (levels), CPU, User Space and Kernel Space

models (Linux device), The Linux Device Model–The Linux Device Model, Kobjects, Ksets, and Subsystems–Subsystems, Low-Level Sysfs Operations–Symbolic Links, Hotplug Event Generation, Buses–Bus attributes, Devices–Driver structure embedding, Classes–Class interfaces, Putting It All Together–Remove a Driver, Hotplug–udev, Dealing with Firmware–How It Works

buses, Buses–Bus attributes

classes, Classes–Class interfaces

devices, Devices–Driver structure embedding

firmware, Dealing with Firmware–How It Works

hotplugging, Hotplug Event Generation, Hotplug–udev

kobjects, Kobjects, Ksets, and Subsystems–Subsystems

lifecycles, Putting It All Together–Remove a Driver

low-level sysfs operations, Low-Level Sysfs Operations–Symbolic Links

modes, Dynamic Allocation of Major Numbers, The file Structure, Kernel Timers, Tasklets–Tasklets

device modes, Dynamic Allocation of Major Numbers

file modes, The file Structure

interrupt, Kernel Timers, Tasklets–Tasklets

asynchronous execution, Kernel Timers

tasklets, Tasklets–Tasklets

mode_t f_mode (struct file field), The file Structure

mode_t mode variable (USB), probe and disconnect in Detail

modprobe utility, Loading and Unloading Modules, The Kernel Symbol Table, The Kernel Symbol Table, Module Parameters

assigning parameter values, Module Parameters

insmod program versus, The Kernel Symbol Table

modularization, layered, The Kernel Symbol Table

module.h header file, Quick Reference

modules, Loadable Modules, Loadable Modules, Classes of Devices and Modules, Classes of Devices and Modules, Security Issues, License Terms, Setting Up Your Test System, The Hello World Module–The Hello World Module, Kernel Modules Versus Applications–A Few Other Details, Kernel Modules Versus Applications, Kernel Modules Versus Applications, Kernel Modules Versus Applications, The Current Process, Compiling Modules–Compiling Modules, Loading and Unloading Modules, Loading and Unloading Modules–Platform Dependency, Loading and Unloading Modules, Version Dependency, Platform Dependency, Platform Dependency, The Kernel Symbol Table–The Kernel Symbol Table, The Kernel Symbol Table, The Kernel Symbol Table, Preliminaries, Initialization and Shutdown–Module-Loading Races, Module-Loading Races, Module Parameters–Module Parameters, Doing It in User Space–Doing It in User Space, Quick Reference, Dynamic Allocation of Major Numbers, Dynamic Allocation of Major Numbers, Dynamic Allocation of Major Numbers, Oops Messages, Completions, A Sample Driver, Kernel-assisted probing, Use of Standard C Types, Module Unloading

applications, Kernel Modules Versus Applications–A Few Other Details

authorization, Security Issues

base module parameter, A Sample Driver

code requirements, Preliminaries

compiling, Compiling Modules–Compiling Modules

complete, Completions

current process and, The Current Process

dynamic module assignment, Dynamic Allocation of Major Numbers

dynamic number assignment, Dynamic Allocation of Major Numbers

faulty (oops messages), Oops Messages

files, Quick Reference

filesystem, Classes of Devices and Modules

header files of, Kernel Modules Versus Applications

hello world, The Hello World Module–The Hello World Module

initialization, Initialization and Shutdown–Module-Loading Races

kdatasize, Use of Standard C Types

license terms, License Terms

loading, Kernel Modules Versus Applications, Loading and Unloading Modules, Loading and Unloading Modules–Platform Dependency, Module-Loading Races, Dynamic Allocation of Major Numbers

insmod program and, Loading and Unloading Modules

races, Module-Loading Races

using init scripts, Dynamic Allocation of Major Numbers

parameters, Module Parameters–Module Parameters

platform dependency, Platform Dependency, Platform Dependency

SCSI, Classes of Devices and Modules

short, Kernel-assisted probing

stacking, The Kernel Symbol Table, The Kernel Symbol Table

symbols, The Kernel Symbol Table–The Kernel Symbol Table

test system setup, Setting Up Your Test System

unloading, Kernel Modules Versus Applications, Loading and Unloading Modules, Module Unloading

user-space programming, Doing It in User Space–Doing It in User Space

version dependency, Version Dependency

MODULE_ALIAS macro, Quick Reference

MODULE_AUTHOR macro, Quick Reference

MODULE_DESCRIPTION macro, Quick Reference

MODULE_DEVICE_TABLE macro, Quick Reference, MODULE_DEVICE_TABLE

module_init function, Initialization and Shutdown

module_param macro, Module Parameters, Quick Reference

mod_timer function, The Timer API, The Implementation of Kernel Timers

monitoring, Debugging by Watching

kernels (debugging by), Debugging by Watching

mremap system calls, Mapping Memory with nopage, Remapping Specific I/O Regions

MSR register, ioctls

MTU, network devices and, The Device Methods

multicasting, Interface Information, Multicast–A Typical Implementation

IFF_MULTICAST flag and, Interface Information

network drivers, Multicast–A Typical Implementation

mutexes, Semaphores and Mutexes, The Linux Semaphore Implementation

initialization, The Linux Semaphore Implementation

mutual exclusion, Concurrency and Its Management