Clean up.

1 files changed, 320 insertions, 417 deletions

diff --git a/c_user/glossary.rst b/c_user/glossary.rst
index 5464bf4..ab490fb 100644
--- a/c_user/glossary.rst
+++ b/c_user/glossary.rst
@@ -2,211 +2,188 @@ Glossary
 ########
 
 :dfn:`active`
-    A term used to describe an object
-    which has been created by an application.
+    A term used to describe an object which has been created by an application.
 
 :dfn:`aperiodic task`
-    A task which must execute only at
-    irregular intervals and has only a soft deadline.
+    A task which must execute only at irregular intervals and has only a soft
+    deadline.
 
 :dfn:`application`
-    In this document, software which makes
-    use of RTEMS.
+    In this document, software which makes use of RTEMS.
 
 :dfn:`ASR`
     see Asynchronous Signal Routine.
 
 :dfn:`asynchronous`
-    Not related in order or timing to
-    other occurrences in the system.
+    Not related in order or timing to other occurrences in the system.
 
 :dfn:`Asynchronous Signal Routine`
-    Similar to a hardware
-    interrupt except that it is associated with a task and is run in
-    the context of a task.  The directives provided by the signal
+    Similar to a hardware interrupt except that it is associated with a task
+    and is run in the context of a task.  The directives provided by the signal
     manager are used to service signals.
 
 :dfn:`atomic operations`
     Atomic operations are defined in terms of *ISO/IEC 9899:2011*.
 
 :dfn:`awakened`
-    A term used to describe a task that has
-    been unblocked and may be scheduled to the CPU.
+    A term used to describe a task that has been unblocked and may be scheduled
+    to the CPU.
 
 :dfn:`big endian`
-    A data representation scheme in which
-    the bytes composing a numeric value are arranged such that the
-    most significant byte is at the lowest address.
+    A data representation scheme in which the bytes composing a numeric value
+    are arranged such that the most significant byte is at the lowest address.
 
 :dfn:`bit-mapped`
-    A data encoding scheme in which each bit
-    in a variable is used to represent something different.  This
-    makes for compact data representation.
+    A data encoding scheme in which each bit in a variable is used to represent
+    something different.  This makes for compact data representation.
 
 :dfn:`block`
     A physically contiguous area of memory.
 
 :dfn:`blocked task`
-    The task state entered by a task which has been previously started and cannot
-    continue execution until the reason for waiting has been satisfied.  Blocked
-    tasks are not an element of the set of ready tasks of a scheduler instance.
+    The task state entered by a task which has been previously started and
+    cannot continue execution until the reason for waiting has been satisfied.
+    Blocked tasks are not an element of the set of ready tasks of a scheduler
+    instance.
 
 :dfn:`broadcast`
-    To simultaneously send a message to a
-    logical set of destinations.
+    To simultaneously send a message to a logical set of destinations.
 
 :dfn:`BSP`
     see Board Support Package.
 
 :dfn:`Board Support Package`
-    A collection of device
-    initialization and control routines specific to a particular
-    type of board or collection of boards.
+    A collection of device initialization and control routines specific to a
+    particular type of board or collection of boards.
 
 :dfn:`buffer`
-    A fixed length block of memory allocated
-    from a partition.
+    A fixed length block of memory allocated from a partition.
 
 :dfn:`calling convention`
-    The processor and compiler
-    dependent rules which define the mechanism used to invoke
-    subroutines in a high-level language.  These rules define the
-    passing of arguments, the call and return mechanism, and the
-    register set which must be preserved.
+    The processor and compiler dependent rules which define the mechanism used
+    to invoke subroutines in a high-level language.  These rules define the
+    passing of arguments, the call and return mechanism, and the register set
+    which must be preserved.
 
 :dfn:`Central Processing Unit`
-    This term is equivalent to
-    the terms processor and microprocessor.
+    This term is equivalent to the terms processor and microprocessor.
 
 :dfn:`chain`
-    A data structure which allows for efficient
-    dynamic addition and removal of elements.  It differs from an
-    array in that it is not limited to a predefined size.
+    A data structure which allows for efficient dynamic addition and removal of
+    elements.  It differs from an array in that it is not limited to a
+    predefined size.
 
 :dfn:`cluster`
     We have clustered scheduling in case the set of processors of a system is
-    partitioned into non-empty pairwise disjoint subsets.  These subsets are called:dfn:`clusters`.  Clusters with a cardinality of one are partitions.  Each
-    cluster is owned by exactly one scheduler instance.
+    partitioned into non-empty pairwise disjoint subsets.  These subsets are
+    called:dfn:`clusters`.  Clusters with a cardinality of one are partitions.
+    Each cluster is owned by exactly one scheduler instance.
 
 :dfn:`coalesce`
-    The process of merging adjacent holes into
-    a single larger hole.  Sometimes this process is referred to as
-    garbage collection.
+    The process of merging adjacent holes into a single larger hole.  Sometimes
+    this process is referred to as garbage collection.
 
 :dfn:`Configuration Table`
-    A table which contains
-    information used to tailor RTEMS for a particular application.
+    A table which contains information used to tailor RTEMS for a particular
+    application.
 
 :dfn:`context`
