Changeset d389819 – RTEMS Project

bsp_howto/analog.rst

r11e1a6f	rd389819
72	72	==========================
73	73
74		At system initialization, the analog driver~~â~~s initialization entry point
	74	At system initialization, the analog driver's initialization entry point
75	75	will be invoked. As part of initialization, the driver will perform
76	76	whatever board initialization is required and then set all

bsp_howto/ata.rst

-                      r11e1a6f
+                      rd389819
 ATA driver supports separate ATA requests queues for each IDE
 controller (one queue per controller). The following structure contains
 information about controllerâs queue and devices attached to the controller:
+information about controller's queue and devices attached to the controller:
 .. code:: c
 …
 ATA request which is appended to the appropriate controller queue depending
 on ATA device the request belongs to. If appended request is single request in
 the controllerâs queue then ATA driver event is generated.
+the controller's queue then ATA driver event is generated.
 ATA driver task which manages queue of ATA driver events is core of ATA

bsp_howto/clock.rst

r11e1a6f	rd389819
9	9
10	10	- 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 theRTEMS Application C User~~â~~s Guide for more details.
	11	a clock tick work properly. See the Clock Manager chapter of theRTEMS Application C User's Guide for more details.
12	12
13	13	- An optional time counter to generate timestamps of the uptime and wall

bsp_howto/console.rst

-                      r11e1a6f
+                      rd389819
 Having RTEMS support for Termios is beneficial because:
 - from the userâs side because it provides standard primitive operations
+- from the user's side because it provides standard primitive operations
   to access the terminal and change configuration settings.  These operations
   are the same under UNIX and RTEMS.
 - from the BSP developerâs side because it frees the
+- from the BSP developer's side because it frees the
   developer from dealing with buffer states and mutual exclusions on them.
   Early RTEMS console device drivers also did their own special

bsp_howto/discrete.rst

-                      r11e1a6f
+                      rd389819
     is an array of the values that should be written to each output
     word on the board during initialization.  This allows the driver
     to start with the boardâs output  in a known state.
+    to start with the board's output  in a known state.
 Initialize a Discrete I/O Board
 ===============================
 At system initialization, the discrete I/O driverâs initialization entry point
+At system initialization, the discrete I/O driver's initialization entry point
 will be invoked.  As part of initialization, the driver will perform
 whatever board initializatin is required and then set all

bsp_howto/index.rst

r11e1a6f	rd389819
3	3	=======================================
4	4
5		COPYRIGHT Â© 1988 - 2015.
	5	COPYRIGHT (c) 1988 - 2015.
6	6
7	7	On-Line Applications Research Corporation (OAR).

bsp_howto/initilization_code.rst

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

bsp_howto/linker_script.rst

-                      r11e1a6f
+                      rd389819
 Even though RAM and ROM can be found in every personal computer,
 one generally doesnât care about them.  In a personal computer,
+one generally doesn't care about them.  In a personal computer,
 a program is nearly always stored on disk and executed in RAM.  Things
 are a bit different for embedded targets: the target will execute the
 …
 - *code (``.text``) section*:
   is the programâs code and it should not be modified.
+  is the program's code and it should not be modified.
   This section may be placed in ROM.
 …
 - *initialized data (``.data``) section*:
   holds the initialized program data which may be modified during the
   programâs life.  This means they have to be in RAM.
+  program's life.  This means they have to be in RAM.
   On the other hand, these variables must be set to predefined values, and
   those predefined values have to be stored in ROM.
 …
 ================
 Now thereâs a problem with the initialized data: the ``.data`` section
+Now there's a problem with the initialized data: the ``.data`` section
 has to be in RAM as this data may be modified during the program execution.
 But how will the values be initialized at boot time?
 …
 Step 3 shows the final executable image as it logically appears in
 the targetâs non-volatile program memory.  The board initialization
+the target's non-volatile program memory.  The board initialization
 code will copy the ""copy of ``.data`` section" (which are stored in
 ROM) to their reserved location in RAM.

bsp_howto/makefiles.rst

-                      r11e1a6f
+                      rd389819
 configuration file is ``make/custom/BSP.cfg``.
 The configuration file is taken into account when building oneâs
+The configuration file is taken into account when building one's
 application using the RTEMS template Makefiles (``make/templates``).
 These application template Makefiles have been included with the
 RTEMS source distribution since the early 1990âs.  However there is
+RTEMS source distribution since the early 1990's.  However there is
 a desire in the RTEMS user community to move all provided examples to
 GNU autoconf. They are included in the 4.9 release series and used for

bsp_howto/miscellanous_support.rst

r11e1a6f	rd389819
115	115	All members of the Timing Test Suite are designed to run WITHOUT
116	116	the Clock Device Driver installed. This increases the predictability
117		of the tests~~â~~ execution as well as avoids occassionally including the
	117	of the tests' execution as well as avoids occassionally including the
118	118	overhead of a clock tick interrupt in the time reported. Because of
119	119	this it is sometimes possible to use the clock tick interrupt source

bsp_howto/networking.rst

-                      r11e1a6f
+                      rd389819
 This chapter is intended to provide an introduction to the
 procedure for writing RTEMS network device drivers.
 The example code is taken from the âGeneric 68360â network device
+The example code is taken from the 'Generic 68360' network device
 driver.  The source code for this driver is located in the``c/src/lib/libbsp/m68k/gen68360/network`` directory in the RTEMS
 source code distribution.  Having a copy of this driver at
 …
 Before starting to write the network driver become completely
 familiar with the programmerâs view of the device.
+familiar with the programmer's view of the device.
 The following points list some of the details of the
 device that must be understood before a driver can be written.
 …
 execute only when they hold the network semaphore (``rtems_bsdnet_semaphore``).
 The transmit and receive tasks must abide by this protocol.  Be very
 careful to avoid âdeadly embracesâ with the other network tasks.
+careful to avoid 'deadly embraces' with the other network tasks.
 A number of routines are provided to make it easier for the network
 driver code to conform to the network task scheduling conventions.
 …
 ``ifp->if_unit``
     The device number.  The network stack uses this number and the
     device name for device name lookups.  For example, if``ifp->if_name`` is â``scc``â and ``ifp->if_unit`` is â``1``â,
     the full device name would be â``scc1``â.  The unit number should be
     obtained from the ânameâ entry in the configuration structure.
+    device name for device name lookups.  For example, if``ifp->if_name`` is '``scc``' and ``ifp->if_unit`` is '``1``',
+    the full device name would be '``scc1``'.  The unit number should be
+    obtained from the 'name' entry in the configuration structure.
 ``ifp->if_mtu``
 …
 calling ``if_attach``.  Ethernet devices should then
 call ``ether_ifattach``.  Both functions take a pointer to the
 deviceâs ``ifnet`` structure as their only argument.
+device's ``ifnet`` structure as their only argument.
 The attach function should return a non-zero value to indicate that
 …
 This function is called each time the network stack wants to start the
 transmitter.  This occures whenever the network stack adds a packet
 to a deviceâs send queue and the ``IFF_OACTIVE`` bit in the
 deviceâs ``if_flags`` is not set.
+to a device's send queue and the ``IFF_OACTIVE`` bit in the
+device's ``if_flags`` is not set.
 For 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
 =========================================
 At system initialization, the non-volatile memory driverâs
+At system initialization, the non-volatile memory driver's
 initialization entry point will be invoked.  As part of
 initialization, the driver will perform
 …
 ===============================
 Depending on the targetâs non-volatile memory configuration, it may be
+Depending on the target's non-volatile memory configuration, it may be
 possible to write to a status register and make the memory area completely
 inaccessible.  This is target dependent and beyond the standard capabilities

bsp_howto/real_time_clock.rst

-                      r11e1a6f
+                      rd389819
 of real-time clock is on a particular board.  This would be useful for
 a BSP supporting multiple board models.  The relevant ports of
 the DMV177âs ``RTC_Table`` configuration table is below:
+the DMV177's ``RTC_Table`` configuration table is below:
 .. code:: c
 …
 This configuration scheme allows one to support multiple versions
 of the same board with a single BSP.  For example, if the first
 generation of a board had Vendor Aâs RTC chip and the second
 generation had Vendor Bâs RTC chip, RTC_Table could contain
+generation of a board had Vendor A's RTC chip and the second
+generation had Vendor B's RTC chip, RTC_Table could contain
 information for both.  The ``deviceProbe`` configured
 for Vendor Aâs RTC chip would need to return TRUE if the
+for Vendor A's RTC chip would need to return TRUE if the
 board was a first generation one.  The ``deviceProbe``
 routines are very board dependent and must be provided by

bsp_howto/shared_memory_support.rst

-                      r11e1a6f
+                      rd389819
 information on RTEMS multiprocessing capabilities and the
 MPCI, refer to the *Multiprocessing Manager* chapter
 of the *RTEMS Application C Userâs Guide*.
+of the *RTEMS Application C User's Guide*.
 Shared Memory Configuration Table
 …
 window onto the shared memory.  For example, some VMEbus boards have
 special address windows to access addresses that are normally reserved
 in the CPUâs address space.
+in the CPU's address space.
 .. code:: c

bsp_howto/target_dependant_files.rst

-                      r11e1a6f
+                      rd389819
 The source code found in the ``cpukit/score/cpu`` is required to
 only depend upon the CPU model variations that GCC distinguishes
 for the purposes of multilibâing.  Multilib is the term the GNU
+for the purposes of multilib'ing.  Multilib is the term the GNU
 community uses to refer to building a single library source multiple
 times with different compiler options so the binary code generated
 is compatible.  As an example, from GCCâs perspective, many PowerPC
+is compatible.  As an example, from GCC's perspective, many PowerPC
 CPU models are just a PPC603e.  Remember that GCC only cares about
 the CPU code itself and need not be aware of any peripherals.  In
 …
 - Does a BSP for a similar board exists?
 - Is the boardâs CPU supported?
+- Is the board's CPU supported?
 If there is already a BSP for the board, then things may already be ready
 …
 that the existing BSP provides device drivers for all the peripherals
 on the board that the application will be using.  For example, the application
 in question may require that the boardâs Ethernet controller be used and
+in question may require that the board's Ethernet controller be used and
 the existing BSP may not support this.
 If the BSP does not exist and the boardâs CPU model is supported, then
+If the BSP does not exist and the board's CPU model is supported, then
 examine the reusable chip library and existing BSPs for a close match.
 Other BSPs and libchip provide starting points for the development
 …
 This will help reduce the development effort required.
 If the boardâs CPU family is supported but the particular CPU model on
+If the board's CPU family is supported but the particular CPU model on
 that board is not, then the RTEMS port to that CPU family will have to
 be augmented.  After this is done, development of the new BSP can proceed.
 …
 - *clock*:
   support for the clock tick â a regular time basis to the kernel.
+  support for the clock tick - a regular time basis to the kernel.
 - *timer*:

bsp_howto/timer.rst

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

c_user/barrier_manager.rst

-                      r11e1a6f
+                      rd389819
 When the task does wait to acquire the barrier, then it
 is placed in the barrierâs task wait queue in FIFO order.
+is placed in the barrier's task wait queue in FIFO order.
 All tasks waiting on a barrier are returned an error
 code when the barrier is deleted.
 …
 The ``rtems_barrier_delete`` directive removes a barrier
 from the system and frees its control block.  A barrier can be
 deleted by any local task that knows the barrierâs ID.  As a
+deleted by any local task that knows the barrier's ID.  As a
 result of this directive, all tasks blocked waiting for the
 barrier to be released, will be readied and returned a status code which
 indicates that the barrier was deleted.  Any subsequent
 references to the barrierâs name and ID are invalid.
+references to the barrier's name and ID are invalid.
 Directives
 ==========
 This section details the barrier managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the barrier manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 ``RTEMS_INVALID_NAME`` - invalid barrier name
 ``RTEMS_INVALID_ADDRESS`` - ``id`` is NULL
 ``RTEMS_TOO_MANY`` - too many barriers createdÂ
+``RTEMS_TOO_MANY`` - too many barriers created
 **DESCRIPTION:**
 …
 ``RTEMS_SUCCESSFUL`` - barrier deleted successfully
 ``RTEMS_INVALID_ID`` - invalid barrier idÂ
+``RTEMS_INVALID_ID`` -c invalid barrier id
 **DESCRIPTION:**
 …
 The calling task will be preempted if it is enabled
 by the taskâs execution mode and a higher priority local task is
+by the task's execution mode and a higher priority local task is
 waiting on the deleted barrier.  The calling task will NOT be
 preempted if all of the tasks that are waiting on the barrier
 …
 This directive releases the barrier specified by id.
 All tasks waiting at the barrier will be unblocked.
 If the running taskâs preemption mode is enabled and one of
+If the running task's preemption mode is enabled and one of
 the unblocked tasks has a higher priority than the running task.

c_user/board_support_packages.rst

-                      r11e1a6f
+                      rd389819
 not involve calls to RTEMS directives.
 The processorâs Interrupt Vector Table which will be used by the
+The processor's Interrupt Vector Table which will be used by the
 application may need to be set to the required value by the reset
 application initialization code.  Because interrupts are enabled
 automatically by RTEMS as part of the context switch to the first task,
 the Interrupt Vector Table MUST be set before this directive is invoked
 to ensure correct interrupt vectoring.  The processorâs Interrupt Vector
+to ensure correct interrupt vectoring.  The processor's Interrupt Vector
 Table must be accessible by RTEMS as it will be modified by the when
 installing user Interrupt Service Routines (ISRs) On some CPUs, RTEMS
 installs itâs own Interrupt Vector Table as part of initialization and
+installs it's own Interrupt Vector Table as part of initialization and
 thus these requirements are met automatically.  The reset code which is
 executed before the call to any RTEMS initialization routines has the
 …
   that allocated.
 - Must initialize the processorâs Interrupt Vector Table.
+- Must initialize the processor's Interrupt Vector Table.
 - Must disable all maskable interrupts.
 …
 stack usage must account for the following requirements:
 - Processorâs interrupt stack frame
 - Processorâs subroutine call stack frame
+- Processor's interrupt stack frame
+- Processor's subroutine call stack frame
 - RTEMS system calls
 …
 The dedicated interrupt stack for the entire application on some
 architectures is supplied and initialized by the reset and initialization
 code of the userâs Board Support Package.  Whether allocated and
+code of the user's Board Support Package.  Whether allocated and
 initialized by the BSP or RTEMS, since all ISRs use this stack, the
 stack size must take into account the worst case stack usage by any
 …
 Some processors do not support a separate stack for interrupts.  In this
 case, without special assistance every taskâs stack must include
 enough space to handle the taskâs worst-case stack usage as well as
+case, without special assistance every task's stack must include
+enough space to handle the task's worst-case stack usage as well as
 the worst-case interrupt stack usage.  This is necessary because the
 worst-case interrupt nesting could occur while any task is executing.

c_user/chains.rst

-                      r11e1a6f
+                      rd389819
 - ``rtems_chain_is_null_node`` - Is the node NULL ?
 - ``rtems_chain_head`` - Return the chainâs head
 - ``rtems_chain_tail`` - Return the chainâs tail
 - ``rtems_chain_are_nodes_equal`` - Are the nodeâs equal ?
+- ``rtems_chain_head`` - Return the chain's head
+- ``rtems_chain_tail`` - Return the chain's tail
+- ``rtems_chain_are_nodes_equal`` - Are the node's equal ?
 - ``rtems_chain_is_empty`` - Is the chain empty ?
 …
+    }
 The node is placed at the start of the userâs structure to allow the
 node address on the chain to be easly cast to the userâs structure
+The node is placed at the start of the user's structure to allow the
+node address on the chain to be easly cast to the user's structure
 address.

c_user/clock_manager.rst

-                      r11e1a6f
+                      rd389819
 is known as the quantum or timeslice.
 The systemâs timeslice is defined as an integral
+The system's timeslice is defined as an integral
 number of ticks, and is specified in the Configuration Table.
 The timeslice is defined for the entire system of tasks, but
 …
 The ``rtems_clock_tick``
 directive implements timeslicing by
 decrementing the running taskâs time-remaining counter when both
 timeslicing and preemption are enabled.  If the taskâs timeslice
+decrementing the running task's time-remaining counter when both
+timeslicing and preemption are enabled.  If the task's timeslice
 has expired, then that task will be preempted if there exists a
 ready task of equal priority.
 …
 RTEMS provides the ``rtems_clock_tick`` directive which is
 called from the userâs real-time clock ISR to inform RTEMS that
