Changeset d389819 in rtems-docs


Ignore:
Timestamp:
Jan 18, 2016, 5:37:40 AM (3 years ago)
Author:
Amar Takhar <amar@…>
Branches:
4.11, master
Children:
f916fca
Parents:
11e1a6f
git-author:
Amar Takhar <amar@…> (01/18/16 05:37:40)
git-committer:
Amar Takhar <verm@…> (05/03/16 00:51:24)
Message:

Convert all Unicode to ASCII(128)

Files:
121 edited

Legend:

Unmodified
Added
Removed
  • bsp_howto/analog.rst

    r11e1a6f rd389819  
    7272==========================
    7373
    74 At system initialization, the analog driver’s initialization entry point
     74At system initialization, the analog driver's initialization entry point
    7575will be invoked.  As part of initialization, the driver will perform
    7676whatever board initialization is required and then set all
  • bsp_howto/ata.rst

    r11e1a6f rd389819  
    102102ATA driver supports separate ATA requests queues for each IDE
    103103controller (one queue per controller). The following structure contains
    104 information about controller’s queue and devices attached to the controller:
     104information about controller's queue and devices attached to the controller:
    105105.. code:: c
    106106
     
    154154ATA request which is appended to the appropriate controller queue depending
    155155on ATA device the request belongs to. If appended request is single request in
    156 the controller’s queue then ATA driver event is generated.
     156the controller's queue then ATA driver event is generated.
    157157
    158158ATA driver task which manages queue of ATA driver events is core of ATA
  • bsp_howto/clock.rst

    r11e1a6f rd389819  
    99
    1010- A steady time basis to the kernel, so that the RTEMS primitives that need
    11   a clock tick work properly.  See the *Clock Manager* chapter of the*RTEMS Application C User’s Guide* for more details.
     11  a clock tick work properly.  See the *Clock Manager* chapter of the*RTEMS Application C User's Guide* for more details.
    1212
    1313- An optional time counter to generate timestamps of the uptime and wall
  • bsp_howto/console.rst

    r11e1a6f rd389819  
    3737Having RTEMS support for Termios is beneficial because:
    3838
    39 - from the user’s side because it provides standard primitive operations
     39- from the user's side because it provides standard primitive operations
    4040  to access the terminal and change configuration settings.  These operations
    4141  are the same under UNIX and RTEMS.
    4242
    43 - from the BSP developer’s side because it frees the
     43- from the BSP developer's side because it frees the
    4444  developer from dealing with buffer states and mutual exclusions on them.
    4545  Early RTEMS console device drivers also did their own special
  • bsp_howto/discrete.rst

    r11e1a6f rd389819  
    7777    is an array of the values that should be written to each output
    7878    word on the board during initialization.  This allows the driver
    79     to start with the board’s output  in a known state.
     79    to start with the board's output  in a known state.
    8080
    8181Initialize a Discrete I/O Board
    8282===============================
    8383
    84 At system initialization, the discrete I/O driver’s initialization entry point
     84At system initialization, the discrete I/O driver's initialization entry point
    8585will be invoked.  As part of initialization, the driver will perform
    8686whatever board initializatin is required and then set all
  • bsp_howto/index.rst

    r11e1a6f rd389819  
    33=======================================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • bsp_howto/initilization_code.rst

    r11e1a6f rd389819  
    55============
    66
    7 The initialization code is the first piece of code executed when there’s a
     7The initialization code is the first piece of code executed when there's a
    88reset/reboot. Its purpose is to initialize the board for the application.
    99This chapter contains a narrative description of the initialization
     
    179179  entered, any C++ Global Constructors will be invoked.
    180180
    181 That’s it.  We just went through the entire sequence.
     181That's it.  We just went through the entire sequence.
    182182
    183183bsp_work_area_initialize() - BSP Specific Work Area Initialization
     
    228228defines device drivers entry points (initialization, open, close, read,
    229229write, and control). For more information about this table, please
    230 refer to the *Configuring a System* chapter in the*RTEMS Application C User’s Guide*.
     230refer to the *Configuring a System* chapter in the*RTEMS Application C User's Guide*.
    231231
    232232The RTEMS initialization procedure calls the initialization function for
     
    290290At ``__uhoh`` label is the default interrupt handler routine. This
    291291routine is only called when an unexpected interrupts is raised.  One can
    292 add their own routine there (in that case there’s a call to a routine -
     292add their own routine there (in that case there's a call to a routine -
    293293$BSP_ROOT/startup/dumpanic.c - that prints which address caused the
    294294interrupt and the contents of the registers, stack, etc.), but this should
     
    326326with multiple peripherals on the CPU itself.  For these devices,
    327327there are always some specific integrated processor registers
    328 that must be initialized.  Refer to the processors’ manuals for
     328that must be initialized.  Refer to the processors' manuals for
    329329details on these registers and be VERY careful programming them.
    330330
     
    349349The RTEMS configuration table contains the maximum number of objects RTEMS
    350350can handle during the application (e.g. maximum number of tasks,
    351 semaphores, etc.). It’s used to allocate the size for the RTEMS inner data
     351semaphores, etc.). It's used to allocate the size for the RTEMS inner data
    352352structures.
    353353
     
    368368information generated by ``<rtems/confdefs.h>`` constant and read only.
    369369
    370 For more information on the RTEMS Configuration Table, refer to the*RTEMS Application C User’s Guide*.
     370For more information on the RTEMS Configuration Table, refer to the*RTEMS Application C User's Guide*.
    371371
    372372.. COMMENT: COPYRIGHT (c) 1988-2008.
  • bsp_howto/linker_script.rst

    r11e1a6f rd389819  
    3535
    3636Even though RAM and ROM can be found in every personal computer,
    37 one generally doesn’t care about them.  In a personal computer,
     37one generally doesn't care about them.  In a personal computer,
    3838a program is nearly always stored on disk and executed in RAM.  Things
    3939are a bit different for embedded targets: the target will execute the
     
    5050
    5151- *code (``.text``) section*:
    52   is the program’s code and it should not be modified.
     52  is the program's code and it should not be modified.
    5353  This section may be placed in ROM.
    5454
     
    5858- *initialized data (``.data``) section*:
    5959  holds the initialized program data which may be modified during the
    60   program’s life.  This means they have to be in RAM.
     60  program's life.  This means they have to be in RAM.
    6161  On the other hand, these variables must be set to predefined values, and
    6262  those predefined values have to be stored in ROM.
     
    301301================
    302302
    303 Now there’s a problem with the initialized data: the ``.data`` section
     303Now there's a problem with the initialized data: the ``.data`` section
    304304has to be in RAM as this data may be modified during the program execution.
    305305But how will the values be initialized at boot time?
     
    355355
    356356Step 3 shows the final executable image as it logically appears in
    357 the target’s non-volatile program memory.  The board initialization
     357the target's non-volatile program memory.  The board initialization
    358358code will copy the ""copy of ``.data`` section" (which are stored in
    359359ROM) to their reserved location in RAM.
  • bsp_howto/makefiles.rst

    r11e1a6f rd389819  
    148148configuration file is ``make/custom/BSP.cfg``.
    149149
    150 The configuration file is taken into account when building one’s
     150The configuration file is taken into account when building one's
    151151application using the RTEMS template Makefiles (``make/templates``).
    152152These application template Makefiles have been included with the
    153 RTEMS source distribution since the early 1990’s.  However there is
     153RTEMS source distribution since the early 1990's.  However there is
    154154a desire in the RTEMS user community to move all provided examples to
    155155GNU autoconf. They are included in the 4.9 release series and used for
  • bsp_howto/miscellanous_support.rst

    r11e1a6f rd389819  
    115115All members of the Timing Test Suite are designed to run *WITHOUT*
    116116the Clock Device Driver installed.  This increases the predictability
    117 of the tests’ execution as well as avoids occassionally including the
     117of the tests' execution as well as avoids occassionally including the
    118118overhead of a clock tick interrupt in the time reported.  Because of
    119119this it is sometimes possible to use the clock tick interrupt source
  • bsp_howto/networking.rst

    r11e1a6f rd389819  
    77This chapter is intended to provide an introduction to the
    88procedure for writing RTEMS network device drivers.
    9 The example code is taken from the ‘Generic 68360’ network device
     9The example code is taken from the 'Generic 68360' network device
    1010driver.  The source code for this driver is located in the``c/src/lib/libbsp/m68k/gen68360/network`` directory in the RTEMS
    1111source code distribution.  Having a copy of this driver at
     
    1616
    1717Before starting to write the network driver become completely
    18 familiar with the programmer’s view of the device.
     18familiar with the programmer's view of the device.
    1919The following points list some of the details of the
    2020device that must be understood before a driver can be written.
     
    7171execute only when they hold the network semaphore (``rtems_bsdnet_semaphore``).
    7272The transmit and receive tasks must abide by this protocol.  Be very
    73 careful to avoid ‘deadly embraces’ with the other network tasks.
     73careful to avoid 'deadly embraces' with the other network tasks.
    7474A number of routines are provided to make it easier for the network
    7575driver code to conform to the network task scheduling conventions.
     
    162162``ifp->if_unit``
    163163    The device number.  The network stack uses this number and the
    164     device name for device name lookups.  For example, if``ifp->if_name`` is ‘``scc``’ and ``ifp->if_unit`` is ‘``1``’,
    165     the full device name would be ‘``scc1``’.  The unit number should be
    166     obtained from the ‘name’ entry in the configuration structure.
     164    device name for device name lookups.  For example, if``ifp->if_name`` is '``scc``' and ``ifp->if_unit`` is '``1``',
     165    the full device name would be '``scc1``'.  The unit number should be
     166    obtained from the 'name' entry in the configuration structure.
    167167
    168168``ifp->if_mtu``
     
    213213calling ``if_attach``.  Ethernet devices should then
    214214call ``ether_ifattach``.  Both functions take a pointer to the
    215 device’s ``ifnet`` structure as their only argument.
     215device's ``ifnet`` structure as their only argument.
    216216
    217217The attach function should return a non-zero value to indicate that
     
    223223This function is called each time the network stack wants to start the
    224224transmitter.  This occures whenever the network stack adds a packet
    225 to a device’s send queue and the ``IFF_OACTIVE`` bit in the
    226 device’s ``if_flags`` is not set.
     225to a device's send queue and the ``IFF_OACTIVE`` bit in the
     226device's ``if_flags`` is not set.
    227227
    228228For many devices this function need only set the ``IFF_OACTIVE`` bit in the``if_flags`` and send an event to the transmit task
  • bsp_howto/non_volatile_memory.rst

    r11e1a6f rd389819  
    128128=========================================
    129129
    130 At system initialization, the non-volatile memory driver’s
     130At system initialization, the non-volatile memory driver's
    131131initialization entry point will be invoked.  As part of
    132132initialization, the driver will perform
     
    141141===============================
    142142
    143 Depending on the target’s non-volatile memory configuration, it may be
     143Depending on the target's non-volatile memory configuration, it may be
    144144possible to write to a status register and make the memory area completely
    145145inaccessible.  This is target dependent and beyond the standard capabilities
  • bsp_howto/real_time_clock.rst

    r11e1a6f rd389819  
    3434of real-time clock is on a particular board.  This would be useful for
    3535a BSP supporting multiple board models.  The relevant ports of
    36 the DMV177’s ``RTC_Table`` configuration table is below:
     36the DMV177's ``RTC_Table`` configuration table is below:
    3737.. code:: c
    3838
     
    105105This configuration scheme allows one to support multiple versions
    106106of the same board with a single BSP.  For example, if the first
    107 generation of a board had Vendor A’s RTC chip and the second
    108 generation had Vendor B’s RTC chip, RTC_Table could contain
     107generation of a board had Vendor A's RTC chip and the second
     108generation had Vendor B's RTC chip, RTC_Table could contain
    109109information for both.  The ``deviceProbe`` configured
    110 for Vendor A’s RTC chip would need to return TRUE if the
     110for Vendor A's RTC chip would need to return TRUE if the
    111111board was a first generation one.  The ``deviceProbe``
    112112routines are very board dependent and must be provided by
  • bsp_howto/shared_memory_support.rst

    r11e1a6f rd389819  
    1212information on RTEMS multiprocessing capabilities and the
    1313MPCI, refer to the *Multiprocessing Manager* chapter
    14 of the *RTEMS Application C User’s Guide*.
     14of the *RTEMS Application C User's Guide*.
    1515
    1616Shared Memory Configuration Table
     
    9696window onto the shared memory.  For example, some VMEbus boards have
    9797special address windows to access addresses that are normally reserved
    98 in the CPU’s address space.
     98in the CPU's address space.
    9999.. code:: c
    100100
  • bsp_howto/target_dependant_files.rst

    r11e1a6f rd389819  
    3232The source code found in the ``cpukit/score/cpu`` is required to
    3333only depend upon the CPU model variations that GCC distinguishes
    34 for the purposes of multilib’ing.  Multilib is the term the GNU
     34for the purposes of multilib'ing.  Multilib is the term the GNU
    3535community uses to refer to building a single library source multiple
    3636times with different compiler options so the binary code generated
    37 is compatible.  As an example, from GCC’s perspective, many PowerPC
     37is compatible.  As an example, from GCC's perspective, many PowerPC
    3838CPU models are just a PPC603e.  Remember that GCC only cares about
    3939the CPU code itself and need not be aware of any peripherals.  In
     
    8787- Does a BSP for a similar board exists?
    8888
    89 - Is the board’s CPU supported?
     89- Is the board's CPU supported?
    9090
    9191If there is already a BSP for the board, then things may already be ready
     
    9393that the existing BSP provides device drivers for all the peripherals
    9494on the board that the application will be using.  For example, the application
    95 in question may require that the board’s Ethernet controller be used and
     95in question may require that the board's Ethernet controller be used and
    9696the existing BSP may not support this.
    9797
    98 If the BSP does not exist and the board’s CPU model is supported, then
     98If the BSP does not exist and the board's CPU model is supported, then
    9999examine the reusable chip library and existing BSPs for a close match.
    100100Other BSPs and libchip provide starting points for the development
     
    104104This will help reduce the development effort required.
    105105
    106 If the board’s CPU family is supported but the particular CPU model on
     106If the board's CPU family is supported but the particular CPU model on
    107107that board is not, then the RTEMS port to that CPU family will have to
    108108be augmented.  After this is done, development of the new BSP can proceed.
     
    180180
    181181- *clock*:
    182   support for the clock tick – a regular time basis to the kernel.
     182  support for the clock tick - a regular time basis to the kernel.
    183183
    184184- *timer*:
  • bsp_howto/timer.rst

    r11e1a6f rd389819  
    8484input FIFO full mode (FIFO means First In First Out and roughly means
    8585buffer). This mode consists in the UART raising an interrupt when n
    86 characters have been received (*n* is the UART’s FIFO length). It results
     86characters have been received (*n* is the UART's FIFO length). It results
    8787in a lower interrupt processing time, but the problem is that a scanf
    8888primitive will block on a receipt of less than *n* characters. The solution
    8989is to set a timer that will check whether there are some characters
    90 waiting in the UART’s input FIFO. The delay time has to be set carefully
     90waiting in the UART's input FIFO. The delay time has to be set carefully
    9191otherwise high rates will be broken:
    9292
  • c_user/barrier_manager.rst

    r11e1a6f rd389819  
    127127
    128128When the task does wait to acquire the barrier, then it
    129 is placed in the barrier’s task wait queue in FIFO order.
     129is placed in the barrier's task wait queue in FIFO order.
    130130All tasks waiting on a barrier are returned an error
    131131code when the barrier is deleted.
     
    144144The ``rtems_barrier_delete`` directive removes a barrier
    145145from the system and frees its control block.  A barrier can be
    146 deleted by any local task that knows the barrier’s ID.  As a
     146deleted by any local task that knows the barrier's ID.  As a
    147147result of this directive, all tasks blocked waiting for the
    148148barrier to be released, will be readied and returned a status code which
    149149indicates that the barrier was deleted.  Any subsequent
    150 references to the barrier’s name and ID are invalid.
     150references to the barrier's name and ID are invalid.
    151151
    152152Directives
    153153==========
    154154
    155 This section details the barrier manager’s
    156 directives.  A subsection is dedicated to each of this manager’s
     155This section details the barrier manager's
     156directives.  A subsection is dedicated to each of this manager's
    157157directives and describes the calling sequence, related
    158158constants, usage, and status codes.
     
    180180``RTEMS_INVALID_NAME`` - invalid barrier name
    181181``RTEMS_INVALID_ADDRESS`` - ``id`` is NULL
    182 ``RTEMS_TOO_MANY`` - too many barriers created 
     182``RTEMS_TOO_MANY`` - too many barriers created
    183183
    184184**DESCRIPTION:**
     
    269269
    270270``RTEMS_SUCCESSFUL`` - barrier deleted successfully
    271 ``RTEMS_INVALID_ID`` - invalid barrier id 
     271``RTEMS_INVALID_ID`` -c invalid barrier id
    272272
    273273**DESCRIPTION:**
     
    282282
    283283The calling task will be preempted if it is enabled
    284 by the task’s execution mode and a higher priority local task is
     284by the task's execution mode and a higher priority local task is
    285285waiting on the deleted barrier.  The calling task will NOT be
    286286preempted if all of the tasks that are waiting on the barrier
     
    379379This directive releases the barrier specified by id.
    380380All tasks waiting at the barrier will be unblocked.
    381 If the running task’s preemption mode is enabled and one of
     381If the running task's preemption mode is enabled and one of
    382382the unblocked tasks has a higher priority than the running task.
    383383
  • c_user/board_support_packages.rst

    r11e1a6f rd389819  
    4141not involve calls to RTEMS directives.
    4242
    43 The processor’s Interrupt Vector Table which will be used by the
     43The processor's Interrupt Vector Table which will be used by the
    4444application may need to be set to the required value by the reset
    4545application initialization code.  Because interrupts are enabled
    4646automatically by RTEMS as part of the context switch to the first task,
    4747the Interrupt Vector Table MUST be set before this directive is invoked
    48 to ensure correct interrupt vectoring.  The processor’s Interrupt Vector
     48to ensure correct interrupt vectoring.  The processor's Interrupt Vector
    4949Table must be accessible by RTEMS as it will be modified by the when
    5050installing user Interrupt Service Routines (ISRs) On some CPUs, RTEMS
    51 installs it’s own Interrupt Vector Table as part of initialization and
     51installs it's own Interrupt Vector Table as part of initialization and
    5252thus these requirements are met automatically.  The reset code which is
    5353executed before the call to any RTEMS initialization routines has the
     
    6767  that allocated.
    6868
    69 - Must initialize the processor’s Interrupt Vector Table.
     69- Must initialize the processor's Interrupt Vector Table.
    7070
    7171- Must disable all maskable interrupts.
     
    9292stack usage must account for the following requirements:
    9393
    94 - Processor’s interrupt stack frame
    95 
    96 - Processor’s subroutine call stack frame
     94- Processor's interrupt stack frame
     95
     96- Processor's subroutine call stack frame
    9797
    9898- RTEMS system calls
     
    116116The dedicated interrupt stack for the entire application on some
    117117architectures is supplied and initialized by the reset and initialization
    118 code of the user’s Board Support Package.  Whether allocated and
     118code of the user's Board Support Package.  Whether allocated and
    119119initialized by the BSP or RTEMS, since all ISRs use this stack, the
    120120stack size must take into account the worst case stack usage by any
     
    125125
    126126Some processors do not support a separate stack for interrupts.  In this
    127 case, without special assistance every task’s stack must include
    128 enough space to handle the task’s worst-case stack usage as well as
     127case, without special assistance every task's stack must include
     128enough space to handle the task's worst-case stack usage as well as
    129129the worst-case interrupt stack usage.  This is necessary because the
    130130worst-case interrupt nesting could occur while any task is executing.
  • c_user/chains.rst

    r11e1a6f rd389819  
    2424- ``rtems_chain_is_null_node`` - Is the node NULL ?
    2525
    26 - ``rtems_chain_head`` - Return the chain’s head
    27 
    28 - ``rtems_chain_tail`` - Return the chain’s tail
    29 
    30 - ``rtems_chain_are_nodes_equal`` - Are the node’s equal ?
     26- ``rtems_chain_head`` - Return the chain's head
     27
     28- ``rtems_chain_tail`` - Return the chain's tail
     29
     30- ``rtems_chain_are_nodes_equal`` - Are the node's equal ?
    3131
    3232- ``rtems_chain_is_empty`` - Is the chain empty ?
     
    107107    }
    108108
    109 The node is placed at the start of the user’s structure to allow the
    110 node address on the chain to be easly cast to the user’s structure
     109The node is placed at the start of the user's structure to allow the
     110node address on the chain to be easly cast to the user's structure
    111111address.
    112112
  • c_user/clock_manager.rst

    r11e1a6f rd389819  
    104104is known as the quantum or timeslice.
    105105
    106 The system’s timeslice is defined as an integral
     106The system's timeslice is defined as an integral
    107107number of ticks, and is specified in the Configuration Table.
    108108The timeslice is defined for the entire system of tasks, but
     
    111111The ``rtems_clock_tick``
    112112directive implements timeslicing by
    113 decrementing the running task’s time-remaining counter when both
    114 timeslicing and preemption are enabled.  If the task’s timeslice
     113decrementing the running task's time-remaining counter when both
     114timeslicing and preemption are enabled.  If the task's timeslice
    115115has expired, then that task will be preempted if there exists a
    116116ready task of equal priority.
     
    144144
    145145RTEMS provides the ``rtems_clock_tick`` directive which is
    146 called from the user’s real-time clock ISR to inform RTEMS that
     146called from the user's real-time clock ISR to inform RTEMS that
    147147a tick has elapsed.  The tick frequency value, defined in
    148148microseconds, is a configuration parameter found in the
     
    204204==========
    205205
    206 This section details the clock manager’s directives.
    207 A subsection is dedicated to each of this manager’s directives
     206This section details the clock manager's directives.
     207A subsection is dedicated to each of this manager's directives
    208208and describes the calling sequence, related constants, usage,
    209209and status codes.
  • c_user/configuring_a_system.rst

    r11e1a6f rd389819  
    104104one version of RTEMS and from one target processor to another.
    105105Therefore it is safest to use ``<rtems/confdefs.h>`` and specify
    106 your application’s requirements in terms of the numbers of objects and
     106your application's requirements in terms of the numbers of objects and
    107107multiples of ``RTEMS_MINIMUM_STACK_SIZE``, as far as is possible. The
    108108automatic estimates of space required will in general change when:
     
    159159
    160160- MACRO NAME
    161   Should be alphanumeric. Can have ’_’ (underscore).
     161  Should be alphanumeric. Can have '_' (underscore).
    162162
    163163- DATA TYPE
     
    168168  The range depends on the Data Type of the macro.
    169169
    170   - − If the data type is of type task priority, then its value should
     170  - - If the data type is of type task priority, then its value should
    171171    be an integer in the range of 1 to 255.
    172   - − If the data type is an integer, then it can have numbers, characters
     172  - - If the data type is an integer, then it can have numbers, characters
    173173    (in case the value is defined using another macro) and arithmetic operations
    174174    (+, -, \*, /).
    175   - − If the data type is a function pointer the first character
     175  - - If the data type is a function pointer the first character
    176176    should be an alphabet or an underscore. The rest of the string
    177177    can be alphanumeric.
    178   - − If the data type is RTEMS Attributes or RTEMS Mode then
     178  - - If the data type is RTEMS Attributes or RTEMS Mode then
    179179    the string should be alphanumeric.
    180   - − If the data type is RTEMS NAME then the value should be
    181     an integer>=0 or RTEMS_BUILD_NAME( ’U’, ’I’, ’1’, ’ ’ )
     180  - - If the data type is RTEMS NAME then the value should be
     181    an integer>=0 or RTEMS_BUILD_NAME( 'U', 'I', '1', ' ' )
    182182
    183183- DEFAULT VALUE
    184184
    185185  The default value should be in the following formats-
    186   Please note that the ’.’ (full stop) is necessary.
    187 
    188   - − In case the value is not defined then:
     186  Please note that the '.' (full stop) is necessary.
     187
     188  - - In case the value is not defined then:
    189189    This is not defined by default.
    190   - − If we know the default value then:
     190  - - If we know the default value then:
    191191    The default value is XXX.
    192   - − If the default value is BSP Specific then:
     192  - - If the default value is BSP Specific then:
    193193    This option is BSP specific.
    194194
     
    20682068---------------------------------------------------------------
    20692069.. index:: CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE
    2070 .. index:: memory for a single message queue’s buffers
     2070.. index:: memory for a single message queue's buffers
    20712071
    20722072*CONSTANT:*
     
    43454345
    43464346``CONFIGURE_APPLICATION_NEEDS_FRAME_BUFFER_DRIVER`` is defined
    4347 if the application wishes to include the BSP’s Frame Buffer Device Driver.
     4347if the application wishes to include the BSP's Frame Buffer Device Driver.
    43484348
    43494349**NOTES:**
  • c_user/constant_bandwidth_server.rst

    r11e1a6f rd389819  
    7373.. index:: CBS periodic tasks
    7474
    75 Each task’s execution begins with a default background priority
     75Each task's execution begins with a default background priority
    7676(see the chapter Scheduling Concepts to understand the concept of
    7777priorities in EDF). Once you decide the tasks should start periodic
     
    147147
    148148If a task is attached to a server using ``rtems_cbs_attach_thread``,
    149 the task’s computation time per period is limited by the server and
     149the task's computation time per period is limited by the server and
    150150the deadline (period) of task is equal to deadline of the server which
    151151means if you conclude a period using ``rate_monotonic_period``,
    152 the length of next period is always determined by the server’s property.
     152the length of next period is always determined by the server's property.
    153153
    154154The task has a guaranteed bandwidth given by the server but should not
     
    221221==========
    222222
    223 This section details the Constant Bandwidth Server’s directives.
    224 A subsection is dedicated to each of this manager’s directives
     223This section details the Constant Bandwidth Server's directives.
     224A subsection is dedicated to each of this manager's directives
    225225and describes the calling sequence, related constants, usage,
    226226and status codes.
     
    309309parameters of the server (period and budget). If these are not valid,``RTEMS_CBS_ERROR_INVALID_PARAMETER`` is returned.
    310310The ``budget_overrun_callback`` is an optional callback function, which is
    311 invoked in case the server’s budget within one period is exceeded.
     311invoked in case the server's budget within one period is exceeded.
    312312Output parameter ``server_id`` becomes an id of the newly created server.
    313313If there is not enough memory, the ``RTEMS_CBS_ERROR_NO_MEMORY``
     
    584584**DESCRIPTION:**
    585585
    586 This directive returns server’s approved budget for subsequent periods.
     586This directive returns server's approved budget for subsequent periods.
    587587
    588588.. COMMENT: COPYRIGHT (c) 1989-2011.
  • c_user/cpu_usage_statistics.rst

    r11e1a6f rd389819  
    8484
    8585Another thing to keep in mind when looking at idle time, is that
    86 many systems – especially during debug – have a task providing
     86many systems - especially during debug - have a task providing
    8787some type of debug interface.  It is usually fine to think of the
    8888total idle time as being the sum of the IDLE task and a debug
     
    9898==========
    9999
    100 This section details the CPU usage statistics manager’s directives.
    101 A subsection is dedicated to each of this manager’s directives
     100This section details the CPU usage statistics manager's directives.
     101A subsection is dedicated to each of this manager's directives
    102102and describes the calling sequence, related constants, usage,
    103103and status codes.
  • c_user/dual_ports_memory_manager.rst

    r11e1a6f rd389819  
    9595==========
    9696
    97 This section details the dual-ported memory manager’s
    98 directives.  A subsection is dedicated to each of this manager’s
     97This section details the dual-ported memory manager's
     98directives.  A subsection is dedicated to each of this manager's
    9999directives and describes the calling sequence, related
    100100constants, usage, and status codes.
  • c_user/event_manager.rst

    r11e1a6f rd389819  
    117117- Target Task is Blocked Waiting for Events
    118118
    119   - If the waiting task’s input event condition is
     119  - If the waiting task's input event condition is
    120120    satisfied, then the task is made ready for execution.
    121121
    122   - If the waiting task’s input event condition is not
     122  - If the waiting task's input event condition is not
    123123    satisfied, then the event set is posted but left pending and the
    124124    task remains blocked.
     
    171171==========
    172172
    173 This section details the event manager’s directives.
    174 A subsection is dedicated to each of this manager’s directives
     173This section details the event manager's directives.
     174A subsection is dedicated to each of this manager's directives
    175175and describes the calling sequence, related constants, usage,
    176176and status codes.
     
    199199
    200200This directive sends an event set, event_in, to the
    201 task specified by id.  If a blocked task’s input event condition
     201task specified by id.  If a blocked task's input event condition
    202202is satisfied by this directive, then it will be made ready.  If
    203203its input event condition is not satisfied, then the events
  • c_user/fatal_error.rst

    r11e1a6f rd389819  
    8282of the error and whether or not the error was internally
    8383generated by the executive.  If the error was generated
    84 from an API, then the error code will be of that API’s
     84from an API, then the error code will be of that API's
    8585error or status codes.  The status codes for the RTEMS
    8686API are in cpukit/rtems/include/rtems/rtems/status.h.  Those
     
    107107==========
    108108
    109 This section details the fatal error manager’s
    110 directives.  A subsection is dedicated to each of this manager’s
     109This section details the fatal error manager's
     110directives.  A subsection is dedicated to each of this manager's
    111111directives and describes the calling sequence, related
    112112constants, usage, and status codes.
     
    138138provided FATAL error extension returns, then the RTEMS default
    139139error handler is invoked.  This directive can be invoked by
    140 RTEMS or by the user’s application code including initialization
     140RTEMS or by the user's application code including initialization
    141141tasks, other tasks, and ISRs.
    142142
  • c_user/glossary.rst

    r11e1a6f rd389819  
    143143
    144144:dfn:`directives`
    145     RTEMS’ provided routines that provide
     145    RTEMS' provided routines that provide
    146146    support mechanisms for real-time applications.
    147147
    148148:dfn:`dispatch`
    149     The act of loading a task’s context onto
     149    The act of loading a task's context onto
    150150    the CPU and transferring control of the CPU to that task.
    151151
     
    178178    The address at which a function or task
    179179    begins to execute.  In C, the entry point of a function is the
    180     function’s name.
     180    function's name.
    181181
    182182:dfn:`events`
     
    340340
    341341:dfn:`manager`
    342     A group of related RTEMS’ directives which
     342    A group of related RTEMS' directives which
    343343    provide access and control over resources.
    344344
     
    369369
    370370:dfn:`mode`
    371     An entry in a task’s control block that is
     371    An entry in a task's control block that is
    372372    used to determine if the task allows preemption, timeslicing,
    373373    processing of signals, and the interrupt disable level used by
     
    436436:dfn:`operating system`
    437437    The software which controls all
    438     the computer’s resources and provides the base upon which
     438    the computer's resources and provides the base upon which
    439439    application programs can be written.
    440440
     
    596596:dfn:`resume`
    597597    Removing a task from the suspend state.  If
    598     the task’s state is ready following a call to the ``rtems_task_resume``
     598    the task's state is ready following a call to the ``rtems_task_resume``
    599599    directive, then the task is available for scheduling.
    600600
     
    672672:dfn:`signal set`
    673673    A thirty-two bit entity which is used to
    674     represent a task’s collection of pending signals and the signals
     674    represent a task's collection of pending signals and the signals
    675675    sent to a task.
    676676
  • c_user/index.rst

    r11e1a6f rd389819  
    11====================
    2 RTEMS C User’s Guide
     2RTEMS C User's Guide
    33====================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • c_user/initialization.rst

    r11e1a6f rd389819  
    2525
    2626Initialization task(s) are the mechanism by which
    27 RTEMS transfers initial control to the user’s application.
     27RTEMS transfers initial control to the user's application.
    2828Initialization tasks differ from other application tasks in that
    2929they are defined in the User Initialization Tasks Table and
     
    212212==========
    213213
    214 This section details the Initialization Manager’s
    215 directives.  A subsection is dedicated to each of this manager’s
     214This section details the Initialization Manager's
     215directives.  A subsection is dedicated to each of this manager's
    216216directives and describes the calling sequence, related
    217217constants, usage, and status codes.
  • c_user/interrupt_manager.rst

    r11e1a6f rd389819  
    5151preserved by the normal C calling convention
    5252for the target
    53 processor and invokes the user’s ISR.  The user’s ISR is
     53processor and invokes the user's ISR.  The user's ISR is
    5454responsible for processing the interrupt, clearing the interrupt
    5555if necessary, and device specific manipulation... index:: rtems_vector_number
     
    8181level interrupts, the ISR should perform the minimum actions
    8282required to service the interrupt.  Other non-essential actions
    83 should be handled by application tasks.  Once the user’s ISR has
     83should be handled by application tasks.  Once the user's ISR has
    8484completed, it returns control to the RTEMS interrupt manager
    8585which will perform task dispatching and restore the registers
     
    120120priorities.  The exact number of interrupt levels is processor
    121121dependent.  RTEMS internally supports 256 interrupt levels which
    122 are mapped to the processor’s interrupt levels.  For specific
     122are mapped to the processor's interrupt levels.  For specific
    123123information on the mapping between RTEMS and the target
    124 processor’s interrupt levels, refer to the Interrupt Processing
     124processor's interrupt levels, refer to the Interrupt Processing
    125125chapter of the Applications Supplement document for a specific
    126126target processor.
     
    158158the system.  The address of the ISR and its associated CPU
    159159vector number are specified to this directive.  This directive
    160 installs the RTEMS interrupt wrapper in the processor’s
    161 Interrupt Vector Table and the address of the user’s ISR in the
    162 RTEMS’ Vector Table.  This directive returns the previous
    163 contents of the specified vector in the RTEMS’ Vector Table.
     160installs the RTEMS interrupt wrapper in the processor's
     161Interrupt Vector Table and the address of the user's ISR in the
     162RTEMS' Vector Table.  This directive returns the previous
     163contents of the specified vector in the RTEMS' Vector Table.
    164164
    165165Directives Allowed from an ISR
     
    254254==========
    255255
    256 This section details the interrupt manager’s
    257 directives.  A subsection is dedicated to each of this manager’s
     256This section details the interrupt manager's
     257directives.  A subsection is dedicated to each of this manager's
    258258directives and describes the calling sequence, related
    259259constants, usage, and status codes.
     
    289289returned in ``old_isr_handler``.
    290290
    291 To release an interrupt vector, pass the old handler’s address obtained
     291To release an interrupt vector, pass the old handler's address obtained
    292292when the vector was first capture.
    293293
  • c_user/io_manager.rst

    r11e1a6f rd389819  
    4242Each application utilizing the RTEMS I/O manager must specify the
    4343address of a Device Driver Table in its Configuration Table. This table
    44 contains each device driver’s entry points that is to be initialised by
     44contains each device driver's entry points that is to be initialised by
    4545RTEMS during initialization.  Each device driver may contain the
    4646following entry points:
     
    6060If the device driver does not support a particular
    6161entry point, then that entry in the Configuration Table should
    62 be NULL.  RTEMS will return``RTEMS_SUCCESSFUL`` as the executive’s and
    63 zero (0) as the device driver’s return code for these device
     62be NULL.  RTEMS will return``RTEMS_SUCCESSFUL`` as the executive's and
     63zero (0) as the device driver's return code for these device
    6464driver entry points.
    6565
     
    7676.. index:: minor device number
    7777
    78 Each call to the I/O manager must provide a device’s
     78Each call to the I/O manager must provide a device's
    7979major and minor numbers as arguments.  The major number is the
    80 index of the requested driver’s entry points in the Device
     80index of the requested driver's entry points in the Device
    8181Driver Table, and is used to select a specific device driver.
    8282The exact usage of the minor number is driver specific, but is
     
    225225==========
    226226
    227 This section details the I/O manager’s directives.  A
    228 subsection is dedicated to each of this manager’s directives and
     227This section details the I/O manager's directives.  A
     228subsection is dedicated to each of this manager's directives and
    229229describes the calling sequence, related constants, usage, and
    230230status codes.
     
    259259This directive attempts to add a new device driver to the Device Driver
    260260Table. The user can specify a specific major device number via the
    261 directive’s ``major`` parameter, or let the registration routine find
     261directive's ``major`` parameter, or let the registration routine find
    262262the next available major device number by specifing a major number of``0``. The selected major device number is returned via the``registered_major`` directive parameter. The directive automatically
    263263allocation major device numbers from the highest value down.
  • c_user/key_concepts.rst

    r11e1a6f rd389819  
    2727by the application and have an RTEMS assigned ID.  All objects
    2828have a user-assigned name.  Although a relationship exists
    29 between an object’s name and its RTEMS assigned ID, the name and
     29between an object's name and its RTEMS assigned ID, the name and
    3030ID are not identical.  Object names are completely arbitrary and
    3131selected by the user as a meaningful "tag" which may commonly
    32 reflect the object’s use in the application.  Conversely, object
     32reflect the object's use in the application.  Conversely, object
    3333IDs are designed to facilitate efficient object manipulation by
    3434the executive.
     
    150150The components of an object ID make it possible
    151151to quickly locate any object in even the most complicated
    152 multiprocessor system.  Object ID’s are associated with an
     152multiprocessor system.  Object ID's are associated with an
    153153object by RTEMS when the object is created and the corresponding
    154154ID is returned by the appropriate object create directive.  The
     
    158158
    159159The object identification directives can be used to
    160 dynamically obtain a particular object’s ID given its name.
     160dynamically obtain a particular object's ID given its name.
    161161This mapping is accomplished by searching the name table
    162162associated with this object type.  If the name is non-unique,
     
    191191by RTEMS which contains the information necessary to manage a
    192192particular object type.  For efficiency reasons, the format of
    193 each object type’s control block is different.  However, many of
     193each object type's control block is different.  However, many of
    194194the fields are similar in function.  The number of each type of
    195195control block is application dependent and determined by the
    196 values specified in the user’s Configuration Table.  An object
     196values specified in the user's Configuration Table.  An object
    197197control block is allocated at object create time and freed when
    198198the object is deleted.  With the exception of user extension
     
    221221dedicated specifically to communication and synchronization
    222222provide well established mechanisms which directly map to the
    223 application’s varying needs.  This level of flexibility allows
     223application's varying needs.  This level of flexibility allows
    224224the application designer to match the features of a particular
    225225manager with the complexity of communication and synchronization
     
    277277real-time scheduling methodology.  This methodology provides
    278278rules which allows one to guarantee that a set of independent
    279 periodic tasks will always meet their deadlines – even under
     279periodic tasks will always meet their deadlines - even under
    280280transient overload conditions.  The rate monotonic manager
    281 provides directives built upon the Clock Manager’s interval
     281provides directives built upon the Clock Manager's interval
    282282timer support routines.
    283283
     
    287287date and time.  This allows selected time operations to be
    288288scheduled at an actual calendar date and time.  For example, a
    289 task could request to delay until midnight on New Year’s Eve
     289task could request to delay until midnight on New Year's Eve
    290290before lowering the ball at Times Square.
    291291The data type ``rtems_time_of_day`` is used to specify
     
    308308translation.  Dynamic memory allocation is required by
    309309applications whose memory requirements vary through the
    310 application’s course of execution.  Address translation is
     310application's course of execution.  Address translation is
    311311needed by applications which share memory with another CPU or an
    312312intelligent Input/Output processor.  The following RTEMS
  • c_user/message_manager.rst

    r11e1a6f rd389819  
    153153retrieve a message from the specified message queue.  If at
    154154least one message is in the queue, then the message is removed
    155 from the queue, copied to the caller’s message buffer, and
     155from the queue, copied to the caller's message buffer, and
    156156returned immediately along with the length of the message.  When
    157157messages are unavailable, one of the following situations
     
    168168
    169169If the task waits for a message, then it is placed in
    170 the message queue’s task wait queue in either FIFO or task
     170the message queue's task wait queue in either FIFO or task
    171171priority order.  All tasks waiting on a message queue are
    172172returned an error code when the message queue is deleted.
     
    178178directives work identically when tasks are waiting to receive a
    179179message.  A task is removed from the task waiting queue,
    180 unblocked,  and the message is copied to a waiting task’s
     180unblocked,  and the message is copied to a waiting task's
    181181message buffer.
    182182
     
    184184message at the rear of the message queue, while``rtems_message_queue_urgent`` places the message at the
    185185front of the queue.  The message is copied to a message buffer
    186 from this message queue’s buffer pool and then placed in the
     186from this message queue's buffer pool and then placed in the
    187187message queue.  Neither directive can successfully send a
    188188message to a message queue which has a full queue of pending
     
    195195message to every task waiting on the specified message queue as
    196196an atomic operation.  The message is copied to each waiting
    197 task’s message buffer and each task is unblocked.  The number of
     197task's message buffer and each task is unblocked.  The number of
    198198tasks which were unblocked is returned to the caller.
    199199
     
    203203The ``rtems_message_queue_delete`` directive removes a message
    204204queue from the system and frees its control block as well as the
    205 memory associated with this message queue’s message buffer pool.
     205memory associated with this message queue's message buffer pool.
    206206A message queue can be deleted by any local task that knows the
    207 message queue’s ID.  As a result of this directive, all tasks
     207message queue's ID.  As a result of this directive, all tasks
    208208blocked waiting to receive a message from the message queue will
    209209be readied and returned a status code which indicates that the
    210210message queue was deleted.  Any subsequent references to the
    211 message queue’s name and ID are invalid.  Any messages waiting
     211message queue's name and ID are invalid.  Any messages waiting
    212212at the message queue are also deleted and deallocated.
    213213
     
    215215==========
    216216
    217 This section details the message manager’s
    218 directives.  A subsection is dedicated to each of this manager’s
     217This section details the message manager's
     218directives.  A subsection is dedicated to each of this manager's
    219219directives and describes the calling sequence, related
    220220constants, usage, and status codes.
     
    285285is to avoid the system overhead incurred by the creation of a
    286286global message queue.  When a global message queue is created,
    287 the message queue’s name and id must be transmitted to every
     287the message queue's name and id must be transmitted to every
    288288node in the system for insertion in the local copy of the global
    289289object table.
     
    423423``RTEMS_INVALID_ADDRESS`` - ``buffer`` is NULL
    424424``RTEMS_UNSATISFIED`` - out of message buffers
    425 ``RTEMS_TOO_MANY`` - queue’s limit has been reached
     425``RTEMS_TOO_MANY`` - queue's limit has been reached
    426426
    427427**DESCRIPTION:**
     
    429429This directive sends the message buffer of size bytes
    430430in length to the queue specified by id.  If a task is waiting at
    431 the queue, then the message is copied to the waiting task’s
     431the queue, then the message is copied to the waiting task's
    432432buffer and the task is unblocked. If no tasks are waiting at the
    433433queue, then the message is copied to a message buffer which is
    434 obtained from this message queue’s message buffer pool.  The
     434obtained from this message queue's message buffer pool.  The
    435435message buffer is then placed at the rear of the queue.
    436436
     
    473473``RTEMS_INVALID_ADDRESS`` - ``buffer`` is NULL
    474474``RTEMS_UNSATISFIED`` - out of message buffers
    475 ``RTEMS_TOO_MANY`` - queue’s limit has been reached
     475``RTEMS_TOO_MANY`` - queue's limit has been reached
    476476
    477477**DESCRIPTION:**
     
    479479This directive sends the message buffer of size bytes
    480480in length to the queue specified by id.  If a task is waiting on
    481 the queue, then the message is copied to the task’s buffer and
     481the queue, then the message is copied to the task's buffer and
    482482the task is unblocked.  If no tasks are waiting on the queue,
    483483then the message is copied to a message buffer which is obtained
    484 from this message queue’s message buffer pool.  The message
     484from this message queue's message buffer pool.  The message
    485485buffer is then placed at the front of the queue.
    486486
     
    531531the queue specified by id to be unblocked and sent the message
    532532contained in buffer.  Before a task is unblocked, the message
    533 buffer of size byes in length is copied to that task’s message
     533buffer of size byes in length is copied to that task's message
    534534buffer.  The number of tasks that were unblocked is returned in
    535535count.
  • c_user/multiprocessing.rst

    r11e1a6f rd389819  
    4646media or topology of a multiprocessor system.  The tasks which
    4747compose a particular application can be spread among as many
    48 processors as needed to satisfy the application’s timing
     48processors as needed to satisfy the application's timing
    4949requirements.  The application tasks can interact using a subset
    5050of the RTEMS directives as if they were on the same processor.
     
    199199remote node and is used to represent a task which must block as
    200200part of a remote operation. This action can occur as part of the``rtems_semaphore_obtain`` and``rtems_message_queue_receive`` directives.  If the
    201 object were local, the task’s control block would be available
     201object were local, the task's control block would be available
    202202for modification to indicate it was blocking on a message queue
    203 or semaphore.  However, the task’s control block resides only on
     203or semaphore.  However, the task's control block resides only on
    204204the same node as the task.  As a result, the remote node must
    205205allocate a proxy to represent the task until it can be readied.
     
    242242on the MPCI layer implementation... index:: MPCI entry points
    243243
    244 The entry points to the routines in the user’s MPCI
     244The entry points to the routines in the user's MPCI
    245245layer should be placed in the Multiprocessor Communications
    246246Interface Table.  The user must provide entry points for each of
     
    297297    );
    298298
    299 where configuration is the address of the user’s
     299where configuration is the address of the user's
    300300Configuration Table.  Operations on global objects cannot be
    301301performed until this component is invoked.  The INITIALIZATION
     
    456456point numbers, bit fields, decimal data, and character strings.
    457457In addition, the representation method for negative integers
    458 could be one’s or two’s complement.  These factors combine to
     458could be one's or two's complement.  These factors combine to
    459459increase the complexity of designing and manipulating data
    460460structures shared between processors.
     
    496496This section details the additional directives
    497497required to support RTEMS in a multiprocessor configuration.  A
    498 subsection is dedicated to each of this manager’s directives and
     498subsection is dedicated to each of this manager's directives and
    499499describes the calling sequence, related constants, usage, and
    500500status codes.
  • c_user/overview.rst

    r11e1a6f rd389819  
    271271
    272272RTEMS utilizes memory for both code and data space.
    273 Although RTEMS’ data space must be in RAM, its code space can be
     273Although RTEMS' data space must be in RAM, its code space can be
    274274located in either ROM or RAM.
    275275
     
    289289find that the use and behavior of the two implementations is
    290290very similar.  A working knowledge of the target processor is
    291 helpful in understanding some of RTEMS’ features.  A thorough
     291helpful in understanding some of RTEMS' features.  A thorough
    292292understanding of the executive cannot be obtained without
    293 studying the entire manual because many of RTEMS’ concepts and
     293studying the entire manual because many of RTEMS' concepts and
    294294features are interrelated.  Experienced RTEMS users will find
    295295that the manual organization facilitates its use as a reference
     
    451451    Object Services: presents a collection of helper services useful
    452452    when manipulating RTEMS objects. These include methods to assist
    453     in obtaining an object’s name in printable form. Additional services
     453    in obtaining an object's name in printable form. Additional services
    454454    are provided to decompose an object Id and determine which API
    455455    and object class it belongs to.
  • c_user/partition_manager.rst

    r11e1a6f rd389819  
    3333
    3434Partitions are managed and maintained as a list of
    35 buffers.  Buffers are obtained from the front of the partition’s
     35buffers.  Buffers are obtained from the front of the partition's
    3636free buffer chain and returned to the rear of the same chain.
    3737When a buffer is on the free buffer chain, RTEMS uses two
     
    7171
    7272The ``rtems_partition_create`` directive creates a partition
    73 with a user-specified name.  The partition’s name, starting
     73with a user-specified name.  The partition's name, starting
    7474address, length and buffer size are all specified to the``rtems_partition_create`` directive.
    7575RTEMS allocates a Partition Control
     
    105105------------------
    106106
    107 Buffers are returned to a partition’s free buffer
     107Buffers are returned to a partition's free buffer
    108108chain with the ``rtems_partition_return_buffer`` directive.  This
    109109directive returns an error status code if the returned buffer
     
    122122==========
    123123
    124 This section details the partition manager’s
    125 directives.  A subsection is dedicated to each of this manager’s
     124This section details the partition manager's
     125directives.  A subsection is dedicated to each of this manager's
    126126directives and describes the calling sequence, related
    127127constants, usage, and status codes.
     
    200200remote tasks must interact with the partition.  This is to avoid
    201201the overhead incurred by the creation of a global partition.
    202 When a global partition is created, the partition’s name and id
     202When a global partition is created, the partition's name and id
    203203must be transmitted to every node in the system for insertion in
    204204the local copy of the global object table.
  • c_user/pci_library.rst

    r11e1a6f rd389819  
    241241On systems where a peripheral PCI device needs to access other PCI devices than
    242242the host the peripheral configuration approach may be handy. Most PCI devices
    243 answers on the PCI host’s requests and start DMA accesses into the Hosts memory,
     243answers on the PCI host's requests and start DMA accesses into the Hosts memory,
    244244however in some complex systems PCI devices may want to access other devices
    245245on the same bus or at another PCI bus.
     
    421421-----------------
    422422
    423 The RTEMS shell has a PCI command ’pci’ which makes it possible to read/write
     423The RTEMS shell has a PCI command 'pci' which makes it possible to read/write
    424424configuration space, print the current PCI configuration and print out a
    425425configuration C-file for the static or peripheral library.
  • c_user/preface.rst

    r11e1a6f rd389819  
    4646as seen by a real-time application.  It does not include the
    4747details of how a kernel implements these functions.  The
    48 standard’s goal is to serve as a complete definition of external
     48standard's goal is to serve as a complete definition of external
    4949interfaces so that application code that conforms to these
    5050interfaces will execute properly in all real-time executive
     
    6969The acceptance of a standard for real-time executives
    7070will produce the same advantages enjoyed from the push for UNIX
    71 standardization by AT&T’s System V Interface Definition and
    72 IEEE’s POSIX efforts.  A compliant multiprocessing executive
     71standardization by AT&T's System V Interface Definition and
     72IEEE's POSIX efforts.  A compliant multiprocessing executive
    7373will allow close coupling between UNIX systems and real-time
    7474executives to provide the many benefits of the UNIX development
  • c_user/rate_monotonic_manager.rst

    r11e1a6f rd389819  
    116116
    117117The information reported can be used to determine the "hot spots"
    118 in the application.  Given a period’s id, the user can determine
     118in the application.  Given a period's id, the user can determine
    119119the length of that period.  From that information and the CPU usage,
    120120the user can calculate the percentage of CPU time consumed by that
    121121periodic task.  For example, a task executing for 20 milliseconds
    122 every 200 milliseconds is consuming 10 percent of the processor’s
     122every 200 milliseconds is consuming 10 percent of the processor's
    123123execution time.  This is usually enough to make it a good candidate
    124124for optimization.
     
    143143the processor utilization for that task.  Processor utilization
    144144is the percentage of processor time used and can be calculated
    145 on a per-task or system-wide basis.  Typically, the task’s
     145on a per-task or system-wide basis.  Typically, the task's
    146146worst-case execution time will be less than its period.  For
    147 example, a periodic task’s requirements may state that it should
     147example, a periodic task's requirements may state that it should
    148148execute for 10 milliseconds every 100 milliseconds.  Although
    149149the execution time may be the average, worst, or best case, the
     
    179179This analysis determines whether a task set is schedulable under
    180180worst-case conditions and emphasizes the predictability of the
    181 system’s behavior.  It has been proven that:
     181system's behavior.  It has been proven that:
    182182
    183183- *RMS is an optimal static priority algorithm for
     
    192192
    193193RMS calls for the static assignment of task
    194 priorities based upon their period.  The shorter a task’s
     194priorities based upon their period.  The shorter a task's
    195195period, the higher its priority.  For example, a task with a 1
    196196millisecond period has higher priority than a task with a 100
     
    198198does not distinguish between the tasks.  However, RTEMS
    199199specifies that when given tasks of equal priority, the task
    200 which has been ready longest will execute first.  RMS’s priority
     200which has been ready longest will execute first.  RMS's priority
    201201assignment scheme does not provide one with exact numeric values
    202202for task priorities.  For example, consider the following task
     
    346346priority, can be created and started before the initialization
    347347deletes itself.  This technique ensures that all tasks begin to
    348 compete for execution time at the same instant – when the user
     348compete for execution time at the same instant - when the user
    349349initialization task deletes itself.
    350350
     
    427427contend for resources.  This assumption can be relaxed by
    428428accounting for the amount of time a task spends waiting to
    429 acquire resources.  Similarly, each task’s execution time must
     429acquire resources.  Similarly, each task's execution time must
    430430account for any I/O performed and any RTEMS directive calls.
    431431
     
    518518with a period of ``RTEMS_PERIOD_STATUS`` ticks, the current
    519519state of the specified rate monotonic period will be returned.  The following
    520 table details the relationship between the period’s status and
     520table details the relationship between the period's status and
    521521the directive status code returned by the``rtems_rate_monotonic_period``
    522522directive:
     
    545545a rate monotonic period.  If the period is running and has not
    546546expired, the period is automatically canceled.  The rate
    547 monotonic period’s control block is returned to the PCB free
     547monotonic period's control block is returned to the PCB free
    548548list when it is deleted.  A rate monotonic period can be deleted
    549549by a task other than the task which created the period.
     
    675675==========
    676676
    677 This section details the rate monotonic manager’s
    678 directives.  A subsection is dedicated to each of this manager’s
     677This section details the rate monotonic manager's
     678directives.  A subsection is dedicated to each of this manager's
    679679directives and describes the calling sequence, related
    680680constants, usage, and status codes.
     
    900900A configure time option can be used to select whether the time information is
    901901given in ticks or seconds and nanoseconds.  The default is seconds and
    902 nanoseconds.  If the period’s state is ``RATE_MONOTONIC_INACTIVE``, both
     902nanoseconds.  If the period's state is ``RATE_MONOTONIC_INACTIVE``, both
    903903time values will be set to 0.  Otherwise, both time values will contain
    904904time information since the last invocation of the``rtems_rate_monotonic_period`` directive.  More
  • c_user/red_black_trees.rst

    r11e1a6f rd389819  
    2222- ``rtems_rtems_rbtree_initialize_empty`` - initialize the red-black tree as empty
    2323
    24 - ``rtems_rtems_rbtree_set_off_tree`` - Clear a node’s links
     24- ``rtems_rtems_rbtree_set_off_tree`` - Clear a node's links
    2525
    26 - ``rtems_rtems_rbtree_root`` - Return the red-black tree’s root node
     26- ``rtems_rtems_rbtree_root`` - Return the red-black tree's root node
    2727
    28 - ``rtems_rtems_rbtree_min`` - Return the red-black tree’s minimum node
     28- ``rtems_rtems_rbtree_min`` - Return the red-black tree's minimum node
    2929
    30 - ``rtems_rtems_rbtree_max`` - Return the red-black tree’s maximum node
     30- ``rtems_rtems_rbtree_max`` - Return the red-black tree's maximum node
    3131
    32 - ``rtems_rtems_rbtree_left`` - Return a node’s left child node
     32- ``rtems_rtems_rbtree_left`` - Return a node's left child node
    3333
    34 - ``rtems_rtems_rbtree_right`` - Return a node’s right child node
     34- ``rtems_rtems_rbtree_right`` - Return a node's right child node
    3535
    36 - ``rtems_rtems_rbtree_parent`` - Return a node’s parent node
     36- ``rtems_rtems_rbtree_parent`` - Return a node's parent node
    3737
    38 - ``rtems_rtems_rbtree_are_nodes_equal`` - Are the node’s equal ?
     38- ``rtems_rtems_rbtree_are_nodes_equal`` - Are the node's equal ?
    3939
    4040- ``rtems_rtems_rbtree_is_empty`` - Is the red-black tree empty ?
     
    8686is designed to be part of a user data structure. To obtain the encapsulating
    8787structure users can use the ``RTEMS_CONTAINER_OF`` macro.
    88 The node can be placed anywhere within the user’s structure and the macro will
    89 calculate the structure’s address from the node’s address.
     88The node can be placed anywhere within the user's structure and the macro will
     89calculate the structure's address from the node's address.
    9090
    9191Controls
  • c_user/region_manager.rst

    r11e1a6f rd389819  
    4848using a first-fit algorithm.  If available, the requester
    4949receives the number of bytes requested (rounded up to the next
    50 page size).  RTEMS requires some overhead from the region’s
     50page size).  RTEMS requires some overhead from the region's
    5151memory for each segment that is allocated.  Therefore, an
    5252application should only modify the memory of a segment that has
    5353been obtained from the region.  The application should NOT
    5454modify the memory outside of any obtained segments and within
    55 the region’s boundaries while the region is currently active in
     55the region's boundaries while the region is currently active in
    5656the system.
    5757
     
    179179
    180180If the task waits for the segment, then it is placed
    181 in the region’s task wait queue in either FIFO or task priority
     181in the region's task wait queue in either FIFO or task priority
    182182order.  All tasks waiting on a region are returned an error when
    183183the message queue is deleted.
     
    191191segment request can now be satisfied.  If so, it is given a
    192192segment and unblocked.  This process is repeated until the first
    193 task’s segment request cannot be satisfied.
     193task's segment request cannot be satisfied.
    194194
    195195Obtaining the Size of a Segment
     
    227227==========
    228228
    229 This section details the region manager’s directives.
    230 A subsection is dedicated to each of this manager’s directives
     229This section details the region manager's directives.
     230A subsection is dedicated to each of this manager's directives
    231231and describes the calling sequence, related constants, usage,
    232232and status codes.
     
    449449indicating this fact is returned.  If the calling task chooses
    450450to wait for the segment and a segment large enough is not
    451 available, then the calling task is placed on the region’s
     451available, then the calling task is placed on the region's
    452452segment wait queue and blocked.  If the region was created with
    453453the ``RTEMS_PRIORITY`` option, then the calling
     
    466466The actual length of the allocated segment may be
    467467larger than the requested size because a segment size is always
    468 a multiple of the region’s page size.
     468a multiple of the region's page size.
    469469
    470470The following segment acquisition option constants
     
    508508segment request can now be satisfied.  If so, it is given a
    509509segment and unblocked.  This process is repeated until the first
    510 task’s segment request cannot be satisfied.
     510task's segment request cannot be satisfied.
    511511
    512512**NOTES:**
     
    553553The actual length of the allocated segment may be
    554554larger than the requested size because a segment size is always
    555 a multiple of the region’s page size.
     555a multiple of the region's page size.
    556556
    557557REGION_RESIZE_SEGMENT - Change size of a segment
  • c_user/rtems_data_types.rst

    r11e1a6f rd389819  
    5050  ``rtems_context`` is the CPU dependent
    5151  data structure used to manage the integer and system
    52   register portion of each task’s context.
     52  register portion of each task's context.
    5353
    5454- .. index:: rtems_context_fp
     
    5656  ``rtems_context_fp`` is the CPU dependent
    5757  data structure used to manage the floating point portion of
    58   each task’s context.
     58  each task's context.
    5959
    6060- .. index:: rtems_device_driver
  • c_user/scheduling_concepts.rst

    r11e1a6f rd389819  
    1313after the occurrence of an event.  For example, software embedded in
    1414life-support systems used to monitor hospital patients must take instant
    15 action if a change in the patient’s status is detected.
     15action if a change in the patient's status is detected.
    1616
    1717The component of RTEMS responsible for providing this capability is
    18 appropriately called the scheduler.  The scheduler’s sole purpose is
     18appropriately called the scheduler.  The scheduler's sole purpose is
    1919to allocate the all important resource of processor time to the various
    2020tasks competing for attention.
     
    176176This is an alternative scheduler in RTEMS for single core applications.
    177177The CBS is a budget aware extension of EDF scheduler. The main goal of this
    178 scheduler is to ensure temporal isolation of tasks meaning that a task’s
     178scheduler is to ensure temporal isolation of tasks meaning that a task's
    179179execution in terms of meeting deadlines must not be influenced by other
    180180tasks as if they were run on multiple independent processors.
     
    233233The most significant task scheduling modification mechanism is the ability
    234234for the user to assign a priority level to each individual task when it
    235 is created and to alter a task’s priority at run-time.  RTEMS supports
     235is created and to alter a task's priority at run-time.  RTEMS supports
    236236up to 255 priority levels.  Level 255 is the lowest priority and level
    2372371 is the highest.
     
    261261limit the amount of time the task can execute before the processor is
    262262allocated to another task.  Each tick of the real-time clock reduces
    263 the currently running task’s timeslice.  When the execution time equals
     263the currently running task's timeslice.  When the execution time equals
    264264the timeslice, RTEMS will dispatch another task of the same priority
    265265to execute.  If there are no other tasks of the same priority ready to
     
    289289dispatcher saves the context of the current task and restores
    290290the context of the task which has been allocated to the
    291 processor.  Saving and restoring a task’s context is the
     291processor.  Saving and restoring a task's context is the
    292292storing/loading of all the essential information about a task to
    293293enable it to continue execution without any effects of the
    294 interruption.  For example, the contents of a task’s register
     294interruption.  For example, the contents of a task's register
    295295set must be the same when it is given the processor as they were
    296296when it was taken away.  All of the information that must be
    297297saved or restored for a context switch is located either in the
    298 TCB or on the task’s stacks.
     298TCB or on the task's stacks.
    299299
    300300Tasks that utilize a numeric coprocessor and are created with the``RTEMS_FLOATING_POINT`` attribute require additional
     
    395395- The running task issues a ``rtems_region_get_segment``
    396396  directive with the wait option and there is not an available segment large
    397   enough to satisfy the task’s request.
     397  enough to satisfy the task's request.
    398398
    399399A blocked task may also be suspended.  Therefore, both the suspension
     
    433433  directive which releases a segment to the region on which the blocked task
    434434  is waiting and a resulting segment is large enough to satisfy
    435   the task’s request.
     435  the task's request.
    436436
    437437- A rate monotonic period expires for a task which blocked
  • c_user/semaphore_manager.rst

    r11e1a6f rd389819  
    126126the semaphore is increased to that of the blocking task.  When
    127127the task holding the task completely releases the binary
    128 semaphore (i.e. not for a nested release), the holder’s priority
     128semaphore (i.e. not for a nested release), the holder's priority
    129129is restored to the value it had before any higher priority was
    130130inherited.
     
    160160raised to the ceiling priority.  When the task holding the task
    161161completely releases the binary semaphore (i.e. not for a nested
    162 release), the holder’s priority is restored to the value it had
     162release), the holder's priority is restored to the value it had
    163163before any higher priority was put into effect.
    164164
     
    299299creating the semaphore is considered the current holder of the
    300300semaphore.  At create time the method for ordering waiting tasks
    301 in the semaphore’s task wait queue (by FIFO or task priority) is
     301in the semaphore's task wait queue (by FIFO or task priority) is
    302302specified.  Additionally, the priority inheritance or priority
    303303ceiling algorithm may be selected for local, binary semaphores
     
    347347
    348348If the task waits to acquire the semaphore, then it
    349 is placed in the semaphore’s task wait queue in either FIFO or
     349is placed in the semaphore's task wait queue in either FIFO or
    350350task priority order.  If the task blocked waiting for a binary
    351 semaphore using priority inheritance and the task’s priority is
     351semaphore using priority inheritance and the task's priority is
    352352greater than that of the task currently holding the semaphore,
    353353then the holding task will inherit the priority of the blocking
     
    357357When a task successfully obtains a semaphore using
    358358priority ceiling and the priority ceiling for this semaphore is
    359 greater than that of the holder, then the holder’s priority will
     359greater than that of the holder, then the holder's priority will
    360360be elevated.
    361361
     
    384384The ``rtems_semaphore_delete`` directive removes a semaphore
    385385from the system and frees its control block.  A semaphore can be
    386 deleted by any local task that knows the semaphore’s ID.  As a
     386deleted by any local task that knows the semaphore's ID.  As a
    387387result of this directive, all tasks blocked waiting to acquire
    388388the semaphore will be readied and returned a status code which
    389389indicates that the semaphore was deleted.  Any subsequent
    390 references to the semaphore’s name and ID are invalid.
     390references to the semaphore's name and ID are invalid.
    391391
    392392Directives
    393393==========
    394394
    395 This section details the semaphore manager’s
    396 directives.  A subsection is dedicated to each of this manager’s
     395This section details the semaphore manager's
     396directives.  A subsection is dedicated to each of this manager's
    397397directives and describes the calling sequence, related
    398398constants, usage, and status codes.
     
    490490tasks must interact with the created semaphore.  This is to
    491491avoid the system overhead incurred by the creation of a global
    492 semaphore.  When a global semaphore is created, the semaphore’s
     492semaphore.  When a global semaphore is created, the semaphore's
    493493name and id must be transmitted to every node in the system for
    494494insertion in the local copy of the global object table.
     
    585585
    586586The calling task will be preempted if it is enabled
    587 by the task’s execution mode and a higher priority local task is
     587by the task's execution mode and a higher priority local task is
    588588waiting on the deleted semaphore.  The calling task will NOT be
    589589preempted if all of the tasks that are waiting on the semaphore
     
    644644chooses to wait for a semaphore and the current semaphore count is zero or
    645645negative, then it is decremented by one and the calling task is placed on
    646 the semaphore’s wait queue and blocked.  If the semaphore was created with
     646the semaphore's wait queue and blocked.  If the semaphore was created with
    647647the ``RTEMS_PRIORITY`` attribute, then the calling task is
    648648inserted into the queue according to its priority.  However, if the
     
    714714This directive releases the semaphore specified by
    715715id.  The semaphore count is incremented by one.  If the count is
    716 zero or negative, then the first task on this semaphore’s wait
     716zero or negative, then the first task on this semaphore's wait
    717717queue is removed and unblocked.  The unblocked task may preempt
    718 the running task if the running task’s preemption mode is
     718the running task if the running task's preemption mode is
    719719enabled and the unblocked task has a higher priority than the
    720720running task.
     
    770770
    771771This directive unblocks all tasks waiting on the semaphore specified by
    772 id.  Since there are tasks blocked on the semaphore, the semaphore’s
     772id.  Since there are tasks blocked on the semaphore, the semaphore's
    773773count is not changed by this directive and thus is zero before and
    774774after this directive is executed.  Tasks which are unblocked as the
     
    778778
    779779This directive may unblock any number of tasks.  Any of the unblocked
    780 tasks may preempt the running task if the running task’s preemption mode is
     780tasks may preempt the running task if the running task's preemption mode is
    781781enabled and an unblocked task has a higher priority than the
    782782running task.
  • c_user/signal_manager.rst

    r11e1a6f rd389819  
    2525The signal manager allows a task to optionally define
    2626an asynchronous signal routine (ASR).  An ASR is to a task what
    27 an ISR is to an application’s set of tasks.  When the processor
     27an ISR is to an application's set of tasks.  When the processor
    2828is interrupted, the execution of an application is also
    2929interrupted and an ISR is given control.  Similarly, when a
    30 signal is sent to a task, that task’s execution path will be
     30signal is sent to a task, that task's execution path will be
    3131"interrupted" by the ASR.  Sending a signal to a task has no
    32 effect on the receiving task’s current execution state... index:: rtems_signal_set
     32effect on the receiving task's current execution state... index:: rtems_signal_set
    3333
    3434A signal flag is used by a task (or ISR) to inform
     
    4141A signal set is posted when it is directed (or sent) to a
    4242task. A pending signal is a signal that has been sent to a task
    43 with a valid ASR, but has not been processed by that task’s ASR.
     43with a valid ASR, but has not been processed by that task's ASR.
    4444
    4545A Comparison of ASRs and ISRs
     
    8686.. index:: ASR mode, building
    8787
    88 In general, an ASR’s mode is built by a bitwise OR of
     88In general, an ASR's mode is built by a bitwise OR of
    8989the desired mode components.  The set of valid mode components
    9090is the same as those allowed with the task_create and task_mode
     
    133133The ``rtems_signal_catch`` directive establishes an ASR for the
    134134calling task.  The address of the ASR and its execution mode are
    135 specified to this directive.  The ASR’s mode is distinct from
    136 the task’s mode.  For example, the task may allow preemption,
    137 while that task’s ASR may have preemption disabled.  Until a
     135specified to this directive.  The ASR's mode is distinct from
     136the task's mode.  For example, the task may allow preemption,
     137while that task's ASR may have preemption disabled.  Until a
    138138task calls ``rtems_signal_catch`` the first time,
    139139its ASR is invalid, and no signal sets can be sent to the task.
     
    141141A task may invalidate its ASR and discard all pending
    142142signals by calling ``rtems_signal_catch``
    143 with a value of NULL for the ASR’s address.  When a task’s
     143with a value of NULL for the ASR's address.  When a task's
    144144ASR is invalid, new signal sets sent to this task are discarded.
    145145
    146146A task may disable ASR processing (``RTEMS_NO_ASR``) via the
    147 task_mode directive.  When a task’s ASR is disabled, the signals
     147task_mode directive.  When a task's ASR is disabled, the signals
    148148sent to it are left pending to be processed later when the ASR
    149149is enabled.
     
    154154replaces the previous one.
    155155
    156 Normally, signal processing is disabled for the ASR’s
     156Normally, signal processing is disabled for the ASR's
    157157execution mode, but if signal processing is enabled for the ASR,
    158158the ASR must be reentrant.
     
    166166of a signal to a task has no effect on the execution state of
    167167that task.  If the task is not the currently running task, then
    168 the signals are left pending and processed by the task’s ASR the
     168the signals are left pending and processed by the task's ASR the
    169169next time the task is dispatched to run.  The ASR is executed
    170170immediately before the task is dispatched.  If the currently
     
    210210==========
    211211
    212 This section details the signal manager’s directives.
    213 A subsection is dedicated to each of this manager’s directives
     212This section details the signal manager's directives.
     213A subsection is dedicated to each of this manager's directives
    214214and describes the calling sequence, related constants, usage,
    215215and status codes.
     
    243243signals are cleared.  Any signals sent to a task with an invalid
    244244ASR are discarded.  The mode parameter specifies the execution
    245 mode for the ASR.  This execution mode supersedes the task’s
     245mode for the ASR.  This execution mode supersedes the task's
    246246execution mode while the ASR is executing.
    247247
     
    309309
    310310Sending a signal set to a task has no effect on that
    311 task’s state.  If a signal set is sent to a blocked task, then
     311task's state.  If a signal set is sent to a blocked task, then
    312312the task will remain blocked and the signals will be processed
    313313when the task becomes the running task.
  • c_user/stack_bounds_checker.rst

    r11e1a6f rd389819  
    3737
    3838The stack bounds checker operates as a set of task extensions.  At
    39 task creation time, the task’s stack is filled with a pattern to
     39task creation time, the task's stack is filled with a pattern to
    4040indicate the stack is unused.  As the task executes, it will overwrite
    41 this pattern in memory.  At each task switch, the stack bounds checker’s
     41this pattern in memory.  At each task switch, the stack bounds checker's
    4242task switch extension is executed.  This extension checks that:
    4343
    44 - the last ``n`` bytes of the task’s stack have
     44- the last ``n`` bytes of the task's stack have
    4545  not been overwritten.  If this pattern has been damaged, it
    4646  indicates that at some point since this task was context
     
    4848
    4949- the current stack pointer of the task is not within
    50   the address range allocated for use as the task’s stack.
     50  the address range allocated for use as the task's stack.
    5151
    5252If either of these conditions is detected, then a blown stack
     
    132132
    133133The above includes the task id and a pointer to the task control block as
    134 well as enough information so one can look at the task’s stack and
     134well as enough information so one can look at the task's stack and
    135135see what was happening.
    136136
     
    138138========
    139139
    140 This section details the stack bounds checker’s routines.
     140This section details the stack bounds checker's routines.
    141141A subsection is dedicated to each of routines
    142142and describes the calling sequence, related constants, usage,
  • c_user/symmetric_multiprocessing_services.rst

    r11e1a6f rd389819  
    174174
    175175Clustered scheduling helps to control the worst-case latencies in
    176 multi-processor systems, see *Brandenburg, Björn B.: Scheduling and
     176multi-processor systems, see *Brandenburg, Bjorn B.: Scheduling and
    177177Locking in Multiprocessor Real-Time Operating Systems. PhD thesis, 2011.http://www.cs.unc.edu/~bbb/diss/brandenburg-diss.pdf*.  The goal is to
    178178reduce the amount of shared state in the system and thus prevention of lock
     
    221221removed from the FIFO.  In case the previously first priority queue is not
    222222empty, then it is appended to the FIFO.  So there is FIFO fairness with respect
    223 to the highest priority task of each scheduler instances. See also *Brandenburg, Björn B.: A fully preemptive multiprocessor semaphore protocol for
     223to the highest priority task of each scheduler instances. See also *Brandenburg, Bjorn B.: A fully preemptive multiprocessor semaphore protocol for
    224224latency-sensitive real-time applications. In Proceedings of the 25th Euromicro
    225 Conference on Real-Time Systems (ECRTS 2013), pages 292–302, 2013.http://www.mpi-sws.org/~bbb/papers/pdf/ecrts13b.pdf*.
     225Conference on Real-Time Systems (ECRTS 2013), pages 292-302, 2013.http://www.mpi-sws.org/~bbb/papers/pdf/ecrts13b.pdf*.
    226226
    227227Such a two level queue may need a considerable amount of memory if fast enqueue
  • c_user/task_manager.rst

    r11e1a6f rd389819  
    3131- ``rtems_task_set_priority`` - Set task priority
    3232
    33 - ``rtems_task_mode`` - Change current task’s mode
     33- ``rtems_task_mode`` - Change current task's mode
    3434
    3535- ``rtems_task_wake_after`` - Wake up after interval
     
    7070  concurrently with other computational sequences.
    7171
    72 From RTEMS’ perspective, a task is the smallest thread of
     72From RTEMS' perspective, a task is the smallest thread of
    7373execution which can compete on its own for system resources.  A
    7474task is manifested by the existence of a task control block
     
    8585upon deletion of the task.
    8686
    87 The TCB’s elements are modified as a result of system calls made
     87The TCB's elements are modified as a result of system calls made
    8888by the application in response to external and internal stimuli.
    8989TCBs are the only RTEMS internal data structure that can be
    9090accessed by an application via user extension routines.  The TCB
    91 contains a task’s name, ID, current priority, current and
     91contains a task's name, ID, current priority, current and
    9292starting states, execution mode, TCB user extension pointer,
    9393scheduling control structures, as well as data required by a
    9494blocked task.
    9595
    96 A task’s context is stored in the TCB when a task switch occurs.
     96A task's context is stored in the TCB when a task switch occurs.
    9797When the task regains control of the processor, its context is
    9898restored from the TCB.  When a task is restarted, the initial
    9999state of the task is restored from the starting context area in
    100 the task’s TCB.
     100the task's TCB.
    101101
    102102Task States
     
    132132.. index:: rtems_task_priority
    133133
    134 A task’s priority determines its importance in relation to the
     134A task's priority determines its importance in relation to the
    135135other tasks executing on the same processor.  RTEMS supports 255
    136136levels of priority ranging from 1 to 255.  The data type``rtems_task_priority`` is used to store task
     
    159159.. index:: rtems_task_mode
    160160
    161 A task’s execution mode is a combination of the following
     161A task's execution mode is a combination of the following
    162162four components:
    163163
     
    170170- interrupt level
    171171
    172 It is used to modify RTEMS’ scheduling process and to alter the
     172It is used to modify RTEMS' scheduling process and to alter the
    173173execution environment of the task.  The data type``rtems_task_mode`` is used to manage the task
    174174execution mode... index:: preemption
     
    177177processor is relinquished.  If preemption is disabled
    178178(``RTEMS_NO_PREEMPT``), the task will retain control of the
    179 processor as long as it is in the executing state – even if a higher
     179processor as long as it is in the executing state - even if a higher
    180180priority task is made ready.  If preemption is enabled
    181181(``RTEMS_PREEMPT``)  and a higher priority task is made ready,
     
    301301treated as private (i.e. per-task) the task can access and modify the
    302302variable, but the modifications will not appear to other tasks, and
    303 other tasks’ modifications to that variable will not affect the value
     303other tasks' modifications to that variable will not affect the value
    304304seen by the task.  This is accomplished by saving and restoring the
    305 variable’s value each time a task switch occurs to or from the calling task.
     305variable's value each time a task switch occurs to or from the calling task.
    306306
    307307The value seen by other tasks, including those which have not added the
     
    323323task variables.  One efficient method is to have a single task
    324324variable that is a pointer to a dynamically allocated structure
    325 containing the task’s private "global" data.
     325containing the task's private "global" data.
    326326
    327327A critical point with per-task variables is that each task must separately
     
    330330*WARNING*: Per-Task variables are inherently broken on SMP systems. They
    331331only work correctly when there is one task executing in the system and
    332 that task is the logical owner of the value in the per-task variable’s
     332that task is the logical owner of the value in the per-task variable's
    333333location. There is no way for a single memory image to contain the
    334334correct value for each task executing on each core. Consequently,
     
    375375In general, a mode and its corresponding mask is built by a
    376376bitwise OR of the desired components.  The set of valid mode
    377 constants and each mode’s corresponding mask constant is
     377constants and each mode's corresponding mask constant is
    378378listed below:
    379379
     
    408408RTEMS_NO_PREEMPT`` to indicate the desired preemption mode and
    409409interrupt level, while the mask parameter should be set to``RTEMS_INTERRUPT_MASK |
    410 RTEMS_NO_PREEMPT_MASK`` to indicate that the calling task’s
     410RTEMS_NO_PREEMPT_MASK`` to indicate that the calling task's
    411411interrupt level and preemption mode are being altered.
    412412
     
    451451
    452452With the ``rtems_task_start``
    453 directive the user specifies the task’s
     453directive the user specifies the task's
    454454starting address and argument.  The argument is used to
    455455communicate some startup information to the task.  As part of
    456 this directive, RTEMS initializes the task’s stack based upon
    457 the task’s initial execution mode and start address.  The
     456this directive, RTEMS initializes the task's stack based upon
     457the task's initial execution mode and start address.  The
    458458starting argument is passed to the task in accordance with the
    459 target processor’s calling convention.
     459target processor's calling convention.
    460460
    461461The ``rtems_task_restart``
     
    464464but with a possibly different argument.  The new argument may be
    465465used to distinguish between the original invocation of the task
    466 and subsequent invocations.  The task’s stack and control block
     466and subsequent invocations.  The task's stack and control block
    467467are modified to reflect their original creation values.
    468468Although references to resources that have been requested are
     
    520520directive is used to obtain or change the
    521521current priority of either the calling task or another task.  If
    522 the new priority requested is``RTEMS_CURRENT_PRIORITY`` or the task’s
     522the new priority requested is``RTEMS_CURRENT_PRIORITY`` or the task's
    523523actual priority, then the current priority will be returned and
    524 the task’s priority will remain unchanged.  If the task’s
     524the task's priority will remain unchanged.  If the task's
    525525priority is altered, then the task will be scheduled according
    526526to its new priority.
     
    535535The ``rtems_task_mode``
    536536directive is used to obtain or change the current
    537 execution mode of the calling task.  A task’s execution mode is
     537execution mode of the calling task.  A task's execution mode is
    538538used to enable preemption, timeslicing, ASR processing, and to
    539 set the task’s interrupt level.
     539set the task's interrupt level.
    540540
    541541The ``rtems_task_restart``
     
    549549directive to allow a task to
    550550delete itself or any other task.  This directive removes all
    551 RTEMS references to the task, frees the task’s control block,
     551RTEMS references to the task, frees the task's control block,
    552552removes it from resource wait queues, and deallocates its stack
    553 as well as the optional floating point context.  The task’s name
     553as well as the optional floating point context.  The task's name
    554554and ID become inactive at this time, and any subsequent
    555555references to either of them is invalid.  In fact, RTEMS may
     
    590590==========
    591591
    592 This section details the task manager’s directives.  A
    593 subsection is dedicated to each of this manager’s directives and
     592This section details the task manager's directives.  A
     593subsection is dedicated to each of this manager's directives and
    594594describes the calling sequence, related constants, usage, and
    595595status codes.
     
    630630It allocates and initializes a TCB, a stack, and an optional
    631631floating point context area.  The mode parameter contains values
    632 which sets the task’s initial execution mode.  The``RTEMS_FLOATING_POINT`` attribute should be
     632which sets the task's initial execution mode.  The``RTEMS_FLOATING_POINT`` attribute should be
    633633specified if the created task
    634634is to use a numeric coprocessor.  For performance reasons, it is
     
    714714interact with them.  This avoids the system overhead incurred by
    715715the creation of a global task.  When a global task is created,
    716 the task’s name and id must be transmitted to every node in the
     716the task's name and id must be transmitted to every node in the
    717717system for insertion in the local copy of the global object
    718718table.
     
    821821This directive readies the task, specified by ``id``, for execution
    822822based on the priority and execution mode specified when the task
    823 was created.  The starting address of the task is given in``entry_point``.  The task’s starting argument is contained in
     823was created.  The starting address of the task is given in``entry_point``.  The task's starting argument is contained in
    824824argument.  This argument can be a single value or used as an index into an
    825825array of parameter blocks.  The type of this numeric argument is an unsigned
     
    862862
    863863This directive resets the task specified by id to begin
    864 execution at its original starting address.  The task’s priority
     864execution at its original starting address.  The task's priority
    865865and execution mode are set to the original creation values.  If
    866866the task is currently blocked, RTEMS automatically makes the
     
    868868dormant state.
    869869
    870 The task’s starting argument is contained in argument.  This argument can be a
     870The task's starting argument is contained in argument.  This argument can be a
    871871single value or an index into an array of parameter blocks.  The type of this
    872872numeric argument is an unsigned integer type with the property that any valid
     
    10871087id.  An id of ``RTEMS_SELF`` is used to indicate
    10881088the calling task.  When new_priority is not equal to``RTEMS_CURRENT_PRIORITY``, the specified
    1089 task’s previous priority is returned in old_priority.  When
     1089task's previous priority is returned in old_priority.  When
    10901090new_priority is ``RTEMS_CURRENT_PRIORITY``,
    1091 the specified task’s current
     1091the specified task's current
    10921092priority is returned in old_priority.  Valid priorities range
    10931093from a high of 1 to a low of 255.
     
    10961096
    10971097The calling task may be preempted if its preemption mode is
    1098 enabled and it lowers its own priority or raises another task’s
     1098enabled and it lowers its own priority or raises another task's
    10991099priority.
    11001100
     
    11081108If the task specified by id is currently holding any binary
    11091109semaphores which use the priority inheritance algorithm, then
    1110 the task’s priority cannot be lowered immediately.  If the
    1111 task’s priority were lowered immediately, then priority
    1112 inversion results.  The requested lowering of the task’s
     1110the task's priority cannot be lowered immediately.  If the
     1111task's priority were lowered immediately, then priority
     1112inversion results.  The requested lowering of the task's
    11131113priority will occur when the task has released all priority
    1114 inheritance binary semaphores.  The task’s priority can be
    1115 increased regardless of the task’s use of priority inheritance
     1114inheritance binary semaphores.  The task's priority can be
     1115increased regardless of the task's use of priority inheritance
    11161116binary semaphores.
    11171117
     
    11451145
    11461146This directive manipulates the execution mode of the calling
    1147 task.  A task’s execution mode enables and disables preemption,
     1147task.  A task's execution mode enables and disables preemption,
    11481148timeslicing, asynchronous signal processing, as well as
    11491149specifying the current interrupt level.  To modify an execution
     
    11681168indicator specified in mode.
    11691169
    1170 The set of task mode constants and each mode’s corresponding
     1170The set of task mode constants and each mode's corresponding
    11711171mask constant is provided in the following table:
    11721172
     
    13281328then be private to the task.  The task can access and modify the
    13291329variable, but the modifications will not appear to other tasks, and
    1330 other tasks’ modifications to that variable will not affect the value
     1330other tasks' modifications to that variable will not affect the value
    13311331seen by the task.  This is accomplished by saving and restoring the
    1332 variable’s value each time a task switch occurs to or from the calling task.
    1333 If the dtor argument is non-NULL it specifies the address of a ‘destructor’
     1332variable's value each time a task switch occurs to or from the calling task.
     1333If the dtor argument is non-NULL it specifies the address of a 'destructor'
    13341334function which will be called when the task is deleted.  The argument
    1335 passed to the destructor function is the task’s value of the variable.
     1335passed to the destructor function is the task's value of the variable.
    13361336
    13371337**NOTES:**
     
    13431343task variables.  One efficient method
    13441344is to have a single task variable that is a pointer to a dynamically
    1345 allocated structure containing the task’s private ‘global’ data.
    1346 In this case the destructor function could be ‘free’.
     1345allocated structure containing the task's private 'global' data.
     1346In this case the destructor function could be 'free'.
    13471347
    13481348Per-task variables are disabled in SMP configurations and this service
     
    14211421**DESCRIPTION:**
    14221422
    1423 This directive removes the given location from a task’s context.
     1423This directive removes the given location from a task's context.
    14241424
    14251425**NOTES:**
  • c_user/timer_manager.rst

    r11e1a6f rd389819  
    184184The ``rtems_timer_delete`` directive is used to delete a timer.
    185185If the timer is running and has not expired, the timer is
    186 automatically canceled.  The timer’s control block is returned
     186automatically canceled.  The timer's control block is returned
    187187to the TMCB free list when it is deleted.  A timer can be
    188188deleted by a task other than the task which created the timer.
    189 Any subsequent references to the timer’s name and ID are invalid.
     189Any subsequent references to the timer's name and ID are invalid.
    190190
    191191Directives
    192192==========
    193193
    194 This section details the timer manager’s directives.
    195 A subsection is dedicated to each of this manager’s directives
     194This section details the timer manager's directives.
     195A subsection is dedicated to each of this manager's directives
    196196and describes the calling sequence, related constants, usage,
    197197and status codes.
  • c_user/timespec_helpers.rst

    r11e1a6f rd389819  
    1010The directives provided by the timespec helpers manager are:
    1111
    12 - ``rtems_timespec_set`` - Set timespec’s value
    13 
    14 - ``rtems_timespec_zero`` - Zero timespec’s value
     12- ``rtems_timespec_set`` - Set timespec's value
     13
     14- ``rtems_timespec_zero`` - Zero timespec's value
    1515
    1616- ``rtems_timespec_is_valid`` - Check if timespec is valid
     
    102102==========
    103103
    104 This section details the Timespec Helpers manager’s directives.
    105 A subsection is dedicated to each of this manager’s directives
     104This section details the Timespec Helpers manager's directives.
     105A subsection is dedicated to each of this manager's directives
    106106and describes the calling sequence, related constants, usage,
    107107and status codes.
  • c_user/user_extensions.rst

    r11e1a6f rd389819  
    7373RTEMS allows the user to have multiple extension sets
    7474active at the same time.  First, a single static extension set
    75 may be defined as the application’s User Extension Table which
     75may be defined as the application's User Extension Table which
    7676is included as part of the Configuration Table.  This extension
    7777set is active for the entire life of the system and may not be
     
    113113
    114114RTEMS provides for a pointer to a user-defined data
    115 area for each extension set to be linked to each task’s control
     115area for each extension set to be linked to each task's control
    116116block.  This set of pointers is an extension of the TCB and can
    117 be used to store additional data required by the user’s
     117be used to store additional data required by the user's
    118118extension functions.
    119119
     
    130130augment the TCB with user-defined information.  For example, an
    131131application could implement task profiling by storing timing
    132 statistics in the TCB’s extended memory area.  When a task
     132statistics in the TCB's extended memory area.  When a task
    133133context switch is being executed, the TASK_SWITCH extension
    134134could read a real-time clock to calculate how long the task
     
    145145deleted.  Since the TCB extension buffers would most likely be
    146146of a fixed size, the RTEMS partition manager could be used to
    147 manage the application’s extended memory area.  The application
     147manage the application's extended memory area.  The application
    148148could create a partition of fixed size TCB extension buffers and
    149 use the partition manager’s allocation and deallocation
     149use the partition manager's allocation and deallocation
    150150directives to obtain and release the extension buffers.
    151151
     
    287287the task that is being swapped out, and heir_task can be used to
    288288access the TCB for the task being swapped in.  This extension is
    289 invoked from RTEMS’ dispatcher routine after the current_task
     289invoked from RTEMS' dispatcher routine after the current_task
    290290context has been saved, but before the heir_task context has
    291291been restored.  This extension should not call any RTEMS
     
    361361the fatal_error_occurred directive.
    362362
    363 If defined, the user’s FATAL error extension is
    364 invoked before RTEMS’ default fatal error routine is invoked and
     363If defined, the user's FATAL error extension is
     364invoked before RTEMS' default fatal error routine is invoked and
    365365the processor is stopped.  For example, this extension could be
    366366used to pass control to a debugger when a fatal error occurs.
     
    411411Standard C Library.  Extension sets which are installed after
    412412the Standard C Library will operate correctly even if they
    413 utilize the C Library because the C Library’s TASK_DELETE
     413utilize the C Library because the C Library's TASK_DELETE
    414414extension is invoked after that of the other extensions.
    415415
     
    445445
    446446The ``rtems_extension_delete`` directive is used to delete an
    447 extension set.  The extension set’s control block is returned to
     447extension set.  The extension set's control block is returned to
    448448the ESCB free list when it is deleted.  An extension set can be
    449449deleted by a task other than the task which created the
    450 extension set.  Any subsequent references to the extension’s
     450extension set.  Any subsequent references to the extension's
    451451name and ID are invalid.
    452452
     
    454454==========
    455455
    456 This section details the user extension manager’s
    457 directives.  A subsection is dedicated to each of this manager’s
     456This section details the user extension manager's
     457directives.  A subsection is dedicated to each of this manager's
    458458directives and describes the calling sequence, related
    459459constants, usage, and status codes.
  • cpu_supplement/atmel_avr.rst

    r11e1a6f rd389819  
    5252
    5353A called function may clobber all registers, except RETS, R4-R7, P3-P5,
    54 FP and SP.  It may also modify the first 12 bytes in the caller’s stack
     54FP and SP.  It may also modify the first 12 bytes in the caller's stack
    5555frame which is used as an argument area for the first three arguments
    5656(which are passed in R0...R3 but may be placed on the stack by the
     
    8181====================
    8282
    83 Discussed in this chapter are the AVR’s interrupt response and
     83Discussed in this chapter are the AVR's interrupt response and
    8484control mechanisms as they pertain to RTEMS.
    8585
  • cpu_supplement/blackfin.rst

    r11e1a6f rd389819  
    5656
    5757A called function may clobber all registers, except RETS, R4-R7, P3-P5,
    58 FP and SP.  It may also modify the first 12 bytes in the caller’s stack
     58FP and SP.  It may also modify the first 12 bytes in the caller's stack
    5959frame which is used as an argument area for the first three arguments
    6060(which are passed in R0...R3 but may be placed on the stack by the
     
    8585====================
    8686
    87 Discussed in this chapter are the Blackfin’s interrupt response and
     87Discussed in this chapter are the Blackfin's interrupt response and
    8888control mechanisms as they pertain to RTEMS. The Blackfin architecture
    8989support 16 kinds of interrupts broken down into Core and general-purpose
  • cpu_supplement/index.rst

    r11e1a6f rd389819  
    33=================================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • cpu_supplement/intel_amd_x86.rst

    r11e1a6f rd389819  
    1010following documents:
    1111
    12 - *386 Programmer’s Reference Manual, Intel, Order No.  230985-002*.
     12- *386 Programmer's Reference Manual, Intel, Order No.  230985-002*.
    1313
    1414- *386 Microprocessor Hardware Reference Manual, Intel,
    1515  Order No. 231732-003*.
    1616
    17 - *80386 System Software Writer’s Guide, Intel, Order No.  231499-001*.
    18 
    19 - *80387 Programmer’s Reference Manual, Intel, Order No.  231917-001*.
     17- *80386 System Software Writer's Guide, Intel, Order No.  231499-001*.
     18
     19- *80387 Programmer's Reference Manual, Intel, Order No.  231917-001*.
    2020
    2121CPU Model Dependent Features
     
    3434endian swaps a thirty-two bit quantity.  This instruction
    3535appears to be present in all CPU models
    36 i486’s and above.
     36i486's and above.
    3737
    3838Calling Conventions
     
    129129dependent details of interrupt processing, it is important to
    130130understand how the RTEMS interrupt manager is mapped onto the
    131 processor’s unique architecture. Discussed in this chapter are
    132 the the processor’s response and control mechanisms as they
     131processor's unique architecture. Discussed in this chapter are
     132the the processor's response and control mechanisms as they
    133133pertain to RTEMS.
    134134
     
    176176
    177177Although RTEMS supports 256 interrupt levels, the
    178 i386 only supports two – enabled and disabled.  Interrupts are
     178i386 only supports two - enabled and disabled.  Interrupts are
    179179enabled when the interrupt-enable flag (IF) in the extended
    180180flags (EFLAGS) is set.  Conversely, interrupt processing is
     
    226226When the i386 is reset,
    227227
    228 - The EAX register is set to indicate the results of the processor’s
     228- The EAX register is set to indicate the results of the processor's
    229229  power-up self test.  If the self-test was not executed, the contents of
    230230  this register are undefined.  Otherwise, a non-zero value indicates the
     
    254254  of memory.
    255255
    256 Typically, an intersegment JMP to the application’s initialization code is
     256Typically, an intersegment JMP to the application's initialization code is
    257257placed at address 0xFFFFFFF0.
    258258
     
    307307
    308308For more information regarding the i386 data structures and their
    309 contents, refer to Intel’s 386 Programmer’s Reference Manual.
     309contents, refer to Intel's 386 Programmer's Reference Manual.
    310310
    311311.. COMMENT: COPYRIGHT (c) 1988-2002.
  • cpu_supplement/lattice_micro32.rst

    r11e1a6f rd389819  
    66architecture "soft" microprocessor, available for free with an open IP
    77core licensing agreement. Although mainly targeted for Lattice FPGA
    8 devices the microprocessor can be implemented on other vendors’ FPGAs,
     8devices the microprocessor can be implemented on other vendors' FPGAs,
    99too.
    1010
     
    193193
    194194Most of the action performed as part of processing the fatal error are
    195 described in detail in the Fatal Error Manager chapter in the User’s
     195described in detail in the Fatal Error Manager chapter in the User's
    196196Guide.  However, the if no user provided extension or BSP specific fatal
    197197error handler takes action, the final default action is to invoke a
     
    222222on developing a BSP, refer to BSP and Device Driver Development Guide
    223223and the chapter titled Board Support Packages in the RTEMS
    224 Applications User’s Guide.
     224Applications User's Guide.
    225225
    226226System Reset
  • cpu_supplement/m68xxx_and_coldfire.rst

    r11e1a6f rd389819  
    1818- *M68000 Family Reference, Motorola, FR68K/D*.
    1919
    20 - *MC68020 User’s Manual, Motorola, MC68020UM/AD*.
    21 
    22 - *MC68881/MC68882 Floating-Point Coprocessor User’s Manual,
     20- *MC68020 User's Manual, Motorola, MC68020UM/AD*.
     21
     22- *MC68881/MC68882 Floating-Point Coprocessor User's Manual,
    2323  Motorola, MC68881UM/AD*.
    2424
     
    137137====================
    138138
    139 Discussed in this section are the MC68xxx’s interrupt response and
     139Discussed in this section are the MC68xxx's interrupt response and
    140140control mechanisms as they pertain to RTEMS.
    141141
     
    183183  interrupt handler will begin execution.  The RTEMS interrupt
    184184  handler saves all registers which are not preserved according to
    185   the calling conventions and invokes the application’s ISR.
     185  the calling conventions and invokes the application's ISR.
    186186
    187187A nested interrupt is processed similarly by these
     
    340340------------------------
    341341
    342 The address of the application’s initialization code should be stored in
     342The address of the application's initialization code should be stored in
    343343the first vector of the EVT which will allow the immediate vectoring to
    344344the application code.  If the application requires that the VBR be some
    345345value besides zero, then it should be set to the required value at this
    346 point.  All tasks share the same MC68020’s VBR value.  Because interrupts
     346point.  All tasks share the same MC68020's VBR value.  Because interrupts
    347347are enabled automatically by RTEMS as part of the context switch to the
    348348first task, the VBR MUST be set by either RTEMS of the BSP before this
     
    352352
    353353In addition to the requirements described in the
    354 Board Support Packages chapter of the Applications User’s
     354Board Support Packages chapter of the Applications User's
    355355Manual for the reset code which is executed before the call to
    356356initialize executive, the MC68020 version has the following
     
    367367  the initialize executive directive.
    368368
    369 - Must initialize the MC68020’s vector table.
     369- Must initialize the MC68020's vector table.
    370370
    371371.. COMMENT: Copyright (c) 2014 embedded brains GmbH.  All rights reserved.
  • cpu_supplement/mips.rst

    r11e1a6f rd389819  
    7575Although RTEMS hides many of the processor dependent
    7676details of interrupt processing, it is important to understand
    77 how the RTEMS interrupt manager is mapped onto the processor’s
    78 unique architecture. Discussed in this chapter are the MIPS’s
     77how the RTEMS interrupt manager is mapped onto the processor's
     78unique architecture. Discussed in this chapter are the MIPS's
    7979interrupt response and control mechanisms as they pertain to
    8080RTEMS.
  • cpu_supplement/port.rst

    r11e1a6f rd389819  
    4343is or is not present and defines a single constant appropriately.
    4444Conditional compilation is utilized to include the appropriate source
    45 code for this CPU model’s feature set.  It is important to note that
     45code for this CPU model's feature set.  It is important to note that
    4646this means that RTEMS is thus compiled using the appropriate feature set
    4747and compilation flags optimal for this CPU model used.  The alternative
     
    119119
    120120Each high-level language compiler generates subroutine entry and exit
    121 code based upon a set of rules known as the compiler’s calling convention.
     121code based upon a set of rules known as the compiler's calling convention.
    122122These rules address the following issues:
    123123
     
    128128- call and return mechanism
    129129
    130 A compiler’s calling convention is of importance when
     130A compiler's calling convention is of importance when
    131131interfacing to subroutines written in another language either
    132132assembly or high-level.  Even when the high-level language and
     
    178178models ranging from pure physical addressing to complex demand
    179179paged virtual memory systems.  RTEMS supports a flat memory
    180 model which ranges contiguously over the processor’s allowable
     180model which ranges contiguously over the processor's allowable
    181181address space.  RTEMS does not support segmentation or virtual
    182182memory of any kind.  The appropriate memory model for RTEMS
     
    220220hides many of the processor dependent details of interrupt processing,
    221221it is important to understand how the RTEMS interrupt manager is mapped
    222 onto the processor’s unique architecture.
     222onto the processor's unique architecture.
    223223
    224224RTEMS supports a dedicated interrupt stack for all architectures.
     
    244244Workspace Area.  The amount of memory allocated for the interrupt stack
    245245is user configured and based upon the ``confdefs.h`` parameter``CONFIGURE_INTERRUPT_STACK_SIZE``.  This parameter is described
    246 in detail in the Configuring a System chapter of the User’s Guide.
     246in detail in the Configuring a System chapter of the User's Guide.
    247247On configurations in which RTEMS allocates the interrupt stack, during
    248248the initialization process, RTEMS will also install its interrupt stack.
     
    319319
    320320Most of the action performed as part of processing the fatal error are
    321 described in detail in the Fatal Error Manager chapter in the User’s
     321described in detail in the Fatal Error Manager chapter in the User's
    322322Guide.  However, the if no user provided extension or BSP specific fatal
    323323error handler takes action, the final default action is to invoke a
     
    415415on developing a BSP, refer to BSP and Device Driver Development Guide
    416416and the chapter titled Board Support Packages in the RTEMS
    417 Applications User’s Guide.
     417Applications User's Guide.
    418418
    419419System Reset
  • cpu_supplement/powerpc.rst

    r11e1a6f rd389819  
    2121  (Motorola Document MPRPPCFPE-01).
    2222
    23 - *IBM PPC403GB Embedded Controller User’s Manual*.
     23- *IBM PPC403GB Embedded Controller User's Manual*.
    2424
    2525- *PoweRisControl MPC500 Family RCPU RISC Central Processing
    2626  Unit Reference Manual* (Motorola Document RCPUURM/AD).
    2727
    28 - *PowerPC 601 RISC Microprocessor User’s Manual*
     28- *PowerPC 601 RISC Microprocessor User's Manual*
    2929  (Motorola Document MPR601UM/AD).
    3030
    31 - *PowerPC 603 RISC Microprocessor User’s Manual*
     31- *PowerPC 603 RISC Microprocessor User's Manual*
    3232  (Motorola Document MPR603UM/AD).
    3333
    34 - *PowerPC 603e RISC Microprocessor User’s Manual*
     34- *PowerPC 603e RISC Microprocessor User's Manual*
    3535  (Motorola Document MPR603EUM/AD).
    3636
    37 - *PowerPC 604 RISC Microprocessor User’s Manual*
     37- *PowerPC 604 RISC Microprocessor User's Manual*
    3838  (Motorola Document MPR604UM/AD).
    3939
    40 - *PowerPC MPC821 Portable Systems Microprocessor User’s Manual*
     40- *PowerPC MPC821 Portable Systems Microprocessor User's Manual*
    4141  (Motorola Document MPC821UM/AD).
    4242
    43 - *PowerQUICC MPC860 User’s Manual* (Motorola Document MPC860UM/AD).
     43- *PowerQUICC MPC860 User's Manual* (Motorola Document MPC860UM/AD).
    4444
    4545Motorola maintains an on-line electronic library for the PowerPC
     
    7676---------
    7777
    78 The macro PPC_ALIGNMENT is set to the PowerPC model’s worst case alignment
     78The macro PPC_ALIGNMENT is set to the PowerPC model's worst case alignment
    7979requirement for data types on a byte boundary.  This value is used
    8080to derive the alignment restrictions for memory allocated from
     
    412412Although RTEMS hides many of the processor dependent
    413413details of interrupt processing, it is important to understand
    414 how the RTEMS interrupt manager is mapped onto the processor’s
    415 unique architecture. Discussed in this chapter are the PowerPC’s
     414how the RTEMS interrupt manager is mapped onto the processor's
     415unique architecture. Discussed in this chapter are the PowerPC's
    416416interrupt response and control mechanisms as they pertain to
    417417RTEMS.
     
    469469performs the following actions:
    470470
    471 - saves the state of the interrupted task on it’s stack,
     471- saves the state of the interrupted task on it's stack,
    472472
    473473- saves all registers which are not normally preserved
    474   by the calling sequence so the user’s interrupt service
     474  by the calling sequence so the user's interrupt service
    475475  routine can be written in a high-level language.
    476476
     
    561561architecture defines a Reset Exception, but leaves the
    562562details of the CPU state as implementation specific.  Please
    563 refer to the User’s Manual for the CPU model in question.
     563refer to the User's Manual for the CPU model in question.
    564564
    565565In general, at power-up the PowerPC begin execution at address
     
    580580
    581581In addition to the requirements described in the*Board Support Packages* chapter of the RTEMS C
    582 Applications User’s Manual for the reset code
     582Applications User's Manual for the reset code
    583583which is executed before the call to ``rtems_initialize_executive``,
    584584the PowrePC version has the following specific requirements:
     
    597597  conditions can be properly handled.
    598598
    599 - Must initialize the PowerPC’s initial Exception Table with default
     599- Must initialize the PowerPC's initial Exception Table with default
    600600  handlers.
    601601
  • cpu_supplement/sparc.rst

    r11e1a6f rd389819  
    3434**ERC32 Specific Information**
    3535
    36 The European Space Agency’s ERC32 is a three chip
     36The European Space Agency's ERC32 is a three chip
    3737computing core implementing a SPARC V7 processor and associated
    3838support circuitry for embedded space applications. The integer
     
    5757- MEC Device Specification
    5858
    59 Additionally, the SPARC RISC User’s Guide from Matra
     59Additionally, the SPARC RISC User's Guide from Matra
    6060MHS documents the functionality of the integer and floating
    6161point units including the instruction set information.  To
     
    113113single constant appropriately.  Conditional compilation is
    114114utilized to include the appropriate source code for this CPU
    115 model’s feature set.  It is important to note that this means
     115model's feature set.  It is important to note that this means
    116116that RTEMS is thus compiled using the appropriate feature set
    117117and compilation flags optimal for this CPU model used.  The
     
    131131The macro CPU_MODEL_NAME is a string which designates
    132132the name of this CPU model.  For example, for the European Space
    133 Agency’s ERC32 SPARC model, this macro is set to the string
     133Agency's ERC32 SPARC model, this macro is set to the string
    134134"erc32".
    135135
     
    386386Because the set of register windows is finite, it is
    387387possible to execute enough save instructions without
    388 corresponding restore’s to consume all of the register windows.
     388corresponding restore's to consume all of the register windows.
    389389This is easily accomplished in a high level language because
    390390each subroutine typically performs a save instruction upon
     
    397397
    398398Similarly, the subroutines will eventually complete
    399 and begin to perform restore’s.  If the restore results in the
     399and begin to perform restore's.  If the restore results in the
    400400need for a register window which has previously been written to
    401401memory as part of an overflow, then a window underflow condition
     
    459459effective call and return mechanism.  A subroutine is invoked
    460460via the call (call) instruction.  This instruction places the
    461 return address in the caller’s output register 7 (o7).  After
     461return address in the caller's output register 7 (o7).  After
    462462the callee executes a save instruction, this value is available
    463463in input register 7 (i7) until the corresponding restore
     
    467467return address.  There is a delay slot following this
    468468instruction which is commonly used to execute a restore
    469 instruction – if a register window was allocated by this
     469instruction - if a register window was allocated by this
    470470subroutine.
    471471
     
    501501
    502502RTEMS assumes that arguments are placed in the
    503 caller’s output registers with the first argument in output
     503caller's output registers with the first argument in output
    504504register 0 (o0), the second argument in output register 1 (o1),
    505505and so forth.  Until the callee executes a save instruction, the
     
    535535models ranging from pure physical addressing to complex demand
    536536paged virtual memory systems.  RTEMS supports a flat memory
    537 model which ranges contiguously over the processor’s allowable
     537model which ranges contiguously over the processor's allowable
    538538address space.  RTEMS does not support segmentation or virtual
    539539memory of any kind.  The appropriate memory model for RTEMS
     
    602602stream.  Although RTEMS hides many of the processor dependent
    603603details of interrupt processing, it is important to understand
    604 how the RTEMS interrupt manager is mapped onto the processor’s
    605 unique architecture. Discussed in this chapter are the SPARC’s
     604how the RTEMS interrupt manager is mapped onto the processor's
     605unique architecture. Discussed in this chapter are the SPARC's
    606606interrupt response and control mechanisms as they pertain to
    607607RTEMS.
     
    677677performs the following actions:
    678678
    679 - saves the state of the interrupted task on it’s stack,
     679- saves the state of the interrupted task on it's stack,
    680680
    681681- insures that a register window is available for
     
    714714RTEMS interrupt handler insures that a register window is
    715715available for subsequent traps before enabling traps and
    716 invoking the user’s interrupt handler.
     716invoking the user's interrupt handler.
    717717
    718718Interrupt Levels
     
    793793since EVERY task stack would have to include enough space to
    794794account for the worst case interrupt stack requirements in
    795 addition to it’s own worst case usage.  RTEMS addresses this
     795addition to it's own worst case usage.  RTEMS addresses this
    796796problem on the SPARC by providing a dedicated interrupt stack
    797797managed by software.
     
    865865For more information on developing a BSP, refer to the chapter
    866866titled Board Support Packages in the RTEMS
    867 Applications User’s Guide.
     867Applications User's Guide.
    868868
    869869System Reset
     
    892892------------------------
    893893
    894 It is the responsibility of the application’s
     894It is the responsibility of the application's
    895895initialization code to initialize the TBR and install trap
    896896handlers for at least the register window overflow and register
     
    899899management.  However, interrupts should be disabled by setting
    900900the Processor Interrupt Level (pil) field of the psr to 15.
    901 RTEMS installs it’s own Trap Table as part of initialization
     901RTEMS installs it's own Trap Table as part of initialization
    902902which is initialized with the contents of the Trap Table in
    903903place when the ``rtems_initialize_executive`` directive was invoked.
     
    927927  conditions can be properly handled.
    928928
    929 - Must initialize the SPARC’s initial trap table with at
     929- Must initialize the SPARC's initial trap table with at
    930930  least trap handlers for register window overflow and register
    931931  window underflow.
  • cpu_supplement/sparc64.rst

    r11e1a6f rd389819  
    1717The following documents were used in developing the SPARC-64 sun4u port:
    1818
    19 - UltraSPARC  User’s Manual
     19- UltraSPARC  User's Manual
    2020  (http://www.sun.com/microelectronics/manuals/ultrasparc/802-7220-02.pdf)
    2121
     
    105105Each high-level language compiler generates
    106106subroutine entry and exit code based upon a set of rules known
    107 as the compiler’s calling convention.   These rules address the
     107as the compiler's calling convention.   These rules address the
    108108following issues:
    109109
     
    114114- call and return mechanism
    115115
    116 A compiler’s calling convention is of importance when
     116A compiler's calling convention is of importance when
    117117interfacing to subroutines written in another language either
    118118assembly or high-level.  Even when the high-level language and
     
    223223*``Processor State Register (pstate)``*
    224224    The privileged pstate register contains control fields for the proces-
    225     sor’s current state. Its flag fields include the interrupt enable, privi-
     225    sor's current state. Its flag fields include the interrupt enable, privi-
    226226    leged mode, and enable FPU.
    227227
     
    271271Because the set of register windows is finite, it is
    272272possible to execute enough save instructions without
    273 corresponding restore’s to consume all of the register windows.
     273corresponding restore's to consume all of the register windows.
    274274This is easily accomplished in a high level language because
    275275each subroutine typically performs a save instruction upon
     
    282282
    283283Similarly, the subroutines will eventually complete
    284 and begin to perform restore’s.  If the restore results in the
     284and begin to perform restore's.  If the restore results in the
    285285need for a register window which has previously been written to
    286286memory as part of an overflow, then a window underflow condition
     
    339339effective call and return mechanism.  A subroutine is invoked
    340340via the call (call) instruction.  This instruction places the
    341 return address in the caller’s output register 7 (o7).  After
     341return address in the caller's output register 7 (o7).  After
    342342the callee executes a save instruction, this value is available
    343343in input register 7 (i7) until the corresponding restore
     
    347347return address.  There is a delay slot following this
    348348instruction which is commonly used to execute a restore
    349 instruction – if a register window was allocated by this
     349instruction - if a register window was allocated by this
    350350subroutine.
    351351
     
    355355restore instructions which manage the set of registers windows.
    356356This allows for the compiler to generate leaf-optimized functions
    357 that utilize the caller’s output registers without using save and restore.
     357that utilize the caller's output registers without using save and restore.
    358358
    359359Calling Mechanism
     
    377377
    378378RTEMS assumes that arguments are placed in the
    379 caller’s output registers with the first argument in output
     379caller's output registers with the first argument in output
    380380register 0 (o0), the second argument in output register 1 (o1),
    381381and so forth.  Until the callee executes a save instruction, the
     
    411411models ranging from pure physical addressing to complex demand
    412412paged virtual memory systems.  RTEMS supports a flat memory
    413 model which ranges contiguously over the processor’s allowable
     413model which ranges contiguously over the processor's allowable
    414414address space.  RTEMS does not support segmentation or virtual
    415415memory of any kind.  The appropriate memory model for RTEMS
     
    543543performs the following actions:
    544544
    545 - saves the state of the interrupted task on it’s stack,
     545- saves the state of the interrupted task on it's stack,
    546546
    547547- switches the processor to trap level 0,
     
    598598since EVERY task stack would have to include enough space to
    599599account for the worst case interrupt stack requirements in
    600 addition to it’s own worst case usage.  RTEMS addresses this
     600addition to it's own worst case usage.  RTEMS addresses this
    601601problem on the SPARC by providing a dedicated interrupt stack
    602602managed by software.
     
    662662For more information on developing a BSP, refer to the chapter
    663663titled Board Support Packages in the RTEMS
    664 Applications User’s Guide.
     664Applications User's Guide.
    665665
    666666HelenOS and Open Firmware
  • cpu_supplement/superh.rst

    r11e1a6f rd389819  
    8585Although RTEMS hides many of the processor dependent
    8686details of interrupt processing, it is important to understand
    87 how the RTEMS interrupt manager is mapped onto the processor’s
    88 unique architecture. Discussed in this chapter are the MIPS’s
     87how the RTEMS interrupt manager is mapped onto the processor's
     88unique architecture. Discussed in this chapter are the MIPS's
    8989interrupt response and control mechanisms as they pertain to
    9090RTEMS.
  • develenv/directory.rst

    r11e1a6f rd389819  
    104104
    105105``${RTEMS_ROOT}/cpukit/``
    106     This directory is the root for all of the "multilib’able"
     106    This directory is the root for all of the "multilib'able"
    107107    portions of RTEMS.  This is a GNU way of saying the
    108108    contents of this directory can be compiled like the
     
    124124``${RTEMS_ROOT}/make/``
    125125    This directory contains files which support the
    126     RTEMS Makefile’s.  From a user’s perspective, the
     126    RTEMS Makefile's.  From a user's perspective, the
    127127    most important parts are found in the ``custom/``
    128128    subdirectory.  Each ".cfg" file in this directory
     
    233233``${RTEMS_ROOT}/c/src/nfsclient/``
    234234    This directory contains a Network File System (NFS) client
    235     for RTEMS.  With this file system, a user’s application can
     235    for RTEMS.  With this file system, a user's application can
    236236    access files on a remote computer.
    237237
     
    555555``${RTEMS_ROOT}/doc/ada_user/``
    556556    This directory contains the source code for the *RTEMS
    557     Applications Ada User’s Guide* which documents the Ada95
     557    Applications Ada User's Guide* which documents the Ada95
    558558    binding to the Classic API.  This manual is produced from
    559559    from the same source base as the *RTEMS Application
    560     C User’s Guide*.
     560    C User's Guide*.
    561561
    562562``${RTEMS_ROOT}/doc/bsp_howto/``
     
    606606
    607607``${RTEMS_ROOT}/doc/posix_users/``
    608     This directory contains the source code for the*RTEMS POSIX API User’s Guide*.  It is important to
    609     note that RTEMS’ support for POSIX is a combination of
     608    This directory contains the source code for the*RTEMS POSIX API User's Guide*.  It is important to
     609    note that RTEMS' support for POSIX is a combination of
    610610    functionality provided by RTEMS and the Newlib C Library
    611611    so some functionality is documented by Newlib.
     
    629629``${RTEMS_ROOT}/doc/user/``
    630630    This directory contains the source code for the *RTEMS
    631     Applications C User’s Guide* which documents the Classic API.
     631    Applications C User's Guide* which documents the Classic API.
    632632
    633633.. COMMENT: COPYRIGHT (c) 1989-2007.
  • develenv/index.rst

    r11e1a6f rd389819  
    33===================================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • develenv/sample.rst

    r11e1a6f rd389819  
    130130    \*** END OF HELLO WORLD TEST \***
    131131
    132 These messages are printed from the application’s
     132These messages are printed from the application's
    133133single initialization task.  If the above messages are not
    134134printed correctly, then either the BSP start up code or the
     
    200200
    201201The first two messages are printed from the
    202 application’s single initialization task.  The final messages
     202application's single initialization task.  The final messages
    203203are printed from the single application task.
    204204
     
    234234    \*** END OF SAMPLE MULTIPROCESSOR APPLICATION \***
    235235
    236 The herald is printed from the application’s single
     236The herald is printed from the application's single
    237237initialization task on each node.  The final messages are
    238238printed from the single application task on each node.
  • develenv/utilities.rst

    r11e1a6f rd389819  
    117117The source for packhex first appeared in the May 1993
    118118issue of Embedded Systems magazine.  The code was downloaded
    119 from their BBS.  Unfortunately, the author’s name was not
     119from their BBS.  Unfortunately, the author's name was not
    120120provided in the listing.
    121121
     
    134134
    135135unhex accepts Intel Hexadecimal, Motorola Srecord, or
    136 TI ’B’ records and converts them to their binary equivalent.
     136TI 'B' records and converts them to their binary equivalent.
    137137The output may sent to standout or may be placed in a specified
    138138file with the -o option.  The designated output file may not be
  • filesystem/call_development.rst

    r11e1a6f rd389819  
    22#############################
    33
    4 This set of routines represents the application’s interface to files and directories
     4This set of routines represents the application's interface to files and directories
    55under the RTEMS filesystem. All routines are compliant with POSIX standards if a
    66specific interface has been established. The list below represents the routines that have
    7 been included as part of the application’s interface.
     7been included as part of the application's interface.
    88
    99# access()
     
    268268reallocated.
    269269
    270 The dd_buf structure’s memory is reallocated before the control structure
     270The dd_buf structure's memory is reallocated before the control structure
    271271that contains the pointer to the dd_buf region.
    272272
     
    630630directory.
    631631
    632 The OPS table evalformake() function for the parent’s filesystem is used
     632The OPS table evalformake() function for the parent's filesystem is used
    633633to locate the node that will be the parent of the new link. It will also
    634 locate the start of the new path’s name. This name will be used to define
     634locate the start of the new path's name. This name will be used to define
    635635a child under the parent directory.
    636636
  • filesystem/fileystem_implmentation.rst

    r11e1a6f rd389819  
    7979
    8080- On filesystems supporting hard links, a link count is maintained.
    81   Prior to node removal, the node’s link count is decremented by one.  The
     81  Prior to node removal, the node's link count is decremented by one.  The
    8282  link count must be less than one to allow for removal of the node.
    8383
     
    169169# write()
    170170
    171 The filesystem’s type as well as the node type within the filesystem
     171The filesystem's type as well as the node type within the filesystem
    172172determine the nature of the processing that must be performed for each of
    173173the functions above. The RTEMS filesystem provides a framework that
     
    635635The is intended to contain a string that identifies the device that contains
    636636the filesystem information. The filesystems that are currently implemented
    637 are memory based and don’t require a device specification.
     637are memory based and don't require a device specification.
    638638
    639639If the mt_point_node.node_access is NULL then we are mounting the base file
     
    646646others.
    647647
    648 The node’s name will be a null string.
     648The node's name will be a null string.
    649649
    650650A filesystem information structure(fs_info) will be allocated and
     
    760760Handler table functions are defined in a ``rtems_filesystem_file_handlers_r``
    761761structure. It defines functions that are specific to a node type in a given
    762 filesystem. One table exists for each of the filesystem’s node types. The
     762filesystem. One table exists for each of the filesystem's node types. The
    763763structure definition appears below. It is followed by general developmental
    764764information on each of the functions associated with regular files contained
  • filesystem/in-memory.rst

    r11e1a6f rd389819  
    5757
    5858*st_uid*
    59     is the user ID of the file’s owner
     59    is the user ID of the file's owner
    6060
    6161*st_gid*
    62     is the group ID of the file’s owner
     62    is the group ID of the file's owner
    6363
    6464*st_atime*
     
    500500type.
    501501
    502 If it is the node’s info element is altered so that the info.directory.mt_fs
     502If it is the node's info element is altered so that the info.directory.mt_fs
    503503element points to the mount table chain entry that is associated with the
    504504mounted filesystem at this point. The info.directory.mt_fs element can be
     
    603603The is intended to contain a string that identifies the device that contains
    604604the filesystem information. The filesystems that are currently implemented
    605 are memory based and don’t require a device specification.
     605are memory based and don't require a device specification.
    606606
    607607If the mt_point_node.node_access is NULL then we are mounting the base file
     
    614614others.
    615615
    616 The node’s name will be a null string.
     616The node's name will be a null string.
    617617
    618618A filesystem information structure(fs_info) will be allocated and
     
    659659
    660660The mount entry mount point node access is verified to be a mounted
    661 directory.  It’s mt_fs is set to NULL.  This identifies to future
     661directory.  It's mt_fs is set to NULL.  This identifies to future
    662662calles into the IMFS that this directory node is no longer a mount
    663663point.  Additionally, it will allow any directories that were hidden
     
    742742Handler table functions are defined in a rtems_filesystem_file_handlers_r
    743743structure. It defines functions that are specific to a node type in a given
    744 filesystem. One table exists for each of the filesystem’s node types. The
     744filesystem. One table exists for each of the filesystem's node types. The
    745745structure definition appears below. It is followed by general developmental
    746746information on each of the functions associated with regular files contained
     
    11151115Handler table functions are defined in a rtems_filesystem_file_handlers_r
    11161116structure. It defines functions that are specific to a node type in a given
    1117 filesystem. One table exists for each of the filesystem’s node types. The
     1117filesystem. One table exists for each of the filesystem's node types. The
    11181118structure definition appears below. It is followed by general developmental
    11191119information on each of the functions associated with directories contained in
     
    14681468Handler table functions are defined in a rtems_filesystem_file_handlers_r
    14691469structure. It defines functions that are specific to a node type in a given
    1470 filesystem. One table exists for each of the filesystem’s node types. The
     1470filesystem. One table exists for each of the filesystem's node types. The
    14711471structure definition appears below. It is followed by general developmental
    14721472information on each of the functions associated with devices contained in
  • filesystem/index.rst

    r11e1a6f rd389819  
    33=============================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • filesystem/pathname_eval.rst

    r11e1a6f rd389819  
    6767    This element is filesystem specific.  A filesystem can define and store
    6868    any information necessary to identify a node at this location.  This element
    69     is normally filled in by the filesystem’s evaluate routine. For the
    70     filesystem’s root node, the filesystem’s initilization routine should
     69    is normally filled in by the filesystem's evaluate routine. For the
     70    filesystem's root node, the filesystem's initilization routine should
    7171    fill this in, and it should remain valid until the instance of the
    7272    filesystem is unmounted.
  • filesystem/system_init.rst

    r11e1a6f rd389819  
    22#####################
    33
    4 After the RTEMS initialization is performed, the application’s
     4After the RTEMS initialization is performed, the application's
    55initialization will be performed. Part of initialization is a call to
    6 rtems_filesystem_initialize(). This routine will mount the ‘In Memory File
    7 System’ as the base filesystem.  Mounting the base filesystem consists
     6rtems_filesystem_initialize(). This routine will mount the 'In Memory File
     7System' as the base filesystem.  Mounting the base filesystem consists
    88of the following:
    99
     
    1111
    1212- Allocation of a ``jnode`` structure that will server as the root node
    13   of the ‘In Memory Filesystem’
     13  of the 'In Memory Filesystem'
    1414
    1515- Initialization of the allocated ``jnode`` with the appropriate OPS,
     
    3737RTEMS initially mounts a RAM based file system known as the base file system.
    3838The root directory of this file system tree serves as the logical root of the
    39 directory hierarchy (Figure 3). Under the root directory a ‘/dev’ directory
     39directory hierarchy (Figure 3). Under the root directory a '/dev' directory
    4040is created under which all I/O device directories and files are registered as
    4141part of the file system hierarchy.
     
    6262------------------------
    6363
    64 At present, the first file system to be mounted is the ‘In Memory File
    65 System’. It is mounted using a standard MOUNT() command in which the mount
     64At present, the first file system to be mounted is the 'In Memory File
     65System'. It is mounted using a standard MOUNT() command in which the mount
    6666point is NULL.  This flags the mount as the first file system to be
    6767registered under the operating system and appropriate initialization of file
     
    8282minor device number. In addition, the configuration information for each
    8383device contains a text string that represents the fully qualified pathname to
    84 that device’s place in the base file system’s hierarchy. A file system node
     84that device's place in the base file system's hierarchy. A file system node
    8585is created for the device along the specified registration path.
    8686
  • networking/dec_21140.rst

    r11e1a6f rd389819  
    4747The board we have chosen for our PC386 implementation is a D-Link DFE-500TX.
    4848This is a dual-speed 10/100Mbps Ethernet PCI adapter with a DEC21140AF chip.
    49 Like other PCI devices, this board has a PCI device’s header containing some
     49Like other PCI devices, this board has a PCI device's header containing some
    5050required configuration registers, as shown in the PCI Register Figure.
    5151By reading
     
    133133
    134134This thread is event driven. Each time a DEC PCI board interrupt occurs, the
    135 handler checks if this is a receive interrupt and send an event “reception”
     135handler checks if this is a receive interrupt and send an event "reception"
    136136to the receiver thread which looks into the entire buffer descriptors ring the
    137137ones that contain a valid incoming frame (bit OWN=0 means descriptor belongs
  • networking/index.rst

    r11e1a6f rd389819  
    22RTEMS Network Supplement
    33========================
    4 COPYRIGHT © 1988 - 2015.
     4COPYRIGHT (c) 1988 - 2015.
    55
    66On-Line Applications Research Corporation (OAR).
  • networking/network_servers.rst

    r11e1a6f rd389819  
    77The RTEMS FTPD is a complete file transfer protocol (FTP) daemon
    88which can store, retrieve, and manipulate files on the local
    9 filesystem.  In addition, the RTEMS FTPD provides “hooks”
     9filesystem.  In addition, the RTEMS FTPD provides "hooks"
    1010which are actions performed on received data.  Hooks are useful
    1111in situations where a destination file is not necessarily
  • networking/network_task_structure.rst

    r11e1a6f rd389819  
    2424aging and removing routing table entries.
    2525
    26 The ‘Network code’ contains routines which may run in the context of
     26The 'Network code' contains routines which may run in the context of
    2727the user application tasks, the interface receive task or the network task.
    2828A network semaphore ensures that
  • networking/networking_driver.rst

    r11e1a6f rd389819  
    77This chapter is intended to provide an introduction to the
    88procedure for writing RTEMS network device drivers.
    9 The example code is taken from the ‘Generic 68360’ network device
     9The example code is taken from the 'Generic 68360' network device
    1010driver.  The source code for this driver is located in the``c/src/lib/libbsp/m68k/gen68360/network`` directory in the RTEMS
    1111source code distribution.  Having a copy of this driver at
     
    1616
    1717Before starting to write the network driver become completely
    18 familiar with the programmer’s view of the device.
     18familiar with the programmer's view of the device.
    1919The following points list some of the details of the
    2020device that must be understood before a driver can be written.
     
    7171execute only when they hold the network semaphore (``rtems_bsdnet_semaphore``).
    7272The transmit and receive tasks must abide by this protocol.  Be very
    73 careful to avoid ‘deadly embraces’ with the other network tasks.
     73careful to avoid 'deadly embraces' with the other network tasks.
    7474A number of routines are provided to make it easier for the network
    7575driver code to conform to the network task scheduling conventions.
     
    161161``ifp->if_unit``
    162162    The device number.  The network stack uses this number and the
    163     device name for device name lookups.  For example, if``ifp->if_name`` is ‘``scc``’ and ``ifp->if_unit`` is ‘``1``’,
    164     the full device name would be ‘``scc1``’.  The unit number should be
    165     obtained from the ‘name’ entry in the configuration structure.
     163    device name for device name lookups.  For example, if``ifp->if_name`` is '``scc``' and ``ifp->if_unit`` is '``1``',
     164    the full device name would be '``scc1``'.  The unit number should be
     165    obtained from the 'name' entry in the configuration structure.
    166166
    167167``ifp->if_mtu``
     
    212212calling ``if_attach``.  Ethernet devices should then
    213213call ``ether_ifattach``.  Both functions take a pointer to the
    214 device’s ``ifnet`` structure as their only argument.
     214device's ``ifnet`` structure as their only argument.
    215215
    216216The attach function should return a non-zero value to indicate that
     
    222222This function is called each time the network stack wants to start the
    223223transmitter.  This occures whenever the network stack adds a packet
    224 to a device’s send queue and the ``IFF_OACTIVE`` bit in the
    225 device’s ``if_flags`` is not set.
     224to a device's send queue and the ``IFF_OACTIVE`` bit in the
     225device's ``if_flags`` is not set.
    226226
    227227For many devices this function need only set the ``IFF_OACTIVE`` bit in the``if_flags`` and send an event to the transmit task
  • networking/preface.rst

    r11e1a6f rd389819  
    1212to understand Ethernet:
    1313
    14 - *Charles Spurgeon’s Ethernet Web Site*
     14- *Charles Spurgeon's Ethernet Web Site*
    1515  "This site provides extensive information about Ethernet
    1616  (IEEE 802.3) local area network (LAN) technology. Including
  • networking/testing_the_driver.rst

    r11e1a6f rd389819  
    1212
    1313- An Ethernet network analyzer or a workstation with an
    14   ‘Ethernet snoop’ program such as ``ethersnoop`` or``tcpdump``.
     14  'Ethernet snoop' program such as ``ethersnoop`` or``tcpdump``.
    1515
    1616- A workstation.
     
    4040- mbuf activity
    4141  There are commented out calls to ``printf`` in the file``sys/mbuf.h`` in the network stack code.  Uncommenting
    42   these lines results in output when mbuf’s are allocated
     42  these lines results in output when mbuf's are allocated
    4343  and freed.  This is very useful for finding memory leaks.
    4444
     
    9292  For a quick reference to the flags, see the table below:
    9393
    94   ‘``U``’
     94  '``U``'
    9595      Up: The route is active.
    9696
    97   ‘``H``’
     97  '``H``'
    9898      Host: The route destination is a single host.
    9999
    100   ‘``G``’
     100  '``G``'
    101101      Gateway: Send anything for this destination on to this remote system, which
    102102      will figure out from there where to send it.
    103103
    104   ‘``S``’
     104  '``S``'
    105105      Static: This route was configured manually, not automatically generated by the
    106106      system.
    107107
    108   ‘``C``’
     108  '``C``'
    109109      Clone: Generates a new route based upon this route for machines we connect
    110110      to. This type of route is normally used for local networks.
    111111
    112   ‘``W``’
     112  '``W``'
    113113      WasCloned: Indicated a route that was auto-configured based upon a local area
    114114      network (Clone) route.
    115115
    116   ‘``L``’
     116  '``L``'
    117117      Link: Route involves references to Ethernet hardware.
    118118
     
    183183  Verify that the program continues to run once the driver has been attached.
    184184
    185 - Issue a ‘``u``’ command to send UDP
    186   packets to the ‘discard’ port.
     185- Issue a '``u``' command to send UDP
     186  packets to the 'discard' port.
    187187  Verify that the packets appear on the network.
    188188
    189 - Issue a ‘``s``’ command to print the network and driver statistics.
     189- Issue a '``s``' command to print the network and driver statistics.
    190190
    191191- On a workstation, add a static route to the target system.
    192192
    193 - On that same workstation try to ‘ping’ the target system.
     193- On that same workstation try to 'ping' the target system.
    194194  Verify that the ICMP echo request and reply packets appear on the net.
    195195
     
    197197  Modify ``networkconfig.h`` to attach the driver
    198198  with reception of broadcast packets enabled.
    199   Try to ‘ping’ the target system again.
     199  Try to 'ping' the target system again.
    200200  Verify that ARP request/reply and ICMP echo request/reply packets appear
    201201  on the net.
    202202
    203 - Issue a ‘``t``’ command to send TCP
    204   packets to the ‘discard’ port.
     203- Issue a '``t``' command to send TCP
     204  packets to the 'discard' port.
    205205  Verify that the packets appear on the network.
    206206
    207 - Issue a ‘``s``’ command to print the network and driver statistics.
     207- Issue a '``s``' command to print the network and driver statistics.
    208208
    209209- Verify that you can telnet to ports 24742
     
    233233  a smaller value, say 514.
    234234
    235 - ‘Ping’ the driver from another workstation and verify
     235- 'Ping' the driver from another workstation and verify
    236236  that frames larger than 514 bytes are correctly rejected.
    237237
     
    249249  still telnet to both the ports.
    250250
    251 - Display the driver statistics (Console ‘``s``’ command or telnet
    252   ‘control-G’ character) and verify that:
     251- Display the driver statistics (Console '``s``' command or telnet
     252  'control-G' character) and verify that:
    253253
    254254  # The number of transmit interrupts is non-zero.
     
    263263- Run the ``netdemo`` program.
    264264
    265 - Issue a ‘``u``’ console command to make the target machine transmit
     265- Issue a '``u``' console command to make the target machine transmit
    266266  a bunch of UDP packets.
    267267
     
    278278
    279279Run the ``ttcp`` network benchmark program.
    280 Transfer large amounts of data (100’s of megabytes) to and from the target
     280Transfer large amounts of data (100's of megabytes) to and from the target
    281281system.
    282282
  • networking/using_networking_rtems_app.rst

    r11e1a6f rd389819  
    127127    standard files created with the information return by the BOOTP/DHCP
    128128    protocol. The IP address is added to :file:`/etc/hosts` with the host
    129     name and domain returned. If no host name or domain is returned``me.mydomain`` is used. The BOOTP/DHCP server’s address is also
     129    name and domain returned. If no host name or domain is returned``me.mydomain`` is used. The BOOTP/DHCP server's address is also
    130130    added to :file:`/etc/hosts`. The domain name server listed in the
    131131    BOOTP/DHCP information are added to :file:`/etc/resolv.conf`. A``search`` record is also added if a domain is returned. The files
     
    163163``char \*gateway``
    164164    The Internet host number of the network gateway machine,
    165     specified in ’dotted decimal’ (``129.128.4.1``) form.
     165    specified in 'dotted decimal' (``129.128.4.1``) form.
    166166
    167167``char \*log_host``
     
    280280``char \*ip_address``
    281281    The Internet address of the device,
    282     specified in ‘dotted decimal’ (``129.128.4.2``) form, or ``NULL``
     282    specified in 'dotted decimal' (``129.128.4.2``) form, or ``NULL``
    283283    if the device configuration information is being obtained from a
    284284    BOOTP/DHCP server.
     
    286286``char \*ip_netmask``
    287287    The Internet inetwork mask of the device,
    288     specified in ‘dotted decimal’ (``255.255.255.0``) form, or ``NULL``
     288    specified in 'dotted decimal' (``255.255.255.0``) form, or ``NULL``
    289289    if the device configuration information is being obtained from a
    290290    BOOTP/DHCP server.
     
    497497For sending, when the socket is connected and the free space becomes at
    498498or above the "low water mark" for the send buffer (default 4096 bytes)
    499 you will receive a writable callback. You don’t get continuous callbacks
    500 if you don’t write anything. Using a non-blocking write socket, you can
     499you will receive a writable callback. You don't get continuous callbacks
     500if you don't write anything. Using a non-blocking write socket, you can
    501501then call write until it returns a value less than the amount of data
    502502requested to be sent or it produces error EWOULDBLOCK (indicating buffer
     
    838838If the interval argument is greater than 0, the routine also starts an
    839839RTEMS task at the specified priority and polls the NTP server every
    840 â€˜interval’ seconds.  NOTE: This mode of operation has not yet been
     840'interval' seconds.  NOTE: This mode of operation has not yet been
    841841implemented.
    842842
     
    844844returns 0.  If an error occurs a message is printed and the routine returns -1
    845845with an error code in errno.
    846 There is no timeout – if there is no response from an NTP server the
     846There is no timeout - if there is no response from an NTP server the
    847847routine will wait forever.
    848848
  • porting/code_tuning.rst

    r11e1a6f rd389819  
    8888----------------------
    8989
    90 The CPU_ALIGNMENT macro should be set to the CPU’s worst alignment
     90The CPU_ALIGNMENT macro should be set to the CPU's worst alignment
    9191requirement for data types on a byte boundary.  This is typically the
    9292alignment requirement for a C double. This alignment does not take into
  • porting/cpu_init.rst

    r11e1a6f rd389819  
    3939context.  If there is not an easy way to initialize the FP context during
    4040Context_Initialize, then it is usually easier to save an "uninitialized"
    41 FP context here and copy it to the task’s during Context_Initialize.  If
     41FP context here and copy it to the task's during Context_Initialize.  If
    4242this technique is used to initialize the FP contexts, then it is important
    4343to ensure that the state of the floating point unit is in a coherent,
  • porting/cpu_model_variations.rst

    r11e1a6f rd389819  
    106106Each of these boards is optimized for a particular project.  The processor
    107107and peripheral set have been chosen to meet a particular set of system
    108 requirements.  The tools in the embedded systems developers’ toolbox must
    109 support their project’s unique board.  RTEMS addresses this issue via the
     108requirements.  The tools in the embedded systems developers toolbox must
     109support their project's unique board.  RTEMS addresses this issue via the
    110110Board Support Package.
    111111
  • porting/idle_thread.rst

    r11e1a6f rd389819  
    8787
    8888If the CPU dependent IDLE thread body is implementation centers upon using
    89 a "halt", "idle", or "shutdown" instruction, then don’t forget to put it
     89a "halt", "idle", or "shutdown" instruction, then don't forget to put it
    9090in an infinite loop as the CPU will have to reexecute this instruction
    9191each time the IDLE thread is dispatched.
  • porting/index.rst

    r11e1a6f rd389819  
    22RTEMS Porting Guide
    33===================
    4 COPYRIGHT © 1988 - 2015.
     4COPYRIGHT (c) 1988 - 2015.
    55
    66On-Line Applications Research Corporation (OAR).
  • porting/interrupts.rst

    r11e1a6f rd389819  
    306306This discussion ignores a lot of the ugly details in a real implementation
    307307such as saving enough registers/state to be able to do something real.
    308 Keep in mind that the goal is to invoke a user’s ISR handler which is
     308Keep in mind that the goal is to invoke a user's ISR handler which is
    309309written in C.  That ISR handler uses a known set of registers thus
    310310allowing the ISR to preserve only those that would normally be corrupted
     
    369369------------------------------
    370370
    371 Does the RTEMS invoke the user’s ISR with the vector number and a pointer
     371Does the RTEMS invoke the user's ISR with the vector number and a pointer
    372372to the saved interrupt frame (1) or just the vector number (0)?
    373373.. code:: c
  • porting/miscellanous.rst

    r11e1a6f rd389819  
    66
    77The ``_CPU_Fatal_halt`` routine is the default fatal error handler. This
    8 routine copies _error into a known place – typically a stack location or
     8routine copies _error into a known place - typically a stack location or
    99a register, optionally disables interrupts, and halts/stops the CPU.  It
    1010is prototyped as follows and is often implemented as a macro:
     
    101101would probably have to be disabled to insure that an interrupt does not
    102102try to access the same "chunk" with the wrong endian.  Another good reason
    103 is that on some CPUs, the endian bit endianness for ALL fetches – both
    104 code and data – so the code will be fetched incorrectly.
     103is that on some CPUs, the endian bit endianness for ALL fetches - both
     104code and data - so the code will be fetched incorrectly.
    105105
    106106The following is an implementation of the ``CPU_swap_u32`` routine that will
     
    143143would probably have to be disabled to insure that an interrupt does not
    144144try to access the same "chunk" with the wrong endian.  Another good reason
    145 is that on some CPUs, the endian bit endianness for ALL fetches – both
    146 code and data – so the code will be fetched incorrectly.
     145is that on some CPUs, the endian bit endianness for ALL fetches - both
     146code and data - so the code will be fetched incorrectly.
    147147
    148148Similarly, here is a portable implementation of the ``CPU_swap_u16``
  • porting/priority_bitmap.rst

    r11e1a6f rd389819  
    8686manner in which a priority is broken into a major and minor components
    8787with the major being the 4 MSB of a priority and minor the 4 LSB.  Thus (0
    88 << 4) + 0 corresponds to priority 0 – the highest priority.  And (15 <<
    89 4) + 14 corresponds to priority 254 – the next to the lowest priority.
     88<< 4) + 0 corresponds to priority 0 - the highest priority.  And (15 <<
     894) + 14 corresponds to priority 254 - the next to the lowest priority.
    9090
    9191If your CPU does not have a "find first bit" instruction, then there are
     
    9595- a series of 16 bit test instructions
    9696
    97 - a "binary search using if’s"
     97- a "binary search using if's"
    9898
    9999- the following algorithm based upon a 16 entry lookup table.  In this pseudo-code, bit_set_table[16] has values which indicate the first bit set:
  • porting/task_context.rst

    r11e1a6f rd389819  
    201201registers assumed to be preserved across subroutine calls
    202202must be preserved.  These registers may be saved in
    203 the task’s context area or on its stack.  However, the
     203the task's context area or on its stack.  However, the
    204204stack pointer and address to resume executing the task
    205205at must be included in the context (normally the subroutine
    206206return address to the caller of ``_Thread_Dispatch``.
    207 The decision of where to store the task’s context is based
     207The decision of where to store the task's context is based
    208208on numerous factors including the capabilities of
    209209the CPU architecture itself and simplicity as well
    210210as external considerations such as debuggers wishing
    211 to examine a task’s context.  In this case, it is
     211to examine a task's context.  In this case, it is
    212212often simpler to save all data in the context area.
    213213
     
    293293indicates whether or not this CPU model has FP support.  For example, the
    294294definition of the i386ex and i386sx CPU models would set I386_HAS_FPU to
    295 FALSE to indicate that these CPU models are i386’s without an i387 and
     295FALSE to indicate that these CPU models are i386's without an i387 and
    296296wish to leave floating point support out of RTEMS when built for the
    297297i386_nofp processor model.  On a CPU with a built-in FPU like the i486,
     
    400400format is not critical for the implementation of the floating point
    401401context switch routines.  In this case, there is no need to figure out the
    402 exact format – only the size.  Of course, although this is enough
     402exact format - only the size.  Of course, although this is enough
    403403information for RTEMS, it is probably not enough for a debugger such as
    404404gdb.  But that is another problem.
     
    417417The CPU_CONTEXT_FP_SIZE macro is set to the size of the floating point
    418418context area. On some CPUs this will not be a "sizeof" because the format
    419 of the floating point area is not defined – only the size is.  This is
     419of the floating point area is not defined - only the size is.  This is
    420420usually on CPUs with a "floating point save context" instruction.  In
    421421general, though it is easier to define the structure as a "sizeof"
  • posix1003_1/files_and_directories.rst

    r11e1a6f rd389819  
    244244NOTE: The newlib unistd.h and sys/unistd.h are installed and the
    245245include search patch is used to get the right one.  There are
    246 conflicts between the newlib unistd.h and RTEMS’ version.
     246conflicts between the newlib unistd.h and RTEMS' version.
    247247
    248248.. COMMENT: COPYRIGHT (c) 1988-2002.
  • posix1003_1/index.rst

    r11e1a6f rd389819  
    33===================================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • posix1003_1/language_specific_services.rst

    r11e1a6f rd389819  
    55==============================
    66
    7 ANSI C Section 4.2 — Diagnostics
     7ANSI C Section 4.2 - Diagnostics
    88.. code:: c
    99
    1010    assert(), Function, Implemented
    1111
    12 ANSI C Section 4.3 — Character Handling
     12ANSI C Section 4.3 - Character Handling
    1313.. code:: c
    1414
     
    2727    toupper(), Function, Implemented
    2828
    29 ANSI C Section 4.4 — Localization
     29ANSI C Section 4.4 - Localization
    3030.. code:: c
    3131
    3232    setlocale(), Function, Implemented
    3333
    34 ANSI C Section 4.5 — Mathematics
     34ANSI C Section 4.5 - Mathematics
    3535.. code:: c
    3636
     
    5858    fmod(), Function, Implemented
    5959
    60 ANSI C Section 4.6 — Non-Local Jumps
     60ANSI C Section 4.6 - Non-Local Jumps
    6161.. code:: c
    6262
     
    6464    longjmp(), Function, Implemented
    6565
    66 ANSI C Section 4.9 — Input/Output
     66ANSI C Section 4.9 - Input/Output
    6767.. code:: c
    6868
     
    106106NOTE: ``rename`` is also included in another section.  `Rename a File`_.
    107107
    108 ANSI C Section 4.10 — General Utilities
     108ANSI C Section 4.10 - General Utilities
    109109.. code:: c
    110110
     
    126126NOTE: ``getenv`` is also included in another section. `Environment Access`_.
    127127
    128 ANSI C Section 4.11 — String Handling
     128ANSI C Section 4.11 - String Handling
    129129.. code:: c
    130130
     
    144144    strlen(), Function, Implemented
    145145
    146 ANSI C Section 4.12 — Date and Time Handling
     146ANSI C Section 4.12 - Date and Time Handling
    147147.. code:: c
    148148
  • posix1003_1/posix1003_1.rst

    r11e1a6f rd389819  
    5959.. COMMENT: can force the copyright description onto a left hand page.
    6060
    61 COPYRIGHT © 1988 - 2015.
     61COPYRIGHT (c) 1988 - 2015.
    6262
    6363On-Line Applications Research Corporation (OAR).
     
    294294    USHRT_MAX, Constant, Implemented
    295295
    296 NOTE: These are implemented in GCC’s limits.h file.
     296NOTE: These are implemented in GCC's limits.h file.
    297297
    298298Minimum Values
     
    11391139NOTE: The newlib unistd.h and sys/unistd.h are installed and the
    11401140include search patch is used to get the right one.  There are
    1141 conflicts between the newlib unistd.h and RTEMS’ version.
     1141conflicts between the newlib unistd.h and RTEMS' version.
    11421142
    11431143.. COMMENT: COPYRIGHT (c) 1988-2002.
     
    15811581==============================
    15821582
    1583 ANSI C Section 4.2 — Diagnostics
     1583ANSI C Section 4.2 - Diagnostics
    15841584.. code:: c
    15851585
    15861586    assert(), Function, Implemented
    15871587
    1588 ANSI C Section 4.3 — Character Handling
     1588ANSI C Section 4.3 - Character Handling
    15891589.. code:: c
    15901590
     
    16031603    toupper(), Function, Implemented
    16041604
    1605 ANSI C Section 4.4 — Localization
     1605ANSI C Section 4.4 - Localization
    16061606.. code:: c
    16071607
    16081608    setlocale(), Function, Implemented
    16091609
    1610 ANSI C Section 4.5 — Mathematics
     1610ANSI C Section 4.5 - Mathematics
    16111611.. code:: c
    16121612
     
    16341634    fmod(), Function, Implemented
    16351635
    1636 ANSI C Section 4.6 — Non-Local Jumps
     1636ANSI C Section 4.6 - Non-Local Jumps
    16371637.. code:: c
    16381638
     
    16401640    longjmp(), Function, Implemented
    16411641
    1642 ANSI C Section 4.9 — Input/Output
     1642ANSI C Section 4.9 - Input/Output
    16431643.. code:: c
    16441644
     
    16821682NOTE: ``rename`` is also included in another section.  `Rename a File`_.
    16831683
    1684 ANSI C Section 4.10 — General Utilities
     1684ANSI C Section 4.10 - General Utilities
    16851685.. code:: c
    16861686
     
    17021702NOTE: ``getenv`` is also included in another section. `Environment Access`_.
    17031703
    1704 ANSI C Section 4.11 — String Handling
     1704ANSI C Section 4.11 - String Handling
    17051705.. code:: c
    17061706
     
    17201720    strlen(), Function, Implemented
    17211721
    1722 ANSI C Section 4.12 — Date and Time Handling
     1722ANSI C Section 4.12 - Date and Time Handling
    17231723.. code:: c
    17241724
  • posix1003_1/terminology.rst

    r11e1a6f rd389819  
    132132    USHRT_MAX, Constant, Implemented
    133133
    134 NOTE: These are implemented in GCC’s limits.h file.
     134NOTE: These are implemented in GCC's limits.h file.
    135135
    136136Minimum Values
  • posix_users/clock.rst

    r11e1a6f rd389819  
    4242==========
    4343
    44 This section details the clock manager’s directives.
    45 A subsection is dedicated to each of this manager’s directives
     44This section details the clock manager's directives.
     45A subsection is dedicated to each of this manager's directives
    4646and describes the calling sequence, related constants, usage,
    4747and status codes.
  • posix_users/condition_variable.rst

    r11e1a6f rd389819  
    4242==========
    4343
    44 This section details the condition variable manager’s directives.
    45 A subsection is dedicated to each of this manager’s directives
     44This section details the condition variable manager's directives.
     45A subsection is dedicated to each of this manager's directives
    4646and describes the calling sequence, related constants, usage,
    4747and status codes.
  • posix_users/device_and_class_specific.rst

    r11e1a6f rd389819  
    4747==========
    4848
    49 This section details the device- and class- specific functions manager’s
    50 directives. A subsection is dedicated to each of this manager’s directives
     49This section details the device- and class- specific functions manager's
     50directives. A subsection is dedicated to each of this manager's directives
    5151and describes the calling sequence, related constants, usage,
    5252and status codes.
  • posix_users/files_and_directory.rst

    r11e1a6f rd389819  
    104104==========
    105105
    106 This section details the files and directories manager’s directives.
    107 A subsection is dedicated to each of this manager’s directives
     106This section details the files and directories manager's directives.
     107A subsection is dedicated to each of this manager's directives
    108108and describes the calling sequence, related constants, usage,
    109109and status codes.
     
    343343
    344344*EACCES*
    345     Search permission is denied for a directory in a file’s path prefix.
     345    Search permission is denied for a directory in a file's path prefix.
    346346
    347347*ENAMETOOLONG*
     
    389389
    390390*EACCES*
    391     Search permission is denied for a directory in a file’s path prefix.
     391    Search permission is denied for a directory in a file's path prefix.
    392392
    393393*ENAMETOOLONG*
     
    436436
    437437*EACCES*
    438     Search permission is denied for a directory in a file’s path prefix.
     438    Search permission is denied for a directory in a file's path prefix.
    439439
    440440**DESCRIPTION:**
     
    476476
    477477*EACCES*
    478     Search permission is denied for a directory in a file’s path prefix.
     478    Search permission is denied for a directory in a file's path prefix.
    479479
    480480*EEXIST*
     
    696696
    697697*EACCES*
    698     Search permission is denied for a directory in a file’s path prefix
     698    Search permission is denied for a directory in a file's path prefix
    699699
    700700*EEXIST*
     
    761761
    762762*EACCES*
    763     Search permission is denied for a directory in a file’s path prefix
     763    Search permission is denied for a directory in a file's path prefix
    764764
    765765*EEXIST*
     
    819819
    820820*EACCES*
    821     Search permission is denied for a directory in a file’s path prefix
     821    Search permission is denied for a directory in a file's path prefix
    822822
    823823*ENAMETOOLONG*
     
    871871
    872872*EACCES*
    873     Search permission is denied for a directory in a file’s path prefix
     873    Search permission is denied for a directory in a file's path prefix
    874874
    875875*EEXIST*
     
    929929
    930930*EACCES*
    931     Search permission is denied for a directory in a file’s path prefix
     931    Search permission is denied for a directory in a file's path prefix
    932932
    933933*EEXIST*
     
    974974
    975975*EACCES*
    976     Search permission is denied for a directory in a file’s path prefix
     976    Search permission is denied for a directory in a file's path prefix
    977977
    978978*EBUSY*
     
    10331033*EACCES*
    10341034    Write access to the directory containing ``pathname`` was not
    1035     allowed for the process’s effective uid, or one of the directories in``pathname`` did not allow search (execute) permission.
     1035    allowed for the process's effective uid, or one of the directories in``pathname`` did not allow search (execute) permission.
    10361036
    10371037*EPERM*
    10381038    The directory containing ``pathname`` has the stickybit (S_ISVTX)
    1039     set and the process’s effective uid is neither the uid of the file to
     1039    set and the process's effective uid is neither the uid of the file to
    10401040    be delected nor that of the director containing it.
    10411041
     
    10971097
    10981098*EACCES*
    1099     Search permission is denied for a directory in a file’s path prefix.
     1099    Search permission is denied for a directory in a file's path prefix.
    11001100
    11011101*EBUSY*
     
    11751175
    11761176*EACCES*
    1177     Search permission is denied for a directory in a file’s path prefix.
     1177    Search permission is denied for a directory in a file's path prefix.
    11781178
    11791179*EBADF*
     
    13441344
    13451345*EACCES*
    1346     Search permission is denied for a directory in a file’s path prefix
     1346    Search permission is denied for a directory in a file's path prefix
    13471347
    13481348*ENAMETOOLONG*
     
    13941394
    13951395*EACCES*
    1396     Search permission is denied for a directory in a file’s path prefix.
     1396    Search permission is denied for a directory in a file's path prefix.
    13971397
    13981398*EBADF*
     
    14651465
    14661466*EFAULT*
    1467     Argument points outside the calling process’s address space.
     1467    Argument points outside the calling process's address space.
    14681468
    14691469*EINVAL*
     
    15061506
    15071507*EACCES*
    1508     Search permission is denied for a directory in a file’s path prefix
     1508    Search permission is denied for a directory in a file's path prefix
    15091509
    15101510*EINVAL*
     
    16351635
    16361636*EFAULT*
    1637     ``Path`` points outside the process’s allocated address space.
     1637    ``Path`` points outside the process's allocated address space.
    16381638
    16391639*EBADF*
     
    17031703
    17041704*EFAULT*
    1705     ``Path`` points outside the process’s allocated address space.
     1705    ``Path`` points outside the process's allocated address space.
    17061706
    17071707*EBADF*
     
    19201920below and the permissions for the new node.
    19211921
    1922 The permissions are modified by the process’s ``umask`` in the usual way: the
     1922The permissions are modified by the process's ``umask`` in the usual way: the
    19231923permissions of the created node are ``(mode & ~umask)``.
    19241924
  • posix_users/index.rst

    r11e1a6f rd389819  
    11============================
    2 RTEMS POSIX API User’s Guide
     2RTEMS POSIX API User's Guide
    33============================
    44
    5 COPYRIGHT © 1988 - 2015.
     5COPYRIGHT (c) 1988 - 2015.
    66
    77On-Line Applications Research Corporation (OAR).
  • posix_users/input_and_output.rst

    r11e1a6f rd389819  
    6868==========
    6969
    70 This section details the input and output primitives manager’s directives.
    71 A subsection is dedicated to each of this manager’s directives
     70This section details the input and output primitives manager's directives.
     71A subsection is dedicated to each of this manager's directives
    7272and describes the calling sequence, related constants, usage,
    7373and status codes.
     
    360360
    361361*EACCESS*
    362     Search permission is denied for a direcotry in a file’s path
     362    Search permission is denied for a direcotry in a file's path
    363363    prefix.
    364364
     
    410410
    411411*F_GETFL*
    412     Read the descriptor’s flags (all flags (as set by open()) are returned).
     412    Read the descriptor's flags (all flags (as set by open()) are returned).
    413413
    414414*F_SETFL*
    415     Set the descriptor’s flags to the value specified by ``arg``. Only``O_APPEND`` and ``O_NONBLOCK`` may be set.
     415    Set the descriptor's flags to the value specified by ``arg``. Only``O_APPEND`` and ``O_NONBLOCK`` may be set.
    416416    The flags are shared between copies (made with ``dup()`` etc.) of the same
    417417    file descriptor.
  • posix_users/key.rst

    r11e1a6f rd389819  
    3131==========
    3232
    33 This section details the key manager’s directives.
    34 A subsection is dedicated to each of this manager’s directives
     33This section details the key manager's directives.
     34A subsection is dedicated to each of this manager's directives
    3535and describes the calling sequence, related constants, usage,
    3636and status codes.
  • posix_users/language_specific_services.rst

    r11e1a6f rd389819  
    6565==========
    6666
    67 This section details the language-specific services for the C programming language manager’s directives.
    68 A subsection is dedicated to each of this manager’s directives
     67This section details the language-specific services for the C programming language manager's directives.
     68A subsection is dedicated to each of this manager's directives
    6969and describes the calling sequence, related constants, usage,
    7070and status codes.
  • posix_users/memory_managment.rst

    r11e1a6f rd389819  
    4343==========
    4444
    45 This section details the memory management manager’s directives.
    46 A subsection is dedicated to each of this manager’s directives
     45This section details the memory management manager's directives.
     46A subsection is dedicated to each of this manager's directives
    4747and describes the calling sequence, related constants, usage,
    4848and status codes.
  • posix_users/message_passing.rst

    r11e1a6f rd389819  
    104104
    105105Every message queue has the ability to notify one (and only one) process
    106 whenever the queue’s state changes from empty (0 messages) to nonempty.
     106whenever the queue's state changes from empty (0 messages) to nonempty.
    107107This means that the process does not have to block or constantly poll
    108108while it waits for a message. By calling mq_notify, you can attach a
     
    195195priority message(s) from the message queue specified by mqdes. The
    196196messages are received in FIFO order within the priorities. The received
    197 message’s priority is stored in the location referenced by the msg_prio.
     197message's priority is stored in the location referenced by the msg_prio.
    198198If the msg_prio is a NULL, the priority is discarded. The message is
    199199removed and stored in an area pointed to by msg_ptr whose length is of
     
    213213The mq_notify() function registers the calling process to be notified of
    214214message arrival at an empty message queue. Every message queue has the
    215 ability to notify one (and only one) process whenever the queue’s state
     215ability to notify one (and only one) process whenever the queue's state
    216216changes from empty (0 messages) to nonempty. This means that the process
    217217does not have to block or constantly poll while it waits for a message.
     
    266266==========
    267267
    268 This section details the message passing manager’s directives. A
    269 subsection is dedicated to each of this manager’s directives and describes
     268This section details the message passing manager's directives. A
     269subsection is dedicated to each of this manager's directives and describes
    270270the calling sequence, related constants, usage, and status codes.
    271271
     
    318318mq_open creates it. Message queues can have multiple senders and
    319319receivers. If mq_open is successful, the function returns a message queue
    320 descriptor. Otherwise, the function returns a -1 and sets ’errno’ to
     320descriptor. Otherwise, the function returns a -1 and sets 'errno' to
    321321indicate the error.
    322322
     
    501501priority message(s) from the message queue specified by mqdes. The
    502502messages are received in FIFO order within the priorities. The received
    503 message’s priority is stored in the location referenced by the msg_prio.
     503message's priority is stored in the location referenced by the msg_prio.
    504504If the msg_prio is a NULL, the priority is discarded. The message is
    505505removed and stored in an area pointed to by msg_ptr whose length is of
     
    549549
    550550Every message queue has the ability to notify one (and only one) process
    551 whenever the queue’s state changes from empty (0 messages) to nonempty.
     551whenever the queue's state changes from empty (0 messages) to nonempty.
    552552This means that the process does not have to block or constantly poll
    553553while it waits for a message. By calling mq_notify, a notification
  • posix_users/mutex.rst

    r11e1a6f rd389819  
    8888========
    8989
    90 This section details the mutex manager’s services.
    91 A subsection is dedicated to each of this manager’s services
     90This section details the mutex manager's services.
     91A subsection is dedicated to each of this manager's services
    9292and describes the calling sequence, related constants, usage,
    9393and status codes.
  • posix_users/preface.rst

    r11e1a6f rd389819  
    22#######
    33
    4 This is the User’s Guide for the POSIX API support
     4This is the User's Guide for the POSIX API support
    55provided in RTEMS.
    66
     
    5353    Portions of this text are reprinted and reproduced in electronic
    5454    form from IEEE Std 1003.1, 2004 Edition, Standard for Information
    55     Technology — Operating System Interface (POSIX), The Open
    56     Group Base Specifications Issue 6, Copyright © 2001-2004 by the
     55    Technology Operating System Interface (POSIX), The Open
     56    Group Base Specifications Issue 6, Copyright (c) 2001-2004 by the
    5757    Institute of Electrical and Electronics Engineers, Inc and The
    5858    Open Group. In the event of any discrepancy between this version
  • posix_users/process_creation_and_execution.rst

    r11e1a6f rd389819  
    5858==========
    5959
    60 This section details the process creation and execution manager’s directives.
    61 A subsection is dedicated to each of this manager’s directives
     60This section details the process creation and execution manager's directives.
     61A subsection is dedicated to each of this manager's directives
    6262and describes the calling sequence, related constants, usage,
    6363and status codes.
  • posix_users/process_environment.rst

    r11e1a6f rd389819  
    104104programs.  In a full POSIX environment with command line shell
    105105and multiple processes,  environment variables may be set in
    106 one process – such as the shell – and inherited by child
     106one process - such as the shell - and inherited by child
    107107processes.  In RTEMS, there is only one process and thus
    108108only one set of environment variables across all processes.
     
    128128==========
    129129
    130 This section details the process environment manager’s directives.
    131 A subsection is dedicated to each of this manager’s directives
     130This section details the process environment manager's directives.
     131A subsection is dedicated to each of this manager's directives
    132132and describes the calling sequence, related constants, usage,
    133133and status codes.
  • posix_users/scheduler.rst

    r11e1a6f rd389819  
    6161==========
    6262
    63 This section details the scheduler manager’s directives.
    64 A subsection is dedicated to each of this manager’s directives
     63This section details the scheduler manager's directives.
     64A subsection is dedicated to each of this manager's directives
    6565and describes the calling sequence, related constants, usage,
    6666and status codes.
  • posix_users/semaphore.rst

    r11e1a6f rd389819  
    7979==========
    8080
    81 This section details the semaphore manager’s directives.
    82 A subsection is dedicated to each of this manager’s directives
     81This section details the semaphore manager's directives.
     82A subsection is dedicated to each of this manager's directives
    8383and describes the calling sequence, related constants, usage,
    8484and status codes.
  • posix_users/services_provided_by_c.rst

    r11e1a6f rd389819  
    166166- ``puts`` - Write a character string on standard output
    167167
    168 - ``remove`` - Delete a file’s name
     168- ``remove`` - Delete a file's name
    169169
    170170- ``rename`` - Rename a file
  • posix_users/signal.rst

    r11e1a6f rd389819  
    116116individual signals and handlers associated with it.   Services
    117117are provided to construct signal sets for the purposes of building
    118 signal sets – type ``sigset_t`` – that are used to
     118signal sets - type ``sigset_t`` - that are used to
    119119provide arguments to the services that mask, unmask, and
    120120check on pending signals.
     
    139139==========
    140140
    141 This section details the signal manager’s directives.
    142 A subsection is dedicated to each of this manager’s directives
     141This section details the signal manager's directives.
     142A subsection is dedicated to each of this manager's directives
    143143and describes the calling sequence, related constants, usage,
    144144and status codes.
  • posix_users/system_database.rst

    r11e1a6f rd389819  
    3939==========
    4040
    41 This section details the system databases manager’s directives.
    42 A subsection is dedicated to each of this manager’s directives
     41This section details the system databases manager's directives.
     42A subsection is dedicated to each of this manager's directives
    4343and describes the calling sequence, related constants, usage,
    4444and status codes.
  • posix_users/thread.rst

    r11e1a6f rd389819  
    8686    If this value is NULL, then RTEMS allocates the memory for the thread stack
    8787    from the RTEMS Workspace Area. Otherwise, this is the user specified
    88     address for the memory to be used for the thread’s stack. Each thread must
     88    address for the memory to be used for the thread's stack. Each thread must
    8989    have a distinct stack area. Each processor family has different alignment
    9090    rules which should be followed.
    9191
    9292*stack size*
    93     is the minimum desired size for this thread’s stack area.
     93    is the minimum desired size for this thread's stack area.
    9494    If the size of this area as specified by the stack size attribute
    9595    is smaller than the minimum for this processor family and the stack
     
    121121========
    122122
    123 This section details the thread manager’s services.
    124 A subsection is dedicated to each of this manager’s services
     123This section details the thread manager's services.
     124A subsection is dedicated to each of this manager's services
    125125and describes the calling sequence, related constants, usage,
    126126and status codes.
     
    853853*EINVAL*
    854854    The user specified a stack address and the size of the area was not
    855     large enough to meet this processor’s minimum stack requirements.
     855    large enough to meet this processor's minimum stack requirements.
    856856
    857857*EINVAL*
  • posix_users/thread_cancellation.rst

    r11e1a6f rd389819  
    3535==========
    3636
    37 This section details the thread cancellation manager’s directives.
    38 A subsection is dedicated to each of this manager’s directives
     37This section details the thread cancellation manager's directives.
     38A subsection is dedicated to each of this manager's directives
    3939and describes the calling sequence, related constants, usage,
    4040and status codes.
  • posix_users/timer.rst

    r11e1a6f rd389819  
    2828============
    2929
    30 This section details the timer manager’s services.
    31 A subsection is dedicated to each of this manager’s services
     30This section details the timer manager's services.
     31A subsection is dedicated to each of this manager's services
    3232and describes the calling sequence, related constants, usage,
    3333and status codes.
  • shell/file_and_directory.rst

    r11e1a6f rd389819  
    537537    Causes cp to write a prompt to the standard error output before copying a file
    538538    that would overwrite an existing file. If the response from the standard input
    539     begins with the character ’y’, the file copy is attempted.
     539    begins with the character 'y', the file copy is attempted.
    540540
    541541*-L*
     
    554554    and the exit value is not altered.
    555555    If the source file has its set user ID bit on and the user ID cannot be
    556     preserved, the set user ID bit is not preserved in the copy’s permissions. If
     556    preserved, the set user ID bit is not preserved in the copy's permissions. If
    557557    the source file has its set group ID bit on and the group ID cannot be
    558     preserved, the set group ID bit is not preserved in the copy’s permissions. If
     558    preserved, the set group ID bit is not preserved in the copy's permissions. If
    559559    the source file has both its set user ID and set group ID bits on, and either
    560560    the user ID or group ID cannot be preserved, neither the set user ID or set
    561     group ID bits are preserved in the copy’s permissions.
     561    group ID bits are preserved in the copy's permissions.
    562562
    563563*-R*
     
    566566    copied, rather than indirected through, and for cp to create special files
    567567    rather than copying them as normal files. Created directories have the same
    568     mode as the corresponding source directory, unmodified by the process’s umask.
     568    mode as the corresponding source directory, unmodified by the process's umask.
    569569
    570570*-v*
     
    593593as described above. The -H and -L options are ignored unless the -R option is
    594594specified. In addition, these options