-    All of the processor registers and
-    operating system data structures associated with a task.
+    All of the processor registers and operating system data structures
+    associated with a task.
 
 :dfn:`context switch`
-    Alternate term for task switch.
-    Taking control of the processor from one task and transferring
-    it to another task.
+    Alternate term for task switch.  Taking control of the processor from one
+    task and transferring it to another task.
 
 :dfn:`control block`
-    A data structure used by the
-    executive to define and control an object.
+    A data structure used by the executive to define and control an object.
 
 :dfn:`core`
-    When used in this manual, this term refers to
-    the internal executive utility functions.  In the interest of
-    application portability, the core of the executive should not be
-    used directly by applications.
+    When used in this manual, this term refers to the internal executive
+    utility functions.  In the interest of application portability, the core of
+    the executive should not be used directly by applications.
 
 :dfn:`CPU`
     An acronym for Central Processing Unit.
 
 :dfn:`critical section`
-    A section of code which must be
-    executed indivisibly.
+    A section of code which must be executed indivisibly.
 
 :dfn:`CRT`
-    An acronym for Cathode Ray Tube.  Normally used
-    in reference to the man-machine interface.
+    An acronym for Cathode Ray Tube.  Normally used in reference to the
+    man-machine interface.
 
 :dfn:`deadline`
-    A fixed time limit by which a task must
-    have completed a set of actions.  Beyond this point, the results
-    are of reduced value and may even be considered useless or
-    harmful.
+    A fixed time limit by which a task must have completed a set of actions.
+    Beyond this point, the results are of reduced value and may even be
+    considered useless or harmful.
 
 :dfn:`device`
-    A peripheral used by the application that
-    requires special operation software.  See also device driver.
+    A peripheral used by the application that requires special operation
+    software.  See also device driver.
 
 :dfn:`device driver`
-    Control software for special
-    peripheral devices used by the application.
+    Control software for special peripheral devices used by the application.
 
 :dfn:`directives`
-    RTEMS' provided routines that provide
-    support mechanisms for real-time applications.
+    RTEMS' provided routines that provide support mechanisms for real-time
+    applications.
 
 :dfn:`dispatch`
-    The act of loading a task's context onto
-    the CPU and transferring control of the CPU to that task.
+    The act of loading a task's context onto the CPU and transferring control
+    of the CPU to that task.
 
 :dfn:`dormant`
-    The state entered by a task after it is
-    created and before it has been started.
+    The state entered by a task after it is created and before it has been
+    started.
 
 :dfn:`Device Driver Table`
-    A table which contains the
-    entry points for each of the configured device drivers.
+    A table which contains the entry points for each of the configured device
+    drivers.
 
 :dfn:`dual-ported`
-    A term used to describe memory which
-    can be accessed at two different addresses.
+    A term used to describe memory which can be accessed at two different
+    addresses.
 
 :dfn:`embedded`
-    An application that is delivered as a
-    hidden part of a larger system.  For example, the software in a
-    fuel-injection control system is an embedded application found
-    in many late-model automobiles.
+    An application that is delivered as a hidden part of a larger system.  For
+    example, the software in a fuel-injection control system is an embedded
+    application found in many late-model automobiles.
 
 :dfn:`envelope`
-    A buffer provided by the MPCI layer to
-    RTEMS which is used to pass messages between nodes in a
-    multiprocessor system.  It typically contains routing
-    information needed by the MPCI.  The contents of an envelope are
-    referred to as a packet.
+    A buffer provided by the MPCI layer to RTEMS which is used to pass messages
+    between nodes in a multiprocessor system.  It typically contains routing
+    information needed by the MPCI.  The contents of an envelope are referred
+    to as a packet.
 
 :dfn:`entry point`
-    The address at which a function or task
-    begins to execute.  In C, the entry point of a function is the
-    function's name.
+    The address at which a function or task begins to execute.  In C, the entry
+    point of a function is the function's name.
 
 :dfn:`events`
-    A method for task communication and
-    synchronization. The directives provided by the event manager
-    are used to service events.
+    A method for task communication and synchronization. The directives
+    provided by the event manager are used to service events.
 
 :dfn:`exception`
     A synonym for interrupt.
 
 :dfn:`executing task`
     The task state entered by a task after it has been given control of the
-    processor.  On SMP configurations a task may be registered as executing on more
-    than one processor for short time frames during task migration.  Blocked tasks
-    can be executing until they issue a thread dispatch.
+    processor.  On SMP configurations a task may be registered as executing on
+    more than one processor for short time frames during task migration.
+    Blocked tasks can be executing until they issue a thread dispatch.
 
 :dfn:`executive`
-    In this document, this term is used to
-    referred to RTEMS.  Commonly, an executive is a small real-time
-    operating system used in embedded systems.
+    In this document, this term is used to referred to RTEMS.  Commonly, an
+    executive is a small real-time operating system used in embedded systems.
 
 :dfn:`exported`
-    An object known by all nodes in a
-    multiprocessor system.  An object created with the GLOBAL
-    attribute will be exported.
+    An object known by all nodes in a multiprocessor system.  An object created
+    with the GLOBAL attribute will be exported.
 
 :dfn:`external address`
