S

S/390 architecture, Platform Dependencies, S/390 and zSeries

porting and, Platform Dependencies

SAK (secure attention key) function, System Hangs

sample programs, obtaining, License Terms

SA_INTERRUPT flag, Installing an Interrupt Handler, Quick Reference

SA_SAMPLE_RANDOM flag, Installing an Interrupt Handler, Quick Reference

SA_SHIRQ flag, Installing an Interrupt Handler, Installing a Shared Handler, Quick Reference

/sbin/hotplug utility, The /sbin/hotplug Utility

sbull drivers, Initialization in sbull, A Simple request Method

initialization, Initialization in sbull

request method, A Simple request Method

sbull ioctl method, The ioctl Method

sbull_request function, Initialization in sbull

SBus, SBus

scatter/gather, Scatter/gather mappings, Scatter/Gather I/O

DMA mappings, Scatter/gather mappings

I/O, Scatter/Gather I/O

scatterlists, Scatter/gather mappings, Scatter/gather mappings, Direct Memory Access

mapping, Scatter/gather mappings, Scatter/gather mappings

structure, Direct Memory Access

sched.h header file, Quick Reference, Measuring Time Lapses

schedule function, System Hangs, Quick Reference, Yielding the processor

execution of code (delaying), Yielding the processor

preventing endless loops with, System Hangs

schedulers (I/O), Request Queues

schedule_timeout function, Timeouts

scheduling kernel timers, Kernel Timers–The Implementation of Kernel Timers

scripts (hotplug), Linux hotplug scripts

SCSI, Classes of Devices and Modules, SCSI

devices, SCSI

modules, Classes of Devices and Modules

scull, Char Drivers, The Design of scull, Dynamic Allocation of Major Numbers, File Operations–File Operations, The inode Structure, Device Registration in scull, The open Method–The open Method, The release Method, scull's Memory Usage–scull's Memory Usage, scull's Memory Usage, read and write, read and write, readv and writev, readv and writev, Playing with the New Devices, Turning the Messages On and Off, Implementing files in /proc, The seq_file interface, The seq_file interface, The seq_file interface, Pitfalls in scull, Pitfalls in scull, Concurrency and Its Management, Semaphores and Mutexes, Using Semaphores in scull, Choosing the ioctl Commands

char drivers, Playing with the New Devices

concurrency, Concurrency and Its Management (see concurrency)

design of, The Design of scull

device registration, Device Registration in scull

drivers (example), Turning the Messages On and Off, Choosing the ioctl Commands

file operations, File Operations–File Operations

inode structure, The inode Structure

locking (adding), Semaphores and Mutexes

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

troubleshooting, Pitfalls in scull

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

next method, The seq_file interface

open method, The open Method–The open Method

pointers, scull's Memory Usage

race conditions, Pitfalls in scull

read method, read and write

readv calls, readv and writev

read_proc method, Implementing files in /proc

release method, The release Method

semaphores, Using Semaphores in scull

show method, The seq_file interface

stop method, The seq_file interface

write method, read and write

writev calls, readv and writev

scull driver (example), Char Drivers

scullc driver (example), A scull Based on the Slab Caches: scullc

scullp, A scull Using Whole Pages: scullp, Remapping RAM with the nopage method

example, A scull Using Whole Pages: scullp

mmap implementations, Remapping RAM with the nopage method

scullpipe devices (example), A Blocking I/O Example–Testing the Scullpipe Driver

scullsingle device, Single-Open Devices

sculluid code, Restricting Access to a Single User at a Time

scullv driver (example), A scull Using Virtual Addresses: scullv, Quick Reference

scull_cleanup function, Cloning the Device on open

scull_getwritespace function, Manual sleeps

searching PCI drivers, Quick Reference

sectors (size of), A Note on Sector Sizes

sector_t bi_sector field (bio structure), The bio structure

sector_t capacity field (gendisk), The gendisk structure

sector_t sector field (request structure), A Simple request Method

secure attention key (SAK) function, System Hangs

security, Security Issues, Security Issues

seeking devices, Seeking a Device

select method, File Operations, poll and select–The Underlying Data Structure

poll method and, File Operations

semaphores, Semaphores and Mutexes, Semaphores and Mutexes, The Linux Semaphore Implementation–Reader/Writer Semaphores, Reader/Writer Semaphores, Completions–Completions

completion, Completions–Completions

implementation, The Linux Semaphore Implementation–Reader/Writer Semaphores

reader/writer, Reader/Writer Semaphores

unlocking, Semaphores and Mutexes

sendfile system, File Operations

sendpage system, File Operations

seqlocks, seqlocks