+called from the user's real-time clock ISR to inform RTEMS that
 a tick has elapsed.  The tick frequency value, defined in
 microseconds, is a configuration parameter found in the
 …
 ==========
 This section details the clock managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the clock manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

c_user/configuring_a_system.rst

-                      r11e1a6f
+                      rd389819
 one version of RTEMS and from one target processor to another.
 Therefore it is safest to use ``<rtems/confdefs.h>`` and specify
 your applicationâs requirements in terms of the numbers of objects and
+your application's requirements in terms of the numbers of objects and
 multiples of ``RTEMS_MINIMUM_STACK_SIZE``, as far as is possible. The
 automatic estimates of space required will in general change when:
 …
 - MACRO NAME
   Should be alphanumeric. Can have â_â (underscore).
+  Should be alphanumeric. Can have '_' (underscore).
 - DATA TYPE
 …
   The range depends on the Data Type of the macro.
   - â If the data type is of type task priority, then its value should
+  - - If the data type is of type task priority, then its value should
     be an integer in the range of 1 to 255.
   - â If the data type is an integer, then it can have numbers, characters
+  - - If the data type is an integer, then it can have numbers, characters
     (in case the value is defined using another macro) and arithmetic operations
     (+, -, \*, /).
   - â If the data type is a function pointer the first character
+  - - If the data type is a function pointer the first character
     should be an alphabet or an underscore. The rest of the string
     can be alphanumeric.
   - â If the data type is RTEMS Attributes or RTEMS Mode then
+  - - If the data type is RTEMS Attributes or RTEMS Mode then
     the string should be alphanumeric.
   - â If the data type is RTEMS NAME then the value should be
     an integer>=0 or RTEMS_BUILD_NAME( âUâ, âIâ, â1â, â â )
+  - - If the data type is RTEMS NAME then the value should be
+    an integer>=0 or RTEMS_BUILD_NAME( 'U', 'I', '1', ' ' )
 - DEFAULT VALUE
   The default value should be in the following formats-
   Please note that the â.â (full stop) is necessary.
   - â In case the value is not defined then:
+  Please note that the '.' (full stop) is necessary.
+  - - In case the value is not defined then:
     This is not defined by default.
   - â If we know the default value then:
+  - - If we know the default value then:
     The default value is XXX.
   - â If the default value is BSP Specific then:
+  - - If the default value is BSP Specific then:
     This option is BSP specific.
 …
 ---------------------------------------------------------------
 .. index:: CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE
 .. index:: memory for a single message queueâs buffers
+.. index:: memory for a single message queue's buffers
 *CONSTANT:*
 …
 ``CONFIGURE_APPLICATION_NEEDS_FRAME_BUFFER_DRIVER`` is defined
 if the application wishes to include the BSPâs Frame Buffer Device Driver.
+if the application wishes to include the BSP's Frame Buffer Device Driver.
 **NOTES:**

c_user/constant_bandwidth_server.rst

-                      r11e1a6f
+                      rd389819
 .. index:: CBS periodic tasks
 Each taskâs execution begins with a default background priority
+Each task's execution begins with a default background priority
 (see the chapter Scheduling Concepts to understand the concept of
 priorities in EDF). Once you decide the tasks should start periodic
 …
 If a task is attached to a server using ``rtems_cbs_attach_thread``,
 the taskâs computation time per period is limited by the server and
+the task's computation time per period is limited by the server and
 the deadline (period) of task is equal to deadline of the server which
 means if you conclude a period using ``rate_monotonic_period``,
 the length of next period is always determined by the serverâs property.
+the length of next period is always determined by the server's property.
 The task has a guaranteed bandwidth given by the server but should not
 …
 ==========
 This section details the Constant Bandwidth Serverâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the Constant Bandwidth Server's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 parameters of the server (period and budget). If these are not valid,``RTEMS_CBS_ERROR_INVALID_PARAMETER`` is returned.
 The ``budget_overrun_callback`` is an optional callback function, which is
 invoked in case the serverâs budget within one period is exceeded.
+invoked in case the server's budget within one period is exceeded.
 Output parameter ``server_id`` becomes an id of the newly created server.
 If there is not enough memory, the ``RTEMS_CBS_ERROR_NO_MEMORY``
 …
 **DESCRIPTION:**
 This directive returns serverâs approved budget for subsequent periods.
+This directive returns server's approved budget for subsequent periods.
 .. COMMENT: COPYRIGHT (c) 1989-2011.

c_user/cpu_usage_statistics.rst

-                      r11e1a6f
+                      rd389819
 Another thing to keep in mind when looking at idle time, is that
 many systems â especially during debug â have a task providing
+many systems - especially during debug - have a task providing
 some type of debug interface.  It is usually fine to think of the
 total idle time as being the sum of the IDLE task and a debug
 …
 ==========
 This section details the CPU usage statistics managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the CPU usage statistics manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

c_user/dual_ports_memory_manager.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the dual-ported memory managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the dual-ported memory manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.

c_user/event_manager.rst

-                      r11e1a6f
+                      rd389819
 - Target Task is Blocked Waiting for Events
   - If the waiting taskâs input event condition is
+  - If the waiting task's input event condition is
     satisfied, then the task is made ready for execution.
   - If the waiting taskâs input event condition is not
+  - If the waiting task's input event condition is not
     satisfied, then the event set is posted but left pending and the
     task remains blocked.
 …
 ==========
 This section details the event managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the event manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 This directive sends an event set, event_in, to the
 task specified by id.  If a blocked taskâs input event condition
+task specified by id.  If a blocked task's input event condition
 is satisfied by this directive, then it will be made ready.  If
 its input event condition is not satisfied, then the events

c_user/fatal_error.rst

-                      r11e1a6f
+                      rd389819
 of the error and whether or not the error was internally
 generated by the executive.  If the error was generated
 from an API, then the error code will be of that APIâs
+from an API, then the error code will be of that API's
 error or status codes.  The status codes for the RTEMS
 API are in cpukit/rtems/include/rtems/rtems/status.h.  Those
 …
 ==========
 This section details the fatal error managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the fatal error manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 provided FATAL error extension returns, then the RTEMS default
 error handler is invoked.  This directive can be invoked by
 RTEMS or by the userâs application code including initialization
+RTEMS or by the user's application code including initialization
 tasks, other tasks, and ISRs.

c_user/glossary.rst

-                      r11e1a6f
+                      rd389819
 :dfn:`directives`
     RTEMSâ provided routines that provide
+    RTEMS' provided routines that provide
     support mechanisms for real-time applications.
 :dfn:`dispatch`
     The act of loading a taskâs context onto
+    The act of loading a task's context onto
     the CPU and transferring control of the CPU to that task.
 …
     The address at which a function or task
     begins to execute.  In C, the entry point of a function is the
     functionâs name.
+    function's name.
 :dfn:`events`
 …
 :dfn:`manager`
     A group of related RTEMSâ directives which
+    A group of related RTEMS' directives which
     provide access and control over resources.
 …
 :dfn:`mode`
     An entry in a taskâs control block that is
+    An entry in a task's control block that is
     used to determine if the task allows preemption, timeslicing,
     processing of signals, and the interrupt disable level used by
 …
 :dfn:`operating system`
     The software which controls all
     the computerâs resources and provides the base upon which
+    the computer's resources and provides the base upon which
     application programs can be written.
 …
 :dfn:`resume`
     Removing a task from the suspend state.  If
     the taskâs state is ready following a call to the ``rtems_task_resume``
+    the task's state is ready following a call to the ``rtems_task_resume``
     directive, then the task is available for scheduling.
 …
 :dfn:`signal set`
     A thirty-two bit entity which is used to
     represent a taskâs collection of pending signals and the signals
+    represent a task's collection of pending signals and the signals
     sent to a task.

c_user/index.rst

-                      r11e1a6f
+                      rd389819
 ====================
 RTEMS C Userâs Guide
+RTEMS C User's Guide
 ====================
 COPYRIGHT Â© 1988 - 2015.
+COPYRIGHT (c) 1988 - 2015.
 On-Line Applications Research Corporation (OAR).

c_user/initialization.rst

-                      r11e1a6f
+                      rd389819
 Initialization task(s) are the mechanism by which
 RTEMS transfers initial control to the userâs application.
+RTEMS transfers initial control to the user's application.
 Initialization tasks differ from other application tasks in that
 they are defined in the User Initialization Tasks Table and
 …
 ==========
 This section details the Initialization Managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the Initialization Manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.

c_user/interrupt_manager.rst

-                      r11e1a6f
+                      rd389819
 preserved by the normal C calling convention
 for the target
 processor and invokes the userâs ISR.  The userâs ISR is
+processor and invokes the user's ISR.  The user's ISR is
 responsible for processing the interrupt, clearing the interrupt
 if necessary, and device specific manipulation... index:: rtems_vector_number
 …
 level interrupts, the ISR should perform the minimum actions
 required to service the interrupt.  Other non-essential actions
 should be handled by application tasks.  Once the userâs ISR has
+should be handled by application tasks.  Once the user's ISR has
 completed, it returns control to the RTEMS interrupt manager
 which will perform task dispatching and restore the registers
 …
 priorities.  The exact number of interrupt levels is processor
 dependent.  RTEMS internally supports 256 interrupt levels which
 are mapped to the processorâs interrupt levels.  For specific
+are mapped to the processor's interrupt levels.  For specific
 information on the mapping between RTEMS and the target
 processorâs interrupt levels, refer to the Interrupt Processing
+processor's interrupt levels, refer to the Interrupt Processing
 chapter of the Applications Supplement document for a specific
 target processor.
 …
 the system.  The address of the ISR and its associated CPU
 vector number are specified to this directive.  This directive
 installs the RTEMS interrupt wrapper in the processorâs
 Interrupt Vector Table and the address of the userâs ISR in the
 RTEMSâ Vector Table.  This directive returns the previous
 contents of the specified vector in the RTEMSâ Vector Table.
+installs the RTEMS interrupt wrapper in the processor's
+Interrupt Vector Table and the address of the user's ISR in the
+RTEMS' Vector Table.  This directive returns the previous
+contents of the specified vector in the RTEMS' Vector Table.
 Directives Allowed from an ISR
 …
 ==========
 This section details the interrupt managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the interrupt manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 returned in ``old_isr_handler``.
 To release an interrupt vector, pass the old handlerâs address obtained
+To release an interrupt vector, pass the old handler's address obtained
 when the vector was first capture.

c_user/io_manager.rst

-                      r11e1a6f
+                      rd389819
 Each application utilizing the RTEMS I/O manager must specify the
 address of a Device Driver Table in its Configuration Table. This table
 contains each device driverâs entry points that is to be initialised by
+contains each device driver's entry points that is to be initialised by
 RTEMS during initialization.  Each device driver may contain the
 following entry points:
 …
 If the device driver does not support a particular
 entry point, then that entry in the Configuration Table should
 be NULL.  RTEMS will return``RTEMS_SUCCESSFUL`` as the executiveâs and
 zero (0) as the device driverâs return code for these device
+be NULL.  RTEMS will return``RTEMS_SUCCESSFUL`` as the executive's and
+zero (0) as the device driver's return code for these device
 driver entry points.
 …
 .. index:: minor device number
 Each call to the I/O manager must provide a deviceâs
+Each call to the I/O manager must provide a device's
 major and minor numbers as arguments.  The major number is the
 index of the requested driverâs entry points in the Device
+index of the requested driver's entry points in the Device
 Driver Table, and is used to select a specific device driver.
 The exact usage of the minor number is driver specific, but is
 …
 ==========
 This section details the I/O managerâs directives.  A
 subsection is dedicated to each of this managerâs directives and
+This section details the I/O manager's directives.  A
+subsection is dedicated to each of this manager's directives and
 describes the calling sequence, related constants, usage, and
 status codes.
 …
 This directive attempts to add a new device driver to the Device Driver
 Table. The user can specify a specific major device number via the
 directiveâs ``major`` parameter, or let the registration routine find
+directive's ``major`` parameter, or let the registration routine find
 the 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
 allocation major device numbers from the highest value down.

c_user/key_concepts.rst

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

c_user/message_manager.rst

-                      r11e1a6f
+                      rd389819
 retrieve a message from the specified message queue.  If at
 least one message is in the queue, then the message is removed
 from the queue, copied to the callerâs message buffer, and
+from the queue, copied to the caller's message buffer, and
 returned immediately along with the length of the message.  When
 messages are unavailable, one of the following situations
 …
 If the task waits for a message, then it is placed in
 the message queueâs task wait queue in either FIFO or task
+the message queue's task wait queue in either FIFO or task
 priority order.  All tasks waiting on a message queue are
 returned an error code when the message queue is deleted.
 …
 directives work identically when tasks are waiting to receive a
 message.  A task is removed from the task waiting queue,
 unblocked,  and the message is copied to a waiting taskâs
+unblocked,  and the message is copied to a waiting task's
 message buffer.
 …
 message at the rear of the message queue, while``rtems_message_queue_urgent`` places the message at the
 front of the queue.  The message is copied to a message buffer
 from this message queueâs buffer pool and then placed in the
+from this message queue's buffer pool and then placed in the
 message queue.  Neither directive can successfully send a
 message to a message queue which has a full queue of pending
 …
 message to every task waiting on the specified message queue as
 an atomic operation.  The message is copied to each waiting
 taskâs message buffer and each task is unblocked.  The number of
+task's message buffer and each task is unblocked.  The number of
 tasks which were unblocked is returned to the caller.
 …
 The ``rtems_message_queue_delete`` directive removes a message
 queue from the system and frees its control block as well as the
 memory associated with this message queueâs message buffer pool.
+memory associated with this message queue's message buffer pool.
 A message queue can be deleted by any local task that knows the
 message queueâs ID.  As a result of this directive, all tasks
+message queue's ID.  As a result of this directive, all tasks
 blocked waiting to receive a message from the message queue will
 be readied and returned a status code which indicates that the
 message queue was deleted.  Any subsequent references to the
 message queueâs name and ID are invalid.  Any messages waiting
+message queue's name and ID are invalid.  Any messages waiting
 at the message queue are also deleted and deallocated.
 …
 ==========
 This section details the message managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the message manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 is to avoid the system overhead incurred by the creation of a
 global message queue.  When a global message queue is created,
 the message queueâs name and id must be transmitted to every
+the message queue's name and id must be transmitted to every
 node in the system for insertion in the local copy of the global
 object table.
 …
 ``RTEMS_INVALID_ADDRESS`` - ``buffer`` is NULL
 ``RTEMS_UNSATISFIED`` - out of message buffers
 ``RTEMS_TOO_MANY`` - queueâs limit has been reached
+``RTEMS_TOO_MANY`` - queue's limit has been reached
 **DESCRIPTION:**
 …
 This directive sends the message buffer of size bytes
 in length to the queue specified by id.  If a task is waiting at
 the queue, then the message is copied to the waiting taskâs
+the queue, then the message is copied to the waiting task's
 buffer and the task is unblocked. If no tasks are waiting at the
 queue, then the message is copied to a message buffer which is
 obtained from this message queueâs message buffer pool.  The
+obtained from this message queue's message buffer pool.  The
 message buffer is then placed at the rear of the queue.
 …
 ``RTEMS_INVALID_ADDRESS`` - ``buffer`` is NULL
 ``RTEMS_UNSATISFIED`` - out of message buffers
 ``RTEMS_TOO_MANY`` - queueâs limit has been reached
+``RTEMS_TOO_MANY`` - queue's limit has been reached
 **DESCRIPTION:**
 …
 This directive sends the message buffer of size bytes
 in length to the queue specified by id.  If a task is waiting on
 the queue, then the message is copied to the taskâs buffer and
+the queue, then the message is copied to the task's buffer and
 the task is unblocked.  If no tasks are waiting on the queue,
 then the message is copied to a message buffer which is obtained
 from this message queueâs message buffer pool.  The message
+from this message queue's message buffer pool.  The message
 buffer is then placed at the front of the queue.
 …
 the queue specified by id to be unblocked and sent the message
 contained in buffer.  Before a task is unblocked, the message
 buffer of size byes in length is copied to that taskâs message
+buffer of size byes in length is copied to that task's message
 buffer.  The number of tasks that were unblocked is returned in
 count.

c_user/multiprocessing.rst

-                      r11e1a6f
+                      rd389819
 media or topology of a multiprocessor system.  The tasks which
 compose a particular application can be spread among as many
 processors as needed to satisfy the applicationâs timing