-    The address used to access
-    dual-ported memory by all the nodes in a system which do not own
-    the memory.
+    The address used to access dual-ported memory by all the nodes in a system
+    which do not own the memory.
 
 :dfn:`FIFO`
     An acronym for First In First Out.
@@ -215,48 +192,43 @@ Glossary
     A discipline for manipulating entries in a data structure.
 
 :dfn:`floating point coprocessor`
-    A component used in
-    computer systems to enhance performance in mathematically
-    intensive situations.  It is typically viewed as a logical
+    A component used in computer systems to enhance performance in
+    mathematically intensive situations.  It is typically viewed as a logical
     extension of the primary processor.
 
 :dfn:`freed`
-    A resource that has been released by the
-    application to RTEMS.
+    A resource that has been released by the application to RTEMS.
 
 :dfn:`Giant lock`
     The :dfn:`Giant lock` is a recursive SMP lock protecting most parts of the
-    operating system state.  Virtually every operating system service must acquire
-    and release the Giant lock during its operation.
+    operating system state.  Virtually every operating system service must
+    acquire and release the Giant lock during its operation.
 
 :dfn:`global`
-    An object that has been created with the
-    GLOBAL attribute and exported to all nodes in a multiprocessor
-    system.
+    An object that has been created with the GLOBAL attribute and exported to
+    all nodes in a multiprocessor system.
 
 :dfn:`handler`
-    The equivalent of a manager, except that it
-    is internal to RTEMS and forms part of the core.  A handler is a
-    collection of routines which provide a related set of functions.
-    For example, there is a handler used by RTEMS to manage all
-    objects.
+    The equivalent of a manager, except that it is internal to RTEMS and forms
+    part of the core.  A handler is a collection of routines which provide a
+    related set of functions.  For example, there is a handler used by RTEMS to
+    manage all objects.
 
 :dfn:`hard real-time system`
-    A real-time system in which a
-    missed deadline causes the worked performed to have no value or
-    to result in a catastrophic effect on the integrity of the
-    system.
+    A real-time system in which a missed deadline causes the worked performed
+    to have no value or to result in a catastrophic effect on the integrity of
+    the system.
 
 :dfn:`heap`
-    A data structure used to dynamically allocate
-    and deallocate variable sized blocks of memory.
+    A data structure used to dynamically allocate and deallocate variable sized
+    blocks of memory.
 
 :dfn:`heir task`
-    A task is an :dfn:`heir` if it is registered as an heir in a processor of the
-    system.  A task can be the heir on at most one processor in the system.  In
-    case the executing and heir tasks differ on a processor and a thread dispatch
-    is marked as necessary, then the next thread dispatch will make the heir task
-    the executing task.
+    A task is an :dfn:`heir` if it is registered as an heir in a processor of
+    the system.  A task can be the heir on at most one processor in the system.
+    In case the executing and heir tasks differ on a processor and a thread
+    dispatch is marked as necessary, then the next thread dispatch will make
+    the heir task the executing task.
 
 :dfn:`heterogeneous`
     A multiprocessor computer system composed of dissimilar processors.
@@ -265,35 +237,31 @@ Glossary
     A multiprocessor computer system composed of a single type of processor.
 
 :dfn:`ID`
-    An RTEMS assigned identification tag used to
-    access an active object.
+    An RTEMS assigned identification tag used to access an active object.
 
 :dfn:`IDLE task`
-    A special low priority task which assumes
-    control of the CPU when no other task is able to execute.
+    A special low priority task which assumes control of the CPU when no other
+    task is able to execute.
 
 :dfn:`interface`
-    A specification of the methodology used
-    to connect multiple independent subsystems.
+    A specification of the methodology used to connect multiple independent
+    subsystems.
 
 :dfn:`internal address`
-    The address used to access
-    dual-ported memory by the node which owns the memory.
+    The address used to access dual-ported memory by the node which owns the
+    memory.
 
 :dfn:`interrupt`
-    A hardware facility that causes the CPU
-    to suspend execution, save its status, and transfer control to a
-    specific location.
+    A hardware facility that causes the CPU to suspend execution, save its
+    status, and transfer control to a specific location.
 
 :dfn:`interrupt level`
-    A mask used to by the CPU to
-    determine which pending interrupts should be serviced.  If a
-    pending interrupt is below the current interrupt level, then the
-    CPU does not recognize that interrupt.
+    A mask used to by the CPU to determine which pending interrupts should be
+    serviced.  If a pending interrupt is below the current interrupt level,
+    then the CPU does not recognize that interrupt.
 
 :dfn:`Interrupt Service Routine`
-    An ISR is invoked by the
-    CPU to process a pending interrupt.
+    An ISR is invoked by the CPU to process a pending interrupt.
 
 :dfn:`I/O`
     An acronym for Input/Output.
@@ -302,234 +270,203 @@ Glossary
     An acronym for Interrupt Service Routine.
 
 :dfn:`kernel`
-    In this document, this term is used as a
-    synonym for executive.
+    In this document, this term is used as a synonym for executive.
 
 :dfn:`list`
-    A data structure which allows for dynamic
-    addition and removal of entries.  It is not statically limited
-    to a particular size.
+    A data structure which allows for dynamic addition and removal of entries.
+    It is not statically limited to a particular size.
 
 :dfn:`little endian`
