Changeset cf301c9 in rtems


Ignore:
Timestamp:
Jan 7, 2013, 2:53:43 PM (7 years ago)
Author:
Alex Ivanov <alexivanov97@…>
Branches:
4.11, master
Children:
40340b2
Parents:
34d12977
git-author:
Alex Ivanov <alexivanov97@…> (01/07/13 14:53:43)
git-committer:
Jennifer Averett <jennifer.averett@…> (01/07/13 14:53:43)
Message:

posix: Doxygen Clean Up Task #1

Location:
cpukit/posix/include
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • cpukit/posix/include/aio.h

    r34d12977 rcf301c9  
    3232 *
    3333 * @brief POSIX Asynchronous Input and Output
     34 *
     35 * @{
    3436 */
    3537
     
    138140
    139141/**
    140  *  @brief Cancel Asynchronous I/O Operation
     142 * @brief Cancel asynchronous I/O operation.
    141143 *
    142  *  6.7.7 Cancel Asynchronous I/O Operation, P1003.1b-1993, p. 163
     144 * 6.7.7 Cancel Asynchronous I/O Operation, P1003.1b-1993, p. 163
    143145 *
    144  *  @param[in] filedes is the file descriptor
    145  *  @param[in] aiocbp is the asynchronous I/O control block
     146 * @param[in] filedes is the file descriptor
     147 * @param[in] aiocbp is a pointer to the asynchronous I/O control block
    146148 *
    147  *  @return This method returns AIO_CANCELED if the requested operation(s)
    148  *          were canceled. Otherwise, AIO_NOTCANCELED is returned indicating
    149  *          that at least one of the requested operation(s) cannot be canceled
     149 * @retval AIO_CANCELED The requested operation(s) were canceled.
     150 * @retval AIO_NOTCANCELED Some of the requested operation(s) cannot be
     151 * canceled since they are in progress.
     152 * @retval AIO_ALLDONE None of the requested operation(s) could be canceled
     153 * since they are already complete
    150154 */
    151155int aio_cancel(
     
    179183#endif /* _POSIX_ASYNCHRONOUS_IO */
    180184
     185/** @} */
     186
    181187#ifdef __cplusplus
    182188}
  • cpukit/posix/include/mqueue.h

    r34d12977 rcf301c9  
    4242
    4343/**
    44  *  @defgroup POSIX_MQUEUE Message Queues
    45  *
    46  *  @ingroup POSIX
    47  */
    48 /**@{*/
     44 * @defgroup POSIX_MQUEUE POSIX Message Queues
     45 *
     46 * @ingroup POSIX
     47 *
     48 * @{
     49 */
    4950
    5051#ifdef __cplusplus
     
    5758
    5859/**
    59  *  Message queue id type.
    60  *
    61  *  @note Use uint32_t since all POSIX Ids are 32-bit currently.
     60 * Message queue id type.
     61 *
     62 * NOTE: Use uint32_t since all POSIX Ids are 32-bit currently.
    6263 */
    6364typedef uint32_t  mqd_t;
    6465
    6566/**
    66  *  This is the message queue attributes structure.
     67 * This is the message queue attributes structure.
    6768 */
    6869struct mq_attr {
     
    7879
    7980/**
    80  *  15.2.2 Open a Message Queue, P1003.1b-1993, p. 272
     81 * 15.2.2 Open a Message Queue, P1003.1b-1993, p. 272
    8182 */
    8283mqd_t mq_open(
     
    8788
    8889/**
    89  *  15.2.2 Close a Message Queue, P1003.1b-1993, p. 275
     90 * 15.2.2 Close a Message Queue, P1003.1b-1993, p. 275
    9091 */
    9192int mq_close(
     
    9495
    9596/**
    96  *  @brief Remove a Message Queue
    97  *
    98  *  15.2.2 Remove a Message Queue, P1003.1b-1993, p. 276
    99  *
    100  *  NOTE:  The structure of the routines is identical to that of POSIX
    101  *         Message_queues to leave the option of having unnamed message
    102  *         queues at a future date.  They are currently not part of the
    103  *         POSIX standard but unnamed message_queues are.  This is also
    104  *         the reason for the apparently unnecessary tracking of
    105  *         the process_shared attribute.  [In addition to the fact that
    106  *         it would be trivial to add pshared to the mq_attr structure
    107  *         and have process private message queues.]
    108  *
    109  *         This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
    110  *         time.
     97 * @brief Remove a message queue.
     98 *
     99 * 15.2.2 Remove a Message Queue, P1003.1b-1993, p. 276
     100 *
     101 * NOTE:  The structure of the routines is identical to that of POSIX
     102 *        Message_queues to leave the option of having unnamed message
     103 *        queues at a future date.  They are currently not part of the
     104 *        POSIX standard but unnamed message_queues are.  This is also
     105 *        the reason for the apparently unnecessary tracking of
     106 *        the process_shared attribute.  [In addition to the fact that
     107 *        it would be trivial to add pshared to the mq_attr structure
     108 *        and have process private message queues.]
     109 *
     110 *        This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
     111 *        time.
    111112 */
    112113int mq_unlink(
     
    115116
    116117/**
    117  *  15.2.4 Send a Message to a Message Queue, P1003.1b-1993, p. 277
    118  *
    119  *  @note P1003.4b/D8, p. 45 adds mq_timedsend().
     118 * 15.2.4 Send a Message to a Message Queue, P1003.1b-1993, p. 277
     119 *
     120 * NOTE; P1003.4b/D8, p. 45 adds mq_timedsend().
    120121 */
    121122int mq_send(
     
    131132
    132133/**
    133  *  @brief Send a Message to a Message Queue
    134  *
    135  *  15.2.4 Send a Message to a Message Queue, P1003.1b-1993, p. 277
    136  *
    137  *  @note P1003.4b/D8, p. 45 adds mq_timedsend().
     134 * @brief Send a message to a message queue.
     135 *
     136 * @see mq_send()
    138137 */
    139138int mq_timedsend(
     
    148147
    149148/**
    150  *  @brief Receive a Message From a Message Queue
    151  *
    152  *  15.2.5 Receive a Message From a Message Queue, P1003.1b-1993, p. 279
    153  *
    154  *  @note P1003.4b/D8, p. 45 adds mq_timedreceive().
     149 * @brief Receive a message from a message queue.
     150 *
     151 * 15.2.5 Receive a Message From a Message Queue, P1003.1b-1993, p. 279
     152 *
     153 * NOTE: P1003.4b/D8, p. 45 adds mq_timedreceive().
    155154 */
    156155ssize_t mq_receive(
     
    176175
    177176/**
    178  * @brief Notify Process that a Message is Available on a Queue
     177 * @brief Notify process that a message is available on a queue.
    179178 *
    180179 * 15.2.6 Notify Process that a Message is Available on a Queue,
     
    189188
    190189/**
    191  * @brief Set Message Queue Attributes
     190 * @brief Set message queue attributes.
    192191 *
    193192 * 15.2.7 Set Message Queue Attributes, P1003.1b-1993, p. 281
     
    208207);
    209208
     209/** @} */
     210
    210211#ifdef __cplusplus
    211212}
     
    213214
    214215#endif /* _POSIX_MESSAGE_PASSING */
    215 /**@}*/
     216
    216217#endif
    217218/* end of include file */
  • cpukit/posix/include/rtems/posix/aio_misc.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/aio_misc.h
     2 * @file
     3 *
     4 * @brief POSIX Asynchronous Input and Output Private Support
    35 *
    46 * This defines private information for the AIO implementation.
  • cpukit/posix/include/rtems/posix/barrier.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/barrier.h
     2 * @file
     3 *
     4 * @brief Constants and Structures Associated with the POSIX Barrier Manager
    35 *
    4  *  This include file contains all the constants and structures associated
    5  *  with the POSIX Barrier Manager.
     6 * This include file contains all the constants and structures associated
     7 * with the POSIX Barrier Manager.
    68 *
    7  *  Directives provided are:
     9 * Directives provided are:
    810 *
    9  *   - create a barrier
    10  *   - delete a barrier
    11  *   - wait for a barrier
     11 *  - create a barrier
     12 *  - delete a barrier
     13 *  - wait for a barrier
    1214 */
    1315
     
    2527
    2628/**
    27  *  @defgroup POSIXBarrier POSIX Barriers
     29 * @defgroup POSIXBarrier POSIX Barriers
    2830 *
    29  *  @ingroup POSIXAPI
     31 * @ingroup POSIXAPI
    3032 *
    31  *  This encapsulates functionality which implements the RTEMS API
    32  *  Barrier Manager.
     33 * This encapsulates functionality which implements the RTEMS API
     34 * Barrier Manager.
     35 *
     36 * @{
    3337 */
    34 /**@{*/
    3538
    3639#ifdef __cplusplus
     
    4245
    4346/**
    44  *  This type defines the control block used to manage each barrier.
     47 * This type defines the control block used to manage each barrier.
    4548 */
    4649
     
    6063
    6164/**
    62  *  @brief _POSIX_Barrier_Manager_initialization
     65 * @brief POSIX barrier manager initialization.
    6366 *
    64  *  This routine performs the initialization necessary for this manager.
    65  *
    66  *  @param[in] maximum_barriers is the total number of barriers allowed to
    67  *             concurrently be active in the system.
     67 * This routine performs the initialization necessary for this manager.
    6868 */
    6969
     
    7171
    7272/**
    73  *  @brief _POSIX_Barrier_Translate_core_barrier_return_code (
     73 * @brief POSIX translate barrier return code.
     74 *
     75 * This routine translates SuperCore Barrier status codes into the
     76 * corresponding POSIX ones.
    7477 *
    75  *  This routine translates SuperCore Barrier status codes into the
    76  *  corresponding POSIX ones.
     78 * @param[in] the_barrier_status is the SuperCore status.
    7779 *
    78  *
    79  *  @param[in] the_barrier_status is the SuperCore status.
    80  *
    81  *  @return the corresponding POSIX status
     80 * @return the corresponding POSIX status
    8281 */
    8382int _POSIX_Barrier_Translate_core_barrier_return_code(
     
    8988#endif
    9089
     90/** @} */
     91
    9192#ifdef __cplusplus
    9293}
    9394#endif
    9495
    95 /**@}*/
    96 
    9796#endif
    9897/*  end of include file */
  • cpukit/posix/include/rtems/posix/cancel.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/cancel.h
     2 * @file
     3 *
     4 * @brief POSIX Thread Cancelation Support
    35 *
    46 * This file contains the prototypes and data types used to implement
     
    2123
    2224/**
    23  *  This structure is used to manage the cancelation handlers.
     25 * This structure is used to manage the cancelation handlers.
    2426 */
    2527typedef struct {
     
    3335
    3436/**
    35  *  @brief _POSIX_Threads_cancel_run
     37 * @brief POSIX run thread cancelation.
    3638 *
    37  *  This support routine runs through the chain of cancel handlers that
    38  *  have been registered and executes them.
     39 * This support routine runs through the chain of cancel handlers that
     40 * have been registered and executes them.
    3941 *
    40  *  @param[in] the_thread is the thread whose cancelation handlers
    41  *             should be run
     42 * @param[in] the_thread is a pointer to the thread whose cancelation handlers
     43 *            should be run
    4244 */
    4345void _POSIX_Threads_cancel_run(
     
    4648
    4749/**
    48  *  @brief _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch
     50 * @brief POSIX evaluate thread cancelation and enable dispatch.
    4951 *
    50  *  This routine separates a piece of code that existed as part of
    51  *  another routine, but had to be separated to improve coverage.
     52 * This routine separates a piece of code that existed as part of
     53 * another routine, but had to be separated to improve coverage.
    5254 *
    53  *  @param[in] the_thread is the thread to evaluate canceling
     55 * @param[in] the_thread is a pointer to the thread to evaluate canceling
    5456 */
    5557void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch (
  • cpukit/posix/include/rtems/posix/cond.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/cond.h
     2 * @file
     3 *
     4 * @brief POSIX Condition Variables Private Support
    35 *
    46 * This include file contains all the private support information for
     
    1921
    2022/**
    21  *  @defgroup POSIX_COND_VARS Condition Variables
     23 * @defgroup POSIX_COND_VARS POSIX Condition Variables
    2224 *
    23  *  @ingroup POSIX
     25 * @ingroup POSIX
     26 *
     27 * @{
    2428 */
    25 /**@{*/
    2629#ifdef __cplusplus
    2730extern "C" {
     
    133136);
    134137
    135 /*
    136  * @brief Implements wake up version of the "signal" operation
     138/**
     139 * @brief Implements wake up version of the "signal" operation.
     140 *
     141 * DESCRIPTION:
    137142 *
    138  *  _POSIX_Condition_variables_Signal_support
    139  *
    140  *  DESCRIPTION:
    141  *
    142  *  A support routine which implements guts of the broadcast and single task
    143  *  wake up version of the "signal" operation.
     143 * A support routine which implements guts of the broadcast and single task
     144 * wake up version of the "signal" operation.
    144145 */
    145 
    146146int _POSIX_Condition_variables_Signal_support(
    147147  pthread_cond_t            *cond,
     
    150150
    151151/**
    152  * @brief POSIX Condition Variables Wait Support
     152 * @brief POSIX condition variables wait support.
    153153 *
    154154 * DESCRIPTION:
     
    181181#include <rtems/posix/cond.inl>
    182182
     183/** @} */
     184
    183185#ifdef __cplusplus
    184186}
    185187#endif
    186 /**@}*/
     188
    187189#endif
    188190/*  end of include file */
  • cpukit/posix/include/rtems/posix/config.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/config.h
     2 * @file
    33 *
     4 * @brief User Defined Configuration Parameters Specific For The POSIX API
     5 *
    46 * This include file contains the table of user defined configuration
    57 * parameters specific for the POSIX API.
     
    6163
    6264/**
    63  *  @brief POSIX API Configuration Table
     65 * @brief POSIX API configuration table.
    6466 *
    65  *  This is the POSIX API Configuration Table expected to be generated
    66  *  by confdefs.h.
     67 * This is the POSIX API Configuration Table expected to be generated
     68 * by confdefs.h.
    6769 */
    6870extern posix_api_configuration_table Configuration_POSIX_API;
  • cpukit/posix/include/rtems/posix/key.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/key.h
     2 * @file
     3 *
     4 * @brief POSIX Key Private Support
    35 *
    46 * This include file contains all the private support information for
     
    2123
    2224/**
    23  *  @defgroup POSIX_KEY Key
     25 * @defgroup POSIX_KEY POSIX Key
    2426 *
    25  *  @ingroup POSIX
     27 * @ingroup POSIX
     28 *
     29 * @{
    2630 */
    27 /**@{*/
     31
    2832#ifdef __cplusplus
    2933extern "C" {
     
    3135
    3236/**
    33  *  This is the data Structure used to manage a POSIX key.
     37 * This is the data Structure used to manage a POSIX key.
    3438 *
    35  *  @note The Values is a table indexed by the index portion of the
    36  *        ID of the currently executing thread.
     39 * NOTE: The Values is a table indexed by the index portion of the
     40 *       ID of the currently executing thread.
    3741 */
    3842typedef struct {
     
    4650
    4751/**
    48  *  The following defines the information control block used to manage
    49  *  this class of objects.
     52 * The following defines the information control block used to manage
     53 * this class of objects.
    5054 */
    5155POSIX_EXTERN Objects_Information  _POSIX_Keys_Information;
    5256
    5357/**
    54  *  @brief POSIX Keys Manager Initialization
     58 * @brief POSIX keys manager initialization.
    5559 *
    56  *  This routine performs the initialization necessary for this manager.
     60 * This routine performs the initialization necessary for this manager.
    5761 */
    5862void _POSIX_Key_Manager_initialization(void);
    5963
    6064/**
    61  *  @brief Thread-Specific Data Key Create
     65 * @brief Create thread-specific data POSIX key.
    6266 *
    63  *  This function executes all the destructors associated with the thread's
    64  *  keys.  This function will execute until all values have been set to NULL.
     67 * This function executes all the destructors associated with the thread's
     68 * keys.  This function will execute until all values have been set to NULL.
    6569 *
    66  *  @param[in] thread is the thread whose keys should have all their
    67  *            destructors run.
     70 * @param[in] thread is a pointer to the thread whose keys should have
     71 *            all their destructors run.
    6872 *
    69  *  @note This is the routine executed when a thread exits to
    70  *        run through all the keys and do the destructor action.
     73 * NOTE: This is the routine executed when a thread exits to
     74 *       run through all the keys and do the destructor action.
    7175 */
    7276void _POSIX_Keys_Run_destructors(
     
    7579
    7680/**
    77  *  @brief Free Key Memory
     81 * @brief Free a POSIX key table memory.
    7882 *
    79  *  This memory frees the key table memory associated with @a the_key.
     83 * This memory frees the key table memory associated with @a the_key.
    8084 *
    81  *  @param[in] the_key is the POSIX key to free the table memory of.
     85 * @param[in] the_key is a pointer to the POSIX key to free
     86 * the table memory of.
    8287 */
    8388void _POSIX_Keys_Free_memory(
     
    8691
    8792/**
    88  *  @brief _POSIX_Keys_Free
     93 * @brief Free a POSIX keys control block.
    8994 *
    90  *  This routine frees a keys control block to the
    91  *  inactive chain of free keys control blocks.
     95 * This routine frees a keys control block to the
     96 * inactive chain of free keys control blocks.
    9297 *
    93  *  @param[in] the_key is the POSIX key to free.
     98 * @param[in] the_key is a pointer to the POSIX key to free.
    9499 */
    95100RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
     
    99104#include <rtems/posix/key.inl>
    100105
     106/** @} */
     107
    101108#ifdef __cplusplus
    102109}
    103110#endif
    104 /**@}*/
     111
    105112#endif
    106113/*  end of include file */
  • cpukit/posix/include/rtems/posix/mqueue.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/mqueue.h
     2 * @file
     3 *
     4 * @brief POSIX Message Queues Private Private Support
    35 *
    46 * This include file contains all the private support information for
    57 * POSIX Message Queues.
    68 *
    7  *  The structure of the routines is identical to that of POSIX
    8  *  Message_queues to leave the option of having unnamed message
    9  *  queues at a future date.  They are currently not part of the
    10  *  POSIX standard but unnamed message_queues are.  This is also
    11  *  the reason for the apparently unnecessary tracking of
    12  *  the process_shared attribute.  [In addition to the fact that
    13  *  it would be trivial to add pshared to the mq_attr structure
    14  *  and have process private message queues.]
    15  *
    16  *  This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
    17  *  time.
     9 * The structure of the routines is identical to that of POSIX
     10 * Message_queues to leave the option of having unnamed message
     11 * queues at a future date.  They are currently not part of the
     12 * POSIX standard but unnamed message_queues are.  This is also
     13 * the reason for the apparently unnecessary tracking of
     14 * the process_shared attribute.  [In addition to the fact that
     15 * it would be trivial to add pshared to the mq_attr structure
     16 * and have process private message queues.]
     17 *
     18 * This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
     19 * time.
    1820 */
    1921
     
    3739
    3840/**
    39  *  @defgroup POSIX_MQUEUE_P Message Queues Private Support Information
    40  *
    41  *  @ingroup POSIX
    42  */
    43 /**@{*/
     41 *  @defgroup POSIX_MQUEUE_P Message Queues Private Support
     42 *
     43 *  @ingroup POSIX_MQUEUE
     44 *
     45 * @{
     46 */
    4447#ifdef __cplusplus
    4548extern "C" {
    4649#endif
    47 
    48 /**
    49  *  @ingroup POSIX_MQUEUE
    50  */
    5150
    5251/*
     
    7978POSIX_EXTERN Objects_Information  _POSIX_Message_queue_Information_fds;
    8079
    81 /*
    82  *  @brief Initializes message_queue Manager Related Data Structures
    83  *
    84  *  DESCRIPTION:
    85  *
    86  *  This routine performs the initialization necessary for this manager.
     80/**
     81 * @brief Initialize message_queue manager related data structures.
     82 *
     83 * DESCRIPTION:
     84 *
     85 * This routine performs the initialization necessary for this manager.
     86 *
     87 * NOTE:  The structure of the routines is identical to that of POSIX
     88 *        Message_queues to leave the option of having unnamed message
     89 *        queues at a future date.  They are currently not part of the
     90 *        POSIX standard but unnamed message_queues are.  This is also
     91 *        the reason for the apparently unnecessary tracking of
     92 *        the process_shared attribute.  [In addition to the fact that
     93 *        it would be trivial to add pshared to the mq_attr structure
     94 *        and have process private message queues.]
     95 *
     96 *        This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
     97 *        time.
     98 *
     99 */
     100
     101void _POSIX_Message_queue_Manager_initialization(void);
     102
     103/*
     104 *
     105 *  _POSIX_Message_queue_Create_support
     106 *
     107 *  DESCRIPTION:
     108 *
     109 *  This routine performs the creation of a message queue utilizing the
     110 *  core message queue.
     111 */
     112
     113int _POSIX_Message_queue_Create_support(
     114  const char                    *name,
     115  size_t                         name_len,
     116  int                            pshared,
     117  struct mq_attr                *attr,
     118  POSIX_Message_queue_Control  **message_queue
     119);
     120
     121/**
     122 * @brief Delete a POSIX message queue.
     123 *
     124 * DESCRIPTION:
     125 *
     126 * This routine supports the mq_unlink and mq_close routines by
     127 * doing most of the work involved with removing a message queue.
     128 */
     129void _POSIX_Message_queue_Delete(
     130  POSIX_Message_queue_Control *the_mq
     131);
     132
     133/*
     134 *  @brief POSIX Message Queue Receive Support
     135 *
     136 *  DESCRIPTION:
     137 *
     138 *  This routine supports the various flavors of receiving a message.
    87139 *
    88140 *  NOTE:  The structure of the routines is identical to that of POSIX
     
    97149 *         This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
    98150 *         time.
    99  *
    100  */
    101 
    102 void _POSIX_Message_queue_Manager_initialization(void);
    103 
    104 /*
    105  *
    106  *  _POSIX_Message_queue_Create_support
    107  *
    108  *  DESCRIPTION:
    109  *
    110  *  This routine performs the creation of a message queue utilizing the
    111  *  core message queue.
    112  */
    113 
    114 int _POSIX_Message_queue_Create_support(
    115   const char                    *name,
    116   size_t                         name_len,
    117   int                            pshared,
    118   struct mq_attr                *attr,
    119   POSIX_Message_queue_Control  **message_queue
    120 );
    121 
    122 /**
    123  *  @brief POSIX Delete Message Queue
    124  *
    125  *  DESCRIPTION:
    126  *
    127  *  This routine supports the mq_unlink and mq_close routines by
    128  *  doing most of the work involved with removing a message queue.
    129  */
    130 void _POSIX_Message_queue_Delete(
    131   POSIX_Message_queue_Control *the_mq
    132 );
    133 
    134 /*
    135  *  @brief POSIX Message Queue Receive Support
    136  *
    137  *  DESCRIPTION:
    138  *
    139  *  This routine supports the various flavors of receiving a message.
    140  *
    141  *  NOTE:  The structure of the routines is identical to that of POSIX
    142  *         Message_queues to leave the option of having unnamed message
    143  *         queues at a future date.  They are currently not part of the
    144  *         POSIX standard but unnamed message_queues are.  This is also
    145  *         the reason for the apparently unnecessary tracking of
    146  *         the process_shared attribute.  [In addition to the fact that
    147  *         it would be trivial to add pshared to the mq_attr structure
    148  *         and have process private message queues.]
    149  *
    150  *         This code ignores the O_RDONLY/O_WRONLY/O_RDWR flag at open
    151  *         time.
    152151 */
    153152
     
    272271#include <rtems/posix/mqueue.inl>
    273272
     273/** @} */
     274
    274275#ifdef __cplusplus
    275276}
    276277#endif
    277 /**@}*/
     278
    278279#endif
    279280/*  end of include file */
  • cpukit/posix/include/rtems/posix/priority.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/priority.h
     2 * @file
     3 *
     4 * @brief POSIX Priority Support
    35 *
    46 * This include file defines the interface to the POSIX priority
     
    2426 *
    2527 * @brief Interface to the POSIX Priority Implementation
     28 *
     29 * @{
    2630 */
    2731
     
    2933
    3034/**
    31  *  1003.1b-1993,2.2.2.80 definition of priority, p. 19
     35 * 1003.1b-1993,2.2.2.80 definition of priority, p. 19
    3236 *
    33  *  "Numerically higher values represent higher priorities."
     37 * "Numerically higher values represent higher priorities."
    3438 *
    35  *  Thus, RTEMS Core has priorities run in the opposite sense of the POSIX API.
     39 * Thus, RTEMS Core has priorities run in the opposite sense of the POSIX API.
    3640 *
    37  *  There are only 254 posix priority levels since a task at priority level
    38  *  255 would never run because of the RTEMS idle task.  This is necessary
    39  *  because GNAT maps the lowest Ada task priority to the lowest thread
    40  *  priority.  The lowest priority Ada task should get to run, so there is
    41  *  a fundamental conflict with having 255 priorities.
     41 * There are only 254 posix priority levels since a task at priority level
     42 * 255 would never run because of the RTEMS idle task.  This is necessary
     43 * because GNAT maps the lowest Ada task priority to the lowest thread
     44 * priority.  The lowest priority Ada task should get to run, so there is
     45 * a fundamental conflict with having 255 priorities.
    4246 *
    43  *  But since RTEMS can be configured with fewer than 256 priorities,
    44  *  we use the internal constant.
     47 * But since RTEMS can be configured with fewer than 256 priorities,
     48 * we use the internal constant.
    4549 */
    4650#define POSIX_SCHEDULER_MAXIMUM_PRIORITY (PRIORITY_MAXIMUM - 1)
     
    5357
    5458/**
    55  *  @brief POSIX Is Priority Valid
     59 * @brief Check if POSIX priority is valid.
    5660 *
    57  *  1003.1b-1993,2.2.2.80 definition of priority, p. 19
     61 * 1003.1b-1993,2.2.2.80 definition of priority, p. 19
    5862 *
    59  *  "Numerically higher values represent higher priorities."
     63 * "Numerically higher values represent higher priorities."
    6064 *
    61  *  Thus, RTEMS Core has priorities run in the opposite sense of the POSIX API.
     65 * Thus, RTEMS Core has priorities run in the opposite sense of the POSIX API.
    6266 *
    63  *  @param[in] priority is the priority to test
     67 * @param[in] priority is the priority to test
    6468 *
    65  *  @return This method returns true if the priority is valid and
    66  *          false otherwise.
     69 * @retval TRUE The priority is valid.
     70 * @retval FALSE The priority is invalid.
    6771 */
    6872bool _POSIX_Priority_Is_valid(
     
    7175
    7276/**
    73  *  @brief Convert POSIX Priority To SuperCore Priority
     77 * @brief Convert POSIX priority to SuperCore priority.
    7478 *
    75  *  This method converts a POSIX API priority into onto the corresponding
    76  *  SuperCore value.
     79 * This method converts a POSIX API priority into onto the corresponding
     80 * SuperCore value.
    7781 *
    78  *  @param[in] priority is the POSIX API priority.
     82 * @param[in] priority is the POSIX API priority.
    7983 *
    80  *  @return This method returns the corresponding SuperCore priority.
     84 * @return This method returns the corresponding SuperCore priority.
    8185 */
    8286RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
     
    8589
    8690/**
    87  *  @brief Convert SuperCore Priority To POSIX Priority
     91 * @brief Convert SuperCore priority To POSIX priority.
    8892 *
    89  *  This method converts a SuperCore priority into onto the corresponding
    90  *  POSIX API value.
     93 * This method converts a SuperCore priority into onto the corresponding
     94 * POSIX API value.
    9195 *
    92  *  @param[in] priority is the POSIX API priority.
     96 * @param[in] priority is the POSIX API priority.
    9397 *
    94  *  @return This method returns the corresponding POSIX priority.
     98 * @return This method returns the corresponding POSIX priority.
    9599 */
    96100RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
     
    100104#include <rtems/posix/priority.inl>
    101105
     106/** @} */
     107
    102108#endif
  • cpukit/posix/include/rtems/posix/psignal.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/psignal.h
     2 * @file
     3 *
     4 * @brief Internal Information about POSIX Signals
    35 *
    46 * This include file defines internal information about POSIX signals.
  • cpukit/posix/include/rtems/posix/psignalimpl.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/psignal.h
     2 * @file
     3 *
     4 * @brief POSIX Signals Support
    35 *
    46 * This include file defines internal information about POSIX signals.
     
    2325 *
    2426 * @brief Internal Information about POSIX Signals
     27 *
     28 * @{
    2529 */
    2630
     
    7377
    7478/**
    75  *  @brief POSIX Signals Manager Initialization
     79 * @brief POSIX signals manager initialization.
    7680 */
    7781void _POSIX_signals_Manager_Initialization(void);
     
    8387
    8488/**
    85  * @brief POSIX Signals Thread Unlock
     89 * @brief Unlock POSIX signals thread.
    8690 *
    8791 * XXX this routine could probably be cleaned up
     
    9498
    9599/**
    96  *  @brief POSIX Signals Check Signal
     100 *  @brief Check POSIX signal.
    97101 */
    98102bool _POSIX_signals_Check_signal(
     
    103107
    104108/**
    105  *  @brief POSIX Signals Clear Signals
     109 * @brief Clear POSIX signals.
    106110 */
    107111bool _POSIX_signals_Clear_signals(
     
    120124
    121125/**
    122  *  @brief POSIX Signals Set Process Signals
     126 *  @brief Set POSIX process signals.
    123127 */
    124128void _POSIX_signals_Set_process_signals(
     
    139143void _POSIX_signals_Abnormal_termination_handler( int signo );
    140144
     145/** @} */
     146
    141147#endif
    142148/* end of file */
  • cpukit/posix/include/rtems/posix/pthread.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/pthread.h
     2 * @file
     3 *
     4 * @brief POSIX Threads Private Support
    35 *
    46 * This include file contains all the private support information for
     
    2224#include <rtems/posix/threadsup.h>
    2325
    24 /**
    25  *  @defgroup POSIX_PTHREADS Private Threads
    26  *
    27  *  @ingroup POSIX
    28  */
    29 /**@{*/
    3026#ifdef __cplusplus
    3127extern "C" {
     
    3834 *
    3935 * @brief Private Support Information for POSIX Threads
     36 *
     37 * @{
    4038 */
    4139
    4240/**
    43  *  The following sets the minimum stack size for POSIX threads.
     41 * The following sets the minimum stack size for POSIX threads.
    4442 */
    4543#define PTHREAD_MINIMUM_STACK_SIZE (_Stack_Minimum() * 2)
    4644
    4745/**
    48  *  The following defines the information control block used to manage
    49  *  this class of objects.
     46 * The following defines the information control block used to manage
     47 * this class of objects.
    5048 */
    5149POSIX_EXTERN Objects_Information  _POSIX_Threads_Information;
    5250
    5351/**
    54  *  This variable contains the default POSIX Thread attributes.
     52 * This variable contains the default POSIX Thread attributes.
    5553 */
    5654extern const pthread_attr_t _POSIX_Threads_Default_attributes;
    5755
    5856/**
    59  *  When the user configures a set of POSIX API initialization threads,
    60  *  This variable will point to the method used to initialize them.
     57 * When the user configures a set of POSIX API initialization threads,
     58 * This variable will point to the method used to initialize them.
    6159 *
    62  *  @note It is instantiated and initialized by confdefs.h based upon
    63  *        application requirements.
     60 * NOTE: It is instantiated and initialized by confdefs.h based upon
     61 *       application requirements.
    6462 */
    6563extern void (*_POSIX_Threads_Initialize_user_threads_p)(void);
    6664
    6765/**
    68  *  @brief _POSIX_Threads_Manager_initialization
     66 * @brief POSIX threads manager initialization.
    6967 *
    70  *  This routine performs the initialization necessary for this manager.
     68 * This routine performs the initialization necessary for this manager.
    7169 */
    7270void _POSIX_Threads_Manager_initialization(void);
    7371
    7472/**
    75  *  @brief _POSIX_Threads_Allocate
     73 * @brief Allocate POSIX thread control block.
    7674 *
    77  *  This function allocates a pthread control block from
    78  *  the inactive chain of free pthread control blocks.
     75 * This function allocates a pthread control block from
     76 * the inactive chain of free pthread control blocks.
    7977 *
    80  *  @return This method returns a newly allocated thread.
     78 * @return This method returns a newly allocated thread.
    8179 */
    8280RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void );
    8381
    8482/**
    85  *  @brief _POSIX_Threads_Free
     83 * @brief Free POSIX control block.
    8684 *
    87  *  This routine frees a pthread control block to the
    88  *  inactive chain of free pthread control blocks.
     85 * This routine frees a pthread control block to the
     86 * inactive chain of free pthread control blocks.
    8987 *
    90  *  @param[in] the_pthread is the thread to free
     88 * @param[in] the_pthread is a pointer to the thread to free.
    9189 */
    9290RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free(
     
    9593
    9694/**
    97  *  @brief _POSIX_Threads_Get
     95 * @brief Map POSIX thread IDs to control blocks.
    9896 *
    99  *  This function maps pthread IDs to pthread control blocks.
    100  *  If ID corresponds to a local pthread, then it returns
    101  *  the_pthread control pointer which maps to ID and location
    102  *  is set to OBJECTS_LOCAL.  if the pthread ID is global and
    103  *  resides on a remote node, then location is set to OBJECTS_REMOTE,
    104  *  and the_pthread is undefined.  Otherwise, location is set
    105  *  to OBJECTS_ERROR and the_pthread is undefined.
     97 * This function maps pthread IDs to pthread control blocks.
     98 * If ID corresponds to a local pthread, then it returns
     99 * the_pthread control pointer which maps to ID and location
     100 * is set to OBJECTS_LOCAL.  if the pthread ID is global and
     101 * resides on a remote node, then location is set to OBJECTS_REMOTE,
     102 * and the_pthread is undefined.  Otherwise, location is set
     103 * to OBJECTS_ERROR and the_pthread is undefined.
    106104 *
    107  *  @param[in] id is the id to lookup
    108  *  @param[in] location points to the returned location value
     105 * @param[in] id is the id to lookup
     106 * @param[in] location points to the returned location value
    109107 *
    110  *  @return This methods returns a pointer to the corresponding Thread_Control.
     108 * @return This methods returns a pointer to the corresponding Thread_Control.
    111109 */
    112110RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get(
     
    116114
    117115/**
    118  *  @brief _POSIX_Threads_Is_null
     116 * @brief Check if a POSIX thread control block is NULL.
    119117 *
    120  *  This function returns TRUE if the_pthread is NULL and FALSE otherwise.
     118 * This function returns @c TRUE if the_pthread is @c NULL and @c FALSE
     119 * otherwise.
    121120 *
    122  *  @param[in] the_pthread is the thread pointer to check.
     121 * @param[in] the_pthread is a pointer to the POSIX thread control block
     122 * to check.
    123123 *
    124  *  @return This method returns true if the thread pointer is null.
     124 * @retval TRUE The thread control block is @c NULL.
     125 * @retval FALSE The thread control block is not @c NULL.
    125126 */
    126127RTEMS_INLINE_ROUTINE bool _POSIX_Threads_Is_null(
     
    129130
    130131/**
    131  *  @brief _POSIX_Threads_Sporadic_budget_callout
     132 * @brief POSIX threads sporadic budget callout.
    132133 *
    133  *  This routine handles the sporadic scheduling algorithm.
     134 * This routine handles the sporadic scheduling algorithm.
    134135 *
    135  *  @param[in] the_thread is the thread whose budget has been exceeded.
     136 * @param[in] the_thread is a pointer to the thread whose budget
     137 * has been exceeded.
    136138 */
    137139void _POSIX_Threads_Sporadic_budget_callout(
     
    140142
    141143/**
    142  *  _POSIX_Threads_Sporadic_budget_TSR
     144 * This routine supports the sporadic scheduling algorithm.  It
     145 * is scheduled to be executed at the end of each replenishment
     146 * period.  In sporadic scheduling a thread will execute at a
     147 * high priority for a user specified amount of CPU time.  When
     148 * it exceeds that amount of CPU time, its priority is automatically
     149 * lowered. This TSR is executed when it is time to replenish
     150 * the thread's processor budget and raise its priority.
    143151 *
    144  *  This routine supports the sporadic scheduling algorithm.  It
    145  *  is scheduled to be executed at the end of each replenishment
    146  *  period.  In sporadic scheduling a thread will execute at a
    147  *  high priority for a user specified amount of CPU time.  When
    148  *  it exceeds that amount of CPU time, its priority is automatically
    149  *  lowered. This TSR is executed when it is time to replenish
    150  *  the thread's processor budget and raise its priority.
    151  *
    152  *  @param[in] id is ignored
    153  *  @param[in] argument is a pointer to the Thread_Control structure
    154  *             for the thread being replenished.
     152 * @param[in] id is ignored
     153 * @param[in] argument is a pointer to the Thread_Control structure
     154 *            for the thread being replenished.
    155155 */
    156156void _POSIX_Threads_Sporadic_budget_TSR(
     
    160160
    161161/**
    162  *  @brief Translate sched_param into SuperCore Terms
     162 * @brief Translate sched_param into SuperCore terms.
    163163 *
    164  *  This method translates the POSIX API sched_param into the corresponding
    165  *  SuperCore settings.
     164 * This method translates the POSIX API sched_param into the corresponding
     165 * SuperCore settings.
    166166 *
    167  *  @param[in] policy is the POSIX scheduling policy
    168  *  @param[in] param points to the scheduling parameter structure
    169  *  @param[in] budget_algorithm points to the output CPU Budget algorithm
    170  *  @param[in] budget_callout points to the output CPU Callout
     167 * @param[in] policy is the POSIX scheduling policy
     168 * @param[in] param points to the scheduling parameter structure
     169 * @param[in] budget_algorithm points to the output CPU Budget algorithm
     170 * @param[in] budget_callout points to the output CPU Callout
    171171 *
    172  *  @return This method returns 0 on success or a POSIX error code.
     172 * @retval 0 Indicates success.
     173 * @retval error_code POSIX error code indicating failure.
    173174 */
    174175int _POSIX_Thread_Translate_sched_param(
     
    180181
    181182/**
    182  * @brief POSIX Threads Initialize User Threads Body
     183 * @brief POSIX threads initialize user threads body.
    183184 *
    184185 * This routine creates and starts all configured user
     
    189190#include <rtems/posix/pthread.inl>
    190191
     192/** @} */
     193
    191194#ifdef __cplusplus
    192195}
    193196#endif
    194 /**@}*/
     197
    195198#endif
    196199/*  end of include file */
  • cpukit/posix/include/rtems/posix/ptimer.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/ptimer.h
     2 * @file
     3 *
     4 * @brief POSIX Timers Private Support
    35 *
    46 * This include file contains all the private support information for
     
    2224
    2325/**
    24  *  @defgroup POSIX_PRIV_TIMERS Timers
     26 * @defgroup POSIX_PRIV_TIMERS POSIX Timers
    2527 *
    26  *  @ingroup POSIX
     28 * @ingroup POSIX
     29 *
     30 * @{
    2731 */
    28 /**@{*/
    2932#ifdef __cplusplus
    3033extern "C" {
     
    9093
    9194/**
    92  *  @brief Get Overrun Count for a POSIX Per-Process Timer
     95 * @brief Get overrun count for a POSIX per-process timer.
    9396 *
    94  *  The expiration of a timer must increase by one a counter.
    95  *  After the signal handler associated to the timer finishes
    96  *  its execution, _POSIX_Timer_TSR will have to set this counter to 0.
     97 * The expiration of a timer must increase by one a counter.
     98 * After the signal handler associated to the timer finishes
     99 * its execution, _POSIX_Timer_TSR will have to set this counter to 0.
    97100 *
    98  *  14.2.4 Per-Process Timers, P1003.1b-1993, p. 267
     101 * 14.2.4 Per-Process Timers, P1003.1b-1993, p. 267
    99102 */
    100103int timer_getoverrun(
    101104  timer_t   timerid
    102105);
    103 /**@}*/
     106
     107/** @} */
     108
    104109#endif
  • cpukit/posix/include/rtems/posix/rwlock.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/rwlock.h
     2 * @file
     3 *
     4 * @brief Constants and Structures Associated with the POSIX RWLock Manager
    35 *
    46 * This include file contains all the constants and structures associated
     
    3436 *
    3537 * @brief Constants and Structures Associated with the POSIX RWLock Manager
     38 *
     39 * @{
    3640 */
    3741
     
    4044
    4145/**
    42  *  This type defines the control block used to manage each RWLock.
     46 * This type defines the control block used to manage each RWLock.
    4347 */
    4448
     
    5155
    5256/**
    53  *  The following defines the information control block used to manage
    54  *  this class of objects.
     57 * The following defines the information control block used to manage
     58 * this class of objects.
    5559 */
    5660
     
    5862
    5963/**
    60  *  @brief _POSIX_RWLock_Manager_initialization
     64 * @brief POSIX RWLock manager initialization.
    6165 *
    62  *  This routine performs the initialization necessary for this manager.
    63  *
    64  *  @param[in] maximum_rwlocks is the total number of RWLocks allowed to
    65  *             concurrently be active in the system.
     66 * This routine performs the initialization necessary for this manager.
    6667 */
    6768
     
    6970
    7071/**
    71  *  @brief POSIX RWLock Translate Core RWLock Return Code
     72 * @brief POSIX translate core RWLock return code.
    7273 *
    73  *  This routine translates SuperCore RWLock status codes into the
    74  *  corresponding POSIX ones.
     74 * This routine translates SuperCore RWLock status codes into the
     75 * corresponding POSIX ones.
    7576 *
    7677 *
    77  *  @param[in] the_RWLock_status is the SuperCore status.
     78 * @param[in] the_RWLock_status is the SuperCore status.
    7879 *
    79  *  @return the corresponding POSIX status
     80 * @return the corresponding POSIX status
     81 * @retval 0 The status indicates that the operation completed successfully.
     82 * @retval EINVAL The status indicates that the thread was blocked waiting for
     83 * an operation to complete and the RWLock was deleted.
     84 * @retval EBUSY This status indicates that the RWLock was not
     85 * immediately available.
     86 * @retval ETIMEDOUT This status indicates that the calling task was
     87 * willing to block but the operation was unable to complete within
     88 * the time allotted because the resource never became available.
    8089 */
    8190int _POSIX_RWLock_Translate_core_RWLock_return_code(
     
    8796#endif
    8897
     98/** @} */
     99
    89100#ifdef __cplusplus
    90101}
  • cpukit/posix/include/rtems/posix/sigset.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/sigset.h
     2 * @file
     3 *
     4 * @brief POSIX Signal Sets Management Helper
    35 *
    46 * This file defines the interface to implementation helper for management
  • cpukit/posix/include/rtems/posix/spinlock.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/spinlock.h
     2 * @file
     3 *
     4 * @brief POSIX Spinlock Support
    35 *
    46 * This include file contains all the constants and structures associated
     
    3436 *
    3537 * @brief Constants and Structures Associated with the POSIX Spinlock Manager
     38 *
     39 * @{
    3640 */
    3741
     
    4044
    4145/**
    42  *  This type defines the control block used to manage each spinlock.
     46 * This type defines the control block used to manage each spinlock.
    4347 */
    4448
     
    5155
    5256/**
    53  *  The following defines the information control block used to manage
    54  *  this class of objects.
     57 * The following defines the information control block used to manage
     58 * this class of objects.
    5559 */
    5660
     
    5862
    5963/**
    60  *  @brief _POSIX_Spinlock_Manager_initialization
     64 * @brief POSIX spinlock manager initialization.
    6165 *
    62  *  This routine performs the initialization necessary for this manager.
    63  *
    64  *  @param[in] maximum_spinlocks is the total number of spinlocks allowed to
    65  *             concurrently be active in the system.
     66 * This routine performs the initialization necessary for this manager.
    6667 */
    6768
     
    6970
    7071/**
    71  *  @brief POSIX Spinlock Translate Core Spinlock Return Code
     72 * @brief Translate core spinlock status code.
    7273 *
    73  *  This routine translates SuperCore Spinlock status codes into the
    74  *  corresponding POSIX ones.
     74 * This routine translates SuperCore Spinlock status codes into the
     75 * corresponding POSIX ones.
     76 *
     77 * @param[in] the_spinlock_status is the SuperCore status.
    7578 *
    76  *
    77  *  @param[in] the_spinlock_status is the SuperCore status.
    78  *
    79  *  @return the corresponding POSIX status
     79 * @return the corresponding POSIX status
    8080 */
    8181int _POSIX_Spinlock_Translate_core_spinlock_return_code(
     
    8787#endif
    8888
     89/** @} */
     90
    8991#ifdef __cplusplus
    9092}
  • cpukit/posix/include/rtems/posix/threadsup.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/threadsup.h
     2 * @file
     3 *
     4 * @brief POSIX Thread API Support
    35 *
    46 * This defines the POSIX thread API extension.
     
    2527 *
    2628 *  @ingroup POSIX
     29 *
     30 * @{
    2731 */
    28 /**@{*/
    2932#ifdef __cplusplus
    3033extern "C" {
    3134#endif
    3235
    33 /*!
    34  *  This defines the POSIX API support structure associated with
    35  *  each thread in a system with POSIX configured.
     36/**
     37 * This defines the POSIX API support structure associated with
     38 * each thread in a system with POSIX configured.
    3639 */
    3740typedef struct {
     
    4750  struct sched_param      schedparam;
    4851  /**
    49    *  This is the high priority to execute at when using the sporadic
    50    *  scheduler.
     52   * This is the high priority to execute at when using the sporadic
     53   * scheduler.
    5154   */
    5255  int                     ss_high_priority;
    5356  /**
    54    *  This is the timer which controls when the thread executes at
    55    *  high and low priority when using the sporadic scheduler.
     57   * This is the timer which controls when the thread executes at
     58   * high and low priority when using the sporadic scheduler.
    5659   */
    5760  Watchdog_Control        Sporadic_timer;
     
    7982} POSIX_API_Control;
    8083
    81 /*!
    82  *  @brief POSIX Thread Exit Shared Helper
     84/**
     85 * @brief POSIX thread exit shared helper.
    8386 *
    84  *  16.1.5.1 Thread Termination, p1003.1c/Draft 10, p. 150
     87 * 16.1.5.1 Thread Termination, p1003.1c/Draft 10, p. 150
    8588 *
    86  *  This method is a helper routine which ensures that all
    87  *  POSIX thread calls which result in a thread exiting will
    88  *  do so in the same manner.
     89 * This method is a helper routine which ensures that all
     90 * POSIX thread calls which result in a thread exiting will
     91 * do so in the same manner.
    8992 *
    90  *  @param[in] the_thread is the thread exiting or being canceled
    91  *  @param[in] value_ptr is the value to be returned by the thread
     93 * @param[in] the_thread is a pointer to the thread exiting or being canceled
     94 * @param[in] value_ptr is a pointer the value to be returned by the thread
    9295 *
    93  *  NOTE: Key destructors are executed in the POSIX api delete extension.
     96 * NOTE: Key destructors are executed in the POSIX api delete extension.
    9497 *
    9598 */
     
    99102);
    100103
     104/** @} */
     105
    101106#ifdef __cplusplus
    102107}
    103108#endif
    104 /**@}*/
     109
    105110#endif
    106111/* end of include file */
  • cpukit/posix/include/rtems/posix/time.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/time.h
     2 * @file
     3 *
     4 * @brief POSIX Time Types
    35 *
    46 * This defines the interface to implementation helper routines related
     
    2123#include <rtems/score/watchdog.h>
    2224/**
    23  *  @defgroup POSIX_TIMETYPES Time Types
     25 * @defgroup POSIX_TIMETYPES POSIX Time Types
    2426 *
    25  *  @ingroup POSIX
     27 * @ingroup POSIX
     28 *
     29 * @{
    2630 */
    27 /**@{*/
    2831
    2932/**
    30  *  @brief Absolute Timeout Conversion Results
     33 * @brief Absolute timeout conversion results.
    3134 *
    32  *  This enumeration defines the possible results of converting
    33  *  an absolute time used for timeouts to POSIX blocking calls to
    34  *  a number of ticks.
     35 * This enumeration defines the possible results of converting
     36 * an absolute time used for timeouts to POSIX blocking calls to
     37 * a number of ticks.
    3538 */
    3639typedef enum {
     
    4649
    4750/**
    48  *  @brief Convert Absolute Timeout to Ticks
     51 * @brief Convert absolute timeout to ticks.
    4952 *
    50  *  This method takes an absolute time being used as a timeout
    51  *  to a blocking directive, validates it and returns the number
    52  *  of corresponding clock ticks for use by the SuperCore.
     53 * This method takes an absolute time being used as a timeout
     54 * to a blocking directive, validates it and returns the number
     55 * of corresponding clock ticks for use by the SuperCore.
    5356 *
    54  *  @param[in] abstime is the timeout
    55  *  @param[in] ticks_out will contain the number of ticks
     57 * @param[in] abstime is a pointer to the timeout
     58 * @param[out] ticks_out will contain the number of ticks
    5659 *
    57  *  @return This method returns the number of ticks in @a ticks_out
    58  *          and a status value indicating whether the absolute time
    59  *          is valid, in the past, equal to the current time or in
    60  *          the future as it should be.
     60 * @return This method returns the number of ticks in @a ticks_out
     61 *         and a status value indicating whether the absolute time
     62 *         is valid, in the past, equal to the current time or in
     63 *         the future as it should be.
    6164 */
    6265POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
     
    6568);
    6669
     70/** @} */
     71
    6772#endif
    68 /**@}*/
  • cpukit/posix/include/rtems/posix/timer.h

    r34d12977 rcf301c9  
    11/**
    2  * @file rtems/posix/timer.h
     2 * @file
     3 *
     4 * @brief POSIX Timers Internal Support
    35 *
    46 * This include files defines the internal support for implementation of
     
    2325
    2426/**
    25  *  @defgroup POSIX_INTERNAL_TIMERS Timers
     27 * @defgroup POSIX_INTERNAL_TIMERS Timers
    2628 *
    27  *  @ingroup POSIX
     29 * @ingroup POSIX
     30 *
     31 * @{
    2832 */
    29 /**@{*/
     33
    3034#ifdef __cplusplus
    3135extern "C" {
     
    109113#endif
    110114
     115/** @} */
     116
    111117#ifdef __cplusplus
    112118}
    113119#endif
    114 /**@}*/
     120
    115121#endif
    116122/* end of include file */
Note: See TracChangeset for help on using the changeset viewer.