source: rtems/cpukit/include/rtems/score/coremsgimpl.h @ ff3a87c1

Last change on this file since ff3a87c1 was ff3a87c1, checked in by Martin Erik Werner <martinerikwerner.aac@…>, on 01/22/23 at 23:02:18

score: Fix minor Rhe->The typo in doxygen

  • Property mode set to 100644
File size: 23.3 KB
Line 
1/* SPDX-License-Identifier: BSD-2-Clause */
2
3/**
4 * @file
5 *
6 * @ingroup RTEMSScoreMessageQueue
7 *
8 * @brief This header file provides interfaces of the
9 *   @ref RTEMSScoreMessageQueue which are used by the implementation and the
10 *   @ref RTEMSImplApplConfig.
11 */
12
13/*
14 *  COPYRIGHT (c) 1989-2009.
15 *  On-Line Applications Research Corporation (OAR).
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 * 1. Redistributions of source code must retain the above copyright
21 *    notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 *    notice, this list of conditions and the following disclaimer in the
24 *    documentation and/or other materials provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39#ifndef _RTEMS_SCORE_COREMSGIMPL_H
40#define _RTEMS_SCORE_COREMSGIMPL_H
41
42#include <rtems/score/coremsg.h>
43#include <rtems/score/status.h>
44#include <rtems/score/chainimpl.h>
45#include <rtems/score/threaddispatch.h>
46#include <rtems/score/threadqimpl.h>
47
48#include <limits.h>
49#include <string.h>
50
51#ifdef __cplusplus
52extern "C" {
53#endif
54
55/**
56 * @addtogroup RTEMSScoreMessageQueue
57 *
58 * @{
59 */
60
61/**
62 *  @brief Used when appending messages onto a message queue.
63 *
64 *  This is the priority constant used when appending messages onto
65 *  a message queue.
66 */
67#define  CORE_MESSAGE_QUEUE_SEND_REQUEST   INT_MAX
68
69/**
70 *  @brief Used when prepending messages onto a message queue.
71 *
72 *  This is the priority constant used when prepending messages onto
73 *  a message queue.
74 */
75#define  CORE_MESSAGE_QUEUE_URGENT_REQUEST INT_MIN
76
77/**
78 *  @brief The modes in which a message may be submitted to a message queue.
79 *
80 *  The following type details the modes in which a message
81 *  may be submitted to a message queue.  The message may be posted
82 *  in a send or urgent fashion.
83 *
84 *  @note  All other values are message priorities.  Numerically smaller
85 *         priorities indicate higher priority messages.
86 */
87typedef int CORE_message_queue_Submit_types;
88
89/**
90 * @brief This handler shall allocate the message buffer storage area for a
91 *   message queue.
92 *
93 * The handler shall set the CORE_message_queue_Control::free_message_buffers
94 * member.
95 *
96 * @param[out] the_message_queue is the message queue control.
97 *
98 * @param size is the message buffer storage area size to allocate.
99 *
100 * @param arg is the handler argument.
101 *
102 * @retval NULL The allocation failed.
103 *
104 * @return Otherwise the pointer to the allocated message buffer storage area
105 *   begin shall be returned.
106 */
107typedef void *( *CORE_message_queue_Allocate_buffers )(
108  CORE_message_queue_Control *the_message_queue,
109  size_t                      size,
110  const void                 *arg
111);
112
113/**
114 * @brief This handler allocates the message buffer storage area for a message
115 *   queue from the RTEMS Workspace.
116 *
117 * The handler sets the CORE_message_queue_Control::free_message_buffers
118 * to _Workspace_Free().
119 *
120 * @param[out] the_message_queue is the message queue control.
121 *
122 * @param size is the message buffer storage area size to allocate.
123 *
124 * @param arg is the unused handler argument.
125 *
126 * @retval NULL The allocation failed.
127 *
128 * @return Otherwise the pointer to the allocated message buffer storage area
129 *   begin is returned.
130 */
131void *_CORE_message_queue_Workspace_allocate(
132  CORE_message_queue_Control *the_message_queue,
133  size_t                      size,
134  const void                 *arg
135);
136
137/**
138 * @brief Initializes a message queue.
139 *
140 * @param[out] the_message_queue is the message queue to initialize.
141 *
142 * @param discipline is the blocking discipline for the message queue.
143 *
144 * @param maximum_pending_messages is the maximum number of messages that will
145 *   be allowed to be pending at any given time.
146 *
147 * @param maximum_message_size is the size of the largest message that may be
148 *   sent to this message queue instance.
149 *
150 * @param allocate_buffers is the message buffer storage area allocation
151 *   handler.
152 *
153 * @param arg is the message buffer storage area allocation handler argument.
154 *
155 * @retval STATUS_SUCCESSFUL The message queue was initialized.
156 *
157 * @retval STATUS_MESSAGE_QUEUE_INVALID_SIZE Calculations with the maximum
158 *   pending messages or maximum message size produced an integer overflow.
159 *
160 * @retval STATUS_MESSAGE_QUEUE_NO_MEMORY The message buffer storage area
161 *   allocation failed.
162 */
163Status_Control _CORE_message_queue_Initialize(
164  CORE_message_queue_Control          *the_message_queue,
165  CORE_message_queue_Disciplines       discipline,
166  uint32_t                             maximum_pending_messages,
167  size_t                               maximum_message_size,
168  CORE_message_queue_Allocate_buffers  allocate_buffers,
169  const void                          *arg
170);
171
172/**
173 * @brief Closes a message queue.
174 *
175 * This package is the implementation of the CORE Message Queue Handler.
176 * This core object provides task synchronization and communication functions
177 * via messages passed to queue objects.
178 *
179 * This function closes a message by returning all allocated space and
180 * flushing @a the_message_queue's task wait queue.
181 *
182 * @param[in, out] the_message_queue The message queue to close.
183 * @param[in, out] queue_context The thread queue context used for
184 *   _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
185 */
186void _CORE_message_queue_Close(
187  CORE_message_queue_Control *the_message_queue,
188  Thread_queue_Context       *queue_context
189);
190
191/**
192 * @brief Flushes pending messages.
193 *
194 * This package is the implementation of the CORE Message Queue Handler.
195 * This core object provides task synchronization and communication functions
196 * via messages passed to queue objects.
197 *
198 * This function flushes @a the_message_queue's pending message queue.  The
199 * number of messages flushed from the queue is returned.
200 *
201 * @param[in, out] the_message_queue The message queue to flush.
202 * @param queue_context The thread queue context with interrupts disabled.
203 *
204 * @return This method returns the number of message pending messages flushed.
205 */
206uint32_t   _CORE_message_queue_Flush(
207  CORE_message_queue_Control *the_message_queue,
208  Thread_queue_Context       *queue_context
209);
210
211#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
212/**
213 * @brief Flushes waiting threads.
214 *
215 * This function flushes the threads which are blocked on
216 * @a the_message_queue's pending message queue.  They are
217 * unblocked whether blocked sending or receiving. It returns
218 * the number of messages flushed from the queue.
219 *
220 * @param[in, out] the_message_queue The message queue to flush.
221 *
222 * @return This method returns the number of messages flushed from the queue.
223 */
224  void _CORE_message_queue_Flush_waiting_threads(
225    CORE_message_queue_Control *the_message_queue
226  );
227#endif
228
229/**
230 * @brief Broadcasts a message to the message queue.
231 *
232 * This package is the implementation of the CORE Message Queue Handler.
233 * This core object provides task synchronization and communication functions
234 * via messages passed to queue objects.
235 *
236 * This function sends a message for every thread waiting on the queue and
237 * returns the number of threads made ready by the message.
238 *
239 * @param[in, out] the_message_queue The message queue to operate upon.
240 * @param buffer The starting address of the message to broadcast.
241 * @param size The size of the message being broadcast.
242 * @param[out] count The variable that will contain the
243 *        number of tasks that are sent this message.
244 * @param queue_context The thread queue context used for
245 *   _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
246 *
247 * @retval STATUS_SUCCESSFUL The message was successfully broadcast.
248 * @retval STATUS_MESSAGE_INVALID_SIZE The message size was too big.
249 */
250Status_Control _CORE_message_queue_Broadcast(
251  CORE_message_queue_Control *the_message_queue,
252  const void                 *buffer,
253  size_t                      size,
254  uint32_t                   *count,
255  Thread_queue_Context       *queue_context
256);
257
258/**
259 * @brief Submits a message to the message queue.
260 *
261 * This routine implements the send and urgent message functions. It
262 * processes a message that is to be submitted to the designated
263 * message queue.  The message will either be processed as a
264 * send message which it will be inserted at the rear of the queue
265 * or it will be processed as an urgent message which will be inserted
266 * at the front of the queue.
267 *
268 * @param[in, out] the_message_queue The message queue to operate upon.
269 * @param executing The executing thread.
270 * @param buffer The starting address of the message to send.
271 * @param size The size of the message being send.
272 * @param submit_type Determines whether the message is prepended,
273 *        appended, or enqueued in priority order.
274 * @param wait Indicates whether the calling thread is willing to block
275 *        if the message queue is full.
276 * @param queue_context The thread queue context used for
277 *   _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
278 *
279 * @retval STATUS_SUCCESSFUL The message was successfully submitted to the message queue.
280 * @retval STATUS_MESSAGE_INVALID_SIZE The message size was too big.
281 * @retval STATUS_TOO_MANY No message buffers were available.
282 * @retval STATUS_MESSAGE_QUEUE_WAIT_IN_ISR The caller is in an ISR, do not block!
283 * @retval STATUS_TIMEOUT A timeout occurred.
284 */
285Status_Control _CORE_message_queue_Submit(
286  CORE_message_queue_Control       *the_message_queue,
287  Thread_Control                   *executing,
288  const void                       *buffer,
289  size_t                            size,
290  CORE_message_queue_Submit_types   submit_type,
291  bool                              wait,
292  Thread_queue_Context             *queue_context
293);
294
295/**
296 * @brief Seizes a message from the message queue.
297 *
298 * This package is the implementation of the CORE Message Queue Handler.
299 * This core object provides task synchronization and communication functions
300 * via messages passed to queue objects.
301 *
302 * This kernel routine dequeues a message, copies the message buffer to
303 * a given destination buffer, and frees the message buffer to the
304 * inactive message pool.  The thread will be blocked if wait is true,
305 * otherwise an error will be given to the thread if no messages are available.
306 *
307 * @param[in, out] the_message_queue The message queue to seize a message from.
308 * @param executing The executing thread.
309 * @param[out] buffer The starting address of the message buffer to
310 *        to be filled in with a message.
311 * @param[out] size_p The size of the @a buffer,
312 *        indicates the maximum size message that the caller can receive.
313 * @param wait Indicates whether the calling thread is willing to block
314 *        if the message queue is empty.
315 * @param queue_context The thread queue context used for
316 *   _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
317 *
318 * @retval STATUS_SUCCESSFUL The message was successfully seized from the message queue.
319 * @retval STATUS_UNSATISFIED Wait was set to false and there is currently no pending message.
320 * @retval STATUS_TIMEOUT A timeout occurred.
321 *
322 * @note Returns message priority via return area in TCB.
323 *
324 * - INTERRUPT LATENCY:
325 *   + available
326 *   + wait
327 */
328Status_Control _CORE_message_queue_Seize(
329  CORE_message_queue_Control *the_message_queue,
330  Thread_Control             *executing,
331  void                       *buffer,
332  size_t                     *size_p,
333  bool                        wait,
334  Thread_queue_Context       *queue_context
335);
336
337/**
338 * @brief Inserts a message into the message queue.
339 *
340 * Copies the specified content into the message storage space and then
341 * inserts the message into the message queue according to the submit type.
342 *
343 * @param[in, out] the_message_queue The message queue to insert a message in.
344 * @param[in, out] the_message The message to insert in the message queue.
345 * @param content_source The message content source.
346 * @param content_size The message content size in bytes.
347 * @param submit_type Determines whether the message is prepended,
348 *        appended, or enqueued in priority order.
349 */
350void _CORE_message_queue_Insert_message(
351  CORE_message_queue_Control        *the_message_queue,
352  CORE_message_queue_Buffer         *the_message,
353  const void                        *content_source,
354  size_t                             content_size,
355  CORE_message_queue_Submit_types    submit_type
356);
357
358/**
359 * @brief Sends a message to the message queue.
360 *
361 * @param[in, out] the_message_queue The message queue to send a message to.
362 * @param buffer The starting address of the message to send.
363 * @param sizeis The size of the message being send.
364 * @param wait Indicates whether the calling thread is willing to block
365 *        if the message queue is full.
366 * @param queue_context The thread queue context used for
367 *   _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
368 *
369 * @retval STATUS_SUCCESSFUL The message was successfully submitted to the message queue.
370 * @retval STATUS_MESSAGE_INVALID_SIZE The message size was too big.
371 * @retval STATUS_TOO_MANY No message buffers were available.
372 * @retval STATUS_MESSAGE_QUEUE_WAIT_IN_ISR The caller is in an ISR, do not block!
373 * @retval STATUS_TIMEOUT A timeout occurred.
374 */
375static inline Status_Control _CORE_message_queue_Send(
376  CORE_message_queue_Control       *the_message_queue,
377  const void                       *buffer,
378  size_t                            size,
379  bool                              wait,
380  Thread_queue_Context             *queue_context
381)
382{
383  return _CORE_message_queue_Submit(
384    the_message_queue,
385    _Thread_Executing,
386    buffer,
387    size,
388    CORE_MESSAGE_QUEUE_SEND_REQUEST,
389    wait,
390    queue_context
391  );
392}
393
394/**
395 * @brief Sends an urgent message to the message queue.
396 *
397 * @param[in, out] the_message_queue The message queue to send an urgent message to.
398 * @param buffer The starting address of the message to send.
399 * @param sizeis The size of the message being send.
400 * @param wait Indicates whether the calling thread is willing to block
401 *        if the message queue is full.
402 * @param queue_context The thread queue context used for
403 *   _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
404 *
405 * @retval STATUS_SUCCESSFUL The message was successfully submitted to the message queue.
406 * @retval STATUS_MESSAGE_INVALID_SIZE The message size was too big.
407 * @retval STATUS_TOO_MANY No message buffers were available.
408 * @retval STATUS_MESSAGE_QUEUE_WAIT_IN_ISR The caller is in an ISR, do not block!
409 * @retval STATUS_TIMEOUT A timeout occurred.
410 */
411static inline Status_Control _CORE_message_queue_Urgent(
412  CORE_message_queue_Control       *the_message_queue,
413  const void                       *buffer,
414  size_t                            size,
415  bool                              wait,
416  Thread_queue_Context             *queue_context
417)
418{
419  return _CORE_message_queue_Submit(
420    the_message_queue,
421    _Thread_Executing,
422    buffer,
423    size,
424    CORE_MESSAGE_QUEUE_URGENT_REQUEST,
425    wait,
426    queue_context
427  );
428}
429
430/**
431 * @brief Acquires the message queue.
432 *
433 * @param[in, out] the_message_queue The message queue to acquire.
434 * @param queue_context The thread queue context.
435 */
436static inline void _CORE_message_queue_Acquire(
437  CORE_message_queue_Control *the_message_queue,
438  Thread_queue_Context       *queue_context
439)
440{
441  _Thread_queue_Acquire( &the_message_queue->Wait_queue, queue_context );
442}
443
444/**
445 * @brief Acquires the message queue critical.
446 *
447 * @param[in, out] the_message_queue The message queue to acquire critical.
448 * @param queue_context The thread queue context.
449 */
450static inline void _CORE_message_queue_Acquire_critical(
451  CORE_message_queue_Control *the_message_queue,
452  Thread_queue_Context       *queue_context
453)
454{
455  _Thread_queue_Acquire_critical( &the_message_queue->Wait_queue, queue_context );
456}
457
458/**
459 * @brief Releases the message queue.
460 *
461 * @param[in, out] the_message_queue The message queue to release.
462 * @param queue_context The thread queue context.
463 */
464static inline void _CORE_message_queue_Release(
465  CORE_message_queue_Control *the_message_queue,
466  Thread_queue_Context       *queue_context
467)
468{
469  _Thread_queue_Release( &the_message_queue->Wait_queue, queue_context );
470}
471
472/**
473 * @brief Copies the source message buffer to the destination message buffer.
474 *
475 * This routine copies the contents of the source message buffer
476 * to the destination message buffer.
477 *
478 * @param source The source message buffer to be copied.
479 * @param[out] destination The destination messag buffer to copy the source to.
480 * @param size The size of the source buffer.
481 */
482static inline void _CORE_message_queue_Copy_buffer (
483  const void *source,
484  void       *destination,
485  size_t      size
486)
487{
488  memcpy(destination, source, size);
489}
490
491/**
492 * @brief Allocates a message buffer from the inactive message buffer chain.
493 *
494 * This function allocates a message buffer from the inactive
495 * message buffer chain.
496 *
497 * @param the_message_queue The message queue to operate upon.
498 *
499 * @retval pointer The allocated message buffer.
500 * @retval NULL The inactive message buffer chain is empty.
501 */
502static inline CORE_message_queue_Buffer *
503_CORE_message_queue_Allocate_message_buffer (
504    CORE_message_queue_Control *the_message_queue
505)
506{
507   return (CORE_message_queue_Buffer *)
508     _Chain_Get_unprotected( &the_message_queue->Inactive_messages );
509}
510
511/**
512 * @brief Frees a message buffer to inactive message buffer chain.
513 *
514 * This routine frees a message buffer to the inactive
515 * message buffer chain.
516 *
517 * @param[in, out] the_message_queue The message queue to free the message buffer to.
518 * @param[out] the_message The message to be freed.
519 */
520static inline void _CORE_message_queue_Free_message_buffer (
521  CORE_message_queue_Control *the_message_queue,
522  CORE_message_queue_Buffer  *the_message
523)
524{
525  _Chain_Append_unprotected( &the_message_queue->Inactive_messages, &the_message->Node );
526}
527
528/**
529 * @brief Gets message priority.
530 *
531 * This function returns the priority of @a the_message.
532 *
533 * @param the_message The message to obtain the priority from.
534 *
535 * @retval priority The priority of this message.
536 * @retval 0 Message priority is disabled.
537 *
538 * @note It encapsulates the optional behavior that message priority is
539 *       disabled if no API requires it.
540 */
541static inline int _CORE_message_queue_Get_message_priority (
542  const CORE_message_queue_Buffer *the_message
543)
544{
545  #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
546    return the_message->priority;
547  #else
548    return 0;
549  #endif
550}
551
552/**
553 * @brief Gets first message of message queue and removes it.
554 *
555 * This function removes the first message from the_message_queue
556 * and returns a pointer to it.
557 *
558 * @param[in, out] the_message_queue The message queue to get the first message from.
559 *
560 * @retval pointer The first message if the message queue is not empty.
561 * @retval NULL The message queue is empty.
562 */
563static inline
564  CORE_message_queue_Buffer *_CORE_message_queue_Get_pending_message (
565  CORE_message_queue_Control *the_message_queue
566)
567{
568  return (CORE_message_queue_Buffer *)
569    _Chain_Get_unprotected( &the_message_queue->Pending_messages );
570}
571
572#if defined(RTEMS_SCORE_COREMSG_ENABLE_NOTIFICATION)
573  /**
574   * @brief Checks if notification is enabled.
575   *
576   * This function returns true if notification is enabled on this message
577   * queue and false otherwise.
578   *
579   * @param the_message_queue The message queue to check if the notification is enabled.
580   *
581   * @retval true Notification is enabled on this message queue.
582   * @retval false Notification is not enabled on this message queue.
583   */
584  static inline bool _CORE_message_queue_Is_notify_enabled (
585    CORE_message_queue_Control *the_message_queue
586  )
587  {
588    return (the_message_queue->notify_handler != NULL);
589  }
590#endif
591
592/**
593 * @brief Initializes notification information.
594 *
595 * This routine initializes the notification information for
596 * @a the_message_queue.
597 *
598 * @param[out] the_message_queue The message queue to initialize the notification information.
599 * @param[out] the_handler The notification information for the message queue.
600 */
601#if defined(RTEMS_SCORE_COREMSG_ENABLE_NOTIFICATION)
602  static inline void _CORE_message_queue_Set_notify (
603    CORE_message_queue_Control        *the_message_queue,
604    CORE_message_queue_Notify_Handler  the_handler
605  )
606  {
607    the_message_queue->notify_handler = the_handler;
608  }
609#else
610  /* turn it into nothing if not enabled */
611  #define _CORE_message_queue_Set_notify( the_message_queue, the_handler ) \
612    do { } while ( 0 )
613#endif
614
615/**
616 * @brief Gets the first locked thread waiting to receive and dequeues it.
617 *
618 * This method dequeues the first locked thread waiting to receive a message,
619 *      dequeues it and returns the corresponding Thread_Control.
620 *
621 * @param[in, out] the_message_queue The message queue to operate upon.
622 * @param buffer The buffer that is copied to the threads mutable_object.
623 * @param size The size of the buffer.
624 * @param submit_type Indicates whether the thread should be willing to block in the future.
625 * @param queue_context The thread queue context.
626 *
627 * @retval thread The Thread_Control for the first locked thread, if there is a locked thread.
628 * @retval NULL There are pending messages or no thread waiting to receive.
629 */
630static inline Thread_Control *_CORE_message_queue_Dequeue_receiver(
631  CORE_message_queue_Control      *the_message_queue,
632  const void                      *buffer,
633  size_t                           size,
634  CORE_message_queue_Submit_types  submit_type,
635  Thread_queue_Context            *queue_context
636)
637{
638  Thread_queue_Heads *heads;
639  Thread_Control     *the_thread;
640
641  /*
642   *  If there are pending messages, then there can't be threads
643   *  waiting for us to send them a message.
644   *
645   *  NOTE: This check is critical because threads can block on
646   *        send and receive and this ensures that we are broadcasting
647   *        the message to threads waiting to receive -- not to send.
648   */
649  if ( the_message_queue->number_of_pending_messages != 0 ) {
650    return NULL;
651  }
652
653  /*
654   *  There must be no pending messages if there is a thread waiting to
655   *  receive a message.
656   */
657  heads = the_message_queue->Wait_queue.Queue.heads;
658  if ( heads == NULL ) {
659    return NULL;
660  }
661
662  the_thread = ( *the_message_queue->operations->surrender )(
663    &the_message_queue->Wait_queue.Queue,
664    heads,
665    NULL,
666    queue_context
667  );
668
669   *(size_t *) the_thread->Wait.return_argument = size;
670   the_thread->Wait.count = (uint32_t) submit_type;
671
672  _CORE_message_queue_Copy_buffer(
673    buffer,
674    the_thread->Wait.return_argument_second.mutable_object,
675    size
676  );
677
678  _Thread_queue_Resume(
679    &the_message_queue->Wait_queue.Queue,
680    the_thread,
681    queue_context
682  );
683
684  return the_thread;
685}
686
687/** @} */
688
689#ifdef __cplusplus
690}
691#endif
692
693#endif
694/* end of include file */
Note: See TracBrowser for help on using the repository browser.