-    A data representation scheme in which
-    the bytes composing a numeric value are arranged such that the
-    least significant byte is at the lowest address.
+    A data representation scheme in which the bytes composing a numeric value
+    are arranged such that the least significant byte is at the lowest address.
 
 :dfn:`local`
-    An object which was created with the LOCAL
-    attribute and is accessible only on the node it was created and
-    resides upon.  In a single processor configuration, all objects
-    are local.
+    An object which was created with the LOCAL attribute and is accessible only
+    on the node it was created and resides upon.  In a single processor
+    configuration, all objects are local.
 
 :dfn:`local operation`
-    The manipulation of an object which
-    resides on the same node as the calling task.
+    The manipulation of an object which resides on the same node as the calling
+    task.
 
 :dfn:`logical address`
-    An address used by an application.
-    In a system without memory management, logical addresses will
-    equal physical addresses.
+    An address used by an application.  In a system without memory management,
+    logical addresses will equal physical addresses.
 
 :dfn:`loosely-coupled`
-    A multiprocessor configuration
-    where shared memory is not used for communication.
+    A multiprocessor configuration where shared memory is not used for
+    communication.
 
 :dfn:`major number`
-    The index of a device driver in the
-    Device Driver Table.
+    The index of a device driver in the Device Driver Table.
 
 :dfn:`manager`
-    A group of related RTEMS' directives which
-    provide access and control over resources.
+    A group of related RTEMS' directives which provide access and control over
+    resources.
 
 :dfn:`memory pool`
     Used interchangeably with heap.
 
 :dfn:`message`
-    A sixteen byte entity used to communicate
-    between tasks.  Messages are sent to message queues and stored
-    in message buffers.
+    A sixteen byte entity used to communicate between tasks.  Messages are sent
+    to message queues and stored in message buffers.
 
 :dfn:`message buffer`
-    A block of memory used to store
-    messages.
+    A block of memory used to store messages.
 
 :dfn:`message queue`
-    An RTEMS object used to synchronize
-    and communicate between tasks by transporting messages between
-    sending and receiving tasks.
+    An RTEMS object used to synchronize and communicate between tasks by
+    transporting messages between sending and receiving tasks.
 
 :dfn:`Message Queue Control Block`
-    A data structure associated with each message queue used by RTEMS
-    to manage that message queue.
+    A data structure associated with each message queue used by RTEMS to manage
+    that message queue.
 
 :dfn:`minor number`
-    A numeric value passed to a device
-    driver, the exact usage of which is driver dependent.
+    A numeric value passed to a device driver, the exact usage of which is
+    driver dependent.
 
 :dfn:`mode`
-    An entry in a task's control block that is
-    used to determine if the task allows preemption, timeslicing,
-    processing of signals, and the interrupt disable level used by
-    the task.
+    An entry in a task's control block that is used to determine if the task
+    allows preemption, timeslicing, processing of signals, and the interrupt
+    disable level used by the task.
 
 :dfn:`MPCI`
-    An acronym for Multiprocessor Communications
-    Interface Layer.
+    An acronym for Multiprocessor Communications Interface Layer.
 
 :dfn:`multiprocessing`
-    The simultaneous execution of two
-    or more processes by a multiple processor computer system.
+    The simultaneous execution of two or more processes by a multiple processor
+    computer system.
 
 :dfn:`multiprocessor`
-    A computer with multiple CPUs
-    available for executing applications.
+    A computer with multiple CPUs available for executing applications.
 
 :dfn:`Multiprocessor Communications Interface Layer`
-    A set
-    of user-provided routines which enable the nodes in a
-    multiprocessor system to communicate with one another.
+    A set of user-provided routines which enable the nodes in a multiprocessor
+    system to communicate with one another.
 
 :dfn:`Multiprocessor Configuration Table`
     The data structure defining the characteristics of the multiprocessor
     target system with which RTEMS will communicate.
 
 :dfn:`multitasking`
-    The alternation of execution amongst a
-    group of processes on a single CPU.  A scheduling algorithm is
-    used to determine which process executes at which time.
+    The alternation of execution amongst a group of processes on a single CPU.
+    A scheduling algorithm is used to determine which process executes at which
+    time.
 
 :dfn:`mutual exclusion`
-    A term used to describe the act of
-    preventing other tasks from accessing a resource simultaneously.
+    A term used to describe the act of preventing other tasks from accessing a
+    resource simultaneously.
 
 :dfn:`nested`
-    A term used to describe an ASR that occurs
-    during another ASR or an ISR that occurs during another ISR.
+    A term used to describe an ASR that occurs during another ASR or an ISR
+    that occurs during another ISR.
 
 :dfn:`node`
-    A term used to reference a processor running
-    RTEMS in a multiprocessor system.
+    A term used to reference a processor running RTEMS in a multiprocessor
+    system.
 
 :dfn:`non-existent`
-    The state occupied by an uncreated or
-    deleted task.
+    The state occupied by an uncreated or deleted task.
 
 :dfn:`numeric coprocessor`