+processors as needed to satisfy the application's timing
 requirements.  The application tasks can interact using a subset
 of the RTEMS directives as if they were on the same processor.
 …
 remote node and is used to represent a task which must block as
 part of a remote operation. This action can occur as part of the``rtems_semaphore_obtain`` and``rtems_message_queue_receive`` directives.  If the
 object were local, the taskâs control block would be available
+object were local, the task's control block would be available
 for modification to indicate it was blocking on a message queue
 or semaphore.  However, the taskâs control block resides only on
+or semaphore.  However, the task's control block resides only on
 the same node as the task.  As a result, the remote node must
 allocate a proxy to represent the task until it can be readied.
 …
 on the MPCI layer implementation... index:: MPCI entry points
 The entry points to the routines in the userâs MPCI
+The entry points to the routines in the user's MPCI
 layer should be placed in the Multiprocessor Communications
 Interface Table.  The user must provide entry points for each of
 …
     );
 where configuration is the address of the userâs
+where configuration is the address of the user's
 Configuration Table.  Operations on global objects cannot be
 performed until this component is invoked.  The INITIALIZATION
 …
 point numbers, bit fields, decimal data, and character strings.
 In addition, the representation method for negative integers
 could be oneâs or twoâs complement.  These factors combine to
+could be one's or two's complement.  These factors combine to
 increase the complexity of designing and manipulating data
 structures shared between processors.
 …
 This section details the additional directives
 required to support RTEMS in a multiprocessor configuration.  A
 subsection is dedicated to each of this managerâs directives and
+subsection is dedicated to each of this manager's directives and
 describes the calling sequence, related constants, usage, and
 status codes.

c_user/overview.rst

-                      r11e1a6f
+                      rd389819
 RTEMS utilizes memory for both code and data space.
 Although RTEMSâ data space must be in RAM, its code space can be
+Although RTEMS' data space must be in RAM, its code space can be
 located in either ROM or RAM.
 …
 find that the use and behavior of the two implementations is
 very similar.  A working knowledge of the target processor is
 helpful in understanding some of RTEMSâ features.  A thorough
+helpful in understanding some of RTEMS' features.  A thorough
 understanding of the executive cannot be obtained without
 studying the entire manual because many of RTEMSâ concepts and
+studying the entire manual because many of RTEMS' concepts and
 features are interrelated.  Experienced RTEMS users will find
 that the manual organization facilitates its use as a reference
 …
     Object Services: presents a collection of helper services useful
     when manipulating RTEMS objects. These include methods to assist
     in obtaining an objectâs name in printable form. Additional services
+    in obtaining an object's name in printable form. Additional services
     are provided to decompose an object Id and determine which API
     and object class it belongs to.

c_user/partition_manager.rst

-                      r11e1a6f
+                      rd389819
 Partitions are managed and maintained as a list of
 buffers.  Buffers are obtained from the front of the partitionâs
+buffers.  Buffers are obtained from the front of the partition's
 free buffer chain and returned to the rear of the same chain.
 When a buffer is on the free buffer chain, RTEMS uses two
 …
 The ``rtems_partition_create`` directive creates a partition
 with a user-specified name.  The partitionâs name, starting
+with a user-specified name.  The partition's name, starting
 address, length and buffer size are all specified to the``rtems_partition_create`` directive.
 RTEMS allocates a Partition Control
 …
 ------------------
 Buffers are returned to a partitionâs free buffer
+Buffers are returned to a partition's free buffer
 chain with the ``rtems_partition_return_buffer`` directive.  This
 directive returns an error status code if the returned buffer
 …
 ==========
 This section details the partition managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the partition manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 remote tasks must interact with the partition.  This is to avoid
 the overhead incurred by the creation of a global partition.
 When a global partition is created, the partitionâs name and id
+When a global partition is created, the partition's name and id
 must be transmitted to every node in the system for insertion in
 the local copy of the global object table.

c_user/pci_library.rst

-                      r11e1a6f
+                      rd389819
 On systems where a peripheral PCI device needs to access other PCI devices than
 the host the peripheral configuration approach may be handy. Most PCI devices
 answers on the PCI hostâs requests and start DMA accesses into the Hosts memory,
+answers on the PCI host's requests and start DMA accesses into the Hosts memory,
 however in some complex systems PCI devices may want to access other devices
 on the same bus or at another PCI bus.
 …
 -----------------
 The RTEMS shell has a PCI command âpciâ which makes it possible to read/write
+The RTEMS shell has a PCI command 'pci' which makes it possible to read/write
 configuration space, print the current PCI configuration and print out a
 configuration C-file for the static or peripheral library.

c_user/preface.rst

-                      r11e1a6f
+                      rd389819
 as seen by a real-time application.  It does not include the
 details of how a kernel implements these functions.  The
 standardâs goal is to serve as a complete definition of external
+standard's goal is to serve as a complete definition of external
 interfaces so that application code that conforms to these
 interfaces will execute properly in all real-time executive
 …
 The acceptance of a standard for real-time executives
 will produce the same advantages enjoyed from the push for UNIX
 standardization by AT&Tâs System V Interface Definition and
 IEEEâs POSIX efforts.  A compliant multiprocessing executive
+standardization by AT&T's System V Interface Definition and
+IEEE's POSIX efforts.  A compliant multiprocessing executive
 will allow close coupling between UNIX systems and real-time
 executives to provide the many benefits of the UNIX development

c_user/rate_monotonic_manager.rst

-                      r11e1a6f
+                      rd389819
 The information reported can be used to determine the "hot spots"
 in the application.  Given a periodâs id, the user can determine
+in the application.  Given a period's id, the user can determine
 the length of that period.  From that information and the CPU usage,
 the user can calculate the percentage of CPU time consumed by that
 periodic task.  For example, a task executing for 20 milliseconds
 every 200 milliseconds is consuming 10 percent of the processorâs
+every 200 milliseconds is consuming 10 percent of the processor's
 execution time.  This is usually enough to make it a good candidate
 for optimization.
 …
 the processor utilization for that task.  Processor utilization
 is the percentage of processor time used and can be calculated
 on a per-task or system-wide basis.  Typically, the taskâs
+on a per-task or system-wide basis.  Typically, the task's
 worst-case execution time will be less than its period.  For
 example, a periodic taskâs requirements may state that it should
+example, a periodic task's requirements may state that it should
 execute for 10 milliseconds every 100 milliseconds.  Although
 the execution time may be the average, worst, or best case, the
 …
 This analysis determines whether a task set is schedulable under
 worst-case conditions and emphasizes the predictability of the
 systemâs behavior.  It has been proven that:
+system's behavior.  It has been proven that:
 - *RMS is an optimal static priority algorithm for
 …
 RMS calls for the static assignment of task
 priorities based upon their period.  The shorter a taskâs
+priorities based upon their period.  The shorter a task's
 period, the higher its priority.  For example, a task with a 1
 millisecond period has higher priority than a task with a 100
 …
 does not distinguish between the tasks.  However, RTEMS
 specifies that when given tasks of equal priority, the task
 which has been ready longest will execute first.  RMSâs priority
+which has been ready longest will execute first.  RMS's priority
 assignment scheme does not provide one with exact numeric values
 for task priorities.  For example, consider the following task
 …
 priority, can be created and started before the initialization
 deletes itself.  This technique ensures that all tasks begin to
 compete for execution time at the same instant â when the user
+compete for execution time at the same instant - when the user
 initialization task deletes itself.
 …
 contend for resources.  This assumption can be relaxed by
 accounting for the amount of time a task spends waiting to
 acquire resources.  Similarly, each taskâs execution time must
+acquire resources.  Similarly, each task's execution time must
 account for any I/O performed and any RTEMS directive calls.
 …
 with a period of ``RTEMS_PERIOD_STATUS`` ticks, the current
 state of the specified rate monotonic period will be returned.  The following
 table details the relationship between the periodâs status and
+table details the relationship between the period's status and
 the directive status code returned by the``rtems_rate_monotonic_period``
 directive:
 …
 a rate monotonic period.  If the period is running and has not
 expired, the period is automatically canceled.  The rate
 monotonic periodâs control block is returned to the PCB free
+monotonic period's control block is returned to the PCB free
 list when it is deleted.  A rate monotonic period can be deleted
 by a task other than the task which created the period.
 …
 ==========
 This section details the rate monotonic managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the rate monotonic manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 A configure time option can be used to select whether the time information is
 given in ticks or seconds and nanoseconds.  The default is seconds and
 nanoseconds.  If the periodâs state is ``RATE_MONOTONIC_INACTIVE``, both
+nanoseconds.  If the period's state is ``RATE_MONOTONIC_INACTIVE``, both
 time values will be set to 0.  Otherwise, both time values will contain
 time information since the last invocation of the``rtems_rate_monotonic_period`` directive.  More

c_user/red_black_trees.rst

-                      r11e1a6f
+                      rd389819
 - ``rtems_rtems_rbtree_initialize_empty`` - initialize the red-black tree as empty
 - ``rtems_rtems_rbtree_set_off_tree`` - Clear a nodeâs links
+- ``rtems_rtems_rbtree_set_off_tree`` - Clear a node's links
 - ``rtems_rtems_rbtree_root`` - Return the red-black treeâs root node
+- ``rtems_rtems_rbtree_root`` - Return the red-black tree's root node
 - ``rtems_rtems_rbtree_min`` - Return the red-black treeâs minimum node
+- ``rtems_rtems_rbtree_min`` - Return the red-black tree's minimum node
 - ``rtems_rtems_rbtree_max`` - Return the red-black treeâs maximum node
+- ``rtems_rtems_rbtree_max`` - Return the red-black tree's maximum node
 - ``rtems_rtems_rbtree_left`` - Return a nodeâs left child node
+- ``rtems_rtems_rbtree_left`` - Return a node's left child node
 - ``rtems_rtems_rbtree_right`` - Return a nodeâs right child node
+- ``rtems_rtems_rbtree_right`` - Return a node's right child node
 - ``rtems_rtems_rbtree_parent`` - Return a nodeâs parent node
+- ``rtems_rtems_rbtree_parent`` - Return a node's parent node
 - ``rtems_rtems_rbtree_are_nodes_equal`` - Are the nodeâs equal ?
+- ``rtems_rtems_rbtree_are_nodes_equal`` - Are the node's equal ?
 - ``rtems_rtems_rbtree_is_empty`` - Is the red-black tree empty ?
 …
 is designed to be part of a user data structure. To obtain the encapsulating
 structure users can use the ``RTEMS_CONTAINER_OF`` macro.
 The node can be placed anywhere within the userâs structure and the macro will
 calculate the structureâs address from the nodeâs address.
+The node can be placed anywhere within the user's structure and the macro will
+calculate the structure's address from the node's address.
 Controls

c_user/region_manager.rst

-                      r11e1a6f
+                      rd389819
 using a first-fit algorithm.  If available, the requester
 receives the number of bytes requested (rounded up to the next
 page size).  RTEMS requires some overhead from the regionâs
+page size).  RTEMS requires some overhead from the region's
 memory for each segment that is allocated.  Therefore, an
 application should only modify the memory of a segment that has
 been obtained from the region.  The application should NOT
 modify the memory outside of any obtained segments and within
 the regionâs boundaries while the region is currently active in
+the region's boundaries while the region is currently active in
 the system.
 …
 If the task waits for the segment, then it is placed
 in the regionâs task wait queue in either FIFO or task priority
+in the region's task wait queue in either FIFO or task priority
 order.  All tasks waiting on a region are returned an error when
 the message queue is deleted.
 …
 segment request can now be satisfied.  If so, it is given a
 segment and unblocked.  This process is repeated until the first
 taskâs segment request cannot be satisfied.
+task's segment request cannot be satisfied.
 Obtaining the Size of a Segment
 …
 ==========
 This section details the region managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the region manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 indicating this fact is returned.  If the calling task chooses
 to wait for the segment and a segment large enough is not
 available, then the calling task is placed on the regionâs
+available, then the calling task is placed on the region's
 segment wait queue and blocked.  If the region was created with
 the ``RTEMS_PRIORITY`` option, then the calling
 …
 The actual length of the allocated segment may be
 larger than the requested size because a segment size is always
 a multiple of the regionâs page size.
+a multiple of the region's page size.
 The following segment acquisition option constants
 …
 segment request can now be satisfied.  If so, it is given a
 segment and unblocked.  This process is repeated until the first
 taskâs segment request cannot be satisfied.
+task's segment request cannot be satisfied.
 **NOTES:**
 …
 The actual length of the allocated segment may be
 larger than the requested size because a segment size is always
 a multiple of the regionâs page size.
+a multiple of the region's page size.
 REGION_RESIZE_SEGMENT - Change size of a segment

c_user/rtems_data_types.rst

-                      r11e1a6f
+                      rd389819
   ``rtems_context`` is the CPU dependent
   data structure used to manage the integer and system
   register portion of each taskâs context.
+  register portion of each task's context.
 - .. index:: rtems_context_fp
 …
   ``rtems_context_fp`` is the CPU dependent
   data structure used to manage the floating point portion of
   each taskâs context.
+  each task's context.
 - .. index:: rtems_device_driver

c_user/scheduling_concepts.rst

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

c_user/semaphore_manager.rst

-                      r11e1a6f
+                      rd389819
 the semaphore is increased to that of the blocking task.  When
 the task holding the task completely releases the binary
 semaphore (i.e. not for a nested release), the holderâs priority
+semaphore (i.e. not for a nested release), the holder's priority
 is restored to the value it had before any higher priority was
 inherited.
 …
 raised to the ceiling priority.  When the task holding the task
 completely releases the binary semaphore (i.e. not for a nested
 release), the holderâs priority is restored to the value it had
+release), the holder's priority is restored to the value it had
 before any higher priority was put into effect.
 …
 creating the semaphore is considered the current holder of the
 semaphore.  At create time the method for ordering waiting tasks
 in the semaphoreâs task wait queue (by FIFO or task priority) is
+in the semaphore's task wait queue (by FIFO or task priority) is
 specified.  Additionally, the priority inheritance or priority
 ceiling algorithm may be selected for local, binary semaphores
 …
 If the task waits to acquire the semaphore, then it
 is placed in the semaphoreâs task wait queue in either FIFO or
+is placed in the semaphore's task wait queue in either FIFO or
 task priority order.  If the task blocked waiting for a binary
 semaphore using priority inheritance and the taskâs priority is
+semaphore using priority inheritance and the task's priority is
 greater than that of the task currently holding the semaphore,
 then the holding task will inherit the priority of the blocking
 …
 When a task successfully obtains a semaphore using
 priority ceiling and the priority ceiling for this semaphore is
 greater than that of the holder, then the holderâs priority will
+greater than that of the holder, then the holder's priority will
 be elevated.
 …
 The ``rtems_semaphore_delete`` directive removes a semaphore
 from the system and frees its control block.  A semaphore can be
 deleted by any local task that knows the semaphoreâs ID.  As a
+deleted by any local task that knows the semaphore's ID.  As a
 result of this directive, all tasks blocked waiting to acquire
 the semaphore will be readied and returned a status code which
 indicates that the semaphore was deleted.  Any subsequent
 references to the semaphoreâs name and ID are invalid.
+references to the semaphore's name and ID are invalid.
 Directives
 ==========
 This section details the semaphore managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the semaphore manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.
 …
 tasks must interact with the created semaphore.  This is to
 avoid the system overhead incurred by the creation of a global
 semaphore.  When a global semaphore is created, the semaphoreâs
+semaphore.  When a global semaphore is created, the semaphore's
 name and id must be transmitted to every node in the system for
 insertion in the local copy of the global object table.
 …
 The calling task will be preempted if it is enabled
 by the taskâs execution mode and a higher priority local task is
+by the task's execution mode and a higher priority local task is
 waiting on the deleted semaphore.  The calling task will NOT be
 preempted if all of the tasks that are waiting on the semaphore
 …
 chooses to wait for a semaphore and the current semaphore count is zero or
 negative, then it is decremented by one and the calling task is placed on
 the semaphoreâs wait queue and blocked.  If the semaphore was created with
+the semaphore's wait queue and blocked.  If the semaphore was created with
 the ``RTEMS_PRIORITY`` attribute, then the calling task is
 inserted into the queue according to its priority.  However, if the
 …
 This directive releases the semaphore specified by
 id.  The semaphore count is incremented by one.  If the count is
 zero or negative, then the first task on this semaphoreâs wait
+zero or negative, then the first task on this semaphore's wait
 queue is removed and unblocked.  The unblocked task may preempt
 the running task if the running taskâs preemption mode is
