- Accessing the memory space of a traced process
- Acknowledge
- Add a taskstruct to the runqueue
- Adding an entry to a wait queue
- Adjusting execution domain module usecounts
- Advanced programmable interrupt controllers
- Allocating a process identification number
- Allocating a user structure
- Alternate signal stack
- An APIC needing read before write
- APIC registers
- Architectureindependent disabling of tracing
- Architecturespecific disabling of tracing
- Atomic addition
- Atomic decrement
- Atomic decrement and test for zero
- Atomic increment
- Atomic operations
- Atomic operations on readwrite semaphore values
- Atomic subtract and test for zero
- Atomic subtraction
- Atomically add and test for negative result
- Atomically exchanging a value
- Background
- Backward compatibility functions for sending signals
- Basic definitions
- Basic functions for accessing APICs
- Bit manipulations
- C language features
- Calculating the goodness of a process
- Calculating the intersection of two capability sets
- Capabilities
- Capability bitmaps
- Changing personality
- Checking a security setting
- Checking capabilities
- Checking for a particular capability
- Checking for additional features
- Checking for an alternate signal stack
- Checking for entries on a wait queue
- Checking for root file system access
- Checking for root privileges
- Checking free space
- Checking if a taskstruct is on the runqueue
- Checking if the computer processing unit is locked up
- Checking if there is a stopped process in a group
- Checking permissions and allocating data structure
- Checking that there is an accounting file
- Checking the revectored bitmap
- Combining two capability sets
- Common code
- Comparing suitabilities of two processes
- Conclusions
- Contents
- Context switching - 2
- Converting between capability types
- Coprocessor error
- Copying external process information
- Copying extra signal information to user space
- Copying signal handlers
- Copying the floating point unit state to the user stack
- Copying the register state to user stack
- Creating a new process
- Creating capability bitmaps
- Credentials and limits
- Customising the interrupt descriptor table
- Data structu res
- Data structure
- Data structures
- Data structures and macros - 2 - 2 3 4
- Deactivating the callback function
- Deallocating a user structure
- Deallocating all queued signals
- Deallocating handler and queue head structures
- Debug
- Debug registers
- Debugging code
- Declaring and initialising list entries
- Default functions for an interrupt controller
- Default handling for a signal
- Defined capabilities
- Delayed timer processing
- Delivering a pending signal
- Descriptor for an interrupt handler
- Descriptor for an interrupt line
- Detecting a pending signal
- Determining if a process group is orphaned
- Determining the quantum for a process
- Device not available
- Disable
- Displaying call frames on the stack
- Displaying interrupt and bottomhalf state
- Displaying register contents
- Displaying stack values
- Emulating push instructions
- Enable
- Enabling and disabling interrupts globally
- Enabling the APIC
- Encoding an unsigned long
- Error in a nonSIMD coprocessor
- Event timers
- Exception handler entry
- Exception handlers
- Exceptions requiring trivial handling
- Exceptions with error code provided by the computer processing unit
- Executing bottom halves
- Extended context information for a signal handler
- Extended information about a signal
- Finding a process to wake up
- Finding an idle processor
- Finding another computer processing unit
- Finding the current taskstruct
- Finding the execution domain corresponding to a personality
- Finding the first bit clear
- Finding the next entry in the thread group list
- Firstlevel handlers for hardware interrupts
- Flags for bug emulation
- Floating point state
- Floating point unit registers not valid
- Flushing all handlers for a process
- Flushing all pending signals for a process
- Forcing the delivery of a signal
- Functions for reading and writing inputoutput ports
- General APIC registers
- General process information
- Generating the handlers
- Generic functions for manipulating a local APIC
- Generic interrupt macros
- Generic Io Apic code
- Generic list handling
- Generic secondlevel interrupt handling
- Getting a pointer to the stack frame in user space
- Getting the virtual flags
- Global flags
- Global scheduler structures
- Handler
- Handling a signal
- Handling expired timers
- Handling faults in vm86 mode
- Highlevel manipulation of readwrite semaphores
- Identification and priority
- Identifing the pending signal
- Important fields hard coded at the beginning
- In Linux
- In Memoriam
- Info
- Information in the thread structure
- Information supplied by user
- Initialisation routine
- Initialising a spinlock
- Initialising fields in the new taskstruct
- Initialising irq13 and irq2
- Initialising software interrupts
- Initialising the interrupt descriptor table
- Initialising the irqdesc [ array for a programmable interrupt controller
- Initialising the process manager
- Initialising timerelated fields
- Inserting a task on a queue
- Installing a signal handler
- Intermediatelevel routines
- Internal processing
- Interrupt handling
- Interrupting Linux
- Interruptsafe locks
- Introduction - 2
- Inverting a capability set
- Kernel statistics
- Line 285 state
- Line 294 ptrace
- Line 296 lockdepth
- Line 303 counter
- Line 305 policy
- Line 306 mm
- Line 321 runlist
- Line 330 binfmt
- Line 337 pgrp
- Line 342 leader
- Line 361 times
- Line 374 user
- Line 384 semundo
- Line 387 thread
- Line 389 fs
- Line 401 notifier
- Linking into process structure
- Loading a debug register
- Loading a segment register
- Locking the wait queue and wake up
- Locks
- Machine check
- Machinespecific registers
- Macro to manipulate an Io Apic register
- Macros and local variables
- Macros for interruptsafe locks
- Macros to read and write memory
- Manager
- Manipulating a specific bit in a bitmap
- Manipulating bits in the virtual flags register
- Manipulating personalities
- Manipulating subsets of a bitmap
- Manipulating the stack of the traced process
- Manipulating the virtual flags register
- Marking a bottom half for execution
- Masking and unmasking irqs on an Io Apic
- Memory management performance information
- Miscellaneous functions
- Miscellaneous information
- Miscellaneous macros
- Moving a taskstruct to the end of the runqueue
- Multiprocessor implementation
- Multiprocessor scheduling
- Notifying child processes of the death of the parent
- Notifying other processes of termination
- Noting the central processing unit assigned
- Operations on semaphores
- Overview of contents
- Parameter checking and initial setup
- Parity error on an expansion card
- Pausing an inpuloulput operation
- Pending signals
- Personalities and execution domains
- Personality types
- Posting signals
- Predefined task queues
- Preface
- Preparing to context switch
- Process accounting
- Process creation
- Process manager variables
- Process status flags
- Process termination
- Putting a process to sleep
- Putting a process to sleep interruptibly
- Putting a process to sleep uninterruptibly
- Queue of pending signals
- Raising a software interrupt
- Reading and writing machinespecific registers
- Reading data from a traced process
- Reading from a register
- Reading the interrupt configuration tables
- Reading values from memory
- Recalculating the signal state
- Recording a scheduling decision
- Releasing a computer processing unit
- Removing a taskstruct from the runqueue
- Removing specified bits from a capability bitmap
- Removing the taskstruct
- Rescheduling the current process
- Resending an irq
- Reserved interrupt vectors
- Resource limits for the initial process
- Restoring registers
- Restoring signal context from user space
- Restoring the floating point unit state from the user stack
- Retrieving values from thread structure
- Returning from a standard stack frame
- Returning from a system call
- Returning from an extended stack frame
- Returning from an interrupt
- Returning from exceptions and interrupts
- Returning to protected mode
- Returning values from vm86 mode
- Routing registers
- Running a software interrupt
- Running the handlers for a hardware interrupt
- Scheduler locks
- Scheduling fields
- Scheduling highpriority tasklets
- Scheduling macros
- Scheduling policies in Linux
- Scheduling preliminaries
- Scheduling standardpriority tasklets
- Searching for a zombie child
- Secondlevel handler for coprocessor error
- Secondlevel timer interrupt handling
- Selecting the next process to run
- Sending a signal to a specific process identification number
- Sending a signal to all processes in a group
- Setting a new personality
- Setting affinity for an Io Apic
- Setting capabilities for all processes
- Setting capabilities for all processes in a group
- Setting or getting an alternate stack context
- Setting up a callback function for signal handling
- Setting up a process to be traced
- Setting up an extended stack frame
- Setting up gates
- Setting up signal context on the user stack
- Setting up the flags field in the new process
- Setting up the thread structure for a child process
- Setting values in the virtual flags register
- Shortcut addressing for sending interprocessor interrupts
- Signal definitions
- Signal handlers
- Signal pending to a traced process
- Signal with a userdefined handler
- Signalling a completion
- Signals
- SIMD coprocessor interrupt
- Single inputoutput functions
- Singlebyte instructions
- Singleprocessor version of spinlocks
- Sleeping for a fixed length of time
- Sleeping interruptibly with a timeout
- Sleeping uninterruptibly with a timeout
- Software interrupts
- Spinlocks with level1 debugging
- Spinlocks with no debugging
- Spurious interrupt
- Startup and shutdown
- Status bits
- String inputouput functions
- Structures
- Subsidiary functions
- Switching the computer processing unit context
- Table of firstlevel handlers
- Table of hardware interrupt line descriptors
- Task queue entries
- Task queues
- Tasklet locking
- Tasklets
- Terminating a process - 2
- Testing a bit
- Testing and setting a bit
- The call function interrupt
- The default interrupt handler
- The execution domain list
- The format of an accounting record
- The generating macros
- The generic handler function
- The highpriority tasklet software interrupt
- The Linux scheduler
- The main handler for a coprocessor error
- The main scheduler
- The nonmaskable interrupt
- The perCPU tasklet lists
- The signal mechanism
- The Solaris X86 binary entry point
- The standard priority tasklet software interrupt
- The taskstruct of the initial process
- The taskunion of the initial process
- The thread field of the initial process
- The timer interrupt handler
- The uniprocessor case
- The virtual flags register
- Traced process handling a system call
- Tracing processes
- Trap handling in vm86 mode
- Trying the computer processing unit on which the process last ran
- Twobyte instructions
- Unidentifiable reason for nonmaskable interrupt
- Uniprocessor implementation
- Unregistering an execution domain
- Usage statistics
- User identification structures
- Variables used by timer interrupt handler
- Vectored interrupts in vm86 mode
- Virtual 8G86 mode
- Wait queue locks
- Wait queues
- Waiting
- Waiting for a child process to exit
- Waiting for a child to exit
- Waiting for completion
- Wakeup macros
- Waking up and trying to schedule a process
- Wrapper for machine check handler
- Writing an accounting record
- Writing data to a traced process
- Writing vm86 state to user space