-    A component used in computer
-    systems to enhance performance in mathematically intensive
-    situations.  It is typically viewed as a logical extension of
-    the primary processor.
+    A component used in computer systems to enhance performance in
+    mathematically intensive situations.  It is typically viewed as a logical
+    extension of the primary processor.
 
 :dfn:`object`
-    In this document, this term is used to refer
-    collectively to tasks, timers, message queues, partitions,
-    regions, semaphores, ports, and rate monotonic periods.  All
-    RTEMS objects have IDs and user-assigned names.
+    In this document, this term is used to refer collectively to tasks, timers,
+    message queues, partitions, regions, semaphores, ports, and rate monotonic
+    periods.  All RTEMS objects have IDs and user-assigned names.
 
 :dfn:`object-oriented`
-    A term used to describe systems
-    with common mechanisms for utilizing a variety of entities.
-    Object-oriented systems shield the application from
+    A term used to describe systems with common mechanisms for utilizing a
+    variety of entities.  Object-oriented systems shield the application from
     implementation details.
 
 :dfn:`operating system`
-    The software which controls all
-    the computer's resources and provides the base upon which
-    application programs can be written.
+    The software which controls all the computer's resources and provides the
+    base upon which application programs can be written.
 
 :dfn:`overhead`
-    The portion of the CPUs processing power
-    consumed by the operating system.
+    The portion of the CPUs processing power consumed by the operating system.
 
 :dfn:`packet`
-    A buffer which contains the messages passed
-    between nodes in a multiprocessor system.  A packet is the
-    contents of an envelope.
+    A buffer which contains the messages passed between nodes in a
+    multiprocessor system.  A packet is the contents of an envelope.
 
 :dfn:`partition`
-    An RTEMS object which is used to allocate
-    and deallocate fixed size blocks of memory from an dynamically
-    specified area of memory.
+    An RTEMS object which is used to allocate and deallocate fixed size blocks
+    of memory from an dynamically specified area of memory.
 
 :dfn:`partition`
     Clusters with a cardinality of one are :dfn:`partitions`.
 
 :dfn:`Partition Control Block`
-    A data structure associated
-    with each partition used by RTEMS to manage that partition.
+    A data structure associated with each partition used by RTEMS to manage
+    that partition.
 
 :dfn:`pending`
-    A term used to describe a task blocked
-    waiting for an event, message, semaphore, or signal.
+    A term used to describe a task blocked waiting for an event, message,
+    semaphore, or signal.
 
 :dfn:`periodic task`
-    A task which must execute at regular
-    intervals and comply with a hard deadline.
+    A task which must execute at regular intervals and comply with a hard
+    deadline.
 
 :dfn:`physical address`
-    The actual hardware address of a
-    resource.
+    The actual hardware address of a resource.
 
 :dfn:`poll`
-    A mechanism used to determine if an event has
-    occurred by periodically checking for a particular status.
-    Typical events include arrival of data, completion of an action,
-    and errors.
+    A mechanism used to determine if an event has occurred by periodically
+    checking for a particular status.  Typical events include arrival of data,
+    completion of an action, and errors.
 
 :dfn:`pool`
-    A collection from which resources are
-    allocated.
+    A collection from which resources are allocated.
 
 :dfn:`portability`
-    A term used to describe the ease with
-    which software can be rehosted on another computer.
+    A term used to describe the ease with which software can be rehosted on
+    another computer.
 
 :dfn:`posting`
-    The act of sending an event, message,
-    semaphore, or signal to a task.
+    The act of sending an event, message, semaphore, or signal to a task.
 
 :dfn:`preempt`
-    The act of forcing a task to relinquish the
-    processor and dispatching to another task.
+    The act of forcing a task to relinquish the processor and dispatching to
+    another task.
 
 :dfn:`priority`
-    A mechanism used to represent the relative
-    importance of an element in a set of items.  RTEMS uses priority
-    to determine which task should execute.
+    A mechanism used to represent the relative importance of an element in a
+    set of items.  RTEMS uses priority to determine which task should execute.
 
 :dfn:`priority boosting`
     A simple approach to extend the priority inheritance protocol for clustered
-    scheduling is :dfn:`priority boosting`.  In case a mutex is owned by a task of
-    another cluster, then the priority of the owner task is raised to an
+    scheduling is :dfn:`priority boosting`.  In case a mutex is owned by a task
+    of another cluster, then the priority of the owner task is raised to an
     artificially high priority, the pseudo-interrupt priority.
 
 :dfn:`priority inheritance`
-    An algorithm that calls for
-    the lower priority task holding a resource to have its priority
-    increased to that of the highest priority task blocked waiting
-    for that resource.  This avoids the problem of priority
-    inversion.
+    An algorithm that calls for the lower priority task holding a resource to
+    have its priority increased to that of the highest priority task blocked
+    waiting for that resource.  This avoids the problem of priority inversion.
 
 :dfn:`priority inversion`
-    A form of indefinite
-    postponement which occurs when a high priority tasks requests
-    access to shared resource currently allocated to low priority
-    task.  The high priority task must block until the low priority
-    task releases the resource.
+    A form of indefinite postponement which occurs when a high priority tasks
+    requests access to shared resource currently allocated to low priority
+    task.  The high priority task must block until the low priority task
+    releases the resource.
 
 :dfn:`processor utilization`