+the running task if the running task's preemption mode is
 enabled and the unblocked task has a higher priority than the
 running task.
 …
 This directive unblocks all tasks waiting on the semaphore specified by
 id.  Since there are tasks blocked on the semaphore, the semaphoreâs
+id.  Since there are tasks blocked on the semaphore, the semaphore's
 count is not changed by this directive and thus is zero before and
 after this directive is executed.  Tasks which are unblocked as the
 …
 This directive may unblock any number of tasks.  Any of the unblocked
 tasks may preempt the running task if the running taskâs preemption mode is
+tasks may preempt the running task if the running task's preemption mode is
 enabled and an unblocked task has a higher priority than the
 running task.

c_user/signal_manager.rst

-                      r11e1a6f
+                      rd389819
 The signal manager allows a task to optionally define
 an asynchronous signal routine (ASR).  An ASR is to a task what
 an ISR is to an applicationâs set of tasks.  When the processor
+an ISR is to an application's set of tasks.  When the processor
 is interrupted, the execution of an application is also
 interrupted and an ISR is given control.  Similarly, when a
 signal is sent to a task, that taskâs execution path will be
+signal is sent to a task, that task's execution path will be
 "interrupted" by the ASR.  Sending a signal to a task has no
 effect on the receiving taskâs current execution state... index:: rtems_signal_set
+effect on the receiving task's current execution state... index:: rtems_signal_set
 A signal flag is used by a task (or ISR) to inform
 …
 A signal set is posted when it is directed (or sent) to a
 task. A pending signal is a signal that has been sent to a task
 with a valid ASR, but has not been processed by that taskâs ASR.
+with a valid ASR, but has not been processed by that task's ASR.
 A Comparison of ASRs and ISRs
 …
 .. index:: ASR mode, building
 In general, an ASRâs mode is built by a bitwise OR of
+In general, an ASR's mode is built by a bitwise OR of
 the desired mode components.  The set of valid mode components
 is the same as those allowed with the task_create and task_mode
 …
 The ``rtems_signal_catch`` directive establishes an ASR for the
 calling task.  The address of the ASR and its execution mode are
 specified to this directive.  The ASRâs mode is distinct from
 the taskâs mode.  For example, the task may allow preemption,
 while that taskâs ASR may have preemption disabled.  Until a
+specified to this directive.  The ASR's mode is distinct from
+the task's mode.  For example, the task may allow preemption,
+while that task's ASR may have preemption disabled.  Until a
 task calls ``rtems_signal_catch`` the first time,
 its ASR is invalid, and no signal sets can be sent to the task.
 …
 A task may invalidate its ASR and discard all pending
 signals by calling ``rtems_signal_catch``
 with a value of NULL for the ASRâs address.  When a taskâs
+with a value of NULL for the ASR's address.  When a task's
 ASR is invalid, new signal sets sent to this task are discarded.
 A task may disable ASR processing (``RTEMS_NO_ASR``) via the
 task_mode directive.  When a taskâs ASR is disabled, the signals
+task_mode directive.  When a task's ASR is disabled, the signals
 sent to it are left pending to be processed later when the ASR
 is enabled.
 …
 replaces the previous one.
 Normally, signal processing is disabled for the ASRâs
+Normally, signal processing is disabled for the ASR's
 execution mode, but if signal processing is enabled for the ASR,
 the ASR must be reentrant.
 …
 of a signal to a task has no effect on the execution state of
 that task.  If the task is not the currently running task, then
 the signals are left pending and processed by the taskâs ASR the
+the signals are left pending and processed by the task's ASR the
 next time the task is dispatched to run.  The ASR is executed
 immediately before the task is dispatched.  If the currently
 …
 ==========
 This section details the signal managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the signal manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 signals are cleared.  Any signals sent to a task with an invalid
 ASR are discarded.  The mode parameter specifies the execution
 mode for the ASR.  This execution mode supersedes the taskâs
+mode for the ASR.  This execution mode supersedes the task's
 execution mode while the ASR is executing.
 …
 Sending a signal set to a task has no effect on that
 taskâs state.  If a signal set is sent to a blocked task, then
+task's state.  If a signal set is sent to a blocked task, then
 the task will remain blocked and the signals will be processed
 when the task becomes the running task.

c_user/stack_bounds_checker.rst

-                      r11e1a6f
+                      rd389819
 The stack bounds checker operates as a set of task extensions.  At
 task creation time, the taskâs stack is filled with a pattern to
+task creation time, the task's stack is filled with a pattern to
 indicate the stack is unused.  As the task executes, it will overwrite
 this pattern in memory.  At each task switch, the stack bounds checkerâs
+this pattern in memory.  At each task switch, the stack bounds checker's
 task switch extension is executed.  This extension checks that:
 - the last ``n`` bytes of the taskâs stack have
+- the last ``n`` bytes of the task's stack have
   not been overwritten.  If this pattern has been damaged, it
   indicates that at some point since this task was context
 …
 - the current stack pointer of the task is not within
   the address range allocated for use as the taskâs stack.
+  the address range allocated for use as the task's stack.
 If either of these conditions is detected, then a blown stack
 …
 The above includes the task id and a pointer to the task control block as
 well as enough information so one can look at the taskâs stack and
+well as enough information so one can look at the task's stack and
 see what was happening.
 …
 ========
 This section details the stack bounds checkerâs routines.
+This section details the stack bounds checker's routines.
 A subsection is dedicated to each of routines
 and describes the calling sequence, related constants, usage,

c_user/symmetric_multiprocessing_services.rst

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

c_user/task_manager.rst

-                      r11e1a6f
+                      rd389819
 - ``rtems_task_set_priority`` - Set task priority
 - ``rtems_task_mode`` - Change current taskâs mode
+- ``rtems_task_mode`` - Change current task's mode
 - ``rtems_task_wake_after`` - Wake up after interval
 …
   concurrently with other computational sequences.
 From RTEMSâ perspective, a task is the smallest thread of
+From RTEMS' perspective, a task is the smallest thread of
 execution which can compete on its own for system resources.  A
 task is manifested by the existence of a task control block
 …
 upon deletion of the task.
 The TCBâs elements are modified as a result of system calls made
+The TCB's elements are modified as a result of system calls made
 by the application in response to external and internal stimuli.
 TCBs are the only RTEMS internal data structure that can be
 accessed by an application via user extension routines.  The TCB
 contains a taskâs name, ID, current priority, current and
+contains a task's name, ID, current priority, current and
 starting states, execution mode, TCB user extension pointer,
 scheduling control structures, as well as data required by a
 blocked task.
 A taskâs context is stored in the TCB when a task switch occurs.
+A task's context is stored in the TCB when a task switch occurs.
 When the task regains control of the processor, its context is
 restored from the TCB.  When a task is restarted, the initial
 state of the task is restored from the starting context area in
 the taskâs TCB.
+the task's TCB.
 Task States
 …
 .. index:: rtems_task_priority
 A taskâs priority determines its importance in relation to the
+A task's priority determines its importance in relation to the
 other tasks executing on the same processor.  RTEMS supports 255
 levels of priority ranging from 1 to 255.  The data type``rtems_task_priority`` is used to store task
 …
 .. index:: rtems_task_mode
 A taskâs execution mode is a combination of the following
+A task's execution mode is a combination of the following
 four components:
 …
 - interrupt level
 It is used to modify RTEMSâ scheduling process and to alter the
+It is used to modify RTEMS' scheduling process and to alter the
 execution environment of the task.  The data type``rtems_task_mode`` is used to manage the task
 execution mode... index:: preemption
 …
 processor is relinquished.  If preemption is disabled
 (``RTEMS_NO_PREEMPT``), the task will retain control of the
 processor as long as it is in the executing state â even if a higher
+processor as long as it is in the executing state - even if a higher
 priority task is made ready.  If preemption is enabled
 (``RTEMS_PREEMPT``)  and a higher priority task is made ready,
 …
 treated as private (i.e. per-task) the task can access and modify the
 variable, but the modifications will not appear to other tasks, and
 other tasksâ modifications to that variable will not affect the value
+other tasks' modifications to that variable will not affect the value
 seen by the task.  This is accomplished by saving and restoring the
 variableâs value each time a task switch occurs to or from the calling task.
+variable's value each time a task switch occurs to or from the calling task.
 The value seen by other tasks, including those which have not added the
 …
 task variables.  One efficient method is to have a single task
 variable that is a pointer to a dynamically allocated structure
 containing the taskâs private "global" data.
+containing the task's private "global" data.
 A critical point with per-task variables is that each task must separately
 …
 *WARNING*: Per-Task variables are inherently broken on SMP systems. They
 only work correctly when there is one task executing in the system and
 that task is the logical owner of the value in the per-task variableâs
+that task is the logical owner of the value in the per-task variable's
 location. There is no way for a single memory image to contain the
 correct value for each task executing on each core. Consequently,
 …
 In general, a mode and its corresponding mask is built by a
 bitwise OR of the desired components.  The set of valid mode
 constants and each modeâs corresponding mask constant is
+constants and each mode's corresponding mask constant is
 listed below:
 …
 RTEMS_NO_PREEMPT`` to indicate the desired preemption mode and
 interrupt level, while the mask parameter should be set to``RTEMS_INTERRUPT_MASK |
 RTEMS_NO_PREEMPT_MASK`` to indicate that the calling taskâs
+RTEMS_NO_PREEMPT_MASK`` to indicate that the calling task's
 interrupt level and preemption mode are being altered.
 …
 With the ``rtems_task_start``
 directive the user specifies the taskâs
+directive the user specifies the task's
 starting address and argument.  The argument is used to
 communicate some startup information to the task.  As part of
 this directive, RTEMS initializes the taskâs stack based upon
 the taskâs initial execution mode and start address.  The
+this directive, RTEMS initializes the task's stack based upon
+the task's initial execution mode and start address.  The
 starting argument is passed to the task in accordance with the
 target processorâs calling convention.
+target processor's calling convention.
 The ``rtems_task_restart``
 …
 but with a possibly different argument.  The new argument may be
 used to distinguish between the original invocation of the task
 and subsequent invocations.  The taskâs stack and control block
+and subsequent invocations.  The task's stack and control block
 are modified to reflect their original creation values.
 Although references to resources that have been requested are
 …
 directive is used to obtain or change the
 current priority of either the calling task or another task.  If
 the new priority requested is``RTEMS_CURRENT_PRIORITY`` or the taskâs
+the new priority requested is``RTEMS_CURRENT_PRIORITY`` or the task's
 actual priority, then the current priority will be returned and
 the taskâs priority will remain unchanged.  If the taskâs
+the task's priority will remain unchanged.  If the task's
 priority is altered, then the task will be scheduled according
 to its new priority.
 …
 The ``rtems_task_mode``
 directive is used to obtain or change the current
 execution mode of the calling task.  A taskâs execution mode is
+execution mode of the calling task.  A task's execution mode is
 used to enable preemption, timeslicing, ASR processing, and to
 set the taskâs interrupt level.
+set the task's interrupt level.
 The ``rtems_task_restart``
 …
 directive to allow a task to
 delete itself or any other task.  This directive removes all
 RTEMS references to the task, frees the taskâs control block,
+RTEMS references to the task, frees the task's control block,
 removes it from resource wait queues, and deallocates its stack
 as well as the optional floating point context.  The taskâs name
+as well as the optional floating point context.  The task's name
 and ID become inactive at this time, and any subsequent
 references to either of them is invalid.  In fact, RTEMS may
 …
 ==========
 This section details the task managerâs directives.  A
 subsection is dedicated to each of this managerâs directives and
+This section details the task manager's directives.  A
+subsection is dedicated to each of this manager's directives and
 describes the calling sequence, related constants, usage, and
 status codes.
 …
 It allocates and initializes a TCB, a stack, and an optional
 floating point context area.  The mode parameter contains values
 which sets the taskâs initial execution mode.  The``RTEMS_FLOATING_POINT`` attribute should be
+which sets the task's initial execution mode.  The``RTEMS_FLOATING_POINT`` attribute should be
 specified if the created task
 is to use a numeric coprocessor.  For performance reasons, it is
 …
 interact with them.  This avoids the system overhead incurred by
 the creation of a global task.  When a global task is created,
 the taskâs name and id must be transmitted to every node in the
+the task's name and id must be transmitted to every node in the
 system for insertion in the local copy of the global object
 table.
 …
 This directive readies the task, specified by ``id``, for execution
 based on the priority and execution mode specified when the task
 was created.  The starting address of the task is given in``entry_point``.  The taskâs starting argument is contained in
+was created.  The starting address of the task is given in``entry_point``.  The task's starting argument is contained in
 argument.  This argument can be a single value or used as an index into an
 array of parameter blocks.  The type of this numeric argument is an unsigned
 …
 This directive resets the task specified by id to begin
 execution at its original starting address.  The taskâs priority
+execution at its original starting address.  The task's priority
 and execution mode are set to the original creation values.  If
 the task is currently blocked, RTEMS automatically makes the
 …
 dormant state.
 The taskâs starting argument is contained in argument.  This argument can be a
+The task's starting argument is contained in argument.  This argument can be a
 single value or an index into an array of parameter blocks.  The type of this
 numeric argument is an unsigned integer type with the property that any valid
 …
 id.  An id of ``RTEMS_SELF`` is used to indicate
 the calling task.  When new_priority is not equal to``RTEMS_CURRENT_PRIORITY``, the specified
 taskâs previous priority is returned in old_priority.  When
+task's previous priority is returned in old_priority.  When
 new_priority is ``RTEMS_CURRENT_PRIORITY``,
 the specified taskâs current
+the specified task's current
 priority is returned in old_priority.  Valid priorities range
 from a high of 1 to a low of 255.
 …
 The calling task may be preempted if its preemption mode is
 enabled and it lowers its own priority or raises another taskâs
+enabled and it lowers its own priority or raises another task's
 priority.
 …
 If the task specified by id is currently holding any binary
 semaphores which use the priority inheritance algorithm, then
 the taskâs priority cannot be lowered immediately.  If the
 taskâs priority were lowered immediately, then priority
 inversion results.  The requested lowering of the taskâs
+the task's priority cannot be lowered immediately.  If the
+task's priority were lowered immediately, then priority
+inversion results.  The requested lowering of the task's
 priority will occur when the task has released all priority
 inheritance binary semaphores.  The taskâs priority can be
 increased regardless of the taskâs use of priority inheritance
+inheritance binary semaphores.  The task's priority can be
+increased regardless of the task's use of priority inheritance
 binary semaphores.
 …
 This directive manipulates the execution mode of the calling
 task.  A taskâs execution mode enables and disables preemption,
+task.  A task's execution mode enables and disables preemption,
 timeslicing, asynchronous signal processing, as well as
 specifying the current interrupt level.  To modify an execution
 …
 indicator specified in mode.
 The set of task mode constants and each modeâs corresponding
+The set of task mode constants and each mode's corresponding
 mask constant is provided in the following table:
 …
 then be private to the task.  The task can access and modify the
 variable, but the modifications will not appear to other tasks, and
 other tasksâ modifications to that variable will not affect the value
+other tasks' modifications to that variable will not affect the value
 seen by the task.  This is accomplished by saving and restoring the
 variableâs value each time a task switch occurs to or from the calling task.
 If the dtor argument is non-NULL it specifies the address of a âdestructorâ
+variable's value each time a task switch occurs to or from the calling task.
+If the dtor argument is non-NULL it specifies the address of a 'destructor'
 function which will be called when the task is deleted.  The argument
 passed to the destructor function is the taskâs value of the variable.
+passed to the destructor function is the task's value of the variable.
 **NOTES:**
 …
 task variables.  One efficient method
 is to have a single task variable that is a pointer to a dynamically
 allocated structure containing the taskâs private âglobalâ data.
 In this case the destructor function could be âfreeâ.
+allocated structure containing the task's private 'global' data.
+In this case the destructor function could be 'free'.
 Per-task variables are disabled in SMP configurations and this service
 …
 **DESCRIPTION:**
 This directive removes the given location from a taskâs context.
+This directive removes the given location from a task's context.
 **NOTES:**

c_user/timer_manager.rst

-                      r11e1a6f
+                      rd389819
 The ``rtems_timer_delete`` directive is used to delete a timer.
 If the timer is running and has not expired, the timer is
 automatically canceled.  The timerâs control block is returned
+automatically canceled.  The timer's control block is returned
 to the TMCB free list when it is deleted.  A timer can be
 deleted by a task other than the task which created the timer.
 Any subsequent references to the timerâs name and ID are invalid.
+Any subsequent references to the timer's name and ID are invalid.
 Directives
 ==========
 This section details the timer managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the timer manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