SEQNUM variable, The /sbin/hotplug Utility

sequences (race conditions), Pitfalls in scull

seq_file interface, The seq_file interface–The seq_file interface

serial line configuration, ioctls

serial_icounter_struct structure, ioctls

setconsole program, Redirecting Console Messages

setterm program, Device Control Without ioctl

set_bit operation, Bit Operations

set_config method, The Device Methods

set_dma_addr function, Talking to the DMA controller

set_dma_count function, Talking to the DMA controller

set_dma_mode function, Talking to the DMA controller

set_mac_address method, The Device Methods

set_mb function, I/O Registers and Conventional Memory

set_multicast_list function, A Typical Implementation

set_multicast_list method, Interface Information, The Device Methods

set_rmb function, I/O Registers and Conventional Memory

set_termios function, set_termios

set_wmb function, I/O Registers and Conventional Memory

sfile argument, The seq_file interface

sg_dma_address function, Direct Memory Access

sg_dma_address macro, Scatter/gather mappings

sg_dma_len function, Direct Memory Access

sg_dma_len macro, Scatter/gather mappings

sharing, Concurrency and Its Management, The Shared Queue, Interrupt Sharing–The /proc Interface and Shared Interrupts

code, Concurrency and Its Management

interrupt handlers, Interrupt Sharing–The /proc Interface and Shared Interrupts

queues, The Shared Queue

short delays, Short Delays

sleeps, Short Delays

short driver (example), A Sample Driver, Reusing short for I/O Memory, Installing an Interrupt Handler, Do-it-yourself probing, Implementing a Handler

accessing I/O memory, Reusing short for I/O Memory

implementing interrupt handlers, Implementing a Handler

installing interrupt handlers, Installing an Interrupt Handler

probing, Do-it-yourself probing

short module, Kernel-assisted probing

shortprint drivers, A Write-Buffering Example–A Write-Buffering Example

show function, Driver structure embedding

show method, The seq_file interface, Default Attributes

kobjects, Default Attributes

seq_file interface, The seq_file interface

shutdown, Initialization and Shutdown, The Linux Device Model

SIGIO signal, Asynchronous Notification

signal handling, A Blocking I/O Example

Simple Character Utility for Loading Localitie, Char Drivers (see scull)

Simple Hardware Operations and Raw Tests, A Sample Driver (see short driver)

simple sleeping, Simple Sleeping

single-open devices, Single-Open Devices

single-page streaming mappings, Single-page streaming mappings

SIOCDEVPRIVATE commands, Custom ioctl Commands

SIOCSIFADDR command, Custom ioctl Commands

SIOCSIFMAP command, Custom ioctl Commands

size, The Size Argument, Manipulating I/O ports, Assigning an Explicit Size to Data Items, Assigning an Explicit Size to Data Items, Page Size, A Note on Sector Sizes

data explicitly, Assigning an Explicit Size to Data Items

explicit, Assigning an Explicit Size to Data Items

kmalloc argument, The Size Argument

pages, Page Size

ports, Manipulating I/O ports

of sectors, A Note on Sector Sizes

skbuff.h header file, Packet Transmission

skb_headlen function, Functions Acting on Socket Buffers

skb_headroom function, Functions Acting on Socket Buffers

skb_is_nonlinear functions, Functions Acting on Socket Buffers

skb_pull function, Functions Acting on Socket Buffers

skb_push function, Functions Acting on Socket Buffers

skb_put function, Functions Acting on Socket Buffers

skb_reserve function, Functions Acting on Socket Buffers

skb_tailroom function, Functions Acting on Socket Buffers

sk_buff structure, Packet Transmission, The Important Fields

fields for, The Important Fields

transmitting packets, Packet Transmission

SLAB_CACHE_DMA flag, Lookaside Caches

SLAB_CTOR_ATOMIC flag, Lookaside Caches

SLAB_CTOR_CONSTRUCTOR flag, Lookaside Caches

SLAB_HWCACHE_ALIGN flag, Lookaside Caches

SLAB_NO_REAP flag, Lookaside Caches

sleeps, Semaphores and Mutexes, Spinlocks and Atomic Context, Blocking I/O–Testing the Scullpipe Driver, Manual sleeps, Short Delays

locking, Semaphores and Mutexes

manual, Manual sleeps

processes, Blocking I/O–Testing the Scullpipe Driver

short delays, Short Delays

spinlocks, Spinlocks and Atomic Context

sleep_on function, Ancient history: sleep_on

slow downs (avoiding), Debugging by Querying

slow interrupt handlers, Fast and Slow Handlers

SMP (symmetric multiprocessor) systems, Concurrency in the Kernel