-    The percentage of processor
-    time used by a task or a set of tasks.
+    The percentage of processor time used by a task or a set of tasks.
 
 :dfn:`proxy`
-    An RTEMS control structure used to represent,
-    on a remote node, a task which must block as part of a remote
-    operation.
+    An RTEMS control structure used to represent, on a remote node, a task
+    which must block as part of a remote operation.
 
 :dfn:`Proxy Control Block`
-    A data structure associated
-    with each proxy used by RTEMS to manage that proxy.
+    A data structure associated with each proxy used by RTEMS to manage that
+    proxy.
 
 :dfn:`PTCB`
     An acronym for Partition Control Block.
@@ -538,8 +475,7 @@ Glossary
     An acronym for Proxy Control Block.
 
 :dfn:`quantum`
-    The application defined unit of time in
-    which the processor is allocated.
+    The application defined unit of time in which the processor is allocated.
 
 :dfn:`queue`
     Alternate term for message queue.
@@ -549,285 +485,252 @@ Glossary
 
 :dfn:`ready task`
     A task occupies this state when it is available to be given control of a
-    processor.  A ready task has no processor assigned.  The scheduler decided that
-    other tasks are currently more important.  A task that is ready to execute and
-    has a processor assigned is called scheduled.
+    processor.  A ready task has no processor assigned.  The scheduler decided
+    that other tasks are currently more important.  A task that is ready to
+    execute and has a processor assigned is called scheduled.
 
 :dfn:`real-time`
-    A term used to describe systems which are
-    characterized by requiring deterministic response times to
-    external stimuli.  The external stimuli require that the
-    response occur at a precise time or the response is incorrect.
+    A term used to describe systems which are characterized by requiring
+    deterministic response times to external stimuli.  The external stimuli
+    require that the response occur at a precise time or the response is
+    incorrect.
 
 :dfn:`reentrant`
-    A term used to describe routines which do
-    not modify themselves or global variables.
+    A term used to describe routines which do not modify themselves or global
+    variables.
 
 :dfn:`region`
-    An RTEMS object which is used to allocate
-    and deallocate variable size blocks of memory from a dynamically
-    specified area of memory.
+    An RTEMS object which is used to allocate and deallocate variable size
+    blocks of memory from a dynamically specified area of memory.
 
 :dfn:`Region Control Block`
-    A data structure associated
-    with each region used by RTEMS to manage that region.
+    A data structure associated with each region used by RTEMS to manage that
+    region.
 
 :dfn:`registers`
-    Registers are locations physically
-    located within a component, typically used for device control or
-    general purpose storage.
+    Registers are locations physically located within a component, typically
+    used for device control or general purpose storage.
 
 :dfn:`remote`
-    Any object that does not reside on the local
-    node.
+    Any object that does not reside on the local node.
 
 :dfn:`remote operation`
-    The manipulation of an object
-    which does not reside on the same node as the calling task.
+    The manipulation of an object which does not reside on the same node as the
+    calling task.
 
 :dfn:`return code`
-    Also known as error code or return
-    value.
+    Also known as error code or return value.
 
 :dfn:`resource`
-    A hardware or software entity to which
-    access must be controlled.
+    A hardware or software entity to which access must be controlled.
 
 :dfn:`resume`
-    Removing a task from the suspend state.  If
-    the task's state is ready following a call to the ``rtems_task_resume``
-    directive, then the task is available for scheduling.
+    Removing a task from the suspend state.  If the task's state is ready
+    following a call to the ``rtems_task_resume`` directive, then the task is
+    available for scheduling.
 
 :dfn:`return code`
-    A value returned by RTEMS directives to
-    indicate the completion status of the directive.
+    A value returned by RTEMS directives to indicate the completion status of
+    the directive.
 
 :dfn:`RNCB`
     An acronym for Region Control Block.
 
 :dfn:`round-robin`
-    A task scheduling discipline in which
-    tasks of equal priority are executed in the order in which they
-    are made ready.
+    A task scheduling discipline in which tasks of equal priority are executed
+    in the order in which they are made ready.
 
 :dfn:`RS-232`
     A standard for serial communications.
 
 :dfn:`running`
-    The state of a rate monotonic timer while
-    it is being used to delineate a period.  The timer exits this
-    state by either expiring or being canceled.
+    The state of a rate monotonic timer while it is being used to delineate a
+    period.  The timer exits this state by either expiring or being canceled.
 
 :dfn:`schedulable`
-    A set of tasks which can be guaranteed
-    to meet their deadlines based upon a specific scheduling
-    algorithm.
+    A set of tasks which can be guaranteed to meet their deadlines based upon a
+    specific scheduling algorithm.
 
 :dfn:`schedule`
-    The process of choosing which task should
-    next enter the executing state.
+    The process of choosing which task should next enter the executing state.
 
 :dfn:`scheduled task`
     A task is :dfn:`scheduled` if it is allowed to execute and has a processor
-    assigned.  Such a task executes currently on a processor or is about to start
-    execution.  A task about to start execution it is an heir task on exactly one
-    processor in the system.
+    assigned.  Such a task executes currently on a processor or is about to
+    start execution.  A task about to start execution it is an heir task on
+    exactly one processor in the system.
 
 :dfn:`scheduler`
     A :dfn:`scheduler` or :dfn:`scheduling algorithm` allocates processors to a
     subset of its set of ready tasks.  So it manages access to the processor
     resource.  Various algorithms exist to choose the tasks allowed to use a