c_user/timespec_helpers.rst

-                      r11e1a6f
+                      rd389819
 The directives provided by the timespec helpers manager are:
 - ``rtems_timespec_set`` - Set timespecâs value
 - ``rtems_timespec_zero`` - Zero timespecâs value
+- ``rtems_timespec_set`` - Set timespec's value
+- ``rtems_timespec_zero`` - Zero timespec's value
 - ``rtems_timespec_is_valid`` - Check if timespec is valid
 …
 ==========
 This section details the Timespec Helpers managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the Timespec Helpers manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

c_user/user_extensions.rst

-                      r11e1a6f
+                      rd389819
 RTEMS allows the user to have multiple extension sets
 active at the same time.  First, a single static extension set
 may be defined as the applicationâs User Extension Table which
+may be defined as the application's User Extension Table which
 is included as part of the Configuration Table.  This extension
 set is active for the entire life of the system and may not be
 …
 RTEMS provides for a pointer to a user-defined data
 area for each extension set to be linked to each taskâs control
+area for each extension set to be linked to each task's control
 block.  This set of pointers is an extension of the TCB and can
 be used to store additional data required by the userâs
+be used to store additional data required by the user's
 extension functions.
 …
 augment the TCB with user-defined information.  For example, an
 application could implement task profiling by storing timing
 statistics in the TCBâs extended memory area.  When a task
+statistics in the TCB's extended memory area.  When a task
 context switch is being executed, the TASK_SWITCH extension
 could read a real-time clock to calculate how long the task
 …
 deleted.  Since the TCB extension buffers would most likely be
 of a fixed size, the RTEMS partition manager could be used to
 manage the applicationâs extended memory area.  The application
+manage the application's extended memory area.  The application
 could create a partition of fixed size TCB extension buffers and
 use the partition managerâs allocation and deallocation
+use the partition manager's allocation and deallocation
 directives to obtain and release the extension buffers.
 …
 the task that is being swapped out, and heir_task can be used to
 access the TCB for the task being swapped in.  This extension is
 invoked from RTEMSâ dispatcher routine after the current_task
+invoked from RTEMS' dispatcher routine after the current_task
 context has been saved, but before the heir_task context has
 been restored.  This extension should not call any RTEMS
 …
 the fatal_error_occurred directive.
 If defined, the userâs FATAL error extension is
 invoked before RTEMSâ default fatal error routine is invoked and
+If defined, the user's FATAL error extension is
+invoked before RTEMS' default fatal error routine is invoked and
 the processor is stopped.  For example, this extension could be
 used to pass control to a debugger when a fatal error occurs.
 …
 Standard C Library.  Extension sets which are installed after
 the Standard C Library will operate correctly even if they
 utilize the C Library because the C Libraryâs TASK_DELETE
+utilize the C Library because the C Library's TASK_DELETE
 extension is invoked after that of the other extensions.
 …
 The ``rtems_extension_delete`` directive is used to delete an
 extension set.  The extension setâs control block is returned to
+extension set.  The extension set's control block is returned to
 the ESCB free list when it is deleted.  An extension set can be
 deleted by a task other than the task which created the
 extension set.  Any subsequent references to the extensionâs
+extension set.  Any subsequent references to the extension's
 name and ID are invalid.
 …
 ==========
 This section details the user extension managerâs
 directives.  A subsection is dedicated to each of this managerâs
+This section details the user extension manager's
+directives.  A subsection is dedicated to each of this manager's
 directives and describes the calling sequence, related
 constants, usage, and status codes.

cpu_supplement/atmel_avr.rst

-                      r11e1a6f
+                      rd389819
 A called function may clobber all registers, except RETS, R4-R7, P3-P5,
 FP and SP.  It may also modify the first 12 bytes in the callerÃ¢ÂÂs stack