snullnet0 (IP number), Assigning IP Numbers

socket buffers, Packet Transmission, Packet Reception, The Socket Buffers–Functions Acting on Socket Buffers

allocation, Packet Reception

software, Version Numbering, Short Delays, Short Delays

(see also applications versus kernel modules)

loops, Short Delays

versions, Short Delays (see versions, numbering)

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

SPARC architecture, Platform Dependencies

SPARC64 platform (data alignment), Data Alignment

special files, Major and Minor Numbers

spinlocks, The Spinlock Functions, Talking to the DMA controller, Utility Fields, Controlling Transmission Concurrency

dma_spin_lock, Talking to the DMA controller

hard_start_xmit function, Controlling Transmission Concurrency

releasing, The Spinlock Functions

xmit_lock function, Utility Fields

splitting kernels, Splitting the Kernel–Loadable Modules

stacking modules, The Kernel Symbol Table, The Kernel Symbol Table

standard C data types, Use of Standard C Types

start method, The seq_file interface

stat file, The /proc Interface

state of request processing, The bio structure

statements, Error Handling During Initialization, printk, ioctl, The Return Value

goto, Error Handling During Initialization

printk, printk (see printk function)

switch, ioctl, The Return Value

with ioctl method, ioctl

return values, The Return Value

static functions (locking), Ambiguous Rules

static numbers, assignment of, Dynamic Allocation of Major Numbers

statistics, Lookaside Caches, The /proc Interface, Initializing Each Device, The Device Methods, Statistical Information, Statistical Information

on caches, Lookaside Caches

on interrupts, The /proc Interface

on network drivers, Statistical Information

on network interfaces, Initializing Each Device, The Device Methods, Statistical Information

status information, Utility Fields

stop method, The seq_file interface, The Device Methods

store method (kobjects), Default Attributes

strace command, Debugging by Watching

strace tool, Testing the Scullpipe Driver

streaming, DMA mappings, Setting up streaming DMA mappings, Single-page streaming mappings

DMA mappings, DMA mappings, Setting up streaming DMA mappings

single-page mappings, Single-page streaming mappings

string operations, String Operations, Quick Reference

struct block_device_operations *fops field (gendisk), The gendisk structure

struct bus_type *bus field, Devices

struct cdev *i_cdev (inode structure field), The inode Structure

struct dentry *f_dentry (struct file field), The file Structure

struct device *parent field, Devices

struct device fields, Devices

struct device_driver *driver field, Devices

struct file, The file Structure

struct file_operations *fops variable (USB), probe and disconnect in Detail

struct file_operations *f_op (struct file field), The file Structure

struct kobject kobj field, Devices

struct module *owner function, Registering a USB Driver

struct module *owner method, File Operations

struct net_device *next field (net_device structure), Global Information

struct pci_device_id structure (PCI), Configuration Registers and Initialization

struct request structure, A Simple request Method

struct request_queue *queue field (gendisk), The gendisk structure

struct scull_qset structure, scull's Memory Usage

struct termios structure (tty drivers), struct termios–struct termios

struct timeval pointer, Knowing the Current Time

struct tty_flip_buffer structure, No read Function?

struct urb structure, struct urb

struct usb_device *dev field (USB), struct urb

struct usb_device_id structure (USB), What Devices Does the Driver Support?

struct usb_driver structure, Registering a USB Driver

struct usb_host_interface *altsetting field (USB), Interfaces

struct usb_host_interface *cur_altsetting field (USB), Interfaces

struct usb_interface structure, probe and disconnect in Detail

struct usb_iso_packet_descriptor iso_frame_desc field (USB), struct urb

structures, Some Important Data Structures, File Operations–File Operations, Char Device Registration–The Older Way, Char Device Registration, scull's Memory Usage, struct urb, Registering a USB Driver, probe and disconnect in Detail, Kobjects, Ksets, and Subsystems–Subsystems, Binary Attributes, Hotplug Operations, Buses, Device structure embedding, Driver structure embedding, Driver structure embedding, The vm_area_struct structure, The vm_area_struct structure, The mmap Device Operation, Direct Memory Access, The gendisk structure, A Simple request Method, The bio structure, Working with bios, Device Registration, Initializing Each Device, The net_device Structure in Detail–Hardware Information, The Important Fields, Custom ioctl Commands, Statistical Information, Kernel Support for Multicasting, struct termios–struct termios, No read Function?, ioctls, The tty_driver Structure in Detail, The tty_operations Structure in Detail, The tty_struct Structure in Detail

bin_attribute, Binary Attributes

bio, The bio structure, Working with bios

bus_type, Buses

