Halo Linux Services

» Linux Process Manager

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 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 initialisation
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
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 semaphores
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 operate on write 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 readwrite locks
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
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 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 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 readwrite locks
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
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

Clamav Gateway
Reviews
Popular Articles
Categories

About | Contact | Write For Us | Shop | Privacy Policy | Resources