Changeset 75e22db in rtems


Ignore:
Timestamp:
Mar 27, 1998, 4:47:53 PM (23 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
b753a345
Parents:
3973e40
Message:

Completed sweep adding directive and constant prefixes.

Location:
doc/user
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • doc/user/bsp.t

    r3973e40 r75e22db  
    5656Normally, the application's initialization is
    5757performed at two separate times:  before the call to
    58 initialize_executive (reset application initialization) and
    59 after initialize_executive in the user's initialization tasks
     58@code{@value{DIRPREFIX}initialize_executive}
     59(reset application initialization) and
     60after @code{@value{DIRPREFIX}initialize_executive}
     61in the user's initialization tasks
    6062(local and global application initialization).  The order of the
    6163startup procedure is as follows:
     
    6365@enumerate
    6466@item Reset application initialization.
    65 @item Call to initialize_executive
     67@item Call to @code{@value{DIRPREFIX}initialize_executive}
    6668@item Local and global application initialization.
    6769@end enumerate
     
    8082by the reset application initialization code.  Because
    8183interrupts are enabled automatically by RTEMS as part of the
    82 initialize_executive directive, the Interrupt Vector Table MUST
     84@code{@value{DIRPREFIX}initialize_executive} directive,
     85the Interrupt Vector Table MUST
    8386be set before this directive is invoked to insure correct
    8487interrupt vectoring.  The processor's Interrupt Vector Table
    8588must be accessible by RTEMS as it will be modified by the
    86 interrupt_catch directive.  On some CPUs, RTEMS installs it's
     89@code{@value{DIRPREFIX}interrupt_catch} directive. 
     90On some CPUs, RTEMS installs it's
    8791own Interrupt Vector Table as part of initialization and thus
    8892these requirements are met automatically.  The reset code which
    89 is executed before the call to initialize_executive has the
    90 following requirements:
     93is executed before the call to @code{@value{DIRPREFIX}initialize_executive}
     94has the following requirements:
    9195
    9296@itemize @bullet
     
    99103@item Must allocate a stack of at least @code{@value{RPREFIX}MINIMUM_STACK_SIZE}
    100104bytes and initialize the stack pointer for the
    101 initialize_executive directive.
     105@code{@value{DIRPREFIX}initialize_executive} directive.
    102106
    103107@item Must initialize the processor's Interrupt Vector Table.
     
    110114@end itemize
    111115
    112 The initialize_executive directive does not return to
     116The @code{@value{DIRPREFIX}initialize_executive} directive does not return to
    113117the initialization code, but causes the highest priority
    114118initialization task to begin execution.  Initialization tasks
     
    209213
    210214Most RTEMS applications will include a clock tick
    211 device driver which invokes the clock_tick directive at regular
    212 intervals.  The clock tick is necessary if the application is to
    213 utilize timeslicing, the clock manager, the timer manager, the
    214 rate monotonic manager, or the timeout option on blocking
     215device driver which invokes the @code{@value{DIRPREFIX}clock_tick}
     216directive at regular intervals.  The clock tick is necessary if
     217the application is to utilize timeslicing, the clock manager, the
     218timer manager, the rate monotonic manager, or the timeout option on blocking
    215219directives.
    216220
     
    227231Table.  An alternate approach is to set the initial count for a
    228232fixed time period (such as one millisecond) and have the ISR
    229 invoke clock_tick on the microseconds_per_tick boundaries.
     233invoke @code{@value{DIRPREFIX}clock_tick}
     234on the microseconds_per_tick boundaries.
    230235Obviously, this can induce some error if the configured
    231236microseconds_per_tick is not evenly divisible by the chosen
  • doc/user/clock.t

    r3973e40 r75e22db  
    5757utilized, periodic timer interrupts are required.  Therefore, a
    5858real-time clock or hardware timer is necessary to create the
    59 timer interrupts.  The clock_tick directive is normally called
     59timer interrupts.  The @code{@value{DIRPREFIX}clock_tick}
     60directive is normally called
    6061by the timer ISR to announce to RTEMS that a system clock tick
    6162has occurred.  Elapsed time is measured in ticks.  A tick is
     
    106107The native date and time format is the only format
    107108supported when setting the system date and time using the
    108 clock_get directive.  Some applications expect to operate on a
    109 "UNIX-style" date and time data structure.  The clock_get
    110 directive can optionally return the current date and time in the
     109@code{@value{DIRPREFIX}clock_get} directive.  Some applications
     110expect to operate on a "UNIX-style" date and time data structure.  The
     111@code{@value{DIRPREFIX}clock_get} directive can optionally return
     112the current date and time in the
    111113following @value{STRUCTURE}:
    112114
     
    152154timeslicing is enabled and disabled on a per task basis.
    153155
    154 The clock_tick directive implements timeslicing by
     156The @code{@value{DIRPREFIX}clock_tick}
     157directive implements timeslicing by
    155158decrementing the running task's time-remaining counter when both
    156159timeslicing and preemption are enabled.  If the task's timeslice
     
    166169interval or up until a given time, and then wake and continue
    167170execution.  This type of timer is created automatically by the
    168 task_wake_after and task_wake_when directives and, as a result,
     171@code{@value{DIRPREFIX}task_wake_after}
     172and @code{@value{DIRPREFIX}task_wake_when} directives and, as a result,
    169173does not have an RTEMS ID.  Once activated, a sleep timer cannot
    170174be explicitly deleted.  Each task may activate one and only one
     
    178182Timeouts are a special type of timer automatically
    179183created when the timeout option is used on the
    180 message_queue_receive, event_receive, semaphore_obtain and
    181 region_get_segment directives.  Each task may have one and only
    182 one timeout active at a time.  When a timeout expires, it
    183 unblocks the task with a timeout status code.
     184@code{@value{DIRPREFIX}message_queue_receive},
     185@code{@value{DIRPREFIX}event_receive},
     186@code{@value{DIRPREFIX}semaphore_obtain} and
     187@code{@value{DIRPREFIX}region_get_segment} directives. 
     188Each task may have one and only one timeout active at a time. 
     189When a timeout expires, it unblocks the task with a timeout status code.
    184190
    185191@ifinfo
     
    200206@subsection Announcing a Tick
    201207
    202 RTEMS provides the clock_tick directive which is
     208RTEMS provides the @code{@value{DIRPREFIX}clock_tick} directive which is
    203209called from the user's real-time clock ISR to inform RTEMS that
    204210a tick has elapsed.  The tick frequency value, defined in
     
    206212Configuration Table.  RTEMS divides one million microseconds
    207213(one second) by the number of microseconds per tick to determine
    208 the number of calls to the clock_tick directive per second.  The
    209 frequency of clock_tick calls determines the resolution
     214the number of calls to the
     215@code{@value{DIRPREFIX}clock_tick} directive per second.  The
     216frequency of @code{@value{DIRPREFIX}clock_tick}
     217calls determines the resolution
    210218(granularity) for all time dependent RTEMS actions.  For
    211 example, calling clock_tick ten times per second yields a higher
    212 resolution than calling clock_tick two times per second.  The
    213 clock_tick directive is responsible for maintaining both
     219example, calling @code{@value{DIRPREFIX}clock_tick}
     220ten times per second yields a higher
     221resolution than calling @code{@value{DIRPREFIX}clock_tick}
     222two times per second.  The @code{@value{DIRPREFIX}clock_tick}
     223directive is responsible for maintaining both
    214224calendar time and the dynamic set of timers.
    215225
     
    219229@subsection Setting the Time
    220230
    221 The clock_set directive allows a task or an ISR to
     231The @code{@value{DIRPREFIX}clock_set} directive allows a task or an ISR to
    222232set the date and time maintained by RTEMS.  If setting the date
    223233and time causes any outstanding timers to pass their deadline,
    224234then the expired timers will be fired during the invocation of
    225 the clock_set directive.
     235the @code{@value{DIRPREFIX}clock_set} directive.
    226236
    227237@ifinfo
     
    230240@subsection Obtaining the Time
    231241
    232 The clock_get directive allows a task or an ISR to
     242The @code{@value{DIRPREFIX}clock_get} directive allows a task or an ISR to
    233243obtain the current date and time or date and time related
    234244information.  The current date and time can be returned in
     
    237247the number of seconds since the RTEMS epoch, the number of ticks
    238248since the executive was initialized, and the number of ticks per
    239 second.  The information returned by the clock_get directive is
     249second.  The information returned by the
     250@code{@value{DIRPREFIX}clock_get} directive is
    240251dependent on the option selected by the caller.  The following
    241252options are available:
     
    244255@item @code{@value{RPREFIX}CLOCK_GET_TOD} - obtain native style date and time
    245256
    246 @item @code{@value{RPREFIX}CLOCK_GET_TIME_VALUE} - obtain UNIX-style date and time
     257@item @code{@value{RPREFIX}CLOCK_GET_TIME_VALUE} - obtain UNIX-style
     258date and time
    247259
    248260@item @code{@value{RPREFIX}CLOCK_GET_TICKS_SINCE_BOOT} - obtain number of ticks
    249261since RTEMS was initialized
    250262
    251 @item @code{@value{RPREFIX}CLOCK_GET_SECONDS_SINCE_EPOCH} - obtain number of seconds
    252 since RTEMS epoch
    253 
    254 @item @code{@value{RPREFIX}CLOCK_GET_TICKS_PER_SECOND} - obtain number of clock ticks
    255 per second
     263@item @code{@value{RPREFIX}CLOCK_GET_SECONDS_SINCE_EPOCH} - obtain number
     264of seconds since RTEMS epoch
     265
     266@item @code{@value{RPREFIX}CLOCK_GET_TICKS_PER_SECOND} - obtain number of clock
     267ticks per second
    256268
    257269@end itemize
     
    327339Re-initializing RTEMS causes the system date and time
    328340to be reset to an uninitialized state.  Another call to
    329 clock_set is required to re-initialize the system date and time
    330 to application specific specifications.
     341@code{@value{DIRPREFIX}clock_set} is required to re-initialize
     342the system date and time to application specific specifications.
    331343
    332344@page
     
    366378the caller is attempting to obtain the date and time (i.e.
    367379option is set to either @code{@value{RPREFIX}CLOCK_GET_SECONDS_SINCE_EPOCH},
    368 @code{@value{RPREFIX}CLOCK_GET_TOD}, or @code{@value{RPREFIX}CLOCK_GET_TIME_VALUE}) and the date and time
    369 has not been set with a previous call to clock_set, then the
    370 @code{@value{RPREFIX}NOT_DEFINED} status code is returned.  The caller can always
    371 obtain the number of ticks per second (option is
    372 @code{@value{RPREFIX}CLOCK_GET_TICKS_PER_SECOND}) and the number of ticks since the
    373 executive was initialized option is @code{@value{RPREFIX}CLOCK_GET_TICKS_SINCE_BOOT}).
     380@code{@value{RPREFIX}CLOCK_GET_TOD}, or
     381@code{@value{RPREFIX}CLOCK_GET_TIME_VALUE}) and the date and time
     382has not been set with a previous call to
     383@code{@value{DIRPREFIX}clock_set}, then the
     384@code{@value{RPREFIX}NOT_DEFINED} status code is returned.
     385The caller can always obtain the number of ticks per second (option is
     386@code{@value{RPREFIX}CLOCK_GET_TICKS_PER_SECOND}) and the number of
     387ticks since the executive was initialized option is
     388@code{@value{RPREFIX}CLOCK_GET_TICKS_SINCE_BOOT}).
    374389
    375390The data type expected for time_buffer is indicated below:
     
    392407@ifset is-Ada
    393408@itemize @bullet
    394 @item @code{@value{RPREFIX}CLOCK_GET_TOD} - Address of an variable of type RTEMS.Time_Of_Day
     409@item @code{@value{RPREFIX}CLOCK_GET_TOD} - Address of an variable of
     410type RTEMS.Time_Of_Day
    395411
    396412@item @code{@value{RPREFIX}CLOCK_GET_TIME_VALUE} - Address of an variable of
    397413type RTEMS.Clock_Time_Value
    398414
    399 @item @code{@value{RPREFIX}CLOCK_GET_TICKS_SINCE_BOOT} - Address of an variable of
    400 type RTEMS.Interval
    401 
    402 @item @code{@value{RPREFIX}CLOCK_GET_SECONDS_SINCE_EPOCH} - Address of an variable of
    403 type RTEMS.Interval
    404 
    405 @item @code{@value{RPREFIX}CLOCK_GET_TICKS_PER_SECOND} - Address of an variable of
    406 type RTEMS.Interval
     415@item @code{@value{RPREFIX}CLOCK_GET_TICKS_SINCE_BOOT} - Address of an
     416variable of type RTEMS.Interval
     417
     418@item @code{@value{RPREFIX}CLOCK_GET_SECONDS_SINCE_EPOCH} - Address of an
     419variable of type RTEMS.Interval
     420
     421@item @code{@value{RPREFIX}CLOCK_GET_TICKS_PER_SECOND} - Address of an
     422variable of type RTEMS.Interval
    407423
    408424@end itemize
     
    416432preempted.  Re-initializing RTEMS causes the system date and
    417433time to be reset to an uninitialized state.  Another call to
    418 clock_set is required to re-initialize the system date and time
    419 to application specific specifications.
     434@code{@value{DIRPREFIX}clock_set} is required to re-initialize the
     435system date and time to application specific specifications.
    420436
    421437@page
  • doc/user/conf.t

    r3973e40 r75e22db  
    3636configure the number of device drivers or which APIs may be used.
    3737THe address of the user-defined Configuration Table is passed as an
    38 argument to the initialize_executive directive, which MUST be
    39 the first RTEMS directive called.  The RTEMS Configuration Table
     38argument to the @code{@value{DIRPREFIX}initialize_executive}
     39directive, which MUST be the first RTEMS directive called. 
     40The RTEMS Configuration Table
    4041is defined in the following @value{LANGUAGE} @value{STRUCTURE}:
    4142
     
    9192If the address is not aligned on a four-word boundary, then
    9293RTEMS will invoke the fatal error handler during
    93 initialize_executive.
     94@code{@value{DIRPREFIX}initialize_executive}.
    9495
    9596@item work_space_size
     
    525526@table @b
    526527@item initialization
    527 is the address of the entry point called by io_initialize
     528is the address of the entry point called by
     529@code{@value{DIRPREFIX}io_initialize}
    528530to initialize a device driver and its associated devices.
    529531
    530532@item open
    531 is the address of the entry point called by io_open.
     533is the address of the entry point called by @code{@value{DIRPREFIX}io_open}.
    532534
    533535@item close
    534 is the address of the entry point called by io_close.
     536is the address of the entry point called by @code{@value{DIRPREFIX}io_close}.
    535537
    536538@item read
    537 is the address of the entry point called by io_read.
     539is the address of the entry point called by @code{@value{DIRPREFIX}io_read}.
    538540
    539541@item write
    540 is the address of the entry point called by io_write.
     542is the address of the entry point called by @code{@value{DIRPREFIX}io_write}.
    541543
    542544@item control
    543 is the address of the entry point called by io_control.
     545is the address of the entry point called by @code{@value{DIRPREFIX}io_control}.
    544546
    545547@end table
     
    691693continue execution (i.e. delete or restart the task) or to
    692694terminate with a fatal error.  If this field is set to NULL, the
    693 default RTEMS task_exitted handler will be invoked.
     695default RTEMS TASK_EXITTED handler will be invoked.
    694696
    695697@item fatal
    696698is the address of the user-supplied
    697699subroutine for the FATAL extension.  This RTEMS extension of
    698 fatal error handling is called from the fatal_error_occurred
     700fatal error handling is called from the
     701@code{@value{DIRPREFIX}fatal_error_occurred}
    699702directive.  If the user's fatal error handler returns or if this
    700703entry is NULL then the default RTEMS fatal error handler will be
     
    972975The starting address of the RTEMS RAM Workspace must
    973976be aligned on a four-byte boundary.  Failure to properly align
    974 the workspace area will result in the fatal_error_occurred
    975 directive being invoked with the @code{@value{RPREFIX}INVALID_ADDRESS} error code.
     977the workspace area will result in the
     978@code{@value{DIRPREFIX}fatal_error_occurred}
     979directive being invoked with the
     980@code{@value{RPREFIX}INVALID_ADDRESS} error code.
    976981
    977982A worksheet is provided in the Memory Requirements
     
    10011006
    10021007Failure to provide enough space in the RTEMS RAM
    1003 Workspace will result in the fatal_error_occurred directive
     1008Workspace will result in the
     1009@code{@value{DIRPREFIX}fatal_error_occurred} directive
    10041010being invoked with the appropriate error code.
  • doc/user/dpmem.t

    r3973e40 r75e22db  
    7777@subsection Creating a Port
    7878
    79 The port_create directive creates a port into a DPMA
     79The @code{@value{DIRPREFIX}port_create} directive creates a port into a DPMA
    8080with the user-defined name.  The user specifies the association
    8181between internal and external representations for the port being
     
    9595ID and assigns it to the created port until it is deleted.  The
    9696port ID may be obtained by either of two methods.  First, as the
    97 result of an invocation of the port_create directive, the task
     97result of an invocation of the
     98@code{@value{DIRPREFIX}port_create} directive, the task
    9899ID is stored in a user provided location.  Second, the port ID
    99 may be obtained later using the port_ident directive.  The port
     100may be obtained later using the
     101@code{@value{DIRPREFIX}port_ident} directive.  The port
    100102ID is used by other dual-ported memory manager directives to
    101103access this port.
     
    106108@subsection Converting an Address
    107109
    108 The port_external_to_internal directive is used to
     110The @code{@value{DIRPREFIX}port_external_to_internal} directive is used to
    109111convert an address from external to internal representation for
    110 the specified port.  The port_internal_to_external directive is
     112the specified port. 
     113The @code{@value{DIRPREFIX}port_internal_to_external} directive is
    111114used to convert an address from internal to external
    112115representation for the specified port.  If an attempt is made to
     
    120123
    121124A port can be removed from the system and returned to
    122 RTEMS with the port_delete directive.  When a port is deleted,
     125RTEMS with the @code{@value{DIRPREFIX}port_delete} directive.  When a port is deleted,
    123126its control block is returned to the DPCB free list.
    124127
  • doc/user/event.t

    r3973e40 r75e22db  
    101101For example, when sending the event set consisting of
    102102@code{@value{RPREFIX}EVENT_6}, @code{@value{RPREFIX}EVENT_15}, and @code{@value{RPREFIX}EVENT_31},
    103 the event parameter to the event_send directive should be
    104 @code{@value{RPREFIX}EVENT_6 @value{OR}
     103the event parameter to the @code{@value{DIRPREFIX}event_send}
     104directive should be @code{@value{RPREFIX}EVENT_6 @value{OR}
    105105@value{RPREFIX}EVENT_15 @value{OR} @value{RPREFIX}EVENT_31}.
    106106
     
    112112In general, an option is built by a bitwise OR of the
    113113desired option components.  The set of valid options for the
    114 event_receive directive are listed in the following table:
     114@code{@value{DIRPREFIX}event_receive} directive are listed
     115in the following table:
    115116
    116117@itemize @bullet
     
    132133This example demonstrates the option parameter needed
    133134to poll for all events in a particular event condition to
    134 arrive.  The option parameter passed to the event_receive
    135 directive should be either
     135arrive.  The option parameter passed to the
     136@code{@value{DIRPREFIX}event_receive} directive should be either
    136137@code{@value{RPREFIX}EVENT_ALL @value{OR} @value{RPREFIX}NO_WAIT}
    137138or @code{@value{RPREFIX}NO_WAIT}.  The option parameter can be set to
    138139@code{@value{RPREFIX}NO_WAIT} because @code{@value{RPREFIX}EVENT_ALL} is the
    139 default condition for event_receive.
     140default condition for @code{@value{DIRPREFIX}event_receive}.
    140141
    141142@ifinfo
     
    157158@subsection Sending an Event Set
    158159
    159 The event_send directive allows a task (or an ISR) to
     160The @code{@value{DIRPREFIX}event_send} directive allows a task (or an ISR) to
    160161direct an event set to a target task.  Based upon the state of
    161162the target task, one of the following situations applies:
     
    188189@subsection Receiving an Event Set
    189190
    190 The event_receive directive is used by tasks to
     191The @code{@value{DIRPREFIX}event_receive} directive is used by tasks to
    191192accept a specific input event condition.  The task also
    192193specifies whether the request is satisfied when all requested
     
    214215
    215216A task can determine the pending event set by calling
    216 the event_receive directive with a value of PENDING_EVENTS for
    217 the input event condition.  The pending events are returned to
    218 the calling task but the event set is left unaltered.
     217the @code{@value{DIRPREFIX}event_receive} directive with a value of
     218@code{@value{RPREFIX}PENDING_EVENTS} for the input event condition. 
     219The pending events are returned to the calling task but the event
     220set is left unaltered.
    219221
    220222@ifinfo
     
    224226
    225227A task can receive all of the currently pending
    226 events by calling the event_receive directive with a value of
    227 @code{@value{RPREFIX}ALL_EVENTS} for the input event condition and
     228events by calling the @code{@value{DIRPREFIX}event_receive}
     229directive with a value of @code{@value{RPREFIX}ALL_EVENTS}
     230for the input event condition and
    228231@code{@value{RPREFIX}NO_WAIT @value{OR} @value{RPREFIX}EVENT_ANY}
    229232for the option set.  The pending events are returned to the
     
    295298Identical events sent to a task are not queued.  In
    296299other words, the second, and subsequent, posting of an event to
    297 a task before it can perform an event_receive has no effect.
     300a task before it can perform an @code{@value{DIRPREFIX}event_receive}
     301has no effect.
    298302
    299303The calling task will be preempted if it has
  • doc/user/example.texi

    r3973e40 r75e22db  
    2727rtems_task init_task();
    2828
    29 #define INIT_NAME      build_name( 'A', 'B', 'C', ' ' ' )
     29#define INIT_NAME      rtems_build_name( 'A', 'B', 'C', ' ' ' )
    3030
    3131rtems_initialization_tasks_table init_task = @{
  • doc/user/fatal.t

    r3973e40 r75e22db  
    8989@subsection Announcing a Fatal Error
    9090
    91 The fatal_error_occurred directive is invoked when a
     91The @code{@value{DIRPREFIX}fatal_error_occurred} directive is invoked when a
    9292fatal error is detected.  Before invoking any user-supplied
    9393fatal error handlers or the RTEMS fatal error handler, the
    94 fatal_error_occurred directive stores useful information in the
     94@code{@value{DIRPREFIX}fatal_error_occurred}
     95directive stores useful information in the
    9596variable @code{_Internal_errors_What_happened}.  This @value{STRUCTURE}
    9697contains three pieces of information:
     
    107108The error type indicator is dependent on the source
    108109of the error and whether or not the error was internally
    109 generated by the executive.
     110generated by the executive.  If the error was generated
     111from an API, then the error code will be of that API's
     112error or status codes.  The status codes for the RTEMS
     113API are in c/src/exec/rtems/headers/status.h.  Those
     114for the POSIX API can be found in <errno.h>.
    110115
    111 The fatal_error_directive directive is responsible
     116The @code{@value{DIRPREFIX}fatal_error_occurred} directive is responsible
    112117for invoking an optional user-supplied fatal error handler
    113118and/or the RTEMS fatal error handler.  All fatal error handlers
     
    119124handler can be specified in the RTEMS configuration table.  The
    120125User Extension Table field fatal contains the address of the
    121 fatal error handler to be executed when the fatal_error_occurred
     126fatal error handler to be executed when the
     127@code{@value{DIRPREFIX}fatal_error_occurred}
    122128directive is called.  If the field is set to NULL or if the
    123129configured fatal error handler returns to the executive, then
  • doc/user/glossary.texi

    r3973e40 r75e22db  
    574574@item resume
    575575Removing a task from the suspend state.  If
    576 the task's state is ready following a call to the task_resume
     576the task's state is ready following a call to the
     577@code{@value{DIRPREFIX}task_resume}
    577578directive, then the task is available for scheduling.
    578579
     
    658659@item suspend
    659660A term used to describe a task that is not
    660 competing for the CPU because it has had a task_suspend
    661 directive.
     661competing for the CPU because it has had a
     662@code{@value{DIRPREFIX}task_suspend} directive.
    662663
    663664@item synchronous
     
    692693The basic unit of time used by RTEMS.  It is a
    693694user-configurable number of microseconds.  The current tick
    694 expires when the clock_tick directive is invoked.
     695expires when the @code{@value{DIRPREFIX}clock_tick}
     696directive is invoked.
    695697
    696698@item tightly-coupled
  • doc/user/init.t

    r3973e40 r75e22db  
    124124
    125125The fatal_error_occurred directive will be called
    126 from initialize_executive for any of the following reasons:
     126from @code{@value{DIRPREFIX}initialize_executive}
     127for any of the following reasons:
    127128
    128129@itemize @bullet
     
    171172@subsection Initializing RTEMS
    172173
    173 The initialize_executive directive is called by the
     174The @code{@value{DIRPREFIX}initialize_executive}
     175directive is called by the
    174176board support package at the completion of its initialization
    175177sequence.  RTEMS assumes that the board support package
    176178successfully completed its initialization activities.  The
    177 initialize_executive directive completes the initialization
     179@code{@value{DIRPREFIX}initialize_executive}
     180directive completes the initialization
    178181sequence by performing the following actions:
    179182
     
    189192This directive MUST be called before any other RTEMS
    190193directives.  The effect of calling any RTEMS directives before
    191 initialize_executive is unpredictable.  Many of RTEMS actions
     194@code{@value{DIRPREFIX}initialize_executive}
     195is unpredictable.  Many of RTEMS actions
    192196during initialization are based upon the contents of the
    193197Configuration Table and CPU Dependent Information Table.  For
     
    199203are enabled, the highest priority, ready task will be dispatched
    200204to run.  Control will not be returned to the board support
    201 package after multitasking is enabled until shutdown_executive
     205package after multitasking is enabled until
     206@code{@value{DIRPREFIX}shutdown_executive}
    202207the directive is called.
    203208
    204 The initialize_executive directive provides a
     209The @code{@value{DIRPREFIX}initialize_executive}
     210directive provides a
    205211conceptually simple way to initialize RTEMS.  However, in
    206212certain cases, this mechanism cannot be used.  The
    207 initialize_executive_early and initialize_executive_late
     213@code{@value{DIRPREFIX}initialize_executive_early}
     214and @code{@value{DIRPREFIX}initialize_executive_late}
    208215directives are provided as an alternative mechanism for
    209 initializing RTEMS.  The initialize_executive_early directive
     216initializing RTEMS.  The
     217@code{@value{DIRPREFIX}initialize_executive_early} directive
    210218returns to the caller BEFORE initiating multitasking.  The
    211 initialize_executive_late directive is invoked to start
     219@code{@value{DIRPREFIX}initialize_executive_late}
     220directive is invoked to start
    212221multitasking.  It is critical that only one of the RTEMS
    213222initialization sequences be used in an application.
     
    218227@subsection Shutting Down RTEMS
    219228
    220 The shutdown_executive directive is invoked by the
     229The @code{@value{DIRPREFIX}shutdown_executive} directive is invoked by the
    221230application to end multitasking and return control to the board
    222231support package.  The board support package resumes execution at
    223232the code immediately following the invocation of the
    224 initialize_executive directive.
     233@code{@value{DIRPREFIX}initialize_executive} directive.
    225234
    226235@ifinfo
     
    282291Table, and the Multiprocessor Communications Interface (MPCI)
    283292Table.  This directive starts multitasking and does not return
    284 to the caller until the shutdown_executive directive is invoked.
     293to the caller until the @code{@value{DIRPREFIX}shutdown_executive}
     294directive is invoked.
    285295
    286296@subheading NOTES:
     
    288298This directive MUST be the first RTEMS directive
    289299called and it DOES NOT RETURN to the caller until the
    290 shutdown_executive is invoked.
     300@code{@value{DIRPREFIX}shutdown_executive}
     301is invoked.
    291302
    292303This directive causes all nodes in the system to
     
    296307
    297308The application must use only one of the two
    298 initialization sequences: initialize_executive or
    299 initialize_executive_early and initialize_executive_late.  The
    300 initialize_executive directive is logically equivalent to
    301 invoking initialize_executive_early and
    302 initialize_executive_late with no intervening actions.
     309initialization sequences:
     310@code{@value{DIRPREFIX}initialize_executive} or
     311@code{@value{DIRPREFIX}initialize_executive_early} and
     312@code{@value{DIRPREFIX}initialize_executive_late}.  The
     313@code{@value{DIRPREFIX}initialize_executive}
     314directive is logically equivalent to invoking
     315@code{@value{DIRPREFIX}initialize_executive_early} and
     316@code{@value{DIRPREFIX}initialize_executive_late}
     317with no intervening actions.
    303318
    304319@page
     
    346361initiated.  The interrupt level in place when the directive is
    347362invoked is returned to the caller.  This interrupt level should
    348 be the same one passed to initialize_executive_late.
     363be the same one passed to
     364@code{@value{DIRPREFIX}initialize_executive_late}.
    349365
    350366@subheading NOTES:
    351367
    352368The application must use only one of the two
    353 initialization sequences: initialize_executive or
    354 initialize_executive_early and initialize_executive_late.
     369initialization sequences:
     370@code{@value{DIRPREFIX}initialize_executive} or
     371@code{@value{DIRPREFIX}nitialize_executive_early} and
     372@code{@value{DIRPREFIX}nitialize_executive_late}.
    355373
    356374@page
     
    385403
    386404This directive is called after the
    387 initialize_executive_early directive has been called to complete
     405@code{@value{DIRPREFIX}initialize_executive_early}
     406directive has been called to complete
    388407the RTEMS initialization sequence and initiate multitasking.
    389 The interrupt level returned by the initialize_executive_early
     408The interrupt level returned by the
     409@code{@value{DIRPREFIX}initialize_executive_early}
    390410directive should be in bsp_level and this value is restored as
    391411part of this directive returning to the caller after the
    392 shutdown_executive directive is invoked.
     412@code{@value{DIRPREFIX}shutdown_executive}
     413directive is invoked.
    393414
    394415@subheading NOTES:
     
    396417This directive MUST be the second RTEMS directive
    397418called and it DOES NOT RETURN to the caller until the
    398 shutdown_executive is invoked.
     419@code{@value{DIRPREFIX}shutdown_executive} is invoked.
    399420
    400421This directive causes all nodes in the system to
     
    404425
    405426The application must use only one of the two
    406 initialization sequences: initialize_executive or
    407 initialize_executive_early and initialize_executive_late.
     427initialization sequences:
     428@code{@value{DIRPREFIX}initialize_executive} or
     429@code{@value{DIRPREFIX}nitialize_executive_early} and
     430@code{@value{DIRPREFIX}initialize_executive_late}.
    408431
    409432
     
    443466package.  The board support package resumes execution at the
    444467code immediately following the invocation of the
    445 initialize_executive directive.
     468@code{@value{DIRPREFIX}initialize_executive} directive.
    446469
    447470@subheading NOTES:
  • doc/user/intr.t

    r3973e40 r75e22db  
    6969if necessary, and device specific manipulation.
    7070
    71 The interrupt_catch directive connects a procedure to
     71The @code{@value{DIRPREFIX}interrupt_catch}
     72directive connects a procedure to
    7273an interrupt vector.  The interrupt service routine is assumed
    7374to abide by these conventions and have a prototype similar to
     
    191192@subsection Establishing an ISR
    192193
    193 The interrupt_catch directive establishes an ISR for
     194The @code{@value{DIRPREFIX}interrupt_catch}
     195directive establishes an ISR for
    194196the system.  The address of the ISR and its associated CPU
    195197vector number are specified to this directive.  This directive
     
    404406
    405407This directive enables maskable interrupts to the @code{level}
    406 which was returned by a previous call to @code{@value{DIRPREFIX}interrupt_disable}.
     408which was returned by a previous call to
     409@code{@value{DIRPREFIX}interrupt_disable}.
    407410Immediately prior to invoking this directive, maskable interrupts should
    408 be disabled by a call to @code{@value{DIRPREFIX}interrupt_disable} and will be enabled
    409 when this directive returns to the caller.
     411be disabled by a call to @code{@value{DIRPREFIX}interrupt_disable}
     412and will be enabled when this directive returns to the caller.
    410413
    411414@subheading NOTES:
     
    445448
    446449This directive temporarily enables maskable interrupts to the @code{level}
    447 which was returned by a previous call to @code{@value{DIRPREFIX}interrupt_disable}. 
     450which was returned by a previous call to
     451@code{@value{DIRPREFIX}interrupt_disable}. 
    448452Immediately prior to invoking this directive, maskable interrupts should
    449 be disabled by a call to @code{@value{DIRPREFIX}interrupt_disable} and will be redisabled
    450 when this directive returns to the caller.
     453be disabled by a call to @code{@value{DIRPREFIX}interrupt_disable}
     454and will be redisabled when this directive returns to the caller.
    451455
    452456@subheading NOTES:
  • doc/user/io.t

    r3973e40 r75e22db  
    8080If the device driver does not support a particular
    8181entry point, then that entry in the Configuration Table should
    82 be NULL.  RTEMS will return @code{@value{RPREFIX}SUCCESSFUL} as the executive's and
     82be NULL.  RTEMS will return
     83@code{@value{RPREFIX}SUCCESSFUL} as the executive's and
    8384zero (0) as the device driver's return code for these device
    8485driver entry points.
     
    224225@subsection Register and Lookup Name
    225226
    226 The io_register directive associates a name with the
     227The @code{@value{DIRPREFIX}io_register} directive associates a name with the
    227228specified device (i.e. major/minor number pair).  Device names
    228229are typically registered as part of the device driver
    229 initialization sequence.  The io_lookup directive is used to
     230initialization sequence.  The @code{@value{DIRPREFIX}io_lookup}
     231directive is used to
    230232determine the major/minor number pair associated with the
    231233specified device name.  The use of these directives frees the
     
    242244application program to utilize device drivers in a standard
    243245manner.  There is a direct correlation between the RTEMS I/O
    244 manager directives io_initialize, io_open, io_close, io_read,
    245 io_write, and io_control and the underlying device driver entry
    246 points.
     246manager directives
     247@code{@value{DIRPREFIX}io_initialize},
     248@code{@value{DIRPREFIX}io_open},
     249@code{@value{DIRPREFIX}io_close},
     250@code{@value{DIRPREFIX}io_read},
     251@code{@value{DIRPREFIX}io_write}, and
     252@code{@value{DIRPREFIX}io_control}
     253and the underlying device driver entry points.
    247254
    248255@ifinfo
  • doc/user/mp.t

    r3973e40 r75e22db  
    205205@item The MPCI layer on the destination node senses the
    206206arrival of a packet (commonly in an ISR), and calls the
    207 multiprocessing_announce directive.  This directive readies the
    208 Multiprocessing Server.
     207@code{@value{DIRPREFIX}multiprocessing_announce}
     208directive.  This directive readies the Multiprocessing Server.
    209209
    210210@item The Multiprocessing Server calls the user-provided
     
    213213
    214214@item The MPCI layer on the originating node senses the
    215 arrival of a packet (typically via an interrupt), and calls the
    216 RTEMS multiprocessing_announce directive.  This directive
     215arrival of a packet (typically via an interrupt), and calls the RTEMS
     216@code{@value{DIRPREFIX}multiprocessing_announce} directive.  This directive
    217217readies the Multiprocessing Server.
    218218
     
    238238remote node and is used to represent a task which must block as
    239239part of a remote operation. This action can occur as part of the
    240 semaphore_obtain and message_queue_receive directives.  If the
     240@code{@value{DIRPREFIX}semaphore_obtain} and
     241@code{@value{DIRPREFIX}message_queue_receive} directives.  If the
    241242object were local, the task's control block would be available
    242243for modification to indicate it was blocking on a message queue
     
    324325packet at a node may generate an interrupt.  Otherwise, the
    325326real-time clock ISR can check for the arrival of a packet.  In
    326 any case, the multiprocessing_announce directive must be called
     327any case, the
     328@code{@value{DIRPREFIX}multiprocessing_announce} directive must be called
    327329to announce the arrival of a packet.  After exiting the ISR,
    328330control will be passed to the Multiprocessing Server to process
     
    337339
    338340The INITIALIZATION component of the user-provided
    339 MPCI layer is called as part of the initialize_executive
     341MPCI layer is called as part of the @code{@value{DIRPREFIX}initialize_executive}
    340342directive to initialize the MPCI layer and associated hardware.
    341343It is invoked immediately after all of the device drivers have
     
    628630@subsection Announcing a Packet
    629631
    630 The multiprocessing_announce directive is called by
     632The @code{@value{DIRPREFIX}multiprocessing_announce} directive is called by
    631633the MPCI layer to inform RTEMS that a packet has arrived from
    632634another node.  This directive can be called from an interrupt
  • doc/user/msg.t

    r3973e40 r75e22db  
    3838@item @code{@value{DIRPREFIX}message_queue_receive} - Receive message from a queue
    3939@item @code{@value{DIRPREFIX}message_queue_get_number_pending} - Get number of messages pending on a queue
    40 @item @code{message_queue_flush} - Flush all messages on a queue
     40@item @code{@value{DIRPREFIX}message_queue_flush} - Flush all messages on a queue
    4141@end itemize
    4242
     
    7272tasks and ISRs.  Message queues can contain a variable number of
    7373messages.  Normally messages are sent to and received from the
    74 queue in FIFO order using the message_queue_send directive.
    75 However, the message_queue_urgent directive can be used to place
     74queue in FIFO order using the @code{@value{DIRPREFIX}message_queue_send}
     75directive.  However, the @code{@value{DIRPREFIX}message_queue_urgent}
     76directive can be used to place
    7677messages at the head of a queue in LIFO order.
    7778
     
    100101
    101102
    102 
    103103An attribute listed as a default is not required to
    104104appear in the attribute list, although it is a good programming
    105105practice to specify default attributes.  If all defaults are
    106 desired, the attribute @code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be specified on
    107 this call.
     106desired, the attribute @code{@value{RPREFIX}DEFAULT_ATTRIBUTES}
     107should be specified on this call.
    108108
    109109This example demonstrates the attribute_set parameter
    110110needed to create a local message queue with the task priority
    111111waiting queue discipline.  The attribute_set parameter to the
    112 message_queue_create directive could be either
     112@code{@value{DIRPREFIX}message_queue_create} directive could be either
    113113@code{@value{RPREFIX}PRIORITY} or
    114114@code{@value{RPREFIX}LOCAL @value{OR} @value{RPREFIX}PRIORITY}. 
    115115The attribute_set parameter can be set to @code{@value{RPREFIX}PRIORITY}
    116 because @code{@value{RPREFIX}LOCAL} is the default for all created message queues.  If
    117 a similar message queue were to be known globally, then the
     116because @code{@value{RPREFIX}LOCAL} is the default for all created
     117message queues.  If a similar message queue were to be known globally, then the
    118118attribute_set parameter would be
    119119@code{@value{RPREFIX}GLOBAL @value{OR} @value{RPREFIX}PRIORITY}.
     
    126126In general, an option is built by a bitwise OR of the
    127127desired option components.  The set of valid options for the
    128 message_queue_receive directive are listed in the following
    129 table:
     128@code{@value{DIRPREFIX}message_queue_receive} directive are
     129listed in the following table:
    130130
    131131@itemize @bullet
     
    137137appear in the option OR list, although it is a good programming
    138138practice to specify default options.  If all defaults are
    139 desired, the option @code{@value{RPREFIX}DEFAULT_OPTIONS} should be specified on this
    140 call.
     139desired, the option @code{@value{RPREFIX}DEFAULT_OPTIONS} should
     140be specified on this call.
    141141
    142142This example demonstrates the option parameter needed
    143143to poll for a message to arrive.  The option parameter passed to
    144 the message_queue_receive directive should be @code{@value{RPREFIX}NO_WAIT}.
     144the @code{@value{DIRPREFIX}message_queue_receive} directive should
     145be @code{@value{RPREFIX}NO_WAIT}.
    145146
    146147@ifinfo
     
    164165@subsection Creating a Message Queue
    165166
    166 The message_queue_create directive creates a message
     167The @code{@value{DIRPREFIX}message_queue_create} directive creates a message
    167168queue with the user-defined name.  The user specifies the
    168169maximum message size and maximum number of messages which can be
     
    187188unique message queue ID.  The message queue ID may be obtained
    188189by either of two methods.  First, as the result of an invocation
    189 of the message_queue_create directive, the queue ID is stored in
    190 a user provided location.  Second, the queue ID may be obtained
    191 later using the message_queue_ident directive.  The queue ID is
    192 used by other message manager directives to access this message
    193 queue.
     190of the @code{@value{DIRPREFIX}message_queue_create} directive, the
     191queue ID is stored in a user provided location.  Second, the queue
     192ID may be obtained later using the @code{@value{DIRPREFIX}message_queue_ident}
     193directive.  The queue ID is used by other message manager
     194directives to access this message queue.
    194195
    195196@ifinfo
     
    198199@subsection Receiving a Message
    199200
    200 The message_queue_receive directive attempts to
     201The @code{@value{DIRPREFIX}message_queue_receive} directive attempts to
    201202retrieve a message from the specified message queue.  If at
    202203least one message is in the queue, then the message is removed
     
    228229
    229230Messages can be sent to a queue with the
    230 message_queue_send and message_queue_urgent directives.  These
     231@code{@value{DIRPREFIX}message_queue_send} and
     232@code{@value{DIRPREFIX}message_queue_urgent} directives.  These
    231233directives work identically when tasks are waiting to receive a
    232234message.  A task is removed from the task waiting queue,
     
    235237
    236238When no tasks are waiting at the queue,
    237 message_queue_send places the message at the rear of the message
    238 queue, while message_queue_urgent places the message at the
     239@code{@value{DIRPREFIX}message_queue_send} places the
     240message at the rear of the message queue, while
     241@code{@value{DIRPREFIX}message_queue_urgent} places the message at the
    239242front of the queue.  The message is copied to a message buffer
    240243from this message queue's buffer pool and then placed in the
     
    248251@subsection Broadcasting a Message
    249252
    250 The message_queue_broadcast directive sends the same
     253The @code{@value{DIRPREFIX}message_queue_broadcast} directive sends the same
    251254message to every task waiting on the specified message queue as
    252255an atomic operation.  The message is copied to each waiting
     
    259262@subsection Deleting a Message Queue
    260263
    261 The message_queue_delete directive removes a message
     264The @code{@value{DIRPREFIX}message_queue_delete} directive removes a message
    262265queue from the system and frees its control block as well as the
    263266memory associated with this message queue's message buffer pool.
     
    682685related to the number of tasks waiting on the message queue,
    683686although it is more efficient than the equivalent number of
    684 invocations of message_queue_send.
     687invocations of @code{@value{DIRPREFIX}message_queue_send}.
    685688
    686689Broadcasting a message to a global message queue
     
    750753queue and the queue is empty, then the calling task is placed on
    751754the message wait queue and blocked.  If the queue was created
    752 with the @code{@value{RPREFIX}PRIORITY} option specified, then the calling task is
    753 inserted into the wait queue according to its priority.  But, if
    754 the queue was created with the @code{@value{RPREFIX}FIFO} option specified, then the
     755with the @code{@value{RPREFIX}PRIORITY} option specified, then
     756the calling task is inserted into the wait queue according to
     757its priority.  But, if the queue was created with the
     758@code{@value{RPREFIX}FIFO} option specified, then the
    755759calling task is placed at the rear of the wait queue.
    756760
  • doc/user/part.t

    r3973e40 r75e22db  
    7777
    7878@itemize @bullet
    79 @item LOCAL - local task (default)
    80 @item GLOBAL - global task
     79@item @code{@value{RPREFIX}LOCAL} - local task (default)
     80@item @code{@value{RPREFIX}GLOBAL} - global task
    8181@end itemize
    82 
    8382
    8483
     
    8988required to appear in the attribute list, although it is a good
    9089programming practice to specify default attributes.  If all
    91 defaults are desired, the attribute @code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be
     90defaults are desired, the attribute
     91@code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be
    9292specified on this call.  The attribute_set parameter should be
    93 GLOBAL to indicate that the partition is to be known globally.
     93@code{@value{RPREFIX}GLOBAL} to indicate that the partition
     94is to be known globally.
    9495
    9596@ifinfo
     
    112113@subsection Creating a Partition
    113114
    114 The partition_create directive creates a partition
     115The @code{@value{DIRPREFIX}partition_create} directive creates a partition
    115116with a user-specified name.  The partition's name, starting
    116117address, length and buffer size are all specified to the
    117 partition_create directive.  RTEMS allocates a Partition Control
     118@code{@value{DIRPREFIX}partition_create} directive. 
     119RTEMS allocates a Partition Control
    118120Block (PTCB) from the PTCB free list.  This data structure is
    119121used by RTEMS to manage the newly created partition.  The number
     
    131133is deleted.  The partition ID may be obtained by either of two
    132134methods.  First, as the result of an invocation of the
    133 partition_create directive, the partition ID is stored in a user
    134 provided location.  Second, the partition ID may be obtained
    135 later using the partition_ident directive.  The partition ID is
    136 used by other partition manager directives to access this
    137 partition.
     135@code{@value{DIRPREFIX}partition_create} directive, the partition
     136ID is stored in a user provided location.  Second, the partition
     137ID may be obtained later using the @code{@value{DIRPREFIX}partition_ident}
     138directive.  The partition ID is used by other partition manager directives
     139to access this partition.
    138140
    139141@ifinfo
     
    143145
    144146A buffer can be obtained by calling the
    145 partition_get_buffer directive.  If a buffer is available, then
     147@code{@value{DIRPREFIX}partition_get_buffer} directive. 
     148If a buffer is available, then
    146149it is returned immediately with a successful return code.
    147150Otherwise, an unsuccessful return code is returned immediately
     
    155158
    156159Buffers are returned to a partition's free buffer
    157 chain with the partition_return_buffer directive.  This
     160chain with the @code{@value{DIRPREFIX}partition_return_buffer} directive.  This
    158161directive returns an error status code if the returned buffer
    159162was not previously allocated from this partition.
     
    164167@subsection Deleting a Partition
    165168
    166 The partition_delete directive allows a partition to
     169The @code{@value{DIRPREFIX}partition_delete} directive allows a partition to
    167170be removed and returned to RTEMS.  When a partition is deleted,
    168171the PTCB for that partition is returned to the PTCB free list.
     
    261264
    262265@itemize @bullet
    263 @item LOCAL - local task (default)
    264 @item GLOBAL - global task
     266@item @code{@value{RPREFIX}LOCAL} - local task (default)
     267@item @code{@value{RPREFIX}GLOBAL} - global task
    265268@end itemize
    266269
     
    390393
    391394The partition must reside on the local node, even if
    392 the partition was created with the GLOBAL option.
     395the partition was created with the @code{@value{RPREFIX}GLOBAL} option.
    393396
    394397@page
  • doc/user/region.t

    r3973e40 r75e22db  
    101101required to appear in the attribute list, although it is a good
    102102programming practice to specify default attributes.  If all
    103 defaults are desired, the attribute @code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be
     103defaults are desired, the attribute
     104@code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be
    104105specified on this call.
    105106
    106107This example demonstrates the attribute_set parameter
    107108needed to create a region with the task priority waiting queue
    108 discipline.  The attribute_set parameter to the region_create
     109discipline.  The attribute_set parameter to the
     110@code{@value{DIRPREFIX}region_create}
    109111directive should be @code{@value{RPREFIX}PRIORITY}.
    110112
     
    116118In general, an option is built by a bitwise OR of the
    117119desired option components.  The set of valid options for the
    118 region_get_segment directive are listed in the following table:
     120@code{@value{DIRPREFIX}region_get_segment} directive are
     121listed in the following table:
    119122
    120123@itemize @bullet
     
    129132required to appear in the option list, although it is a good
    130133programming practice to specify default options.  If all
    131 defaults are desired, the option @code{@value{RPREFIX}DEFAULT_OPTIONS} should be
     134defaults are desired, the option
     135@code{@value{RPREFIX}DEFAULT_OPTIONS} should be
    132136specified on this call.
    133137
    134138This example demonstrates the option parameter needed
    135139to poll for a segment.  The option parameter passed to the
    136 region_get_segment directive should be @code{@value{RPREFIX}NO_WAIT}.
     140@code{@value{DIRPREFIX}region_get_segment} directive should
     141be @code{@value{RPREFIX}NO_WAIT}.
    137142
    138143@ifinfo
     
    157162@subsection Creating a Region
    158163
    159 The region_create directive creates a region with the
     164The @code{@value{DIRPREFIX}region_create} directive creates a region with the
    160165user-defined name.  The user may select FIFO or task priority as
    161166the method for placing waiting tasks in the task wait queue.
     
    186191deleted.  The region ID may be obtained by either of two
    187192methods.  First, as the result of an invocation of the
    188 region_create directive, the region ID is stored in a user
     193@code{@value{DIRPREFIX}region_create} directive,
     194the region ID is stored in a user
    189195provided location.  Second, the region ID may be obtained later
    190 using the region_ident directive.  The region ID is used by
    191 other region manager directives to access this region.
     196using the @code{@value{DIRPREFIX}region_ident} directive. 
     197The region ID is used by other region manager directives to
     198access this region.
    192199
    193200@ifinfo
     
    196203@subsection Adding Memory to a Region
    197204
    198 The region_extend directive may be used to add memory
     205The @code{@value{DIRPREFIX}region_extend} directive may be used to add memory
    199206to an existing region.  The caller specifies the size in bytes
    200207and starting address of the memory being added.
     
    210217@subsection Acquiring a Segment
    211218
    212 The region_get_segment directive attempts to acquire
     219The @code{@value{DIRPREFIX}region_get_segment} directive attempts to acquire
    213220a segment from a specified region.  If the region has enough
    214221available free memory, then a segment is returned successfully
     
    219226@item By default, the calling task will wait forever to acquire the segment.
    220227
    221 @item Specifying the @code{@value{RPREFIX}NO_WAIT} option forces an immediate return
    222 with an error status code.
     228@item Specifying the @code{@value{RPREFIX}NO_WAIT} option forces
     229an immediate return with an error status code.
    223230
    224231@item Specifying a timeout limits the interval the task will
     
    237244
    238245When a segment is returned to a region by the
    239 region_return_segment directive, it is merged with its
     246@code{@value{DIRPREFIX}region_return_segment} directive, it is merged with its
    240247unallocated neighbors to form the largest possible segment.  The
    241248first task on the wait queue is examined to determine if its
     
    249256@subsection Obtaining the Size of a Segment
    250257
    251 The region_get_segment_size directive returns the
     258The @code{@value{DIRPREFIX}region_get_segment_size} directive returns the
    252259size in bytes of the specified segment.  The size returned
    253260includes any "extra" memory included in the segment because of
     
    260267
    261268A region can be removed from the system and returned
    262 to RTEMS with the region_delete directive.  When a region is
     269to RTEMS with the @code{@value{DIRPREFIX}region_delete}
     270directive.  When a region is
    263271deleted, its control block is returned to the RNCB free list.  A
    264272region with segments still allocated is not allowed to be
     
    350358waiting for a segment to be serviced according to task priority.
    351359Specifying @code{@value{RPREFIX}FIFO} in attribute_set or selecting
    352 @code{@value{RPREFIX}DEFAULT_ATTRIBUTES} will cause waiting tasks to be serviced in
    353 First In-First Out order.
     360@code{@value{RPREFIX}DEFAULT_ATTRIBUTES} will cause waiting tasks to
     361be serviced in First In-First Out order.
    354362
    355363The starting_address parameter must be aligned on a
     
    366374
    367375@itemize @bullet
    368 @item FIFO - tasks wait by FIFO (default)
    369 @item PRIORITY - tasks wait by priority
     376@item @code{@value{RPREFIX}FIFO} - tasks wait by FIFO (default)
     377@item @code{@value{RPREFIX}PRIORITY} - tasks wait by priority
    370378@end itemize
    371379
     
    556564This directive obtains a variable size segment from
    557565the region specified by id.  The address of the allocated
    558 segment is returned in segment.  The @code{@value{RPREFIX}WAIT} and @code{@value{RPREFIX}NO_WAIT} components
     566segment is returned in segment.  The @code{@value{RPREFIX}WAIT}
     567and @code{@value{RPREFIX}NO_WAIT} components
    559568of the options parameter are used to specify whether the calling
    560569tasks wish to wait for a segment to become available or return
     
    570579available, then the calling task is placed on the region's
    571580segment wait queue and blocked.  If the region was created with
    572 the @code{@value{RPREFIX}PRIORITY} option, then the calling task is inserted into the
     581the @code{@value{RPREFIX}PRIORITY} option, then the calling
     582task is inserted into the
    573583wait queue according to its priority.  However, if the region
    574 was created with the @code{@value{RPREFIX}FIFO} option, then the calling task is
    575 placed at the rear of the wait queue.
     584was created with the @code{@value{RPREFIX}FIFO} option, then the calling
     585task is placed at the rear of the wait queue.
    576586
    577587The timeout parameter specifies the maximum interval
    578588that a task is willing to wait to obtain a segment.  If timeout
    579 is set to @code{@value{RPREFIX}NO_TIMEOUT}, then the calling task will wait forever.
     589is set to @code{@value{RPREFIX}NO_TIMEOUT}, then the
     590calling task will wait forever.
    580591
    581592@subheading NOTES:
  • doc/user/rtmon.t

    r3973e40 r75e22db  
    697697@subsection Creating a Rate Monotonic Period
    698698
    699 The rate_monotonic_create directive creates a rate
     699The @code{@value{DIRPREFIX}rate_monotonic_create} directive creates a rate
    700700monotonic period which is to be used by the calling task to
    701701delineate a period.  RTEMS allocates a Period Control Block
     
    711711@subsection Manipulating a Period
    712712
    713 The rate_monotonic_period directive is used to
     713The @code{@value{DIRPREFIX}rate_monotonic_period} directive is used to
    714714establish and maintain periodic execution utilizing a previously
    715715created rate monotonic period.   Once initiated by the
    716 rate_monotonic_period directive, the period is said to run until
    717 it either expires or is reinitiated.  The state of the rate
     716@code{@value{DIRPREFIX}rate_monotonic_period} directive, the period is
     717said to run until it either expires or is reinitiated.  The state of the rate
    718718monotonic period results in one of the following scenarios:
    719719
     
    729729
    730730@item If the rate monotonic period has expired before the task
    731 invokes the rate_monotonic_period directive, the period will be
    732 initiated with a length of period ticks and the calling task
     731invokes the @code{@value{DIRPREFIX}rate_monotonic_period} directive,
     732the period will be initiated with a length of period ticks and the calling task
    733733returns immediately with a timeout error status.
     734
    734735@end itemize
    735736
     
    739740@subsection Obtaining a Period's Status
    740741
    741 If the rate_monotonic_period directive is invoked
    742 with a period of @code{@value{RPREFIX}PERIOD_STATUS} ticks, the current state of the
    743 specified rate monotonic period will be returned.  The following
     742If the @code{@value{DIRPREFIX}rate_monotonic_period} directive is invoked
     743with a period of @code{@value{RPREFIX}PERIOD_STATUS} ticks, the current
     744state of the specified rate monotonic period will be returned.  The following
    744745table details the relationship between the period's status and
    745 the directive status code returned by the rate_monotonic_period
     746the directive status code returned by the
     747@code{@value{DIRPREFIX}rate_monotonic_period}
    746748directive:
    747749
     
    762764@subsection Canceling a Period
    763765
    764 The rate_monotonic_cancel directive is used to stop
     766The @code{@value{DIRPREFIX}rate_monotonic_cancel} directive is used to stop
    765767the period maintained by the specified rate monotonic period.
    766768The period is stopped and the rate monotonic period can be
    767 reinitiated using the rate_monotonic_period directive.
     769reinitiated using the @code{@value{DIRPREFIX}rate_monotonic_period} directive.
    768770
    769771@ifinfo
     
    772774@subsection Deleting a Rate Monotonic Period
    773775
    774 The rate_monotonic_delete directive is used to delete
     776The @code{@value{DIRPREFIX}rate_monotonic_delete} directive is used to delete
    775777a rate monotonic period.  If the period is running and has not
    776778expired, the period is automatically canceled.  The rate
     
    803805  rtems_status_code status;
    804806
    805   name = build_name( 'P', 'E', 'R', 'D' );
     807  name = rtems_build_name( 'P', 'E', 'R', 'D' );
    806808
    807809  (void) rate_monotonic_create( name, &period );
     
    824826The above task creates a rate monotonic period as
    825827part of its initialization.  The first time the loop is
    826 executed, the rate_monotonic_period directive will initiate the
    827 period for 100 ticks and return immediately.  Subsequent
    828 invocations of the rate_monotonic_period directive will result
     828executed, the @code{@value{DIRPREFIX}rate_monotonic_period}
     829directive will initiate the period for 100 ticks and return
     830immediately.  Subsequent invocations of the
     831@code{@value{DIRPREFIX}rate_monotonic_period} directive will result
    829832in the task blocking for the remainder of the 100 tick period.
    830833If, for any reason, the body of the loop takes more than 100
    831 ticks to execute, the rate_monotonic_period directive will
    832 return the TIMEOUT status.  If the above task misses its
    833 deadline, it will delete the rate monotonic period and itself.
     834ticks to execute, the @code{@value{DIRPREFIX}rate_monotonic_period}
     835directive will return the @code{@value{RPREFIX}TIMEOUT} status. 
     836If the above task misses its deadline, it will delete the rate
     837monotonic period and itself.
    834838
    835839@ifinfo
     
    854858  rtems_status_code status;
    855859
    856   name_1 = build_name( 'P', 'E', 'R', '1' );
    857   name_2 = build_name( 'P', 'E', 'R', '2' );
     860  name_1 = rtems_build_name( 'P', 'E', 'R', '1' );
     861  name_2 = rtems_build_name( 'P', 'E', 'R', '2' );
    858862
    859863  (void ) rate_monotonic_create( name_1, &period_1 );
     
    898902The above task creates two rate monotonic periods as
    899903part of its initialization.  The first time the loop is
    900 executed, the rate_monotonic_period directive will initiate the
    901 period_1 period for 100 ticks and return immediately.
    902 Subsequent invocations of the rate_monotonic_period directive
     904executed, the @code{@value{DIRPREFIX}rate_monotonic_period}
     905directive will initiate the period_1 period for 100 ticks
     906and return immediately.  Subsequent invocations of the
     907@code{@value{DIRPREFIX}rate_monotonic_period} directive
    903908for period_1 will result in the task blocking for the remainder
    904909of the 100 tick period.  The period_2 period is used to control
    905910the execution time of the two sets of actions within each 100
    906 tick period established by period_1.  The rate_monotonic_cancel(
    907 period_2 ) call is performed to insure that the period_2 period
     911tick period established by period_1.  The
     912@code{@value{DIRPREFIX}rate_monotonic_cancel( period_2 )}
     913call is performed to insure that the period_2 period
    908914does not expire while the task is blocked on the period_1
    909915period.  If this cancel operation were not performed, every time
    910 the rate_monotonic_period( period_1, 40 ) call is executed,
    911 except for the initial one, a directive status of TIMEOUT is
    912 returned.  It is important to note that every time this call is
    913 made, the period_1 period will be initiated immediately and the
    914 task will not block.
     916the @code{@value{DIRPREFIX}rate_monotonic_period( period_1, 40 )}
     917call is executed, except for the initial one, a directive status
     918of @code{@value{RPREFIX}TIMEOUT} is returned.  It is important to
     919note that every time this call is made, the period_1 period will be
     920initiated immediately and the task will not block.
    915921
    916922If, for any reason, the task misses any deadline, the
    917 rate_monotonic_period directive will return the TIMEOUT
     923@code{@value{DIRPREFIX}rate_monotonic_period} directive will
     924return the @code{@value{RPREFIX}TIMEOUT}
    918925directive status.  If the above task misses its deadline, it
    919926will delete the rate monotonic periods and itself.
     
    10641071This directive cancels the rate monotonic period id.
    10651072This period will be reinitiated by the next invocation of
    1066 rate_monotonic_period with id.
     1073@code{@value{DIRPREFIX}rate_monotonic_period} with id.
    10671074
    10681075@subheading NOTES:
     
    12291236@end ifset
    12301237
     1238@c RATE_MONOTONIC_INACTIVE does not have RTEMS_ in front of it.
     1239
    12311240If the period's state is @code{RATE_MONOTONIC_INACTIVE}, both
    12321241ticks_since_last_period and ticks_executed_since_last_period
    12331242will be set to 0.  Otherwise, ticks_since_last_period will
    12341243contain the number of clock ticks which have occurred since
    1235 the last invocation of the rtems_rate_monotonic_period directive.
     1244the last invocation of the
     1245@code{@value{DIRPREFIX}rate_monotonic_period} directive.
    12361246Also in this case, the ticks_executed_since_last_period will indicate
    12371247how much processor time the owning task has consumed since the invocation
    1238 of the rtems_rate_monotonic_period directive.
     1248of the @code{@value{DIRPREFIX}rate_monotonic_period} directive.
    12391249
    12401250@subheading NOTES:
  • doc/user/schedule.t

    r3973e40 r75e22db  
    167167The final mechanism for altering the RTEMS scheduling
    168168algorithm is called manual round-robin.  Manual round-robin is
    169 invoked by using the task_wake_after directive with a time
    170 interval of @code{@value{RPREFIX}YIELD_PROCESSOR}.  This allows a task to give up the
     169invoked by using the @code{@value{DIRPREFIX}task_wake_after}
     170directive with a time interval of @code{@value{RPREFIX}YIELD_PROCESSOR}. 
     171This allows a task to give up the
    171172processor and be immediately returned to the ready chain at the
    172173end of its priority group.  If no other tasks of the same
     
    196197
    197198Tasks that utilize a numeric coprocessor and are
    198 created with the @code{@value{RPREFIX}FLOATING_POINT} attribute require additional
    199 operations during a context switch.  These additional operations
     199created with the @code{@value{RPREFIX}FLOATING_POINT} attribute
     200require additional operations during a context switch.  These
     201additional operations
    200202are necessary to save and restore the floating point context of
    201203@code{@value{RPREFIX}FLOATING_POINT} tasks.  To avoid unnecessary save and restore
     
    289291
    290292A task occupies the non-existent state before a
    291 task_create has been issued on its behalf.  A task enters the
     293@code{@value{DIRPREFIX}task_create} has been
     294issued on its behalf.  A task enters the
    292295non-existent state from any other state in the system when it is
    293 deleted with the task_delete directive.  While a task occupies
     296deleted with the @code{@value{DIRPREFIX}task_delete}
     297directive.  While a task occupies
    294298this state it does not have a TCB or a task ID assigned to it;
    295299therefore, no other tasks in the system may reference this task.
    296300
    297 When a task is created via the task_create directive
     301When a task is created via the @code{@value{DIRPREFIX}task_create} directive
    298302it enters the dormant state.  This state is not entered through
    299303any other means.  Although the task exists in the system, it
    300304cannot actively compete for system resources.  It will remain in
    301 the dormant state until it is started via the task_start
     305the dormant state until it is started via the @code{@value{DIRPREFIX}task_start}
    302306directive, at which time it enters the ready state.  The task is
    303307now permitted to be scheduled for the processor and to compete
     
    309313blocks itself through voluntary operations that cause the task
    310314to wait.  The only way a task can block a task other than itself
    311 is with the task_suspend directive.  A task enters the blocked
    312 state due to any of the following conditions:
     315is with the @code{@value{DIRPREFIX}task_suspend} directive. 
     316A task enters the blocked state due to any of the following conditions:
    313317
    314318@itemize @bullet
    315 @item A task issues a task_suspend directive which blocks
    316 either itself or another task in the system.
    317 
    318 @item The running task issues a message_queue_receive
     319@item A task issues a @code{@value{DIRPREFIX}task_suspend} directive
     320which blocks either itself or another task in the system.
     321
     322@item The running task issues a @code{@value{DIRPREFIX}message_queue_receive}
    319323directive with the wait option and the message queue is empty.
    320324
    321 @item The running task issues an event_receive directive with
    322 the wait option and the currently pending events do not satisfy
    323 the request.
    324 
    325 @item The running task issues a semaphore_obtain directive
    326 with the wait option and the requested semaphore is unavailable.
    327 
    328 @item The running task issues a task_wake_after directive
    329 which blocks the task for the given time interval.  If the time
     325@item The running task issues an @code{@value{DIRPREFIX}event_receive}
     326directive with the wait option and the currently pending events do not
     327satisfy the request.
     328
     329@item The running task issues a @code{@value{DIRPREFIX}semaphore_obtain}
     330directive with the wait option and the requested semaphore is unavailable.
     331
     332@item The running task issues a @code{@value{DIRPREFIX}task_wake_after}
     333directive which blocks the task for the given time interval.  If the time
    330334interval specified is zero, the task yields the processor and
    331335remains in the ready state.
    332336
    333 @item The running task issues a task_wake_when directive which
    334 blocks the task until the requested date and time arrives.
    335 
    336 @item The running task issues a region_get_segment directive
    337 with the wait option and there is not an available segment large
     337@item The running task issues a @code{@value{DIRPREFIX}task_wake_when}
     338directive which blocks the task until the requested date and time arrives.
     339
     340@item The running task issues a @code{@value{DIRPREFIX}region_get_segment}
     341directive with the wait option and there is not an available segment large
    338342enough to satisfy the task's request.
    339343
    340 @item The running task issues a rate_monotonic_period
     344@item The running task issues a @code{@value{DIRPREFIX}rate_monotonic_period}
    341345directive and must wait for the specified rate monotonic period
    342346to conclude.
     
    357361@itemize @bullet
    358362
    359 @item A running task issues a task_resume directive for a task
    360 that is suspended and the task is not blocked waiting on any
    361 resource.
    362 
    363 @item A running task issues a message_queue_send,
    364 message_queue_broadcast, or a message_queue_urgent directive
     363@item A running task issues a @code{@value{DIRPREFIX}task_resume}
     364directive for a task that is suspended and the task is not blocked
     365waiting on any resource.
     366
     367@item A running task issues a @code{@value{DIRPREFIX}message_queue_send},
     368@code{@value{DIRPREFIX}message_queue_broadcast}, or a
     369@code{@value{DIRPREFIX}message_queue_urgent} directive
    365370which posts a message to the queue on which the blocked task is
    366371waiting.
    367372
    368 @item A running task issues an event_send directive which
    369 sends an event condition to a task which is blocked waiting on
    370 that event condition.
    371 
    372 @item A running task issues a semaphore_release directive
    373 which releases the semaphore on which the blocked task is
     373@item A running task issues an @code{@value{DIRPREFIX}event_send}
     374directive which sends an event condition to a task which is blocked
     375waiting on that event condition.
     376
     377@item A running task issues a @code{@value{DIRPREFIX}semaphore_release}
     378directive which releases the semaphore on which the blocked task is
    374379waiting.
    375380
    376381@item A timeout interval expires for a task which was blocked
    377 by a call to the task_wake_after directive.
     382by a call to the @code{@value{DIRPREFIX}task_wake_after} directive.
    378383
    379384@item A timeout period expires for a task which blocked by a
    380 call to the task_wake_when directive.
    381 
    382 @item A running task issues a region_return_segment directive
    383 which releases a segment to the region on which the blocked task
     385call to the @code{@value{DIRPREFIX}task_wake_when} directive.
     386
     387@item A running task issues a @code{@value{DIRPREFIX}region_return_segment}
     388directive which releases a segment to the region on which the blocked task
    384389is waiting and a resulting segment is large enough to satisfy
    385390the task's request.
    386391
    387392@item A rate monotonic period expires for a task which blocked
    388 by a call to the rate_monotonic_period directive.
     393by a call to the @code{@value{DIRPREFIX}rate_monotonic_period} directive.
    389394
    390395@item A timeout interval expires for a task which was blocked
     
    396401task is waiting.
    397402
    398 @item A running task issues a task_restart directive for the
    399 blocked task.
     403@item A running task issues a @code{@value{DIRPREFIX}task_restart}
     404directive for the blocked task.
    400405
    401406@item The running task, with its preemption mode enabled, may
  • doc/user/sem.t

    r3973e40 r75e22db  
    5454
    5555A semaphore can be viewed as a protected variable
    56 whose value can be modified only with the semaphore_create,
    57 semaphore_obtain, and semaphore_release directives.  RTEMS
     56whose value can be modified only with the
     57@code{@value{DIRPREFIX}semaphore_create},
     58@code{@value{DIRPREFIX}semaphore_obtain}, and
     59@code{@value{DIRPREFIX}semaphore_release} directives.  RTEMS
    5860supports both binary and counting semaphores. A binary semaphore
    5961is restricted to values of zero or one, while a counting
     
    6668of one to indicate that no task is executing the critical
    6769section of code.  Upon entry to the critical section, a task
    68 must issue the semaphore_obtain directive to prevent other tasks
    69 from entering the critical section.  Upon exit from the critical
    70 section, the task must issue the semaphore_release directive to
     70must issue the @code{@value{DIRPREFIX}semaphore_obtain}
     71directive to prevent other tasks from entering the critical section. 
     72Upon exit from the critical section, the task must issue the
     73@code{@value{DIRPREFIX}semaphore_release} directive to
    7174allow another task to execute the critical section.
    7275
     
    7578printers could be administered by a semaphore created with an
    7679initial count of three.  When a task requires access to one of
    77 the printers, it issues the semaphore_obtain directive to obtain
    78 access to a printer.  If a printer is not currently available,
    79 the task can wait for a printer to become available or return
     80the printers, it issues the @code{@value{DIRPREFIX}semaphore_obtain}
     81directive to obtain access to a printer.  If a printer is not currently
     82available, the task can wait for a printer to become available or return
    8083immediately.  When the task has completed printing, it should
    81 issue the semaphore_release directive to allow other tasks
    82 access to the printer.
     84issue the @code{@value{DIRPREFIX}semaphore_release}
     85directive to allow other tasks access to the printer.
    8386
    8487Task synchronization may be achieved by creating a
    8588semaphore with an initial count of zero.  One task waits for the
    86 arrival of another task by issuing a semaphore_obtain directive
    87 when it reaches a synchronization point.  The other task
    88 performs a corresponding semaphore_release operation when it
    89 reaches its synchronization point, thus unblocking the pending
    90 task.
     89arrival of another task by issuing a @code{@value{DIRPREFIX}semaphore_obtain}
     90directive when it reaches a synchronization point.  The other task
     91performs a corresponding @code{@value{DIRPREFIX}semaphore_release}
     92operation when it reaches its synchronization point, thus unblocking
     93the pending task.
    9194
    9295@ifinfo
     
    104107RTEMS addresses this problem by allowing the task
    105108holding the binary semaphore to obtain the same binary semaphore
    106 multiple times in a nested manner.  Each semaphore_obtain must
    107 be accompanied with a semaphore_release.  The semaphore will
     109multiple times in a nested manner.  Each
     110@code{@value{DIRPREFIX}semaphore_obtain} must be accompanied with a
     111@code{@value{DIRPREFIX}semaphore_release}.  The semaphore will
    108112only be made available for acquisition by other tasks when the
    109 outermost semaphore_obtain is matched with a semaphore_release.
     113outermost @code{@value{DIRPREFIX}semaphore_obtain} is matched with
     114a @code{@value{DIRPREFIX}semaphore_release}.
    110115
    111116
     
    213218
    214219@itemize @bullet
    215 @item FIFO - tasks wait by FIFO (default)
    216 @item PRIORITY - tasks wait by priority
    217 @item BINARY_SEMAPHORE - restrict values to 0 and 1 (default)
    218 @item COUNTING_SEMAPHORE - no restriction on values
    219 @item NO_INHERIT_PRIORITY - do not use priority inheritance (default)
    220 @item INHERIT_PRIORITY - use priority inheritance
    221 @item PRIORITY_CEILING - use priority ceiling
    222 @item NO_PRIORITY_CEILING - do not use priority ceiling (default)
    223 @item LOCAL - local task (default)
    224 @item GLOBAL - global task
     220@item @code{@value{RPREFIX}FIFO} - tasks wait by FIFO (default)
     221
     222@item @code{@value{RPREFIX}PRIORITY} - tasks wait by priority
     223
     224@item @code{@value{RPREFIX}BINARY_SEMAPHORE} - restrict values to
     2250 and 1 (default)
     226
     227@item @code{@value{RPREFIX}COUNTING_SEMAPHORE} - no restriction on values
     228
     229@item @code{@value{RPREFIX}NO_INHERIT_PRIORITY} - do not use priority
     230inheritance (default)
     231
     232@item @code{@value{RPREFIX}INHERIT_PRIORITY} - use priority inheritance
     233
     234@item @code{@value{RPREFIX}PRIORITY_CEILING} - use priority ceiling
     235
     236@item @code{@value{RPREFIX}NO_PRIORITY_CEILING} - do not use priority
     237ceiling (default)
     238
     239@item @code{@value{RPREFIX}LOCAL} - local task (default)
     240
     241@item @code{@value{RPREFIX}GLOBAL} - global task
    225242@end itemize
    226243
     
    231248required to appear in the attribute list, although it is a good
    232249programming practice to specify default attributes.  If all
    233 defaults are desired, the attribute @code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be
     250defaults are desired, the attribute
     251@code{@value{RPREFIX}DEFAULT_ATTRIBUTES} should be
    234252specified on this call.
    235253
     
    237255needed to create a local semaphore with the task priority
    238256waiting queue discipline.  The attribute_set parameter passed to
    239 the semaphore_create directive could be either
     257the @code{@value{DIRPREFIX}semaphore_create} directive could be either
    240258@code{@value{RPREFIX}PRIORITY} or
    241259@code{@value{RPREFIX}LOCAL @value{OR} @value{RPREFIX}PRIORITY}. 
     
    253271In general, an option is built by a bitwise OR of the
    254272desired option components.  The set of valid options for the
    255 semaphore_obtain directive are listed in the following table:
     273@code{@value{DIRPREFIX}semaphore_obtain} directive are listed
     274in the following table:
    256275
    257276@itemize @bullet
     
    271290This example demonstrates the option parameter needed
    272291to poll for a semaphore.  The option parameter passed to the
    273 semaphore_obtain directive should be @code{@value{RPREFIX}NO_WAIT}.
     292@code{@value{DIRPREFIX}semaphore_obtain}
     293directive should be @code{@value{RPREFIX}NO_WAIT}.
    274294
    275295@ifinfo
     
    292312@subsection Creating a Semaphore
    293313
    294 The semaphore_create directive creates a binary or
     314The @code{@value{DIRPREFIX}semaphore_create} directive creates a binary or
    295315counting semaphore with a user-specified name as well as an
    296316initial count.  If a binary semaphore is created with a count of
     
    318338deleted.  The semaphore ID may be obtained by either of two
    319339methods.  First, as the result of an invocation of the
    320 semaphore_create directive, the semaphore ID is stored in a user
    321 provided location.  Second, the semaphore ID may be obtained
    322 later using the semaphore_ident directive.  The semaphore ID is
     340@code{@value{DIRPREFIX}semaphore_create} directive, the
     341semaphore ID is stored in a user provided location.  Second,
     342the semaphore ID may be obtained later using the
     343@code{@value{DIRPREFIX}semaphore_ident} directive.  The semaphore ID is
    323344used by other semaphore manager directives to access this
    324345semaphore.
     
    329350@subsection Acquiring a Semaphore
    330351
    331 The semaphore_obtain directive is used to acquire the
     352The @code{@value{DIRPREFIX}semaphore_obtain} directive is used to acquire the
    332353specified semaphore.  A simplified version of the
    333 semaphore_obtain directive can be described as follows:
     354@code{@value{DIRPREFIX}semaphore_obtain} directive can be described as follows:
    334355
    335356@example
     
    374395@subsection Releasing a Semaphore
    375396
    376 The semaphore_release directive is used to release
     397The @code{@value{DIRPREFIX}semaphore_release} directive is used to release
    377398the specified semaphore.  A simplified version of the
    378 semaphore_release directive can be described as follows:
     399@code{@value{DIRPREFIX}semaphore_release} directive can be described as follows:
    379400
    380401@example
     
    389410semaphore that uses priority inheritance or priority ceiling and
    390411the task does not currently hold any other binary semaphores,
    391 then the task performing the semaphore_release will have its
    392 priority restored to its normal value.
     412then the task performing the @code{@value{DIRPREFIX}semaphore_release}
     413will have its priority restored to its normal value.
    393414
    394415@ifinfo
     
    397418@subsection Deleting a Semaphore
    398419
    399 The semaphore_delete directive removes a semaphore
     420The @code{@value{DIRPREFIX}semaphore_delete} directive removes a semaphore
    400421from the system and frees its control block.  A semaphore can be
    401422deleted by any local task that knows the semaphore's ID.  As a
     
    493514
    494515@itemize @bullet
    495 @item FIFO - tasks wait by FIFO (default)
    496 @item PRIORITY - tasks wait by priority
    497 @item BINARY_SEMAPHORE - restrict values to 0 and 1 (default)
    498 @item COUNTING_SEMAPHORE - no restriction on values
    499 @item NO_INHERIT_PRIORITY - do not use priority inheritance (default)
    500 @item INHERIT_PRIORITY - use priority inheritance
    501 @item PRIORITY_CEILING - use priority ceiling
    502 @item NO_PRIORITY_CEILING - do not use priority ceiling (default)
    503 @item LOCAL - local task (default)
    504 @item GLOBAL - global task
     516@item @code{@value{RPREFIX}FIFO} - tasks wait by FIFO (default)
     517
     518@item @code{@value{RPREFIX}PRIORITY} - tasks wait by priority
     519
     520@item @code{@value{RPREFIX}BINARY_SEMAPHORE} - restrict values to
     5210 and 1 (default)
     522
     523@item @code{@value{RPREFIX}COUNTING_SEMAPHORE} - no restriction on values
     524
     525@item @code{@value{RPREFIX}NO_INHERIT_PRIORITY} - do not use priority
     526inheritance (default)
     527
     528@item @code{@value{RPREFIX}INHERIT_PRIORITY} - use priority inheritance
     529
     530@item @code{@value{RPREFIX}PRIORITY_CEILING} - use priority ceiling
     531
     532@item @code{@value{RPREFIX}NO_PRIORITY_CEILING} - do not use priority
     533ceiling (default)
     534
     535@item @code{@value{RPREFIX}LOCAL} - local task (default)
     536
     537@item @code{@value{RPREFIX}GLOBAL} - global task
    505538@end itemize
    506539
     
    632665
    633666The semaphore must reside on the local node, even if
    634 the semaphore was created with the GLOBAL option.
     667the semaphore was created with the @code{@value{RPREFIX}GLOBAL} option.
    635668
    636669Proxies, used to represent remote tasks, are
  • doc/user/signal.t

    r3973e40 r75e22db  
    109109
    110110This example demonstrates the signal parameter used
    111 when sending the signal set consisting of
    112 @code{@value{RPREFIX}SIGNAL_6}, @code{@value{RPREFIX}SIGNAL_15}, and @code{@value{RPREFIX}SIGNAL_31}. 
    113 The signal parameter provided to the signal_send directive should be
     111when sending the signal set consisting of
     112@code{@value{RPREFIX}SIGNAL_6},
     113@code{@value{RPREFIX}SIGNAL_15}, and
     114@code{@value{RPREFIX}SIGNAL_31}.  The signal parameter provided
     115to the @code{@value{DIRPREFIX}signal_send} directive should be
    114116@code{@value{RPREFIX}SIGNAL_6 @value{OR}
    115117@value{RPREFIX}SIGNAL_15 @value{OR} @value{RPREFIX}SIGNAL_31}.
     
    162164
    163165This example demonstrates the mode parameter used
    164 with the signal_catch to establish an ASR which executes at
     166with the @code{@value{DIRPREFIX}signal_catch}
     167to establish an ASR which executes at
    165168interrupt level three and is non-preemptible.  The mode should
    166169be set to
     
    186189@subsection Establishing an ASR
    187190
    188 The signal_catch directive establishes an ASR for the
     191The @code{@value{DIRPREFIX}signal_catch} directive establishes an ASR for the
    189192calling task.  The address of the ASR and its execution mode are
    190193specified to this directive.  The ASR's mode is distinct from
    191194the task's mode.  For example, the task may allow preemption,
    192195while that task's ASR may have preemption disabled.  Until a
    193 task calls signal_catch the first time, its ASR is invalid, and
    194 no signal sets can be sent to the task.
     196task calls @code{@value{DIRPREFIX}signal_catch} the first time,
     197its ASR is invalid, and no signal sets can be sent to the task.
    195198
    196199A task may invalidate its ASR and discard all pending
    197 signals by calling signal_catch with a value of NULL for the
    198 ASR's address.  When a task's ASR is invalid, new signal sets
    199 sent to this task are discarded.
    200 
    201 A task may disable ASR processing (NO_ASR) via the
     200signals by calling @code{@value{DIRPREFIX}signal_catch}
     201with a value of NULL for the ASR's address.  When a task's
     202ASR is invalid, new signal sets sent to this task are discarded.
     203
     204A task may disable ASR processing (@code{@value{RPREFIX}NO_ASR}) via the
    202205task_mode directive.  When a task's ASR is disabled, the signals
    203206sent to it are left pending to be processed later when the ASR
     
    206209Any directive that can be called from a task can also
    207210be called from an ASR.  A task is only allowed one active ASR.
    208 Thus, each call to signal_catch replaces the previous one.
     211Thus, each call to @code{@value{DIRPREFIX}signal_catch}
     212replaces the previous one.
    209213
    210214Normally, signal processing is disabled for the ASR's
     
    217221@subsection Sending a Signal Set
    218222
    219 The signal_send directive allows both tasks and ISRs
    220 to send signals to a target task.  The target task and a set of
    221 signals are specified to the signal_send directive.  The sending
     223The @code{@value{DIRPREFIX}signal_send} directive allows both
     224tasks and ISRs to send signals to a target task.  The target task and
     225a set of signals are specified to the
     226@code{@value{DIRPREFIX}signal_send} directive.  The sending
    222227of a signal to a task has no effect on the execution state of
    223228that task.  If the task is not the currently running task, then
  • doc/user/task.t

    r3973e40 r75e22db  
    7474@subsection Task Definition
    7575
    76 Many definitions of a task have been proposed in computer
    77 literature.  Unfortunately, none of these definitions
    78 encompasses all facets of the concept in a manner which is
    79 operating system independent.  Several of the more common
    80 definitions are provided to enable each user to select a
    81 definition which best matches their own experience and
    82 understanding of the task concept:
     76Many definitions of a task have been proposed in computer literature.
     77Unfortunately, none of these definitions encompasses all facets of the
     78concept in a manner which is operating system independent.  Several of the
     79more common definitions are provided to enable each user to select a
     80definition which best matches their own experience and understanding of the
     81task concept:
    8382
    8483@itemize @bullet
     
    194193execution environment of the task.
    195194
    196 The preemption component allows a task to determine when control
    197 of the processor is relinquished.  If preemption is disabled
    198 (@code{@value{RPREFIX}NO_PREEMPT}), the task will retain control of the processor as
    199 long as it is in the executing state -- even if a higher
    200 priority task is made ready.  If preemption is enabled (@code{@value{RPREFIX}PREEMPT})
    201 and a higher priority task is made ready, then the processor
    202 will be taken away from the current task immediately and given
    203 to the higher priority task.
    204 
    205 The timeslicing component is used by the RTEMS scheduler to
    206 determine how the processor is allocated to tasks of equal
    207 priority.  If timeslicing is enabled (@code{@value{RPREFIX}TIMESLICE}), then RTEMS
    208 will limit the amount of time the task can execute before the
    209 processor is allocated to another ready task of equal priority.
    210 The length of the timeslice is application dependent and
    211 specified in the Configuration Table.  If timeslicing is
    212 disabled (@code{@value{RPREFIX}NO_TIMESLICE}), then the task will be allowed to
    213 execute until a task of higher priority is made ready.  If
    214 @code{@value{RPREFIX}NO_PREEMPT} is selected, then the timeslicing component is
    215 ignored by the scheduler.
    216 
    217 The asynchronous signal processing component is used to
    218 determine when received signals are to be processed by the task.
    219  If signal processing is enabled (@code{@value{RPREFIX}ASR}), then signals sent to the
    220 task will be processed the next time the task executes.  If
    221 signal processing is disabled (@code{@value{RPREFIX}NO_ASR}), then all signals
    222 received by the task will remain posted until signal processing
    223 is enabled.  This component affects only tasks which have
    224 established a routine to process asynchronous signals.
     195The preemption component allows a task to determine when control of the
     196processor is relinquished.  If preemption is disabled
     197(@code{@value{RPREFIX}NO_PREEMPT}), the task will retain control of the
     198processor as long as it is in the executing state -- even if a higher
     199priority task is made ready.  If preemption is enabled
     200(@code{@value{RPREFIX}PREEMPT})  and a higher priority task is made ready,
     201then the processor will be taken away from the current task immediately and
     202given to the higher priority task.
     203
     204The timeslicing component is used by the RTEMS scheduler to determine how
     205the processor is allocated to tasks of equal priority.  If timeslicing is
     206enabled (@code{@value{RPREFIX}TIMESLICE}), then RTEMS will limit the amount
     207of time the task can execute before the processor is allocated to another
     208ready task of equal priority. The length of the timeslice is application
     209dependent and specified in the Configuration Table.  If timeslicing is
     210disabled (@code{@value{RPREFIX}NO_TIMESLICE}), then the task will be
     211allowed to execute until a task of higher priority is made ready.  If
     212@code{@value{RPREFIX}NO_PREEMPT} is selected, then the timeslicing
     213component is ignored by the scheduler.
     214
     215The asynchronous signal processing component is used to determine when
     216received signals are to be processed by the task.
     217If signal processing is enabled (@code{@value{RPREFIX}ASR}), then signals
     218sent to the task will be processed the next time the task executes.  If
     219signal processing is disabled (@code{@value{RPREFIX}NO_ASR}), then all
     220signals received by the task will remain posted until signal processing is
     221enabled.  This component affects only tasks which have established a
     222routine to process asynchronous signals.
    225223
    226224The interrupt level component is used to determine which
     
    275273@subsection Floating Point Considerations
    276274
    277 Creating a task with the @code{@value{RPREFIX}FLOATING_POINT} flag results in
    278 additional memory being allocated for the TCB to store the state
    279 of the numeric coprocessor during task switches.  This
    280 additional memory is @b{NOT} allocated for @code{@value{RPREFIX}NO_FLOATING_POINT} tasks.
    281 Saving and restoring the context of a @code{@value{RPREFIX}FLOATING_POINT} task takes
    282 longer than that of a @code{@value{RPREFIX}NO_FLOATING_POINT} task because of the
    283 relatively large amount of time required for the numeric
    284 coprocessor to save or restore its computational state.
    285 
    286 Since RTEMS was designed specifically for embedded military
    287 applications which are floating point intensive, the executive
    288 is optimized to avoid unnecessarily saving and restoring the
    289 state of the numeric coprocessor.  The state of the numeric
    290 coprocessor is only saved when a @code{@value{RPREFIX}FLOATING_POINT} task is
    291 dispatched and that task was not the last task to utilize the
    292 coprocessor.  In a system with only one @code{@value{RPREFIX}FLOATING_POINT} task, the
    293 state of the numeric coprocessor will never be saved or
    294 restored. 
    295 
    296 Although the overhead imposed by @code{@value{RPREFIX}FLOATING_POINT} tasks is
    297 minimal, some applications may wish to completely avoid the
    298 overhead associated with @code{@value{RPREFIX}FLOATING_POINT} tasks and still utilize
    299 a numeric coprocessor.  By preventing a task from being
    300 preempted while performing a sequence of floating point
    301 operations, a @code{@value{RPREFIX}NO_FLOATING_POINT} task can utilize the numeric
    302 coprocessor without incurring the overhead of a @code{@value{RPREFIX}FLOATING_POINT}
    303 context switch.  This approach also avoids the allocation of a
    304 floating point context area.  However, if this approach is taken
    305 by the application designer, NO tasks should be created as
    306 @code{@value{RPREFIX}FLOATING_POINT} tasks.  Otherwise, the floating point context
    307 will not be correctly maintained because RTEMS assumes that the
    308 state of the numeric coprocessor will not be altered by
    309 @code{@value{RPREFIX}NO_FLOATING_POINT} tasks.
     275Creating a task with the @code{@value{RPREFIX}FLOATING_POINT} flag results
     276in additional memory being allocated for the TCB to store the state of the
     277numeric coprocessor during task switches.  This additional memory is
     278@b{NOT} allocated for @code{@value{RPREFIX}NO_FLOATING_POINT} tasks. Saving
     279and restoring the context of a @code{@value{RPREFIX}FLOATING_POINT} task
     280takes longer than that of a @code{@value{RPREFIX}NO_FLOATING_POINT} task
     281because of the relatively large amount of time required for the numeric
     282coprocessor to save or restore its computational state.
     283
     284Since RTEMS was designed specifically for embedded military applications
     285which are floating point intensive, the executive is optimized to avoid
     286unnecessarily saving and restoring the state of the numeric coprocessor.
     287The state of the numeric coprocessor is only saved when a
     288@code{@value{RPREFIX}FLOATING_POINT} task is dispatched and that task was
     289not the last task to utilize the coprocessor.  In a system with only one
     290@code{@value{RPREFIX}FLOATING_POINT} task, the state of the numeric
     291coprocessor will never be saved or restored.
     292
     293Although the overhead imposed by @code{@value{RPREFIX}FLOATING_POINT} tasks
     294is minimal, some applications may wish to completely avoid the overhead
     295associated with @code{@value{RPREFIX}FLOATING_POINT} tasks and still
     296utilize a numeric coprocessor.  By preventing a task from being preempted
     297while performing a sequence of floating point operations, a
     298@code{@value{RPREFIX}NO_FLOATING_POINT} task can utilize the numeric
     299coprocessor without incurring the overhead of a
     300@code{@value{RPREFIX}FLOATING_POINT} context switch.  This approach also
     301avoids the allocation of a floating point context area.  However, if this
     302approach is taken by the application designer, NO tasks should be created
     303as @code{@value{RPREFIX}FLOATING_POINT} tasks.  Otherwise, the floating
     304point context will not be correctly maintained because RTEMS assumes that
     305the state of the numeric coprocessor will not be altered by
     306@code{@value{RPREFIX}NO_FLOATING_POINT} tasks.
    310307
    311308If the supported processor type does not have hardware floating
    312 capabilities or a standard numeric coprocessor, RTEMS will not
    313 provide built-in support for hardware floating point on that
    314 processor.  In this case, all tasks are considered
    315 @code{@value{RPREFIX}NO_FLOATING_POINT} whether created as @code{@value{RPREFIX}FLOATING_POINT} or
    316 @code{@value{RPREFIX}NO_FLOATING_POINT} tasks.  A floating point emulation software
    317 library must be utilized for floating point operations.
    318 
    319 On some processors, it is possible to disable the floating point
    320 unit dynamically.  If this capability is supported by the target
    321 processor, then RTEMS will utilize this capability to enable the
    322 floating point unit only for tasks which are created with the
    323 @code{@value{RPREFIX}FLOATING_POINT} attribute.  The consequence of a
    324 @code{@value{RPREFIX}NO_FLOATING_POINT} task attempting to access the floating point
    325 unit is CPU dependent but will i general result in an exception
    326 condition.
     309capabilities or a standard numeric coprocessor, RTEMS will not provide
     310built-in support for hardware floating point on that processor.  In this
     311case, all tasks are considered @code{@value{RPREFIX}NO_FLOATING_POINT}
     312whether created as @code{@value{RPREFIX}FLOATING_POINT} or
     313@code{@value{RPREFIX}NO_FLOATING_POINT} tasks.  A floating point emulation
     314software library must be utilized for floating point operations.
     315
     316On some processors, it is possible to disable the floating point unit
     317dynamically.  If this capability is supported by the target processor, then
     318RTEMS will utilize this capability to enable the floating point unit only
     319for tasks which are created with the @code{@value{RPREFIX}FLOATING_POINT}
     320attribute.  The consequence of a @code{@value{RPREFIX}NO_FLOATING_POINT}
     321task attempting to access the floating point unit is CPU dependent but will
     322generally result in an exception condition.
    327323
    328324@ifinfo
     
    439435    <TD ALIGN=center><STRONG>Mask Constant</STRONG></TD>
    440436    <TD ALIGN=center><STRONG>Description</STRONG></TD></TR>
    441 <TR><TD ALIGN=center>PREEMPT</TD>
    442     <TD ALIGN=center>PREEMPT_MASK</TD>
     437<TR><TD ALIGN=center>@value{RPREFIX}PREEMPT</TD>
     438    <TD ALIGN=center>@value{RPREFIX}PREEMPT_MASK</TD>
    443439    <TD ALIGN=center>enables preemption</TD></TR>
    444 <TR><TD ALIGN=center>NO_PREEMPT</TD>
    445     <TD ALIGN=center>PREEMPT_MASK</TD>
     440<TR><TD ALIGN=center>@value{RPREFIX}NO_PREEMPT</TD>
     441    <TD ALIGN=center>@value{RPREFIX}PREEMPT_MASK</TD>
    446442    <TD ALIGN=center>disables preemption</TD></TR>
    447 <TR><TD ALIGN=center>NO_TIMESLICE</TD>
    448     <TD ALIGN=center>TIMESLICE_MASK</TD>
     443<TR><TD ALIGN=center>@value{RPREFIX}NO_TIMESLICE</TD>
     444    <TD ALIGN=center>@value{RPREFIX}TIMESLICE_MASK</TD>
    449445    <TD ALIGN=center>disables timeslicing</TD></TR>
    450 <TR><TD ALIGN=center>TIMESLICE</TD>
    451     <TD ALIGN=center>TIMESLICE_MASK</TD>
     446<TR><TD ALIGN=center>@value{RPREFIX}TIMESLICE</TD>
     447    <TD ALIGN=center>@value{RPREFIX}TIMESLICE_MASK</TD>
    452448    <TD ALIGN=center>enables timeslicing</TD></TR>
    453 <TR><TD ALIGN=center>ASR</TD>
    454     <TD ALIGN=center>ASR_MASK</TD>
     449<TR><TD ALIGN=center>@value{RPREFIX}ASR</TD>
     450    <TD ALIGN=center>@value{RPREFIX}ASR_MASK</TD>
    455451    <TD ALIGN=center>enables ASR processing</TD></TR>
    456 <TR><TD ALIGN=center>NO_ASR</TD>
    457     <TD ALIGN=center>ASR_MASK</TD>
     452<TR><TD ALIGN=center>@value{RPREFIX}NO_ASR</TD>
     453    <TD ALIGN=center>@value{RPREFIX}ASR_MASK</TD>
    458454    <TD ALIGN=center>disables ASR processing</TD></TR>
    459 <TR><TD ALIGN=center>INTERRUPT_LEVEL(0)</TD>
    460     <TD ALIGN=center>INTERRUPT_MASK</TD>
     455<TR><TD ALIGN=center>@value{RPREFIX}INTERRUPT_LEVEL(0)</TD>
     456    <TD ALIGN=center>@value{RPREFIX}INTERRUPT_MASK</TD>
    461457    <TD ALIGN=center>enables all interrupts</TD></TR>
    462 <TR><TD ALIGN=center>INTERRUPT_LEVEL(n)</TD>
    463     <TD ALIGN=center>INTERRUPT_MASK</TD>
     458<TR><TD ALIGN=center>@value{RPREFIX}INTERRUPT_LEVEL(n)</TD>
     459    <TD ALIGN=center>@value{RPREFIX}INTERRUPT_MASK</TD>
    464460    <TD ALIGN=center>sets interrupts level n</TD></TR>
    465461  </TABLE>
     
    468464@end ifset
    469465
    470 
    471 
    472 
    473 Mode values are specifically designed to be mutually exclusive,
    474 therefore bitwise OR and addition operations are equivalent as
    475 long as each mode appears exactly once in the component list.  A
    476 mode component listed as a default is not required to appear in
    477 the mode component list, although it is a good programming
    478 practice to specify default components.  If all defaults are
    479 desired, the mode @code{@value{RPREFIX}DEFAULT_MODES} and the mask @code{@value{RPREFIX}ALL_MODE_MASKS}
    480 should be used.
    481 
    482 The following example demonstrates the mode and mask parameters
    483 used with the task_mode directive to place a task at interrupt
    484 level 3 and make it non-preemptible.  The mode should be set to
    485 @code{@value{RPREFIX}INTERRUPT_LEVEL(3)
    486 @value{OR} @value{RPREFIX}NO_PREEMPT} to indicate the desired
    487 preemption mode and interrupt level, while the mask parameter
    488 should be set to
    489 @code{@value{RPREFIX}INTERRUPT_MASK @value{OR} @value{RPREFIX}NO_PREEMPT_MASK}
    490 to indicate that the calling task's interrupt level and preemption mode are
    491 being altered.
     466Mode values are specifically designed to be mutually exclusive, therefore
     467bitwise OR and addition operations are equivalent as long as each mode
     468appears exactly once in the component list.  A mode component listed as a
     469default is not required to appear in the mode component list, although it
     470is a good programming practice to specify default components.  If all
     471defaults are desired, the mode @code{@value{RPREFIX}DEFAULT_MODES} and the
     472mask @code{@value{RPREFIX}ALL_MODE_MASKS} should be used.
     473
     474The following example demonstrates the mode and mask parameters used with
     475the @code{@value{DIRPREFIX}task_mode}
     476directive to place a task at interrupt level 3 and make it
     477non-preemptible.  The mode should be set to
     478@code{@value{RPREFIX}INTERRUPT_LEVEL(3)  @value{OR}
     479@value{RPREFIX}NO_PREEMPT} to indicate the desired preemption mode and
     480interrupt level, while the mask parameter should be set to
     481@code{@value{RPREFIX}INTERRUPT_MASK @value{OR}
     482@value{RPREFIX}NO_PREEMPT_MASK} to indicate that the calling task's
     483interrupt level and preemption mode are being altered.
    492484
    493485@ifinfo
     
    516508@subsection Creating Tasks
    517509
    518 The task_create directive creates a task by allocating a task
     510The @code{@value{DIRPREFIX}task_create}
     511directive creates a task by allocating a task
    519512control block, assigning the task a user-specified name,
    520513allocating it a stack and floating point context area, setting a
     
    532525assigns it to the created task until it is deleted.  The task ID
    533526may be obtained by either of two methods.  First, as the result
    534 of an invocation of the task_create directive, the task ID is
     527of an invocation of the @code{@value{DIRPREFIX}task_create}
     528directive, the task ID is
    535529stored in a user provided location.  Second, the task ID may be
    536 obtained later using the task_ident directive.  The task ID is
     530obtained later using the @code{@value{DIRPREFIX}task_ident}
     531directive.  The task ID is
    537532used by other directives to manipulate this task.
    538533
     
    542537@subsection Starting and Restarting Tasks
    543538
    544 The task_start directive is used to place a dormant task in the
     539The @code{@value{DIRPREFIX}task_start}
     540directive is used to place a dormant task in the
    545541ready state.  This enables the task to compete, based on its
    546542current priority, for the processor and other system resources.
     
    549545started.
    550546
    551 With the task_start directive the user specifies the task's
     547With the @code{@value{DIRPREFIX}task_start}
     548directive the user specifies the task's
    552549starting address and argument.  The argument is used to
    553550communicate some startup information to the task.  As part of
     
    557554target processor's calling convention.
    558555
    559 The task_restart directive restarts a task at its initial
     556The @code{@value{DIRPREFIX}task_restart}
     557directive restarts a task at its initial
    560558starting address with its original priority and execution mode,
    561559but with a possibly different argument.  The new argument may be
     
    574572@subsection Suspending and Resuming Tasks
    575573
    576 The task_suspend directive is used to place either the caller or
     574The @code{@value{DIRPREFIX}task_suspend}
     575directive is used to place either the caller or
    577576another task into a suspended state.  The task remains suspended
    578 until a task_resume directive is issued.  This implies that a
     577until a @code{@value{DIRPREFIX}task_resume}
     578directive is issued.  This implies that a
    579579task may be suspended as well as blocked waiting either to
    580580acquire a resource or for the expiration of a timer.
    581581
    582 The task_resume directive is used to remove another task from
     582The @code{@value{DIRPREFIX}task_resume}
     583directive is used to remove another task from
    583584the suspended state. If the task is not also blocked, resuming
    584585it will place it in the ready state, allowing it to once again
     
    595596@subsection Delaying the Currently Executing Task
    596597
    597 The task_wake_after directive creates a sleep timer which allows
    598 a task to go to sleep for a specified interval.  The task is
    599 blocked until the delay interval has elapsed, at which time the
    600 task is unblocked.  A task calling the task_wake_after directive
    601 with a delay interval of @code{@value{RPREFIX}YIELD_PROCESSOR} ticks will yield the
    602 processor to any other ready task of equal or greater priority
    603 and remain ready to execute.
    604 
    605 The task_wake_when directive creates a sleep timer which allows
     598The @code{@value{DIRPREFIX}task_wake_after} directive creates a sleep timer
     599which allows a task to go to sleep for a specified interval.  The task is
     600blocked until the delay interval has elapsed, at which time the task is
     601unblocked.  A task calling the @code{@value{DIRPREFIX}task_wake_after}
     602directive with a delay
     603interval of @code{@value{RPREFIX}YIELD_PROCESSOR} ticks will yield the
     604processor to any other ready task of equal or greater priority and remain
     605ready to execute.
     606
     607The @code{@value{DIRPREFIX}task_wake_when}
     608directive creates a sleep timer which allows
    606609a task to go to sleep until a specified date and time.  The
    607610calling task is blocked until the specified date and time has
     
    613616@subsection Changing Task Priority
    614617
    615 The task_set_priority directive is used to obtain or change the
     618The @code{@value{DIRPREFIX}task_set_priority}
     619directive is used to obtain or change the
    616620current priority of either the calling task or another task.  If
    617 the new priority requested is CURRENT_PRIORITY or the task's
     621the new priority requested is
     622@code{@value{RPREFIX}CURRENT_PRIORITY} or the task's
    618623actual priority, then the current priority will be returned and
    619624the task's priority will remain unchanged.  If the task's
     
    621626to its new priority.
    622627
    623 The task_restart directive resets the priority of a task to its
     628The @code{@value{DIRPREFIX}task_restart}
     629directive resets the priority of a task to its
    624630original value.
    625631
     
    629635@subsection Changing Task Mode
    630636
    631 The task_mode directive is used to obtain or change the current
     637The @code{@value{DIRPREFIX}task_mode}
     638directive is used to obtain or change the current
    632639execution mode of the calling task.  A task's execution mode is
    633640used to enable preemption, timeslicing, ASR processing, and to
    634641set the task's interrupt level. 
    635642
    636 The task_restart directive resets the mode of a task to its
     643The @code{@value{DIRPREFIX}task_restart}
     644directive resets the mode of a task to its
    637645original value.
    638646
     
    644652RTEMS provides sixteen notepad locations for each task.  Each
    645653notepad location may contain a note consisting of four bytes of
    646 information.  RTEMS provides two directives, task_set_note and
    647 task_get_note, that enable a user to access and change the
    648 notepad locations.  The task_set_note directive enables the user
     654information.  RTEMS provides two directives,
     655@code{@value{DIRPREFIX}task_set_note} and
     656@code{@value{DIRPREFIX}task_get_note}, that enable a user
     657to access and change the
     658notepad locations.  The @code{@value{DIRPREFIX}task_set_note}
     659directive enables the user
    649660to set a task's notepad entry to a specified note.  The
    650 task_get_note directive allows the user to obtain the note
     661@code{@value{DIRPREFIX}task_get_note}
     662directive allows the user to obtain the note
    651663contained in any one of the sixteen notepads of a specified task.
    652664
     
    656668@subsection Task Deletion
    657669
    658 RTEMS provides the task_delete directive to allow a task to
     670RTEMS provides the @code{@value{DIRPREFIX}task_delete}
     671directive to allow a task to
    659672delete itself or any other task.  This directive removes all
    660673RTEMS references to the task, frees the task's control block,
     
    666679application.
    667680
    668 Unexpired delay timers (i.e. those used by task_wake_after and
    669 task_wake_when) and timeout timers associated with the task are
     681Unexpired delay timers (i.e. those used by
     682@code{@value{DIRPREFIX}task_wake_after} and
     683@code{@value{DIRPREFIX}task_wake_when}) and
     684timeout timers associated with the task are
    670685automatically deleted, however, other resources dynamically
    671686allocated by the task are NOT automatically returned to RTEMS.
     
    758773floating point context area.  The mode parameter contains values
    759774which sets the task's initial execution mode.  The
    760 @code{@value{RPREFIX}FLOATING_POINT} attribute should be specified if the created task
     775@code{@value{RPREFIX}FLOATING_POINT} attribute should be
     776specified if the created task
    761777is to use a numeric coprocessor.  For performance reasons, it is
    762778recommended that tasks not using the numeric coprocessor should
    763 specify the @code{@value{RPREFIX}NO_FLOATING_POINT} attribute.  If the GLOBAL
     779specify the @code{@value{RPREFIX}NO_FLOATING_POINT} attribute. 
     780If the @code{@value{RPREFIX}GLOBAL}
    764781attribute is specified, the task can be accessed from remote
    765782nodes.  The task id, returned in id, is used in other task
    766783related directives to access the task.  When created, a task is
    767784placed in the dormant state and can only be made ready to
    768 execute using the directive task_start.
     785execute using the directive @code{@value{DIRPREFIX}task_start}.
    769786
    770787@subheading NOTES:
     
    777794target processor.
    778795
    779 The requested stack size should be at least @code{@value{RPREFIX}MINIMUM_STACK_SIZE}
    780 bytes.  The value of @code{@value{RPREFIX}MINIMUM_STACK_SIZE} is processor dependent.
     796The requested stack size should be at least
     797@code{@value{RPREFIX}MINIMUM_STACK_SIZE}
     798bytes.  The value of @code{@value{RPREFIX}MINIMUM_STACK_SIZE}
     799is processor dependent.
    781800Application developers should consider the stack usage of the
    782801device drivers when calculating the stack size required for
     
    923942Any actions performed on a dormant task such as suspension or
    924943change of priority are nullified when the task is initiated via
    925 the task_start directive.
     944the @code{@value{DIRPREFIX}task_start} directive.
    926945
    927946@page
     
    969988argument can be a single value or an index into an array of
    970989parameter blocks.  This new argument may be used to distinguish
    971 between the initial task_start of the task and any ensuing calls
    972 to task_restart of the task.  This can be beneficial in deleting
    973 a task.  Instead of deleting a task using the task_delete
     990between the initial @code{@value{DIRPREFIX}task_start}
     991of the task and any ensuing calls
     992to @code{@value{DIRPREFIX}task_restart}
     993of the task.  This can be beneficial in deleting
     994a task.  Instead of deleting a task using
     995the @code{@value{DIRPREFIX}task_delete}
    974996directive, a task can delete another task by restarting that
    975997task, and allowing that task to release resources back to RTEMS
     
    9841006
    9851007The task must reside on the local node, even if the task was
    986 created with the GLOBAL option.
     1008created with the @code{@value{RPREFIX}GLOBAL} option.
    9871009
    9881010@page
     
    10431065
    10441066The task must reside on the local node, even if the task was
    1045 created with the GLOBAL option.
     1067created with the @code{@value{RPREFIX}GLOBAL} option.
    10461068
    10471069@page
     
    10801102additive to any other blocked state that the task may already be
    10811103in.  The task will not execute again until another task issues
    1082 the task_resume directive for this task and any blocked state
     1104the @code{@value{DIRPREFIX}task_resume}
     1105directive for this task and any blocked state
    10831106has been removed.
    10841107
     
    10931116
    10941117If the task specified by id is already suspended, then the
    1095 ALREADY_SUSPENDED status code is returned.
     1118@code{@value{RPREFIX}ALREADY_SUSPENDED} status code is returned.
    10961119
    10971120@page
     
    11411164
    11421165If the task specified by id is not suspended, then the
    1143 INCORRECT_STATE status code is returned.
     1166@code{@value{RPREFIX}INCORRECT_STATE} status code is returned.
    11441167
    11451168@page
     
    11791202@subheading DESCRIPTION:
    11801203This directive manipulates the priority of the task specified by
    1181 id.  An id of @code{@value{RPREFIX}SELF} is used to indicate the calling task.  When
    1182 new_priority is not equal to CURRENT_PRIORITY, the specified
     1204id.  An id of @code{@value{RPREFIX}SELF} is used to indicate
     1205the calling task.  When new_priority is not equal to
     1206@code{@value{RPREFIX}CURRENT_PRIORITY}, the specified
    11831207task's previous priority is returned in old_priority.  When
    1184 new_priority is CURRENT_PRIORITY, the specified task's current
     1208new_priority is @code{@value{RPREFIX}CURRENT_PRIORITY},
     1209the specified task's current
    11851210priority is returned in old_priority.  Valid priorities range
    11861211from a high of 1 to a low of 255.
     
    12531278
    12541279A task can obtain its current execution mode, without modifying
    1255 it, by calling this directive with a mask value of @code{@value{RPREFIX}CURRENT_MODE}.
     1280it, by calling this directive with a mask value of
     1281@code{@value{RPREFIX}CURRENT_MODE}.
    12561282
    12571283To temporarily disable the processing of a valid ASR, a task
    1258 should call this directive with the NO_ASR indicator specified
    1259 in mode.
     1284should call this directive with the @code{@value{RPREFIX}NO_ASR}
     1285indicator specified in mode.
    12601286
    12611287The set of task mode constants and each mode's corresponding
     
    12641290@ifset use-ascii
    12651291@itemize @bullet
    1266 @item PREEMPT is masked by PREEMPT_MASK and enables preemption
    1267 @item NO_PREEMPT is masked by PREEMPT_MASK and disables preemption
    1268 @item NO_TIMESLICE is masked by TIMESLICE_MASK and disables timeslicing
    1269 @item TIMESLICE is masked by TIMESLICE_MASK and enables timeslicing
    1270 @item ASR is masked by ASR_MASK and enables ASR processing
    1271 @item NO_ASR is masked by ASR_MASK and disables ASR processing
    1272 @item INTERRUPT_LEVEL(0) is masked by INTERRUPT_MASK and enables all interrupts
    1273 @item INTERRUPT_LEVEL(n) is masked by INTERRUPT_MASK and sets interrupts level n
     1292@item @code{@value{RPREFIX}PREEMPT} is masked by
     1293@code{@value{RPREFIX}PREEMPT_MASK} and enables preemption
     1294
     1295@item @code{@value{RPREFIX}NO_PREEMPT} is masked by
     1296@code{@value{RPREFIX}PREEMPT_MASK} and disables preemption
     1297
     1298@item @code{@value{RPREFIX}NO_TIMESLICE} is masked by
     1299@code{@value{RPREFIX}TIMESLICE_MASK} and disables timeslicing
     1300
     1301@item @code{@value{RPREFIX}TIMESLICE} is masked by
     1302@code{@value{RPREFIX}TIMESLICE_MASK} and enables timeslicing
     1303
     1304@item @code{@value{RPREFIX}ASR} is masked by
     1305@code{@value{RPREFIX}ASR_MASK} and enables ASR processing
     1306
     1307@item @code{@value{RPREFIX}NO_ASR} is masked by
     1308@code{@value{RPREFIX}ASR_MASK} and disables ASR processing
     1309
     1310@item @code{@value{RPREFIX}INTERRUPT_LEVEL(0)} is masked by
     1311@code{@value{RPREFIX}INTERRUPT_MASK} and enables all interrupts
     1312
     1313@item @code{@value{RPREFIX}INTERRUPT_LEVEL(n)} is masked by
     1314@code{@value{RPREFIX}INTERRUPT_MASK} and sets interrupts level n
    12741315 
    12751316@end itemize
     
    12801321@c this is temporary
    12811322@itemize @bullet
    1282 @item PREEMPT is masked by PREEMPT_MASK and enables preemption
    1283 @item NO_PREEMPT is masked by PREEMPT_MASK and disables preemption
    1284 @item NO_TIMESLICE is masked by TIMESLICE_MASK and disables timeslicing
    1285 @item TIMESLICE is masked by TIMESLICE_MASK and enables timeslicing
    1286 @item ASR is masked by ASR_MASK and enables ASR processing
    1287 @item NO_ASR is masked by ASR_MASK and disables ASR processing
    1288 @item INTERRUPT_LEVEL(0) is masked by INTERRUPT_MASK and enables all interrupts
    1289 @item INTERRUPT_LEVEL(n) is masked by INTERRUPT_MASK and sets interrupts level n
     1323@item @code{@value{RPREFIX}PREEMPT} is masked by
     1324@code{@value{RPREFIX}PREEMPT_MASK} and enables preemption
     1325
     1326@item @code{@value{RPREFIX}NO_PREEMPT} is masked by
     1327@code{@value{RPREFIX}PREEMPT_MASK} and disables preemption
     1328
     1329@item @code{@value{RPREFIX}NO_TIMESLICE} is masked by
     1330@code{@value{RPREFIX}TIMESLICE_MASK} and disables timeslicing
     1331
     1332@item @code{@value{RPREFIX}TIMESLICE} is masked by
     1333@code{@value{RPREFIX}TIMESLICE_MASK} and enables timeslicing
     1334
     1335@item @code{@value{RPREFIX}ASR} is masked by
     1336@code{@value{RPREFIX}ASR_MASK} and enables ASR processing
     1337
     1338@item @code{@value{RPREFIX}NO_ASR} is masked by
     1339@code{@value{RPREFIX}ASR_MASK} and disables ASR processing
     1340
     1341@item @code{@value{RPREFIX}INTERRUPT_LEVEL(0)} is masked by
     1342@code{@value{RPREFIX}INTERRUPT_MASK} and enables all interrupts
     1343
     1344@item @code{@value{RPREFIX}INTERRUPT_LEVEL(n)} is masked by
     1345@code{@value{RPREFIX}INTERRUPT_MASK} and sets interrupts level n
    12901346 
    12911347@end itemize
     
    13021358    <TD ALIGN=center><STRONG>Mask Constant</STRONG></TD>
    13031359    <TD ALIGN=center><STRONG>Description</STRONG></TD></TR>
    1304 <TR><TD ALIGN=center>PREEMPT</TD>
    1305     <TD ALIGN=center>PREEMPT_MASK</TD>
     1360<TR><TD ALIGN=center>@value{RPREFIX}PREEMPT</TD>
     1361    <TD ALIGN=center>@value{RPREFIX}PREEMPT_MASK</TD>
    13061362    <TD ALIGN=center>enables preemption</TD></TR>
    1307 <TR><TD ALIGN=center>NO_PREEMPT</TD>
    1308     <TD ALIGN=center>PREEMPT_MASK</TD>
     1363<TR><TD ALIGN=center>@value{RPREFIX}NO_PREEMPT</TD>
     1364    <TD ALIGN=center>@value{RPREFIX}PREEMPT_MASK</TD>
    13091365    <TD ALIGN=center>disables preemption</TD></TR>
    1310 <TR><TD ALIGN=center>NO_TIMESLICE</TD>
    1311     <TD ALIGN=center>TIMESLICE_MASK</TD>
     1366<TR><TD ALIGN=center>@value{RPREFIX}NO_TIMESLICE</TD>
     1367    <TD ALIGN=center>@value{RPREFIX}TIMESLICE_MASK</TD>
    13121368    <TD ALIGN=center>disables timeslicing</TD></TR>
    1313 <TR><TD ALIGN=center>TIMESLICE</TD>
    1314     <TD ALIGN=center>TIMESLICE_MASK</TD>
     1369<TR><TD ALIGN=center>@value{RPREFIX}TIMESLICE</TD>
     1370    <TD ALIGN=center>@value{RPREFIX}TIMESLICE_MASK</TD>
    13151371    <TD ALIGN=center>enables timeslicing</TD></TR>
    1316 <TR><TD ALIGN=center>ASR</TD>
    1317     <TD ALIGN=center>ASR_MASK</TD>
     1372<TR><TD ALIGN=center>@value{RPREFIX}ASR</TD>
     1373    <TD ALIGN=center>@value{RPREFIX}ASR_MASK</TD>
    13181374    <TD ALIGN=center>enables ASR processing</TD></TR>
    1319 <TR><TD ALIGN=center>NO_ASR</TD>
    1320     <TD ALIGN=center>ASR_MASK</TD>
     1375<TR><TD ALIGN=center>@value{RPREFIX}NO_ASR</TD>
     1376    <TD ALIGN=center>@value{RPREFIX}ASR_MASK</TD>
    13211377    <TD ALIGN=center>disables ASR processing</TD></TR>
    1322 <TR><TD ALIGN=center>INTERRUPT_LEVEL(0)</TD>
    1323     <TD ALIGN=center>INTERRUPT_MASK</TD>
     1378<TR><TD ALIGN=center>@value{RPREFIX}INTERRUPT_LEVEL(0)</TD>
     1379    <TD ALIGN=center>@value{RPREFIX}INTERRUPT_MASK</TD>
    13241380    <TD ALIGN=center>enables all interrupts</TD></TR>
    1325 <TR><TD ALIGN=center>INTERRUPT_LEVEL(n)</TD>
    1326     <TD ALIGN=center>INTERRUPT_MASK</TD>
     1381<TR><TD ALIGN=center>@value{RPREFIX}INTERRUPT_LEVEL(n)</TD>
     1382    <TD ALIGN=center>@value{RPREFIX}INTERRUPT_MASK</TD>
    13271383    <TD ALIGN=center>sets interrupts level n</TD></TR>
    13281384  </TABLE>
     
    13721428This directive will not cause the running task to be preempted.
    13731429
    1374 If id is set to @code{@value{RPREFIX}SELF}, the calling task accesses its own notepad.
     1430If id is set to @code{@value{RPREFIX}SELF},
     1431the calling task accesses its own notepad.
    13751432
    13761433@c This version of the paragraph avoids the overfull hbox error.
     
    14241481
    14251482@subheading NOTES:
    1426 If id is set to @code{@value{RPREFIX}SELF}, the calling task accesses its own notepad
    1427 locations.
     1483If id is set to @code{@value{RPREFIX}SELF}, the calling
     1484task accesses its own notepad locations.
    14281485
    14291486This directive will not cause the running task to be preempted.
     
    14711528This directive blocks the calling task for the specified number
    14721529of system clock ticks.  When the requested interval has elapsed,
    1473 the task is made ready.  The clock_tick directive automatically
    1474 updates the delay period.
     1530the task is made ready.  The @code{@value{DIRPREFIX}clock_tick}
     1531directive automatically updates the delay period.
    14751532
    14761533@subheading NOTES:
    1477 Setting the system date and time with the clock_set directive
    1478 has no effect on a task_wake_after blocked task.
     1534Setting the system date and time with the
     1535@code{@value{DIRPREFIX}clock_set} directive
     1536has no effect on a @code{@value{DIRPREFIX}task_wake_after} blocked task.
    14791537
    14801538A task may give up the processor and remain in the ready state
  • doc/user/timer.t

    r3973e40 r75e22db  
    6666application to schedule operations to occur at specific times in
    6767the future.  User supplied timer service routines are invoked by
    68 the clock_tick directive when the timer fires.  Timer service
    69 routines may perform any operations or directives which normally
     68the @code{@value{DIRPREFIX}clock_tick} directive
     69when the timer fires.  Timer service routines may perform
     70any operations or directives which normally
    7071would be performed by the application code which invoked the
    71 clock_tick directive.
     72@code{@value{DIRPREFIX}clock_tick} directive.
    7273
    7374The timer can be used to implement watchdog routines
     
    132133@subsection Creating a Timer
    133134
    134 The timer_create directive creates a timer by
     135The @code{@value{DIRPREFIX}timer_create} directive creates a timer by
    135136allocating a Timer Control Block (TMCB), assigning the timer a
    136137user-specified name, and assigning it a timer ID.  Newly created
     
    146147timer ID and assigns it to the created timer until it is
    147148deleted.  The timer ID may be obtained by either of two methods.
    148 First, as the result of an invocation of the timer_create
     149First, as the result of an invocation of the
     150@code{@value{DIRPREFIX}timer_create}
    149151directive, the timer ID is stored in a user provided location.
    150 Second, the timer ID may be obtained later using the timer_ident
    151 directive.  The timer ID is used by other directives to
    152 manipulate this timer.
     152Second, the timer ID may be obtained later using the
     153@code{@value{DIRPREFIX}timer_ident} directive.  The timer ID
     154is used by other directives to manipulate this timer.
    153155
    154156@ifinfo
     
    157159@subsection Initiating an Interval Timer
    158160
    159 The timer_fire_after directive initiates a timer to
     161The @code{@value{DIRPREFIX}timer_fire_after} directive initiates a timer to
    160162fire a user provided timer service routine after the specified
    161163number of clock ticks have elapsed.  When the interval has
    162164elapsed, the timer service routine will be invoked from the
    163 clock_tick directive.
     165@code{@value{DIRPREFIX}clock_tick} directive.
    164166
    165167@ifinfo
     
    168170@subsection Initiating a Time of Day Timer
    169171
    170 The timer_fire_when directive initiates a timer to
     172The @code{@value{DIRPREFIX}timer_fire_when} directive initiates a timer to
    171173fire a user provided timer service routine when the specified
    172174time of day has been reached.  When the interval has elapsed,
    173 the timer service routine will be invoked from the clock_tick
    174 directive.
     175the timer service routine will be invoked from the
     176@code{@value{DIRPREFIX}clock_tick} directive.
    175177
    176178@ifinfo
     
    179181@subsection Canceling a Timer
    180182
    181 The timer_cancel directive is used to halt the
     183The @code{@value{DIRPREFIX}timer_cancel} directive is used to halt the
    182184specified timer.  Once canceled, the timer service routine will
    183185not fire unless the timer is reinitiated.  The timer can be
    184 reinitiated using the timer_reset, timer_fire_after, and
    185 timer_fire_when directives.
     186reinitiated using the @code{@value{DIRPREFIX}timer_reset},
     187@code{@value{DIRPREFIX}timer_fire_after}, and
     188@code{@value{DIRPREFIX}timer_fire_when} directives.
    186189
    187190@ifinfo
     
    190193@subsection Resetting a Timer
    191194
    192 The timer_reset directive is used to restore an
     195The @code{@value{DIRPREFIX}timer_reset} directive is used to restore an
    193196interval timer initiated by a previous invocation of
    194 timer_fire_after to its original interval length.  If the
     197@code{@value{DIRPREFIX}timer_fire_after} to
     198its original interval length.  If the
    195199timer has not been used or the last usage of this timer
    196 was by a timer_fire_when directive, then an error is
     200was by a @code{@value{DIRPREFIX}timer_fire_when} directive, then an error is
    197201returned.  The timer service routine is not changed or
    198202fired by this directive.
     
    203207@subsection Deleting a Timer
    204208
    205 The timer_delete directive is used to delete a timer.
     209The @code{@value{DIRPREFIX}timer_delete} directive is used to delete a timer.
    206210If the timer is running and has not expired, the timer is
    207211automatically canceled.  The timer's control block is returned
     
    353357
    354358This directive cancels the timer id.  This timer will
    355 be reinitiated by the next invocation of timer_reset,
    356 timer_fire_after, or timer_fire_when with id.
     359be reinitiated by the next invocation of @code{@value{DIRPREFIX}timer_reset},
     360@code{@value{DIRPREFIX}timer_fire_after}, or
     361@code{@value{DIRPREFIX}timer_fire_when} with id.
    357362
    358363@subheading NOTES:
     
    538543This directive resets the timer associated with id.
    539544This timer must have been previously initiated with a
    540 timer_fire_after directive.  If active the timer is canceled,
     545@code{@value{DIRPREFIX}timer_fire_after}
     546directive.  If active the timer is canceled,
    541547after which the timer is reinitiated using the same interval and
    542 timer service routine which the original timer_fire_after
     548timer service routine which the original
     549@code{@value{DIRPREFIX}timer_fire_after}
    543550directive used.
    544551
     
    546553
    547554If the timer has not been used or the last usage of this timer
    548 was by a timer_fire_when directive, then the NOT_DEFINED error is
     555was by a @code{@value{DIRPREFIX}timer_fire_when}
     556directive, then the @code{@value{RPREFIX}NOT_DEFINED} error is
    549557returned.
    550558
  • doc/user/userext.t

    r3973e40 r75e22db  
    139139
    140140Second, the user can install dynamic extensions using
    141 the extension_create directive.  These extensions are RTEMS
     141the @code{@value{DIRPREFIX}extension_create}
     142directive.  These extensions are RTEMS
    142143objects in that they have a name, an ID, and can be dynamically
    143144created and deleted.  In contrast to the static extension set,
     
    608609@subsection Creating an Extension Set
    609610
    610 The extension_create directive creates and installs
     611The @code{@value{DIRPREFIX}extension_create} directive creates and installs
    611612an extension set by allocating a Extension Set Control Block
    612613(ESCB), assigning the extension set a user-specified name, and
     
    624625set until it is deleted.  The extension ID may be obtained by
    625626either of two methods.  First, as the result of an invocation of
    626 the extension_create directive, the extension set ID is stored
     627the @code{@value{DIRPREFIX}extension_create}
     628directive, the extension set ID is stored
    627629in a user provided location.  Second, the extension set ID may
    628 be obtained later using the extension_ident directive.  The
    629 extension set ID is used by other directives to manipulate this
    630 extension set.
     630be obtained later using the @code{@value{DIRPREFIX}extension_ident}
     631directive.  The extension set ID is used by other directives
     632to manipulate this extension set.
    631633
    632634@ifinfo
     
    635637@subsection Deleting an Extension Set
    636638
    637 The extension_delete directive is used to delete an
     639The @code{@value{DIRPREFIX}extension_delete} directive is used to delete an
    638640extension set.  The extension set's control block is returned to
    639641the ESCB free list when it is deleted.  An extension set can be
Note: See TracChangeset for help on using the changeset viewer.