-    processor out of the set of ready tasks.  One method is to assign each task a
-    priority number and assign the tasks with the lowest priority number to one
-    processor of the set of processors owned by a scheduler instance.
+    processor out of the set of ready tasks.  One method is to assign each task
+    a priority number and assign the tasks with the lowest priority number to
+    one processor of the set of processors owned by a scheduler instance.
 
 :dfn:`scheduler instance`
     A :dfn:`scheduler instance` is a scheduling algorithm with a corresponding
-    context to store its internal state.  Each processor in the system is owned by
-    at most one scheduler instance.  The processor to scheduler instance assignment
-    is determined at application configuration time.  See `Configuring a System`_.
+    context to store its internal state.  Each processor in the system is owned
+    by at most one scheduler instance.  The processor to scheduler instance
+    assignment is determined at application configuration time.  See
+    `Configuring a System`_.
 
 :dfn:`segments`
-    Variable sized memory blocks allocated
-    from a region.
+    Variable sized memory blocks allocated from a region.
 
 :dfn:`semaphore`
-    An RTEMS object which is used to
-    synchronize tasks and provide mutually exclusive access to
-    resources.
+    An RTEMS object which is used to synchronize tasks and provide mutually
+    exclusive access to resources.
 
 :dfn:`Semaphore Control Block`
-    A data structure associated
-    with each semaphore used by RTEMS to manage that semaphore.
+    A data structure associated with each semaphore used by RTEMS to manage
+    that semaphore.
 
 :dfn:`shared memory`
-    Memory which is accessible by
-    multiple nodes in a multiprocessor system.
+    Memory which is accessible by multiple nodes in a multiprocessor system.
 
 :dfn:`signal`
-    An RTEMS provided mechanism to communicate
-    asynchronously with a task.  Upon reception of a signal, the ASR
-    of the receiving task will be invoked.
+    An RTEMS provided mechanism to communicate asynchronously with a task.
+    Upon reception of a signal, the ASR of the receiving task will be invoked.
 
 :dfn:`signal set`
-    A thirty-two bit entity which is used to
-    represent a task's collection of pending signals and the signals
-    sent to a task.
+    A thirty-two bit entity which is used to represent a task's collection of
+    pending signals and the signals sent to a task.
 
 :dfn:`SMCB`
     An acronym for Semaphore Control Block.
 
 :dfn:`SMP locks`
     The :dfn:`SMP locks` ensure mutual exclusion on the lowest level and are a
-    replacement for the sections of disabled interrupts.  Interrupts are usually
-    disabled while holding an SMP lock.  They are implemented using atomic
-    operations.  Currently a ticket lock is used in RTEMS.
+    replacement for the sections of disabled interrupts.  Interrupts are
+    usually disabled while holding an SMP lock.  They are implemented using
+    atomic operations.  Currently a ticket lock is used in RTEMS.
 
 :dfn:`SMP barriers`
     The :dfn:`SMP barriers` ensure that a defined set of independent threads of
     execution on a set of processors reaches a common synchronization point in
-    time.  They are implemented using atomic operations.  Currently a sense barrier
-    is used in RTEMS.
+    time.  They are implemented using atomic operations.  Currently a sense
+    barrier is used in RTEMS.
 
 :dfn:`soft real-time system`
-    A real-time system in which a
-    missed deadline does not compromise the integrity of the system.
+    A real-time system in which a missed deadline does not compromise the
+    integrity of the system.
 
 :dfn:`sporadic task`
-    A task which executes at irregular
-    intervals and must comply with a hard deadline.  A minimum
-    period of time between successive iterations of the task can be
-    guaranteed.
+    A task which executes at irregular intervals and must comply with a hard
+    deadline.  A minimum period of time between successive iterations of the
+    task can be guaranteed.
 
 :dfn:`stack`
-    A data structure that is managed using a Last
-    In First Out (LIFO) discipline.  Each task has a stack
-    associated with it which is  used to store return information
-    and local variables.
+    A data structure that is managed using a Last In First Out (LIFO)
+    discipline.  Each task has a stack associated with it which is used to
+    store return information and local variables.
 
 :dfn:`status code`
-    Also known as error code or return
-    value.
+    Also known as error code or return value.
 
 :dfn:`suspend`
-    A term used to describe a task that is not
-    competing for the CPU because it has had a ``rtems_task_suspend`` directive.
+    A term used to describe a task that is not competing for the CPU because it
+    has had a ``rtems_task_suspend`` directive.
 
 :dfn:`synchronous`
-    Related in order or timing to other
-    occurrences in the system.
+    Related in order or timing to other occurrences in the system.
 
 :dfn:`system call`
-    In this document, this is used as an
-    alternate term for directive.
+    In this document, this is used as an alternate term for directive.
 
 :dfn:`target`
-    The system on which the application will
-    ultimately execute.
+    The system on which the application will ultimately execute.
 
 :dfn:`task`
     A logically complete thread of execution.  It consists normally of a set of
-    registers and a stack.  The terms :dfn:`task` and :dfn:`thread` are synonym in
-    RTEMS.  The scheduler assigns processors to a subset of the ready tasks.
+    registers and a stack.  The terms :dfn:`task` and :dfn:`thread` are synonym
+    in RTEMS.  The scheduler assigns processors to a subset of the ready tasks.
 
 :dfn:`Task Control Block`
-    A data structure associated with
-    each task used by RTEMS to manage that task.
+    A data structure associated with each task used by RTEMS to manage that
+    task.
 
 :dfn:`task migration`
-    :dfn:`Task migration` happens in case a task stops execution on one processor
-    and resumes execution on another processor.
+    :dfn:`Task migration` happens in case a task stops execution on one
+    processor and resumes execution on another processor.
 
 :dfn:`task processor affinity`
     The set of processors on which a task is allowed to execute.
 
 :dfn:`task switch`
-    Alternate terminology for context
-    switch.  Taking control of the processor from one task and given
-    to another.
+    Alternate terminology for context switch.  Taking control of the processor
+    from one task and given to another.
 
 :dfn:`TCB`
     An acronym for Task Control Block.
 
 :dfn:`thread dispatch`
-    The :dfn:`thread dispatch` transfers control of the processor from the currently
-    executing thread to the heir thread of the processor.
+    The :dfn:`thread dispatch` transfers control of the processor from the
+    currently executing thread to the heir thread of the processor.
 
 :dfn:`tick`
-    The basic unit of time used by RTEMS.  It is a
-    user-configurable number of microseconds.  The current tick
-    expires when the ``rtems_clock_tick``
+    The basic unit of time used by RTEMS.  It is a user-configurable number of
+    microseconds.  The current tick expires when the ``rtems_clock_tick``
     directive is invoked.
 
 :dfn:`tightly-coupled`
-    A multiprocessor configuration
-    system which communicates via shared memory.
+    A multiprocessor configuration system which communicates via shared memory.
 
 :dfn:`timeout`
-    An argument provided to a number of
-    directives which determines the maximum length of time an
-    application task is willing to wait to acquire the resource if
-    it is not immediately available.
+    An argument provided to a number of directives which determines the maximum
+    length of time an application task is willing to wait to acquire the
+    resource if it is not immediately available.
 
 :dfn:`timer`
-    An RTEMS object used to invoke subprograms at
-    a later time.
+    An RTEMS object used to invoke subprograms at a later time.
 
 :dfn:`Timer Control Block`
-    A data structure associated
-    with each timer used by RTEMS to manage that timer.
+    A data structure associated with each timer used by RTEMS to manage that
+    timer.
 
 :dfn:`timeslicing`
-    A task scheduling discipline in which
-    tasks of equal priority are executed for a specific period of
-    time before being preempted by another task.
+    A task scheduling discipline in which tasks of equal priority are executed
+    for a specific period of time before being preempted by another task.
 
 :dfn:`timeslice`
-    The application defined unit of time in
-    which the processor is allocated.
+    The application defined unit of time in which the processor is allocated.
 
 :dfn:`TMCB`
     An acronym for Timer Control Block.
 
 :dfn:`transient overload`
-    A temporary rise in system
-    activity which may cause deadlines to be missed.  Rate Monotonic
-    Scheduling can be used to determine if all deadlines will be met
-    under transient overload.
+    A temporary rise in system activity which may cause deadlines to be missed.
+    Rate Monotonic Scheduling can be used to determine if all deadlines will be
+    met under transient overload.
 
 :dfn:`user extensions`
-    Software routines provided by the
-    application to enhance the functionality of RTEMS.
+    Software routines provided by the application to enhance the functionality
+    of RTEMS.
 
 :dfn:`User Extension Table`
-    A table which contains the
-    entry points for each user extensions.
+    A table which contains the entry points for each user extensions.
 
 :dfn:`User Initialization Tasks Table`
-    A table which
-    contains the information needed to create and start each of the
-    user initialization tasks.
+    A table which contains the information needed to create and start each of
+    the user initialization tasks.
 
 :dfn:`user-provided`
-    Alternate term for user-supplied.
-    This term is used to designate any software routines which must
-    be written by the application designer.
+    Alternate term for user-supplied.  This term is used to designate any
+    software routines which must be written by the application designer.
 
 :dfn:`user-supplied`
-    Alternate term for user-provided.
-    This term is used to designate any software routines which must
-    be written by the application designer.
+    Alternate term for user-provided.  This term is used to designate any
+    software routines which must be written by the application designer.
 
 :dfn:`vector`
-    Memory pointers used by the processor to
-    fetch the address of routines which will handle various
-    exceptions and interrupts.
+    Memory pointers used by the processor to fetch the address of routines
+    which will handle various exceptions and interrupts.
 
 :dfn:`wait queue`
-    The list of tasks blocked pending the
-    release of a particular resource.  Message queues, regions, and
-    semaphores have a wait queue associated with them.
+    The list of tasks blocked pending the release of a particular resource.
+    Message queues, regions, and semaphores have a wait queue associated with
+    them.
 
 :dfn:`yield`
     When a task voluntarily releases control of the processor.
-