cdev configuration, Char Device Registration

data, Some Important Data Structures, File Operations–File Operations

devices, Device structure embedding

dev_mc_list, Kernel Support for Multicasting

drivers, Driver structure embedding

file_operations (mmap method and), The mmap Device Operation

gendisk, The gendisk structure

ifreq, Custom ioctl Commands

kobjects, Kobjects, Ksets, and Subsystems–Subsystems

kset_hotplug_ops, Hotplug Operations

ldd_driver, Driver structure embedding

net_device, Device Registration, The net_device Structure in Detail–Hardware Information

net_device_stats, Initializing Each Device, Statistical Information

registration, Char Device Registration–The Older Way

scatterlist, Direct Memory Access

serial_icounter_struct, ioctls

sk_buff, The Important Fields

struct request, A Simple request Method

struct scull_qset, scull's Memory Usage

struct termios (tty drivers), struct termios–struct termios

struct tty_flip_buffer, No read Function?

struct urb, struct urb

struct usb_driver, Registering a USB Driver

struct usb_interface, probe and disconnect in Detail

tty_driver, The tty_driver Structure in Detail

tty_operations, The tty_operations Structure in Detail

tty_struct, The tty_struct Structure in Detail

vm_area_struct, The vm_area_struct structure

vm_operations_struct, The vm_area_struct structure

submission of urbs, Submitting Urbs, Submitting and Controlling a Urb

SUBSYSTEM variable, The /sbin/hotplug Utility

subsystems, Splitting the Kernel, Classes of Devices and Modules, The Kernel Symbol Table, Configuration Registers and Initialization, Configuration Registers and Initialization, USB Drivers, Kobject Hierarchies, Ksets, and Subsystems, Subsystems, Class interfaces, How It Works

classes, Class interfaces

deviceID register (PCI), Configuration Registers and Initialization

firmware, How It Works

ksets, Subsystems

memory management, Splitting the Kernel

module stacking, The Kernel Symbol Table

USB, Classes of Devices and Modules, USB Drivers (see USB)

vendorID register (PCI), Configuration Registers and Initialization

Super-H architecture, Platform Dependencies

supervisor mode, User Space and Kernel Space, User Space and Kernel Space

support, Debugging Support in the Kernel–Debugging Support in the Kernel, Kernel Support for Multicasting, Media Independent Interface Support, Ethtool Support

Ethtool, Ethtool Support

kernels (debugging), Debugging Support in the Kernel–Debugging Support in the Kernel

MII, Media Independent Interface Support

multicasting, Kernel Support for Multicasting

swappers, Yielding the processor

switch statements, ioctl, The Return Value

return values, The Return Value

with ioctl method, ioctl

symbolic links (kobjects), Symbolic Links

symbols, The Kernel Symbol Table–The Kernel Symbol Table, Turning the Messages On and Off, Do-it-yourself probing, Quick Reference, The mmap Device Operation, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Direct Memory Access, Queue control functions, Packet Reception, Kernel Support for Multicasting

BLK_BOUNCE_HIGH, Queue control functions

bytes, Quick Reference

CHECKSUM, Packet Reception

DMA_BIDIRECTIONAL, Setting up streaming DMA mappings

DMA_FROM_DEVICE, Setting up streaming DMA mappings

DMA_NONE, Setting up streaming DMA mappings

DMA_TO_DEVICE, Setting up streaming DMA mappings, Direct Memory Access

IFF_, Kernel Support for Multicasting

NR_IRQS, Do-it-yourself probing

PAGE_SIZE, The mmap Device Operation

PCI_DMA_FROMDEVICE, Setting up streaming DMA mappings

PCI_DMA_TODEVICE, Setting up streaming DMA mappings

PDEBUG/PDEBUGG, Turning the Messages On and Off

symmetric multiprocessor (SMP) systems, Concurrency in the Kernel

synchronization, Completions, PCI double-address cycle mappings

DMA buffers, PCI double-address cycle mappings

semaphores, Completions

sysfs directory, USB and Sysfs–USB and Sysfs, struct termios

trees (USB), USB and Sysfs–USB and Sysfs

tty driver, struct termios

sysfs filesystem, Low-Level Sysfs Operations–Symbolic Links, Sysfs Operations

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

syslogd daemon, How Messages Get Logged

sysrq operations, System Hangs

sysrq.txt file, System Hangs

system calls, Loading and Unloading Modules

system faults, Kernel Modules Versus Applications, Debugging System Faults

debugging, Debugging System Faults

handling, Kernel Modules Versus Applications

system hangs, System Hangs–System Hangs

system shutdown, The Linux Device Model

sys_syslog function, printk