+FP and SP.  It may also modify the first 12 bytes in the caller's stack
 frame which is used as an argument area for the first three arguments
 (which are passed in R0...R3 but may be placed on the stack by the
 …
 ====================
 Discussed in this chapter are the AVRâs interrupt response and
+Discussed in this chapter are the AVR's interrupt response and
 control mechanisms as they pertain to RTEMS.

cpu_supplement/blackfin.rst

-                      r11e1a6f
+                      rd389819
 A called function may clobber all registers, except RETS, R4-R7, P3-P5,
 FP and SP.  It may also modify the first 12 bytes in the callerÃ¢ÂÂs stack
+FP and SP.  It may also modify the first 12 bytes in the caller's stack
 frame which is used as an argument area for the first three arguments
 (which are passed in R0...R3 but may be placed on the stack by the
 …
 ====================
 Discussed in this chapter are the Blackfinâs interrupt response and
+Discussed in this chapter are the Blackfin's interrupt response and
 control mechanisms as they pertain to RTEMS. The Blackfin architecture
 support 16 kinds of interrupts broken down into Core and general-purpose

cpu_supplement/index.rst

r11e1a6f	rd389819
3	3	=================================
4	4
5		COPYRIGHT Â© 1988 - 2015.
	5	COPYRIGHT (c) 1988 - 2015.
6	6
7	7	On-Line Applications Research Corporation (OAR).

cpu_supplement/intel_amd_x86.rst

-                      r11e1a6f
+                      rd389819
 following documents:
 - *386 Programmerâs Reference Manual, Intel, Order No.  230985-002*.
+- *386 Programmer's Reference Manual, Intel, Order No.  230985-002*.
 - *386 Microprocessor Hardware Reference Manual, Intel,
   Order No. 231732-003*.
 - *80386 System Software Writerâs Guide, Intel, Order No.  231499-001*.
 - *80387 Programmerâs Reference Manual, Intel, Order No.  231917-001*.
+- *80386 System Software Writer's Guide, Intel, Order No.  231499-001*.
+- *80387 Programmer's Reference Manual, Intel, Order No.  231917-001*.
 CPU Model Dependent Features
 …
 endian swaps a thirty-two bit quantity.  This instruction
 appears to be present in all CPU models
 i486âs and above.
+i486's and above.
 Calling Conventions
 …
 dependent details of interrupt processing, it is important to
 understand how the RTEMS interrupt manager is mapped onto the
 processorâs unique architecture. Discussed in this chapter are
 the the processorâs response and control mechanisms as they
+processor's unique architecture. Discussed in this chapter are
+the the processor's response and control mechanisms as they
 pertain to RTEMS.
 …
 Although RTEMS supports 256 interrupt levels, the
 i386 only supports two â enabled and disabled.  Interrupts are
+i386 only supports two - enabled and disabled.  Interrupts are
 enabled when the interrupt-enable flag (IF) in the extended
 flags (EFLAGS) is set.  Conversely, interrupt processing is
 …
 When the i386 is reset,
 - The EAX register is set to indicate the results of the processorâs
+- The EAX register is set to indicate the results of the processor's
   power-up self test.  If the self-test was not executed, the contents of
   this register are undefined.  Otherwise, a non-zero value indicates the
 …
   of memory.
 Typically, an intersegment JMP to the applicationâs initialization code is
+Typically, an intersegment JMP to the application's initialization code is
 placed at address 0xFFFFFFF0.
 …
 For more information regarding the i386 data structures and their
 contents, refer to Intelâs 386 Programmerâs Reference Manual.
+contents, refer to Intel's 386 Programmer's Reference Manual.
 .. COMMENT: COPYRIGHT (c) 1988-2002.

cpu_supplement/lattice_micro32.rst

-                      r11e1a6f
+                      rd389819
 architecture "soft" microprocessor, available for free with an open IP
 core licensing agreement. Although mainly targeted for Lattice FPGA
 devices the microprocessor can be implemented on other vendorsâ FPGAs,
+devices the microprocessor can be implemented on other vendors' FPGAs,
 too.
 …
 Most of the action performed as part of processing the fatal error are
 described in detail in the Fatal Error Manager chapter in the Userâs
+described in detail in the Fatal Error Manager chapter in the User's
 Guide.  However, the if no user provided extension or BSP specific fatal
 error handler takes action, the final default action is to invoke a
 …
 on developing a BSP, refer to BSP and Device Driver Development Guide
 and the chapter titled Board Support Packages in the RTEMS
 Applications Userâs Guide.
+Applications User's Guide.
 System Reset

cpu_supplement/m68xxx_and_coldfire.rst

-                      r11e1a6f
+                      rd389819
 - *M68000 Family Reference, Motorola, FR68K/D*.
 - *MC68020 Userâs Manual, Motorola, MC68020UM/AD*.
 - *MC68881/MC68882 Floating-Point Coprocessor Userâs Manual,
+- *MC68020 User's Manual, Motorola, MC68020UM/AD*.
+- *MC68881/MC68882 Floating-Point Coprocessor User's Manual,
   Motorola, MC68881UM/AD*.
 …
 ====================
 Discussed in this section are the MC68xxxâs interrupt response and
+Discussed in this section are the MC68xxx's interrupt response and
 control mechanisms as they pertain to RTEMS.
 …
   interrupt handler will begin execution.  The RTEMS interrupt
   handler saves all registers which are not preserved according to
   the calling conventions and invokes the applicationâs ISR.
+  the calling conventions and invokes the application's ISR.
 A nested interrupt is processed similarly by these
 …
 ------------------------
 The address of the applicationâs initialization code should be stored in
+The address of the application's initialization code should be stored in
 the first vector of the EVT which will allow the immediate vectoring to
 the application code.  If the application requires that the VBR be some
 value besides zero, then it should be set to the required value at this
 point.  All tasks share the same MC68020âs VBR value.  Because interrupts
+point.  All tasks share the same MC68020's VBR value.  Because interrupts
 are enabled automatically by RTEMS as part of the context switch to the
 first task, the VBR MUST be set by either RTEMS of the BSP before this
 …
 In addition to the requirements described in the
 Board Support Packages chapter of the Applications Userâs
+Board Support Packages chapter of the Applications User's
 Manual for the reset code which is executed before the call to
 initialize executive, the MC68020 version has the following
 …
   the initialize executive directive.
 - Must initialize the MC68020âs vector table.
+- Must initialize the MC68020's vector table.
 .. COMMENT: Copyright (c) 2014 embedded brains GmbH.  All rights reserved.

cpu_supplement/mips.rst

-                      r11e1a6f
+                      rd389819
 Although RTEMS hides many of the processor dependent
 details of interrupt processing, it is important to understand
 how the RTEMS interrupt manager is mapped onto the processorâs
 unique architecture. Discussed in this chapter are the MIPSâs
+how the RTEMS interrupt manager is mapped onto the processor's
+unique architecture. Discussed in this chapter are the MIPS's
 interrupt response and control mechanisms as they pertain to
 RTEMS.

cpu_supplement/port.rst

-                      r11e1a6f
+                      rd389819
 is or is not present and defines a single constant appropriately.
 Conditional compilation is utilized to include the appropriate source
 code for this CPU modelâs feature set.  It is important to note that
+code for this CPU model's feature set.  It is important to note that
 this means that RTEMS is thus compiled using the appropriate feature set
 and compilation flags optimal for this CPU model used.  The alternative
 …
 Each high-level language compiler generates subroutine entry and exit
 code based upon a set of rules known as the compilerâs calling convention.
+code based upon a set of rules known as the compiler's calling convention.
 These rules address the following issues:
 …
 - call and return mechanism
 A compilerâs calling convention is of importance when
+A compiler's calling convention is of importance when
 interfacing to subroutines written in another language either
 assembly or high-level.  Even when the high-level language and
 …
 models ranging from pure physical addressing to complex demand
 paged virtual memory systems.  RTEMS supports a flat memory
 model which ranges contiguously over the processorâs allowable
+model which ranges contiguously over the processor's allowable
 address space.  RTEMS does not support segmentation or virtual
 memory of any kind.  The appropriate memory model for RTEMS
 …
 hides many of the processor dependent details of interrupt processing,
 it is important to understand how the RTEMS interrupt manager is mapped
 onto the processorâs unique architecture.
+onto the processor's unique architecture.
 RTEMS supports a dedicated interrupt stack for all architectures.
 …
 Workspace Area.  The amount of memory allocated for the interrupt stack
 is user configured and based upon the ``confdefs.h`` parameter``CONFIGURE_INTERRUPT_STACK_SIZE``.  This parameter is described
 in detail in the Configuring a System chapter of the Userâs Guide.
+in detail in the Configuring a System chapter of the User's Guide.
 On configurations in which RTEMS allocates the interrupt stack, during
 the initialization process, RTEMS will also install its interrupt stack.
 …
 Most of the action performed as part of processing the fatal error are
 described in detail in the Fatal Error Manager chapter in the Userâs
+described in detail in the Fatal Error Manager chapter in the User's
 Guide.  However, the if no user provided extension or BSP specific fatal
 error handler takes action, the final default action is to invoke a
 …
 on developing a BSP, refer to BSP and Device Driver Development Guide
 and the chapter titled Board Support Packages in the RTEMS
 Applications Userâs Guide.
+Applications User's Guide.
 System Reset

cpu_supplement/powerpc.rst

-                      r11e1a6f
+                      rd389819
   (Motorola Document MPRPPCFPE-01).
 - *IBM PPC403GB Embedded Controller Userâs Manual*.
+- *IBM PPC403GB Embedded Controller User's Manual*.
 - *PoweRisControl MPC500 Family RCPU RISC Central Processing
   Unit Reference Manual* (Motorola Document RCPUURM/AD).
 - *PowerPC 601 RISC Microprocessor Userâs Manual*
+- *PowerPC 601 RISC Microprocessor User's Manual*
   (Motorola Document MPR601UM/AD).
 - *PowerPC 603 RISC Microprocessor Userâs Manual*
+- *PowerPC 603 RISC Microprocessor User's Manual*
   (Motorola Document MPR603UM/AD).
 - *PowerPC 603e RISC Microprocessor Userâs Manual*
+- *PowerPC 603e RISC Microprocessor User's Manual*
   (Motorola Document MPR603EUM/AD).
 - *PowerPC 604 RISC Microprocessor Userâs Manual*
+- *PowerPC 604 RISC Microprocessor User's Manual*
   (Motorola Document MPR604UM/AD).
 - *PowerPC MPC821 Portable Systems Microprocessor Userâs Manual*
+- *PowerPC MPC821 Portable Systems Microprocessor User's Manual*
   (Motorola Document MPC821UM/AD).
 - *PowerQUICC MPC860 Userâs Manual* (Motorola Document MPC860UM/AD).
+- *PowerQUICC MPC860 User's Manual* (Motorola Document MPC860UM/AD).
 Motorola maintains an on-line electronic library for the PowerPC
 …
 ---------
 The macro PPC_ALIGNMENT is set to the PowerPC modelâs worst case alignment
+The macro PPC_ALIGNMENT is set to the PowerPC model's worst case alignment
 requirement for data types on a byte boundary.  This value is used
 to derive the alignment restrictions for memory allocated from
 …
 Although RTEMS hides many of the processor dependent
 details of interrupt processing, it is important to understand
 how the RTEMS interrupt manager is mapped onto the processorâs
 unique architecture. Discussed in this chapter are the PowerPCâs
+how the RTEMS interrupt manager is mapped onto the processor's
+unique architecture. Discussed in this chapter are the PowerPC's
 interrupt response and control mechanisms as they pertain to
 RTEMS.
 …
 performs the following actions:
 - saves the state of the interrupted task on itâs stack,
+- saves the state of the interrupted task on it's stack,
 - saves all registers which are not normally preserved
   by the calling sequence so the userâs interrupt service
+  by the calling sequence so the user's interrupt service
   routine can be written in a high-level language.
 …
 architecture defines a Reset Exception, but leaves the
 details of the CPU state as implementation specific.  Please
 refer to the Userâs Manual for the CPU model in question.
+refer to the User's Manual for the CPU model in question.
 In general, at power-up the PowerPC begin execution at address
 …
 In addition to the requirements described in the*Board Support Packages* chapter of the RTEMS C
 Applications Userâs Manual for the reset code
+Applications User's Manual for the reset code
 which is executed before the call to ``rtems_initialize_executive``,
 the PowrePC version has the following specific requirements:
 …
   conditions can be properly handled.
 - Must initialize the PowerPCâs initial Exception Table with default
+- Must initialize the PowerPC's initial Exception Table with default
   handlers.

cpu_supplement/sparc.rst

-                      r11e1a6f
+                      rd389819
 **ERC32 Specific Information**
 The European Space Agencyâs ERC32 is a three chip
+The European Space Agency's ERC32 is a three chip
 computing core implementing a SPARC V7 processor and associated
 support circuitry for embedded space applications. The integer
 …
 - MEC Device Specification
 Additionally, the SPARC RISC Userâs Guide from Matra
+Additionally, the SPARC RISC User's Guide from Matra
 MHS documents the functionality of the integer and floating
 point units including the instruction set information.  To
 …
 single constant appropriately.  Conditional compilation is
 utilized to include the appropriate source code for this CPU
 modelâs feature set.  It is important to note that this means
+model's feature set.  It is important to note that this means
 that RTEMS is thus compiled using the appropriate feature set
 and compilation flags optimal for this CPU model used.  The
 …
 The macro CPU_MODEL_NAME is a string which designates
 the name of this CPU model.  For example, for the European Space
 Agencyâs ERC32 SPARC model, this macro is set to the string
+Agency's ERC32 SPARC model, this macro is set to the string
 "erc32".
 …
 Because the set of register windows is finite, it is
 possible to execute enough save instructions without
 corresponding restoreâs to consume all of the register windows.
+corresponding restore's to consume all of the register windows.
 This is easily accomplished in a high level language because
 each subroutine typically performs a save instruction upon
 …
 Similarly, the subroutines will eventually complete
 and begin to perform restoreâs.  If the restore results in the
+and begin to perform restore's.  If the restore results in the
 need for a register window which has previously been written to
 memory as part of an overflow, then a window underflow condition
 …
 effective call and return mechanism.  A subroutine is invoked
 via the call (call) instruction.  This instruction places the
 return address in the callerâs output register 7 (o7).  After
+return address in the caller's output register 7 (o7).  After
 the callee executes a save instruction, this value is available
 in input register 7 (i7) until the corresponding restore
 …
 return address.  There is a delay slot following this
 instruction which is commonly used to execute a restore
 instruction â if a register window was allocated by this
+instruction - if a register window was allocated by this
 subroutine.
 …
 RTEMS assumes that arguments are placed in the
 callerâs output registers with the first argument in output
+caller's output registers with the first argument in output
 register 0 (o0), the second argument in output register 1 (o1),
 and so forth.  Until the callee executes a save instruction, the
 …
 models ranging from pure physical addressing to complex demand
 paged virtual memory systems.  RTEMS supports a flat memory
 model which ranges contiguously over the processorâs allowable
+model which ranges contiguously over the processor's allowable
 address space.  RTEMS does not support segmentation or virtual
 memory of any kind.  The appropriate memory model for RTEMS
 …
 stream.  Although RTEMS hides many of the processor dependent
 details of interrupt processing, it is important to understand
 how the RTEMS interrupt manager is mapped onto the processorâs
 unique architecture. Discussed in this chapter are the SPARCâs
+how the RTEMS interrupt manager is mapped onto the processor's
+unique architecture. Discussed in this chapter are the SPARC's
 interrupt response and control mechanisms as they pertain to
 RTEMS.
 …
 performs the following actions:
 - saves the state of the interrupted task on itâs stack,
+- saves the state of the interrupted task on it's stack,
 - insures that a register window is available for
 …
 RTEMS interrupt handler insures that a register window is
 available for subsequent traps before enabling traps and
 invoking the userâs interrupt handler.
+invoking the user's interrupt handler.
 Interrupt Levels
 …
 since EVERY task stack would have to include enough space to
 account for the worst case interrupt stack requirements in
 addition to itâs own worst case usage.  RTEMS addresses this
+addition to it's own worst case usage.  RTEMS addresses this
 problem on the SPARC by providing a dedicated interrupt stack
 managed by software.
 …
 For more information on developing a BSP, refer to the chapter
 titled Board Support Packages in the RTEMS
 Applications Userâs Guide.
+Applications User's Guide.
 System Reset
 …
 ------------------------
 It is the responsibility of the applicationâs
+It is the responsibility of the application's
 initialization code to initialize the TBR and install trap
 handlers for at least the register window overflow and register
 …
 management.  However, interrupts should be disabled by setting
 the Processor Interrupt Level (pil) field of the psr to 15.
 RTEMS installs itâs own Trap Table as part of initialization
+RTEMS installs it's own Trap Table as part of initialization
 which is initialized with the contents of the Trap Table in
 place when the ``rtems_initialize_executive`` directive was invoked.
 …
   conditions can be properly handled.
 - Must initialize the SPARCâs initial trap table with at
+- Must initialize the SPARC's initial trap table with at
   least trap handlers for register window overflow and register
   window underflow.

cpu_supplement/sparc64.rst

-                      r11e1a6f
+                      rd389819
 The following documents were used in developing the SPARC-64 sun4u port:
 - UltraSPARC  UserÃ¢ÂÂs Manual
+- UltraSPARC  User's Manual
   (http://www.sun.com/microelectronics/manuals/ultrasparc/802-7220-02.pdf)
 …
 Each high-level language compiler generates
 subroutine entry and exit code based upon a set of rules known
 as the compilerâs calling convention.   These rules address the
+as the compiler's calling convention.   These rules address the
 following issues:
 …
 - call and return mechanism
 A compilerâs calling convention is of importance when
+A compiler's calling convention is of importance when
 interfacing to subroutines written in another language either
 assembly or high-level.  Even when the high-level language and
 …
 *``Processor State Register (pstate)``*
     The privileged pstate register contains control fields for the proces-
     sorÃ¢ÂÂs current state. Its flag fields include the interrupt enable, privi-
+    sor's current state. Its flag fields include the interrupt enable, privi-
     leged mode, and enable FPU.
 …
 Because the set of register windows is finite, it is
 possible to execute enough save instructions without
 corresponding restoreâs to consume all of the register windows.
+corresponding restore's to consume all of the register windows.
 This is easily accomplished in a high level language because
 each subroutine typically performs a save instruction upon
 …
 Similarly, the subroutines will eventually complete
 and begin to perform restoreâs.  If the restore results in the
+and begin to perform restore's.  If the restore results in the
 need for a register window which has previously been written to
 memory as part of an overflow, then a window underflow condition
 …
 effective call and return mechanism.  A subroutine is invoked
 via the call (call) instruction.  This instruction places the
 return address in the callerâs output register 7 (o7).  After
+return address in the caller's output register 7 (o7).  After
 the callee executes a save instruction, this value is available
 in input register 7 (i7) until the corresponding restore
 …
 return address.  There is a delay slot following this
 instruction which is commonly used to execute a restore
 instruction â if a register window was allocated by this
+instruction - if a register window was allocated by this
 subroutine.
 …
 restore instructions which manage the set of registers windows.
 This allows for the compiler to generate leaf-optimized functions
 that utilize the callerÃ¢ÂÂs output registers without using save and restore.
+that utilize the caller's output registers without using save and restore.
 Calling Mechanism
 …
 RTEMS assumes that arguments are placed in the
 callerâs output registers with the first argument in output
+caller's output registers with the first argument in output
 register 0 (o0), the second argument in output register 1 (o1),
 and so forth.  Until the callee executes a save instruction, the
 …
 models ranging from pure physical addressing to complex demand
 paged virtual memory systems.  RTEMS supports a flat memory
 model which ranges contiguously over the processorâs allowable
+model which ranges contiguously over the processor's allowable
 address space.  RTEMS does not support segmentation or virtual
 memory of any kind.  The appropriate memory model for RTEMS
 …
 performs the following actions:
 - saves the state of the interrupted task on itâs stack,
+- saves the state of the interrupted task on it's stack,
 - switches the processor to trap level 0,
 …
 since EVERY task stack would have to include enough space to
 account for the worst case interrupt stack requirements in
 addition to itâs own worst case usage.  RTEMS addresses this
+addition to it's own worst case usage.  RTEMS addresses this
 problem on the SPARC by providing a dedicated interrupt stack
 managed by software.
 …
 For more information on developing a BSP, refer to the chapter
 titled Board Support Packages in the RTEMS
 Applications Userâs Guide.
+Applications User's Guide.
 HelenOS and Open Firmware

cpu_supplement/superh.rst

-                      r11e1a6f
+                      rd389819
 Although RTEMS hides many of the processor dependent
 details of interrupt processing, it is important to understand
 how the RTEMS interrupt manager is mapped onto the processorâs
 unique architecture. Discussed in this chapter are the MIPSâs
+how the RTEMS interrupt manager is mapped onto the processor's
+unique architecture. Discussed in this chapter are the MIPS's
 interrupt response and control mechanisms as they pertain to
 RTEMS.

develenv/directory.rst

-                      r11e1a6f
+                      rd389819
 ``${RTEMS_ROOT}/cpukit/``
     This directory is the root for all of the "multilibâable"
+    This directory is the root for all of the "multilib'able"
     portions of RTEMS.  This is a GNU way of saying the
     contents of this directory can be compiled like the
 …
 ``${RTEMS_ROOT}/make/``
     This directory contains files which support the
     RTEMS Makefileâs.  From a userâs perspective, the
+    RTEMS Makefile's.  From a user's perspective, the
     most important parts are found in the ``custom/``
     subdirectory.  Each ".cfg" file in this directory
 …
 ``${RTEMS_ROOT}/c/src/nfsclient/``
     This directory contains a Network File System (NFS) client
     for RTEMS.  With this file system, a userâs application can
+    for RTEMS.  With this file system, a user's application can
     access files on a remote computer.
 …
 ``${RTEMS_ROOT}/doc/ada_user/``
     This directory contains the source code for the *RTEMS
     Applications Ada Userâs Guide* which documents the Ada95
+    Applications Ada User's Guide* which documents the Ada95
     binding to the Classic API.  This manual is produced from
     from the same source base as the *RTEMS Application
     C Userâs Guide*.
+    C User's Guide*.
 ``${RTEMS_ROOT}/doc/bsp_howto/``
 …
 ``${RTEMS_ROOT}/doc/posix_users/``
     This directory contains the source code for the*RTEMS POSIX API Userâs Guide*.  It is important to
     note that RTEMSâ support for POSIX is a combination of
+    This directory contains the source code for the*RTEMS POSIX API User's Guide*.  It is important to
+    note that RTEMS' support for POSIX is a combination of
     functionality provided by RTEMS and the Newlib C Library
     so some functionality is documented by Newlib.
 …
 ``${RTEMS_ROOT}/doc/user/``
     This directory contains the source code for the *RTEMS
     Applications C Userâs Guide* which documents the Classic API.
+    Applications C User's Guide* which documents the Classic API.
 .. COMMENT: COPYRIGHT (c) 1989-2007.

develenv/index.rst

r11e1a6f	rd389819
3	3	===================================
4	4
5		COPYRIGHT Â© 1988 - 2015.
	5	COPYRIGHT (c) 1988 - 2015.
6	6
7	7	On-Line Applications Research Corporation (OAR).

develenv/sample.rst

-                      r11e1a6f
+                      rd389819
     \*** END OF HELLO WORLD TEST \***
 These messages are printed from the applicationâs
+These messages are printed from the application's
 single initialization task.  If the above messages are not
 printed correctly, then either the BSP start up code or the
 …
 The first two messages are printed from the
 applicationâs single initialization task.  The final messages
+application's single initialization task.  The final messages
 are printed from the single application task.
 …
     \*** END OF SAMPLE MULTIPROCESSOR APPLICATION \***
 The herald is printed from the applicationâs single
+The herald is printed from the application's single
 initialization task on each node.  The final messages are
 printed from the single application task on each node.

develenv/utilities.rst

-                      r11e1a6f
+                      rd389819
 The source for packhex first appeared in the May 1993
 issue of Embedded Systems magazine.  The code was downloaded
 from their BBS.  Unfortunately, the authorâs name was not
+from their BBS.  Unfortunately, the author's name was not
 provided in the listing.
 …
 unhex accepts Intel Hexadecimal, Motorola Srecord, or
 TI âBâ records and converts them to their binary equivalent.
+TI 'B' records and converts them to their binary equivalent.
 The output may sent to standout or may be placed in a specified
 file with the -o option.  The designated output file may not be

filesystem/call_development.rst

-                      r11e1a6f
+                      rd389819
 #############################
 This set of routines represents the applicationâs interface to files and directories
+This set of routines represents the application's interface to files and directories
 under the RTEMS filesystem. All routines are compliant with POSIX standards if a
 specific interface has been established. The list below represents the routines that have
 been included as part of the applicationâs interface.
+been included as part of the application's interface.
 # access()
 …
 reallocated.
 The dd_buf structureâs memory is reallocated before the control structure
+The dd_buf structure's memory is reallocated before the control structure
 that contains the pointer to the dd_buf region.
 …
 directory.
 The OPS table evalformake() function for the parentâs filesystem is used
+The OPS table evalformake() function for the parent's filesystem is used
 to locate the node that will be the parent of the new link. It will also
 locate the start of the new pathâs name. This name will be used to define
+locate the start of the new path's name. This name will be used to define
 a child under the parent directory.

filesystem/fileystem_implmentation.rst

-                      r11e1a6f
+                      rd389819
 - On filesystems supporting hard links, a link count is maintained.
   Prior to node removal, the nodeâs link count is decremented by one.  The
+  Prior to node removal, the node's link count is decremented by one.  The
   link count must be less than one to allow for removal of the node.
 …
 # write()
 The filesystemâs type as well as the node type within the filesystem
+The filesystem's type as well as the node type within the filesystem
 determine the nature of the processing that must be performed for each of
 the functions above. The RTEMS filesystem provides a framework that
 …
 The is intended to contain a string that identifies the device that contains
 the filesystem information. The filesystems that are currently implemented
 are memory based and donât require a device specification.
+are memory based and don't require a device specification.
 If the mt_point_node.node_access is NULL then we are mounting the base file
 …
 others.
 The nodeâs name will be a null string.
+The node's name will be a null string.
 A filesystem information structure(fs_info) will be allocated and
 …
 Handler table functions are defined in a ``rtems_filesystem_file_handlers_r``
 structure. It defines functions that are specific to a node type in a given
 filesystem. One table exists for each of the filesystemâs node types. The
+filesystem. One table exists for each of the filesystem's node types. The
 structure definition appears below. It is followed by general developmental
 information on each of the functions associated with regular files contained

filesystem/in-memory.rst

-                      r11e1a6f
+                      rd389819
 *st_uid*
     is the user ID of the fileâs owner
+    is the user ID of the file's owner
 *st_gid*
     is the group ID of the fileâs owner
+    is the group ID of the file's owner
 *st_atime*
 …
 type.
 If it is the nodeâs info element is altered so that the info.directory.mt_fs
+If it is the node's info element is altered so that the info.directory.mt_fs
 element points to the mount table chain entry that is associated with the
 mounted filesystem at this point. The info.directory.mt_fs element can be
 …
 The is intended to contain a string that identifies the device that contains
 the filesystem information. The filesystems that are currently implemented
 are memory based and donât require a device specification.
+are memory based and don't require a device specification.
 If the mt_point_node.node_access is NULL then we are mounting the base file
 …
 others.
 The nodeâs name will be a null string.
+The node's name will be a null string.
 A filesystem information structure(fs_info) will be allocated and
 …
 The mount entry mount point node access is verified to be a mounted
 directory.  Itâs mt_fs is set to NULL.  This identifies to future
+directory.  It's mt_fs is set to NULL.  This identifies to future
 calles into the IMFS that this directory node is no longer a mount
 point.  Additionally, it will allow any directories that were hidden
 …
 Handler table functions are defined in a rtems_filesystem_file_handlers_r
 structure. It defines functions that are specific to a node type in a given
 filesystem. One table exists for each of the filesystemâs node types. The
+filesystem. One table exists for each of the filesystem's node types. The
 structure definition appears below. It is followed by general developmental
 information on each of the functions associated with regular files contained
 …
 Handler table functions are defined in a rtems_filesystem_file_handlers_r
 structure. It defines functions that are specific to a node type in a given
 filesystem. One table exists for each of the filesystemâs node types. The
+filesystem. One table exists for each of the filesystem's node types. The
 structure definition appears below. It is followed by general developmental
 information on each of the functions associated with directories contained in
 …
 Handler table functions are defined in a rtems_filesystem_file_handlers_r
 structure. It defines functions that are specific to a node type in a given
 filesystem. One table exists for each of the filesystemâs node types. The
+filesystem. One table exists for each of the filesystem's node types. The
 structure definition appears below. It is followed by general developmental
 information on each of the functions associated with devices contained in

filesystem/index.rst

r11e1a6f	rd389819
3	3	=============================
4	4
5		COPYRIGHT Â© 1988 - 2015.
	5	COPYRIGHT (c) 1988 - 2015.
6	6
7	7	On-Line Applications Research Corporation (OAR).

filesystem/pathname_eval.rst

-                      r11e1a6f
+                      rd389819
     This element is filesystem specific.  A filesystem can define and store
     any information necessary to identify a node at this location.  This element
     is normally filled in by the filesystemâs evaluate routine. For the
     filesystemâs root node, the filesystemâs initilization routine should
+    is normally filled in by the filesystem's evaluate routine. For the
+    filesystem's root node, the filesystem's initilization routine should
     fill this in, and it should remain valid until the instance of the
     filesystem is unmounted.

filesystem/system_init.rst

-                      r11e1a6f
+                      rd389819
 #####################
 After the RTEMS initialization is performed, the applicationâs
+After the RTEMS initialization is performed, the application's
 initialization will be performed. Part of initialization is a call to
 rtems_filesystem_initialize(). This routine will mount the âIn Memory File
 Systemâ as the base filesystem.  Mounting the base filesystem consists
+rtems_filesystem_initialize(). This routine will mount the 'In Memory File
+System' as the base filesystem.  Mounting the base filesystem consists
 of the following:
 …
 - Allocation of a ``jnode`` structure that will server as the root node
   of the âIn Memory Filesystemâ
+  of the 'In Memory Filesystem'
 - Initialization of the allocated ``jnode`` with the appropriate OPS,
 …
 RTEMS initially mounts a RAM based file system known as the base file system.
 The root directory of this file system tree serves as the logical root of the
 directory hierarchy (Figure 3). Under the root directory a â/devâ directory
+directory hierarchy (Figure 3). Under the root directory a '/dev' directory
 is created under which all I/O device directories and files are registered as
 part of the file system hierarchy.
 …
 ------------------------
 At present, the first file system to be mounted is the âIn Memory File
 Systemâ. It is mounted using a standard MOUNT() command in which the mount
+At present, the first file system to be mounted is the 'In Memory File
+System'. It is mounted using a standard MOUNT() command in which the mount
 point is NULL.  This flags the mount as the first file system to be
 registered under the operating system and appropriate initialization of file
 …
 minor device number. In addition, the configuration information for each
 device contains a text string that represents the fully qualified pathname to
 that deviceâs place in the base file systemâs hierarchy. A file system node
+that device's place in the base file system's hierarchy. A file system node
 is created for the device along the specified registration path.

networking/dec_21140.rst

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

networking/index.rst

r11e1a6f	rd389819
2	2	RTEMS Network Supplement
3	3	========================
4		COPYRIGHT Â© 1988 - 2015.
	4	COPYRIGHT (c) 1988 - 2015.
5	5
6	6	On-Line Applications Research Corporation (OAR).

networking/network_servers.rst

r11e1a6f	rd389819
7	7	The RTEMS FTPD is a complete file transfer protocol (FTP) daemon
8	8	which can store, retrieve, and manipulate files on the local
9		filesystem. In addition, the RTEMS FTPD provides ~~âhooksâ~~
	9	filesystem. In addition, the RTEMS FTPD provides "hooks"
10	10	which are actions performed on received data. Hooks are useful
11	11	in situations where a destination file is not necessarily

networking/network_task_structure.rst

r11e1a6f	rd389819
24	24	aging and removing routing table entries.
25	25
26		The ~~âNetwork codeâ~~ contains routines which may run in the context of
	26	The 'Network code' contains routines which may run in the context of
27	27	the user application tasks, the interface receive task or the network task.
28	28	A network semaphore ensures that

networking/networking_driver.rst

-                      r11e1a6f
+                      rd389819
 This chapter is intended to provide an introduction to the
 procedure for writing RTEMS network device drivers.
 The example code is taken from the âGeneric 68360â network device
+The example code is taken from the 'Generic 68360' network device
 driver.  The source code for this driver is located in the``c/src/lib/libbsp/m68k/gen68360/network`` directory in the RTEMS
 source code distribution.  Having a copy of this driver at
 …
 Before starting to write the network driver become completely
 familiar with the programmerâs view of the device.
+familiar with the programmer's view of the device.
 The following points list some of the details of the
 device that must be understood before a driver can be written.
 …
 execute only when they hold the network semaphore (``rtems_bsdnet_semaphore``).
 The transmit and receive tasks must abide by this protocol.  Be very
 careful to avoid âdeadly embracesâ with the other network tasks.
+careful to avoid 'deadly embraces' with the other network tasks.
 A number of routines are provided to make it easier for the network
 driver code to conform to the network task scheduling conventions.
 …
 ``ifp->if_unit``
     The device number.  The network stack uses this number and the
     device name for device name lookups.  For example, if``ifp->if_name`` is â``scc``â and ``ifp->if_unit`` is â``1``â,
     the full device name would be â``scc1``â.  The unit number should be
     obtained from the ânameâ entry in the configuration structure.
+    device name for device name lookups.  For example, if``ifp->if_name`` is '``scc``' and ``ifp->if_unit`` is '``1``',
+    the full device name would be '``scc1``'.  The unit number should be
+    obtained from the 'name' entry in the configuration structure.
 ``ifp->if_mtu``
 …
 calling ``if_attach``.  Ethernet devices should then
 call ``ether_ifattach``.  Both functions take a pointer to the
 deviceâs ``ifnet`` structure as their only argument.
+device's ``ifnet`` structure as their only argument.
 The attach function should return a non-zero value to indicate that
 …
 This function is called each time the network stack wants to start the
 transmitter.  This occures whenever the network stack adds a packet
 to a deviceâs send queue and the ``IFF_OACTIVE`` bit in the
 deviceâs ``if_flags`` is not set.
+to a device's send queue and the ``IFF_OACTIVE`` bit in the
+device's ``if_flags`` is not set.
 For 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
12	12	to understand Ethernet:
13	13
14		- Charles Spurgeon~~â~~s Ethernet Web Site
	14	- Charles Spurgeon's Ethernet Web Site
15	15	"This site provides extensive information about Ethernet
16	16	(IEEE 802.3) local area network (LAN) technology. Including

networking/testing_the_driver.rst

-                      r11e1a6f
+                      rd389819
 - An Ethernet network analyzer or a workstation with an
   âEthernet snoopâ program such as ``ethersnoop`` or``tcpdump``.
+  'Ethernet snoop' program such as ``ethersnoop`` or``tcpdump``.
 - A workstation.
 …
 - mbuf activity
   There are commented out calls to ``printf`` in the file``sys/mbuf.h`` in the network stack code.  Uncommenting
   these lines results in output when mbufâs are allocated
+  these lines results in output when mbuf's are allocated
   and freed.  This is very useful for finding memory leaks.
 …
   For a quick reference to the flags, see the table below:
   â``U``â
+  '``U``'
       Up: The route is active.
   â``H``â
+  '``H``'
       Host: The route destination is a single host.
   â``G``â
+  '``G``'
       Gateway: Send anything for this destination on to this remote system, which
       will figure out from there where to send it.
   â``S``â
+  '``S``'
       Static: This route was configured manually, not automatically generated by the
       system.
   â``C``â
+  '``C``'
       Clone: Generates a new route based upon this route for machines we connect
       to. This type of route is normally used for local networks.
   â``W``â
+  '``W``'
       WasCloned: Indicated a route that was auto-configured based upon a local area
       network (Clone) route.
   â``L``â
+  '``L``'
       Link: Route involves references to Ethernet hardware.
 …
   Verify that the program continues to run once the driver has been attached.
 - Issue a â``u``â command to send UDP
   packets to the âdiscardâ port.
+- Issue a '``u``' command to send UDP
+  packets to the 'discard' port.
   Verify that the packets appear on the network.
 - Issue a â``s``â command to print the network and driver statistics.
+- Issue a '``s``' command to print the network and driver statistics.
 - On a workstation, add a static route to the target system.
 - On that same workstation try to âpingâ the target system.
+- On that same workstation try to 'ping' the target system.
   Verify that the ICMP echo request and reply packets appear on the net.
 …
   Modify ``networkconfig.h`` to attach the driver
   with reception of broadcast packets enabled.
   Try to âpingâ the target system again.
+  Try to 'ping' the target system again.
   Verify that ARP request/reply and ICMP echo request/reply packets appear
   on the net.
 - Issue a â``t``â command to send TCP
   packets to the âdiscardâ port.
+- Issue a '``t``' command to send TCP
+  packets to the 'discard' port.
   Verify that the packets appear on the network.
 - Issue a â``s``â command to print the network and driver statistics.
+- Issue a '``s``' command to print the network and driver statistics.
 - Verify that you can telnet to ports 24742
 …
   a smaller value, say 514.
 - âPingâ the driver from another workstation and verify
+- 'Ping' the driver from another workstation and verify
   that frames larger than 514 bytes are correctly rejected.
 …
   still telnet to both the ports.
 - Display the driver statistics (Console â``s``â command or telnet
   âcontrol-Gâ character) and verify that:
+- Display the driver statistics (Console '``s``' command or telnet
+  'control-G' character) and verify that:
   # The number of transmit interrupts is non-zero.
 …
 - Run the ``netdemo`` program.
 - Issue a â``u``â console command to make the target machine transmit
+- Issue a '``u``' console command to make the target machine transmit
   a bunch of UDP packets.
 …
 Run the ``ttcp`` network benchmark program.
 Transfer large amounts of data (100âs of megabytes) to and from the target
+Transfer large amounts of data (100's of megabytes) to and from the target
 system.

networking/using_networking_rtems_app.rst

-                      r11e1a6f
+                      rd389819
     standard files created with the information return by the BOOTP/DHCP
     protocol. The IP address is added to :file:`/etc/hosts` with the host
     name and domain returned. If no host name or domain is returned``me.mydomain`` is used. The BOOTP/DHCP serverâs address is also
+    name and domain returned. If no host name or domain is returned``me.mydomain`` is used. The BOOTP/DHCP server's address is also
     added to :file:`/etc/hosts`. The domain name server listed in the
     BOOTP/DHCP information are added to :file:`/etc/resolv.conf`. A``search`` record is also added if a domain is returned. The files
 …
 ``char \*gateway``
     The Internet host number of the network gateway machine,
     specified in âdotted decimalâ (``129.128.4.1``) form.
+    specified in 'dotted decimal' (``129.128.4.1``) form.
 ``char \*log_host``
 …
 ``char \*ip_address``
     The Internet address of the device,
     specified in âdotted decimalâ (``129.128.4.2``) form, or ``NULL``
+    specified in 'dotted decimal' (``129.128.4.2``) form, or ``NULL``
     if the device configuration information is being obtained from a
     BOOTP/DHCP server.
 …
 ``char \*ip_netmask``
     The Internet inetwork mask of the device,
     specified in âdotted decimalâ (``255.255.255.0``) form, or ``NULL``
+    specified in 'dotted decimal' (``255.255.255.0``) form, or ``NULL``
     if the device configuration information is being obtained from a
     BOOTP/DHCP server.
 …
 For sending, when the socket is connected and the free space becomes at
 or above the "low water mark" for the send buffer (default 4096 bytes)
 you will receive a writable callback. You donât get continuous callbacks
 if you donât write anything. Using a non-blocking write socket, you can
+you will receive a writable callback. You don't get continuous callbacks
+if you don't write anything. Using a non-blocking write socket, you can
 then call write until it returns a value less than the amount of data
 requested to be sent or it produces error EWOULDBLOCK (indicating buffer
 …
 If the interval argument is greater than 0, the routine also starts an
 RTEMS task at the specified priority and polls the NTP server every
 âintervalâ seconds.  NOTE: This mode of operation has not yet been
+'interval' seconds.  NOTE: This mode of operation has not yet been
 implemented.
 …
 returns 0.  If an error occurs a message is printed and the routine returns -1
 with an error code in errno.
 There is no timeout â if there is no response from an NTP server the
+There is no timeout - if there is no response from an NTP server the
 routine will wait forever.

porting/code_tuning.rst

r11e1a6f	rd389819
88	88	----------------------
89	89
90		The CPU_ALIGNMENT macro should be set to the CPU~~â~~s worst alignment
	90	The CPU_ALIGNMENT macro should be set to the CPU's worst alignment
91	91	requirement for data types on a byte boundary. This is typically the
92	92	alignment requirement for a C double. This alignment does not take into

porting/cpu_init.rst

r11e1a6f	rd389819
39	39	context. If there is not an easy way to initialize the FP context during
40	40	Context_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
	41	FP context here and copy it to the task's during Context_Initialize. If
42	42	this technique is used to initialize the FP contexts, then it is important
43	43	to ensure that the state of the floating point unit is in a coherent,

porting/cpu_model_variations.rst

-                      r11e1a6f
+                      rd389819
 Each of these boards is optimized for a particular project.  The processor
 and peripheral set have been chosen to meet a particular set of system
 requirements.  The tools in the embedded systems developersÂ toolbox must
 support their projectÂs unique board.  RTEMS addresses this issue via the
+requirements.  The tools in the embedded systems developers toolbox must
+support their project's unique board.  RTEMS addresses this issue via the
 Board Support Package.

porting/idle_thread.rst

r11e1a6f	rd389819
87	87
88	88	If 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
	89	a "halt", "idle", or "shutdown" instruction, then don't forget to put it
90	90	in an infinite loop as the CPU will have to reexecute this instruction
91	91	each time the IDLE thread is dispatched.

porting/index.rst

r11e1a6f	rd389819
2	2	RTEMS Porting Guide
3	3	===================
4		COPYRIGHT Â© 1988 - 2015.
	4	COPYRIGHT (c) 1988 - 2015.
5	5
6	6	On-Line Applications Research Corporation (OAR).

porting/interrupts.rst

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

porting/miscellanous.rst

-                      r11e1a6f
+                      rd389819
 The ``_CPU_Fatal_halt`` routine is the default fatal error handler. This
 routine copies _error into a known place â typically a stack location or
+routine copies _error into a known place - typically a stack location or
 a register, optionally disables interrupts, and halts/stops the CPU.  It
 is prototyped as follows and is often implemented as a macro:
 …
 would probably have to be disabled to insure that an interrupt does not
 try to access the same "chunk" with the wrong endian.  Another good reason
 is that on some CPUs, the endian bit endianness for ALL fetches â both
 code and data â so the code will be fetched incorrectly.
+is that on some CPUs, the endian bit endianness for ALL fetches - both
+code and data - so the code will be fetched incorrectly.
 The following is an implementation of the ``CPU_swap_u32`` routine that will
 …
 would probably have to be disabled to insure that an interrupt does not
 try to access the same "chunk" with the wrong endian.  Another good reason
 is that on some CPUs, the endian bit endianness for ALL fetches â both
 code and data â so the code will be fetched incorrectly.
+is that on some CPUs, the endian bit endianness for ALL fetches - both
+code and data - so the code will be fetched incorrectly.
 Similarly, here is a portable implementation of the ``CPU_swap_u16``

porting/priority_bitmap.rst

-                      r11e1a6f
+                      rd389819
 manner in which a priority is broken into a major and minor components
 with the major being the 4 MSB of a priority and minor the 4 LSB.  Thus (0
 << 4) + 0 corresponds to priority 0 â the highest priority.  And (15 <<
 ) + 14 corresponds to priority 254 â the next to the lowest priority.
+<< 4) + 0 corresponds to priority 0 - the highest priority.  And (15 <<
+) + 14 corresponds to priority 254 - the next to the lowest priority.
 If your CPU does not have a "find first bit" instruction, then there are
 …
 - a series of 16 bit test instructions
 - a "binary search using ifâs"
+- a "binary search using if's"
 - 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
 registers assumed to be preserved across subroutine calls
 must be preserved.  These registers may be saved in
 the taskâs context area or on its stack.  However, the
+the task's context area or on its stack.  However, the
 stack pointer and address to resume executing the task
 at must be included in the context (normally the subroutine
 return address to the caller of ``_Thread_Dispatch``.
 The decision of where to store the taskâs context is based
+The decision of where to store the task's context is based
 on numerous factors including the capabilities of
 the CPU architecture itself and simplicity as well
 as external considerations such as debuggers wishing
 to examine a taskâs context.  In this case, it is
+to examine a task's context.  In this case, it is
 often simpler to save all data in the context area.
 …
 indicates whether or not this CPU model has FP support.  For example, the
 definition of the i386ex and i386sx CPU models would set I386_HAS_FPU to
 FALSE to indicate that these CPU models are i386âs without an i387 and
+FALSE to indicate that these CPU models are i386's without an i387 and
 wish to leave floating point support out of RTEMS when built for the
 i386_nofp processor model.  On a CPU with a built-in FPU like the i486,
 …
 format is not critical for the implementation of the floating point
 context switch routines.  In this case, there is no need to figure out the
 exact format â only the size.  Of course, although this is enough
+exact format - only the size.  Of course, although this is enough
 information for RTEMS, it is probably not enough for a debugger such as
 gdb.  But that is another problem.
 …
 The CPU_CONTEXT_FP_SIZE macro is set to the size of the floating point
 context area. On some CPUs this will not be a "sizeof" because the format
 of the floating point area is not defined â only the size is.  This is
+of the floating point area is not defined - only the size is.  This is
 usually on CPUs with a "floating point save context" instruction.  In
 general, though it is easier to define the structure as a "sizeof"

posix1003_1/files_and_directories.rst

r11e1a6f	rd389819
244	244	NOTE: The newlib unistd.h and sys/unistd.h are installed and the
245	245	include search patch is used to get the right one. There are
246		conflicts between the newlib unistd.h and RTEMS~~â~~ version.
	246	conflicts between the newlib unistd.h and RTEMS' version.
247	247
248	248	.. COMMENT: COPYRIGHT (c) 1988-2002.

posix1003_1/index.rst

r11e1a6f	rd389819
3	3	===================================
4	4
5		COPYRIGHT Â© 1988 - 2015.
	5	COPYRIGHT (c) 1988 - 2015.
6	6
7	7	On-Line Applications Research Corporation (OAR).

posix1003_1/language_specific_services.rst

-                      r11e1a6f
+                      rd389819
 ==============================
 ANSI C Section 4.2 â Diagnostics
+ANSI C Section 4.2 - Diagnostics
 .. code:: c
     assert(), Function, Implemented
 ANSI C Section 4.3 â Character Handling
+ANSI C Section 4.3 - Character Handling
 .. code:: c
 …
     toupper(), Function, Implemented
 ANSI C Section 4.4 â Localization
+ANSI C Section 4.4 - Localization
 .. code:: c
     setlocale(), Function, Implemented
 ANSI C Section 4.5 â Mathematics
+ANSI C Section 4.5 - Mathematics
 .. code:: c
 …
     fmod(), Function, Implemented
 ANSI C Section 4.6 â Non-Local Jumps
+ANSI C Section 4.6 - Non-Local Jumps
 .. code:: c
 …
     longjmp(), Function, Implemented
 ANSI C Section 4.9 â Input/Output
+ANSI C Section 4.9 - Input/Output
 .. code:: c
 …
 NOTE: ``rename`` is also included in another section.  `Rename a File`_.
 ANSI C Section 4.10 â General Utilities
+ANSI C Section 4.10 - General Utilities
 .. code:: c
 …
 NOTE: ``getenv`` is also included in another section. `Environment Access`_.
 ANSI C Section 4.11 â String Handling
+ANSI C Section 4.11 - String Handling
 .. code:: c
 …
     strlen(), Function, Implemented
 ANSI C Section 4.12 â Date and Time Handling
+ANSI C Section 4.12 - Date and Time Handling
 .. code:: c

posix1003_1/posix1003_1.rst

-                      r11e1a6f
+                      rd389819
 .. COMMENT: can force the copyright description onto a left hand page.
 COPYRIGHT Â© 1988 - 2015.
+COPYRIGHT (c) 1988 - 2015.
 On-Line Applications Research Corporation (OAR).
 …
     USHRT_MAX, Constant, Implemented
 NOTE: These are implemented in GCCâs limits.h file.
+NOTE: These are implemented in GCC's limits.h file.
 Minimum Values
 …
 NOTE: The newlib unistd.h and sys/unistd.h are installed and the
 include search patch is used to get the right one.  There are
 conflicts between the newlib unistd.h and RTEMSâ version.
+conflicts between the newlib unistd.h and RTEMS' version.
 .. COMMENT: COPYRIGHT (c) 1988-2002.
 …
 ==============================
 ANSI C Section 4.2 â Diagnostics
+ANSI C Section 4.2 - Diagnostics
 .. code:: c
     assert(), Function, Implemented
 ANSI C Section 4.3 â Character Handling
+ANSI C Section 4.3 - Character Handling
 .. code:: c
 …
     toupper(), Function, Implemented
 ANSI C Section 4.4 â Localization
+ANSI C Section 4.4 - Localization
 .. code:: c
     setlocale(), Function, Implemented
 ANSI C Section 4.5 â Mathematics
+ANSI C Section 4.5 - Mathematics
 .. code:: c
 …
     fmod(), Function, Implemented
 ANSI C Section 4.6 â Non-Local Jumps
+ANSI C Section 4.6 - Non-Local Jumps
 .. code:: c
 …
     longjmp(), Function, Implemented
 ANSI C Section 4.9 â Input/Output
+ANSI C Section 4.9 - Input/Output
 .. code:: c
 …
 NOTE: ``rename`` is also included in another section.  `Rename a File`_.
 ANSI C Section 4.10 â General Utilities
+ANSI C Section 4.10 - General Utilities
 .. code:: c
 …
 NOTE: ``getenv`` is also included in another section. `Environment Access`_.
 ANSI C Section 4.11 â String Handling
+ANSI C Section 4.11 - String Handling
 .. code:: c
 …
     strlen(), Function, Implemented
 ANSI C Section 4.12 â Date and Time Handling
+ANSI C Section 4.12 - Date and Time Handling
 .. code:: c

posix1003_1/terminology.rst

r11e1a6f	rd389819
132	132	USHRT_MAX, Constant, Implemented
133	133
134		NOTE: These are implemented in GCC~~â~~s limits.h file.
	134	NOTE: These are implemented in GCC's limits.h file.
135	135
136	136	Minimum Values

posix_users/clock.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the clock managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the clock manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/condition_variable.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the condition variable managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the condition variable manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/device_and_class_specific.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the device- and class- specific functions managerâs
 directives. A subsection is dedicated to each of this managerâs directives
+This section details the device- and class- specific functions manager's
+directives. A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/files_and_directory.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the files and directories managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the files and directories manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 *ENAMETOOLONG*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 *ENAMETOOLONG*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 **DESCRIPTION:**
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 *EEXIST*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *EEXIST*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *EEXIST*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *ENAMETOOLONG*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *EEXIST*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *EEXIST*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *EBUSY*
 …
 *EACCES*
     Write access to the directory containing ``pathname`` was not
     allowed for the processâs effective uid, or one of the directories in``pathname`` did not allow search (execute) permission.
+    allowed for the process's effective uid, or one of the directories in``pathname`` did not allow search (execute) permission.
 *EPERM*
     The directory containing ``pathname`` has the stickybit (S_ISVTX)
     set and the processâs effective uid is neither the uid of the file to
+    set and the process's effective uid is neither the uid of the file to
     be delected nor that of the director containing it.
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 *EBUSY*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 *EBADF*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *ENAMETOOLONG*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix.
+    Search permission is denied for a directory in a file's path prefix.
 *EBADF*
 …
 *EFAULT*
     Argument points outside the calling processâs address space.
+    Argument points outside the calling process's address space.
 *EINVAL*
 …
 *EACCES*
     Search permission is denied for a directory in a fileâs path prefix
+    Search permission is denied for a directory in a file's path prefix
 *EINVAL*
 …
 *EFAULT*
     ``Path`` points outside the processâs allocated address space.
+    ``Path`` points outside the process's allocated address space.
 *EBADF*
 …
 *EFAULT*
     ``Path`` points outside the processâs allocated address space.
+    ``Path`` points outside the process's allocated address space.
 *EBADF*
 …
 below and the permissions for the new node.
 The permissions are modified by the processâs ``umask`` in the usual way: the
+The permissions are modified by the process's ``umask`` in the usual way: the
 permissions of the created node are ``(mode & ~umask)``.

posix_users/index.rst

-                      r11e1a6f
+                      rd389819
 ============================
 RTEMS POSIX API Userâs Guide
+RTEMS POSIX API User's Guide
 ============================
 COPYRIGHT Â© 1988 - 2015.
+COPYRIGHT (c) 1988 - 2015.
 On-Line Applications Research Corporation (OAR).

posix_users/input_and_output.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the input and output primitives managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the input and output primitives manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 *EACCESS*
     Search permission is denied for a direcotry in a fileâs path
+    Search permission is denied for a direcotry in a file's path
     prefix.
 …
 *F_GETFL*
     Read the descriptorâs flags (all flags (as set by open()) are returned).
+    Read the descriptor's flags (all flags (as set by open()) are returned).
 *F_SETFL*
     Set the descriptorâs flags to the value specified by ``arg``. Only``O_APPEND`` and ``O_NONBLOCK`` may be set.
+    Set the descriptor's flags to the value specified by ``arg``. Only``O_APPEND`` and ``O_NONBLOCK`` may be set.
     The flags are shared between copies (made with ``dup()`` etc.) of the same
     file descriptor.

posix_users/key.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the key managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the key manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/language_specific_services.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the language-specific services for the C programming language managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the language-specific services for the C programming language manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/memory_managment.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the memory management managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the memory management manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/message_passing.rst

-                      r11e1a6f
+                      rd389819
 Every message queue has the ability to notify one (and only one) process
 whenever the queueâs state changes from empty (0 messages) to nonempty.
+whenever the queue's state changes from empty (0 messages) to nonempty.
 This means that the process does not have to block or constantly poll
 while it waits for a message. By calling mq_notify, you can attach a
 …
 priority message(s) from the message queue specified by mqdes. The
 messages are received in FIFO order within the priorities. The received
 messageâs priority is stored in the location referenced by the msg_prio.
+message's priority is stored in the location referenced by the msg_prio.
 If the msg_prio is a NULL, the priority is discarded. The message is
 removed and stored in an area pointed to by msg_ptr whose length is of
 …
 The mq_notify() function registers the calling process to be notified of
 message arrival at an empty message queue. Every message queue has the
 ability to notify one (and only one) process whenever the queueâs state
+ability to notify one (and only one) process whenever the queue's state
 changes from empty (0 messages) to nonempty. This means that the process
 does not have to block or constantly poll while it waits for a message.
 …
 ==========
 This section details the message passing managerâs directives. A
 subsection is dedicated to each of this managerâs directives and describes
+This section details the message passing manager's directives. A
+subsection is dedicated to each of this manager's directives and describes
 the calling sequence, related constants, usage, and status codes.
 …
 mq_open creates it. Message queues can have multiple senders and
 receivers. If mq_open is successful, the function returns a message queue
 descriptor. Otherwise, the function returns a -1 and sets âerrnoâ to
+descriptor. Otherwise, the function returns a -1 and sets 'errno' to
 indicate the error.
 …
 priority message(s) from the message queue specified by mqdes. The
 messages are received in FIFO order within the priorities. The received
 messageâs priority is stored in the location referenced by the msg_prio.
+message's priority is stored in the location referenced by the msg_prio.
 If the msg_prio is a NULL, the priority is discarded. The message is
 removed and stored in an area pointed to by msg_ptr whose length is of
 …
 Every message queue has the ability to notify one (and only one) process
 whenever the queueâs state changes from empty (0 messages) to nonempty.
+whenever the queue's state changes from empty (0 messages) to nonempty.
 This means that the process does not have to block or constantly poll
 while it waits for a message. By calling mq_notify, a notification

posix_users/mutex.rst

-                      r11e1a6f
+                      rd389819
 ========
 This section details the mutex managerâs services.
 A subsection is dedicated to each of this managerâs services
+This section details the mutex manager's services.
+A subsection is dedicated to each of this manager's services
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/preface.rst

-                      r11e1a6f
+                      rd389819
 #######
 This is the Userâs Guide for the POSIX API support
+This is the User's Guide for the POSIX API support
 provided in RTEMS.
 …
     Portions of this text are reprinted and reproduced in electronic
     form from IEEE Std 1003.1, 2004 Edition, Standard for Information
     Technology Ã¢ÂÂ Operating System Interface (POSIX), The Open
     Group Base Specifications Issue 6, Copyright ÃÂ© 2001-2004 by the
+    Technology Operating System Interface (POSIX), The Open
+    Group Base Specifications Issue 6, Copyright (c) 2001-2004 by the
     Institute of Electrical and Electronics Engineers, Inc and The
     Open Group. In the event of any discrepancy between this version

posix_users/process_creation_and_execution.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the process creation and execution managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the process creation and execution manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/process_environment.rst

-                      r11e1a6f
+                      rd389819
 programs.  In a full POSIX environment with command line shell
 and multiple processes,  environment variables may be set in
 one process â such as the shell â and inherited by child
+one process - such as the shell - and inherited by child
 processes.  In RTEMS, there is only one process and thus
 only one set of environment variables across all processes.
 …
 ==========
 This section details the process environment managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the process environment manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/scheduler.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the scheduler managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the scheduler manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/semaphore.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the semaphore managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the semaphore manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/services_provided_by_c.rst

r11e1a6f	rd389819
166	166	- ``puts`` - Write a character string on standard output
167	167
168		- ``remove`` - Delete a file~~â~~s name
	168	- ``remove`` - Delete a file's name
169	169
170	170	- ``rename`` - Rename a file

posix_users/signal.rst

-                      r11e1a6f
+                      rd389819
 individual signals and handlers associated with it.   Services
 are provided to construct signal sets for the purposes of building
 signal sets â type ``sigset_t`` â that are used to
+signal sets - type ``sigset_t`` - that are used to
 provide arguments to the services that mask, unmask, and
 check on pending signals.
 …
 ==========
 This section details the signal managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the signal manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/system_database.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the system databases managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the system databases manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/thread.rst

-                      r11e1a6f
+                      rd389819
     If this value is NULL, then RTEMS allocates the memory for the thread stack
     from the RTEMS Workspace Area. Otherwise, this is the user specified
     address for the memory to be used for the threadâs stack. Each thread must
+    address for the memory to be used for the thread's stack. Each thread must
     have a distinct stack area. Each processor family has different alignment
     rules which should be followed.
 *stack size*
     is the minimum desired size for this threadâs stack area.
+    is the minimum desired size for this thread's stack area.
     If the size of this area as specified by the stack size attribute
     is smaller than the minimum for this processor family and the stack
 …
 ========
 This section details the thread managerâs services.
 A subsection is dedicated to each of this managerâs services
+This section details the thread manager's services.
+A subsection is dedicated to each of this manager's services
 and describes the calling sequence, related constants, usage,
 and status codes.
 …
 *EINVAL*
     The user specified a stack address and the size of the area was not
     large enough to meet this processorâs minimum stack requirements.
+    large enough to meet this processor's minimum stack requirements.
 *EINVAL*

posix_users/thread_cancellation.rst

-                      r11e1a6f
+                      rd389819
 ==========
 This section details the thread cancellation managerâs directives.
 A subsection is dedicated to each of this managerâs directives
+This section details the thread cancellation manager's directives.
+A subsection is dedicated to each of this manager's directives
 and describes the calling sequence, related constants, usage,
 and status codes.

posix_users/timer.rst

-                      r11e1a6f
+                      rd389819
 ============
 This section details the timer managerâs services.
 A subsection is dedicated to each of this managerâs services
+This section details the timer manager's services.
+A subsection is dedicated to each of this manager's services
 and describes the calling sequence, related constants, usage,
 and status codes.

shell/file_and_directory.rst

-                      r11e1a6f
+                      rd389819
     Causes cp to write a prompt to the standard error output before copying a file
     that would overwrite an existing file. If the response from the standard input
     begins with the character âyâ, the file copy is attempted.
+    begins with the character 'y', the file copy is attempted.
 *-L*
 …
     and the exit value is not altered.
     If the source file has its set user ID bit on and the user ID cannot be
     preserved, the set user ID bit is not preserved in the copyâs permissions. If
+    preserved, the set user ID bit is not preserved in the copy's permissions. If
     the source file has its set group ID bit on and the group ID cannot be
     preserved, the set group ID bit is not preserved in the copyâs permissions. If
+    preserved, the set group ID bit is not preserved in the copy's permissions. If
     the source file has both its set user ID and set group ID bits on, and either
     the user ID or group ID cannot be preserved, neither the set user ID or set
     group ID bits are preserved in the copyâs permissions.
+    group ID bits are preserved in the copy's permissions.
 *-R*
 …
     copied, rather than indirected through, and for cp to create special files
     rather than copying them as normal files. Created directories have the same
     mode as the corresponding source directory, unmodified by the processâs umask.
+    mode as the corresponding source directory, unmodified by the process's umask.
 *-v*
 …
 as described above. The -H and -L options are ignored unless the -R option is

Context Navigation

Changeset d389819 in rtems-docs

Legend: