source: rtems/testsuites/sptests/spsysinit01/init.c @ bc5b56a

Last change on this file since bc5b56a was bc5b56a, checked in by Sebastian Huber <sebastian.huber@…>, on Dec 4, 2017 at 7:56:00 AM

libio: Use API mutex

  • Property mode set to 100644
File size: 14.6 KB
Line 
1/*
2 * Copyright (c) 2015, 2016 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * The license and distribution terms for this file may be
11 * found in the file LICENSE in this distribution or at
12 * http://www.rtems.com/license/LICENSE.
13 */
14
15#ifdef HAVE_CONFIG_H
16  #include "config.h"
17#endif
18
19#include "tmacros.h"
20
21#include <sys/types.h>
22#include <sys/stat.h>
23
24#include <assert.h>
25#include <pthread.h>
26#include <string.h>
27#include <stdlib.h>
28#include <unistd.h>
29
30#include <rtems.h>
31#include <rtems/ioimpl.h>
32#include <rtems/libio_.h>
33#include <rtems/sysinit.h>
34
35#include <rtems/extensionimpl.h>
36#ifdef RTEMS_POSIX_API
37#include <rtems/posix/barrierimpl.h>
38#include <rtems/posix/mqueueimpl.h>
39#include <rtems/posix/muteximpl.h>
40#include <rtems/posix/psignalimpl.h>
41#include <rtems/posix/pthreadimpl.h>
42#include <rtems/posix/rwlockimpl.h>
43#include <rtems/posix/semaphoreimpl.h>
44#include <rtems/posix/shmimpl.h>
45#include <rtems/posix/timerimpl.h>
46#endif /* RTEMS_POSIX_API */
47#include <rtems/posix/keyimpl.h>
48#include <rtems/rtems/barrierimpl.h>
49#include <rtems/rtems/dpmemimpl.h>
50#include <rtems/rtems/messageimpl.h>
51#include <rtems/rtems/partimpl.h>
52#include <rtems/rtems/ratemonimpl.h>
53#include <rtems/rtems/regionimpl.h>
54#include <rtems/rtems/semimpl.h>
55#include <rtems/rtems/tasksimpl.h>
56#include <rtems/rtems/timerimpl.h>
57#include <rtems/score/apimutex.h>
58#include <rtems/score/chainimpl.h>
59#include <rtems/score/sysstate.h>
60#include <rtems/score/userextimpl.h>
61#include <rtems/score/wkspace.h>
62
63const char rtems_test_name[] = "SPSYSINIT 1";
64
65typedef enum {
66  BSP_WORK_AREAS_PRE,
67  BSP_WORK_AREAS_POST,
68  BSP_START_PRE,
69  BSP_START_POST,
70  INITIAL_EXTENSIONS_PRE,
71  INITIAL_EXTENSIONS_POST,
72  DATA_STRUCTURES_PRE,
73  DATA_STRUCTURES_POST,
74  USER_EXTENSIONS_PRE,
75  USER_EXTENSIONS_POST,
76  CLASSIC_TASKS_PRE,
77  CLASSIC_TASKS_POST,
78  CLASSIC_TIMER_PRE,
79  CLASSIC_TIMER_POST,
80  CLASSIC_SIGNAL_PRE,
81  CLASSIC_SIGNAL_POST,
82  CLASSIC_EVENT_PRE,
83  CLASSIC_EVENT_POST,
84  CLASSIC_MESSAGE_QUEUE_PRE,
85  CLASSIC_MESSAGE_QUEUE_POST,
86  CLASSIC_SEMAPHORE_PRE,
87  CLASSIC_SEMAPHORE_POST,
88  CLASSIC_PARTITION_PRE,
89  CLASSIC_PARTITION_POST,
90  CLASSIC_REGION_PRE,
91  CLASSIC_REGION_POST,
92  CLASSIC_DUAL_PORTED_MEMORY_PRE,
93  CLASSIC_DUAL_PORTED_MEMORY_POST,
94  CLASSIC_RATE_MONOTONIC_PRE,
95  CLASSIC_RATE_MONOTONIC_POST,
96  CLASSIC_BARRIER_PRE,
97  CLASSIC_BARRIER_POST,
98#ifdef RTEMS_POSIX_API
99  POSIX_SIGNALS_PRE,
100  POSIX_SIGNALS_POST,
101  POSIX_THREADS_PRE,
102  POSIX_THREADS_POST,
103  POSIX_MESSAGE_QUEUE_PRE,
104  POSIX_MESSAGE_QUEUE_POST,
105  POSIX_SEMAPHORE_PRE,
106  POSIX_SEMAPHORE_POST,
107  POSIX_TIMER_PRE,
108  POSIX_TIMER_POST,
109  POSIX_SHM_PRE,
110  POSIX_SHM_POST,
111#endif /* RTEMS_POSIX_API */
112  POSIX_KEYS_PRE,
113  POSIX_KEYS_POST,
114#ifdef RTEMS_POSIX_API
115  POSIX_CLEANUP_PRE,
116  POSIX_CLEANUP_POST,
117#endif /* RTEMS_POSIX_API */
118  IDLE_THREADS_PRE,
119  IDLE_THREADS_POST,
120  LIBIO_PRE,
121  LIBIO_POST,
122  ROOT_FILESYSTEM_PRE,
123  ROOT_FILESYSTEM_POST,
124  BSP_PRE_DRIVERS_PRE,
125  BSP_PRE_DRIVERS_POST,
126  DEVICE_DRIVERS_PRE,
127  DEVICE_DRIVERS_POST,
128  CLASSIC_USER_TASKS_PRE,
129  CLASSIC_USER_TASKS_POST,
130#ifdef RTEMS_POSIX_API
131  POSIX_USER_THREADS_PRE,
132  POSIX_USER_THREADS_POST,
133#endif /* RTEMS_POSIX_API */
134  STD_FILE_DESCRIPTORS_PRE,
135  STD_FILE_DESCRIPTORS_POST,
136  LAST_FIRST,
137  LAST_SECOND,
138  LAST_THIRD,
139  LAST_FOURTH,
140  LAST_FIFTH,
141  LAST_SIXTH,
142  LAST_SEVENTH,
143  LAST_EIGHTH,
144  LAST_NINETH,
145  LAST_TENTH,
146  LAST_MIDDLE,
147  LAST_LAST,
148  INIT_TASK,
149  DONE
150} init_step;
151
152#define FIRST(x) \
153  static void x##_first(void); \
154  RTEMS_SYSINIT_ITEM( \
155    x##_first, \
156    x, \
157    RTEMS_SYSINIT_ORDER_FIRST \
158  ); \
159  static void x##_first(void)
160
161#define LAST(x) \
162  static void x##_last(void); \
163  RTEMS_SYSINIT_ITEM( \
164    x##_last, \
165    x, \
166    RTEMS_SYSINIT_ORDER_LAST \
167  ); \
168  static void x##_last(void)
169
170#define LAST_STEP(x) \
171  static void last_##x(void) \
172  { \
173    next_step(LAST_##x); \
174  } \
175  RTEMS_SYSINIT_ITEM( \
176    last_##x, \
177    RTEMS_SYSINIT_LAST, \
178    RTEMS_SYSINIT_ORDER_##x \
179  )
180
181static init_step step;
182
183static void next_step(init_step expected)
184{
185  assert(step == expected);
186  step = expected + 1;
187}
188
189FIRST(RTEMS_SYSINIT_BSP_WORK_AREAS)
190{
191  assert(_Workspace_Area.area_begin == 0);
192  next_step(BSP_WORK_AREAS_PRE);
193}
194
195LAST(RTEMS_SYSINIT_BSP_WORK_AREAS)
196{
197  assert(_Workspace_Area.area_begin != 0);
198  next_step(BSP_WORK_AREAS_POST);
199}
200
201FIRST(RTEMS_SYSINIT_BSP_START)
202{
203  /*
204   * Since the work performed here is BSP-specific, there is no way to test pre
205   * and post conditions.
206   */
207  next_step(BSP_START_PRE);
208}
209
210LAST(RTEMS_SYSINIT_BSP_START)
211{
212  /*
213   * Some BSPs initialize the printk() support in bsp_start().  So, print begin
214   * of test after bsp_start().
215   */
216  TEST_BEGIN();
217
218  next_step(BSP_START_POST);
219}
220
221FIRST(RTEMS_SYSINIT_INITIAL_EXTENSIONS)
222{
223  assert(_Chain_Is_empty(&_User_extensions_Switches_list));
224  next_step(INITIAL_EXTENSIONS_PRE);
225}
226
227LAST(RTEMS_SYSINIT_INITIAL_EXTENSIONS)
228{
229  assert(!_Chain_Is_empty(&_User_extensions_Switches_list));
230  next_step(INITIAL_EXTENSIONS_POST);
231}
232
233FIRST(RTEMS_SYSINIT_DATA_STRUCTURES)
234{
235  assert(_Thread_Internal_information.Objects.maximum == 0);
236  next_step(DATA_STRUCTURES_PRE);
237}
238
239LAST(RTEMS_SYSINIT_DATA_STRUCTURES)
240{
241  assert(_Thread_Internal_information.Objects.maximum != 0);
242  next_step(DATA_STRUCTURES_POST);
243}
244
245FIRST(RTEMS_SYSINIT_USER_EXTENSIONS)
246{
247  assert(_Extension_Information.maximum == 0);
248  next_step(USER_EXTENSIONS_PRE);
249}
250
251LAST(RTEMS_SYSINIT_USER_EXTENSIONS)
252{
253  assert(_Extension_Information.maximum != 0);
254  next_step(USER_EXTENSIONS_POST);
255}
256
257FIRST(RTEMS_SYSINIT_CLASSIC_TASKS)
258{
259  assert(_RTEMS_tasks_Information.Objects.maximum == 0);
260  next_step(CLASSIC_TASKS_PRE);
261}
262
263LAST(RTEMS_SYSINIT_CLASSIC_TASKS)
264{
265  assert(_RTEMS_tasks_Information.Objects.maximum != 0);
266  next_step(CLASSIC_TASKS_POST);
267}
268
269FIRST(RTEMS_SYSINIT_CLASSIC_TIMER)
270{
271  assert(_Timer_Information.maximum == 0);
272  next_step(CLASSIC_TIMER_PRE);
273}
274
275LAST(RTEMS_SYSINIT_CLASSIC_TIMER)
276{
277  assert(_Timer_Information.maximum != 0);
278  next_step(CLASSIC_TIMER_POST);
279}
280
281FIRST(RTEMS_SYSINIT_CLASSIC_SIGNAL)
282{
283  /* There is nothing to do in case RTEMS_MULTIPROCESSING is not defined */
284  next_step(CLASSIC_SIGNAL_PRE);
285}
286
287LAST(RTEMS_SYSINIT_CLASSIC_SIGNAL)
288{
289  next_step(CLASSIC_SIGNAL_POST);
290}
291
292FIRST(RTEMS_SYSINIT_CLASSIC_EVENT)
293{
294  /* There is nothing to do in case RTEMS_MULTIPROCESSING is not defined */
295  next_step(CLASSIC_EVENT_PRE);
296}
297
298LAST(RTEMS_SYSINIT_CLASSIC_EVENT)
299{
300  next_step(CLASSIC_EVENT_POST);
301}
302
303FIRST(RTEMS_SYSINIT_CLASSIC_MESSAGE_QUEUE)
304{
305  assert(_Message_queue_Information.maximum == 0);
306  next_step(CLASSIC_MESSAGE_QUEUE_PRE);
307}
308
309LAST(RTEMS_SYSINIT_CLASSIC_MESSAGE_QUEUE)
310{
311  assert(_Message_queue_Information.maximum != 0);
312  next_step(CLASSIC_MESSAGE_QUEUE_POST);
313}
314
315FIRST(RTEMS_SYSINIT_CLASSIC_SEMAPHORE)
316{
317  assert(_Semaphore_Information.maximum == 0);
318  next_step(CLASSIC_SEMAPHORE_PRE);
319}
320
321LAST(RTEMS_SYSINIT_CLASSIC_SEMAPHORE)
322{
323  assert(_Semaphore_Information.maximum != 0);
324  next_step(CLASSIC_SEMAPHORE_POST);
325}
326
327FIRST(RTEMS_SYSINIT_CLASSIC_PARTITION)
328{
329  assert(_Partition_Information.maximum == 0);
330  next_step(CLASSIC_PARTITION_PRE);
331}
332
333LAST(RTEMS_SYSINIT_CLASSIC_PARTITION)
334{
335  assert(_Partition_Information.maximum != 0);
336  next_step(CLASSIC_PARTITION_POST);
337}
338
339FIRST(RTEMS_SYSINIT_CLASSIC_REGION)
340{
341  assert(_Region_Information.maximum == 0);
342  next_step(CLASSIC_REGION_PRE);
343}
344
345LAST(RTEMS_SYSINIT_CLASSIC_REGION)
346{
347  assert(_Region_Information.maximum != 0);
348  next_step(CLASSIC_REGION_POST);
349}
350
351FIRST(RTEMS_SYSINIT_CLASSIC_DUAL_PORTED_MEMORY)
352{
353  assert(_Dual_ported_memory_Information.maximum == 0);
354  next_step(CLASSIC_DUAL_PORTED_MEMORY_PRE);
355}
356
357LAST(RTEMS_SYSINIT_CLASSIC_DUAL_PORTED_MEMORY)
358{
359  assert(_Dual_ported_memory_Information.maximum != 0);
360  next_step(CLASSIC_DUAL_PORTED_MEMORY_POST);
361}
362
363FIRST(RTEMS_SYSINIT_CLASSIC_RATE_MONOTONIC)
364{
365  assert(_Rate_monotonic_Information.maximum == 0);
366  next_step(CLASSIC_RATE_MONOTONIC_PRE);
367}
368
369LAST(RTEMS_SYSINIT_CLASSIC_RATE_MONOTONIC)
370{
371  assert(_Rate_monotonic_Information.maximum != 0);
372  next_step(CLASSIC_RATE_MONOTONIC_POST);
373}
374
375FIRST(RTEMS_SYSINIT_CLASSIC_BARRIER)
376{
377  assert(_Barrier_Information.maximum == 0);
378  next_step(CLASSIC_BARRIER_PRE);
379}
380
381LAST(RTEMS_SYSINIT_CLASSIC_BARRIER)
382{
383  assert(_Barrier_Information.maximum != 0);
384  next_step(CLASSIC_BARRIER_POST);
385}
386
387#ifdef RTEMS_POSIX_API
388
389FIRST(RTEMS_SYSINIT_POSIX_SIGNALS)
390{
391  assert(
392    memcmp(
393      &_POSIX_signals_Vectors,
394      _POSIX_signals_Default_vectors,
395      sizeof(_POSIX_signals_Vectors)
396    ) != 0
397  );
398  next_step(POSIX_SIGNALS_PRE);
399}
400
401LAST(RTEMS_SYSINIT_POSIX_SIGNALS)
402{
403  assert(
404    memcmp(
405      &_POSIX_signals_Vectors,
406      _POSIX_signals_Default_vectors,
407      sizeof(_POSIX_signals_Vectors)
408    ) == 0
409  );
410  next_step(POSIX_SIGNALS_POST);
411}
412
413FIRST(RTEMS_SYSINIT_POSIX_THREADS)
414{
415  assert(_POSIX_Threads_Information.Objects.maximum == 0);
416  next_step(POSIX_THREADS_PRE);
417}
418
419LAST(RTEMS_SYSINIT_POSIX_THREADS)
420{
421  assert(_POSIX_Threads_Information.Objects.maximum != 0);
422  next_step(POSIX_THREADS_POST);
423}
424
425FIRST(RTEMS_SYSINIT_POSIX_MESSAGE_QUEUE)
426{
427  assert(_POSIX_Message_queue_Information.maximum == 0);
428  next_step(POSIX_MESSAGE_QUEUE_PRE);
429}
430
431LAST(RTEMS_SYSINIT_POSIX_MESSAGE_QUEUE)
432{
433  assert(_POSIX_Message_queue_Information.maximum != 0);
434  next_step(POSIX_MESSAGE_QUEUE_POST);
435}
436
437FIRST(RTEMS_SYSINIT_POSIX_SEMAPHORE)
438{
439  assert(_POSIX_Semaphore_Information.maximum == 0);
440  next_step(POSIX_SEMAPHORE_PRE);
441}
442
443LAST(RTEMS_SYSINIT_POSIX_SEMAPHORE)
444{
445  assert(_POSIX_Semaphore_Information.maximum != 0);
446  next_step(POSIX_SEMAPHORE_POST);
447}
448
449FIRST(RTEMS_SYSINIT_POSIX_TIMER)
450{
451  assert(_POSIX_Timer_Information.maximum == 0);
452  next_step(POSIX_TIMER_PRE);
453}
454
455LAST(RTEMS_SYSINIT_POSIX_TIMER)
456{
457  assert(_POSIX_Timer_Information.maximum != 0);
458  next_step(POSIX_TIMER_POST);
459}
460
461FIRST(RTEMS_SYSINIT_POSIX_SHM)
462{
463  assert(_POSIX_Shm_Information.maximum == 0);
464  next_step(POSIX_SHM_PRE);
465}
466
467LAST(RTEMS_SYSINIT_POSIX_SHM)
468{
469  assert(_POSIX_Shm_Information.maximum != 0);
470  next_step(POSIX_SHM_POST);
471}
472
473static size_t user_extensions_pre_posix_cleanup;
474
475FIRST(RTEMS_SYSINIT_POSIX_CLEANUP)
476{
477  user_extensions_pre_posix_cleanup =
478    _Chain_Node_count_unprotected(&_User_extensions_List.Active);
479  next_step(POSIX_CLEANUP_PRE);
480}
481
482LAST(RTEMS_SYSINIT_POSIX_CLEANUP)
483{
484  assert(
485    user_extensions_pre_posix_cleanup + 1 ==
486      _Chain_Node_count_unprotected(&_User_extensions_List.Active)
487  );
488  next_step(POSIX_CLEANUP_POST);
489}
490
491#endif /* RTEMS_POSIX_API */
492
493FIRST(RTEMS_SYSINIT_POSIX_KEYS)
494{
495  assert(_POSIX_Keys_Information.maximum == 0);
496  next_step(POSIX_KEYS_PRE);
497}
498
499LAST(RTEMS_SYSINIT_POSIX_KEYS)
500{
501  assert(_POSIX_Keys_Information.maximum != 0);
502  next_step(POSIX_KEYS_POST);
503}
504
505FIRST(RTEMS_SYSINIT_IDLE_THREADS)
506{
507  assert(_System_state_Is_before_initialization(_System_state_Get()));
508  next_step(IDLE_THREADS_PRE);
509}
510
511LAST(RTEMS_SYSINIT_IDLE_THREADS)
512{
513  assert(_System_state_Is_before_multitasking(_System_state_Get()));
514  next_step(IDLE_THREADS_POST);
515}
516
517FIRST(RTEMS_SYSINIT_LIBIO)
518{
519  assert(rtems_libio_iop_free_head == NULL);
520  next_step(LIBIO_PRE);
521}
522
523LAST(RTEMS_SYSINIT_LIBIO)
524{
525  assert(rtems_libio_iop_free_head == &rtems_libio_iops[0]);
526  next_step(LIBIO_POST);
527}
528
529FIRST(RTEMS_SYSINIT_ROOT_FILESYSTEM)
530{
531  struct stat st;
532  int rv;
533
534  rv = stat("/", &st);
535  assert(rv == -1);
536  next_step(ROOT_FILESYSTEM_PRE);
537}
538
539LAST(RTEMS_SYSINIT_ROOT_FILESYSTEM)
540{
541  struct stat st;
542  int rv;
543
544  rv = stat("/", &st);
545  assert(rv == 0);
546  next_step(ROOT_FILESYSTEM_POST);
547}
548
549FIRST(RTEMS_SYSINIT_BSP_PRE_DRIVERS)
550{
551  /*
552   * Since the work performed here is BSP-specific, there is no way to test pre
553   * and post conditions.
554   */
555  next_step(BSP_PRE_DRIVERS_PRE);
556}
557
558LAST(RTEMS_SYSINIT_BSP_PRE_DRIVERS)
559{
560  next_step(BSP_PRE_DRIVERS_POST);
561}
562
563FIRST(RTEMS_SYSINIT_DEVICE_DRIVERS)
564{
565  assert(!_IO_All_drivers_initialized);
566  next_step(DEVICE_DRIVERS_PRE);
567}
568
569LAST(RTEMS_SYSINIT_DEVICE_DRIVERS)
570{
571  assert(_IO_All_drivers_initialized);
572  next_step(DEVICE_DRIVERS_POST);
573}
574
575FIRST(RTEMS_SYSINIT_CLASSIC_USER_TASKS)
576{
577  _Objects_Allocator_lock();
578  assert(_Objects_Active_count(&_RTEMS_tasks_Information.Objects) == 0);
579  _Objects_Allocator_unlock();
580  next_step(CLASSIC_USER_TASKS_PRE);
581}
582
583LAST(RTEMS_SYSINIT_CLASSIC_USER_TASKS)
584{
585  _Objects_Allocator_lock();
586  assert(_Objects_Active_count(&_RTEMS_tasks_Information.Objects) == 1);
587  _Objects_Allocator_unlock();
588  next_step(CLASSIC_USER_TASKS_POST);
589}
590
591#ifdef RTEMS_POSIX_API
592
593FIRST(RTEMS_SYSINIT_POSIX_USER_THREADS)
594{
595  _Objects_Allocator_lock();
596  assert(_Objects_Active_count(&_POSIX_Threads_Information.Objects) == 0);
597  _Objects_Allocator_unlock();
598  next_step(POSIX_USER_THREADS_PRE);
599}
600
601LAST(RTEMS_SYSINIT_POSIX_USER_THREADS)
602{
603  _Objects_Allocator_lock();
604  assert(_Objects_Active_count(&_POSIX_Threads_Information.Objects) == 1);
605  _Objects_Allocator_unlock();
606  next_step(POSIX_USER_THREADS_POST);
607}
608
609#endif /* RTEMS_POSIX_API */
610
611FIRST(RTEMS_SYSINIT_STD_FILE_DESCRIPTORS)
612{
613  struct stat st;
614  int rv;
615
616  rv = fstat(0, &st);
617  assert(rv == -1);
618  next_step(STD_FILE_DESCRIPTORS_PRE);
619}
620
621LAST(RTEMS_SYSINIT_STD_FILE_DESCRIPTORS)
622{
623  struct stat st;
624  int rv;
625
626  rv = fstat(0, &st);
627  assert(rv == 0);
628  next_step(STD_FILE_DESCRIPTORS_POST);
629}
630
631LAST_STEP(FIRST);
632LAST_STEP(SECOND);
633LAST_STEP(THIRD);
634LAST_STEP(FOURTH);
635LAST_STEP(FIFTH);
636LAST_STEP(SIXTH);
637LAST_STEP(SEVENTH);
638LAST_STEP(EIGHTH);
639LAST_STEP(NINETH);
640LAST_STEP(TENTH);
641LAST_STEP(MIDDLE);
642LAST_STEP(LAST);
643
644static void Init(rtems_task_argument arg)
645{
646#ifdef RTEMS_POSIX_API
647  pthread_cleanup_push(NULL, NULL);
648  pthread_cleanup_pop(0);
649#endif /* RTEMS_POSIX_API */
650  next_step(INIT_TASK);
651  TEST_END();
652  exit(0);
653}
654
655#ifdef RTEMS_POSIX_API
656
657static void *POSIX_Init(void *arg)
658{
659  return NULL;
660}
661
662#endif /* RTEMS_POSIX_API */
663
664#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
665#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
666
667#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1
668
669#define CONFIGURE_MAXIMUM_BARRIERS 1
670
671#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 1
672
673#define CONFIGURE_MAXIMUM_PARTITIONS 1
674
675#define CONFIGURE_MAXIMUM_PERIODS 1
676
677#define CONFIGURE_MAXIMUM_PORTS 1
678
679#define CONFIGURE_MAXIMUM_REGIONS 1
680
681#define CONFIGURE_MAXIMUM_SEMAPHORES 1
682
683#define CONFIGURE_MAXIMUM_TASKS 1
684
685#define CONFIGURE_MAXIMUM_TIMERS 1
686
687#ifdef RTEMS_POSIX_API
688
689#define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES 1
690
691
692#define CONFIGURE_MAXIMUM_POSIX_SEMAPHORES 1
693
694#define CONFIGURE_MAXIMUM_POSIX_SHMS 1
695
696#define CONFIGURE_MAXIMUM_POSIX_TIMERS 1
697
698#define CONFIGURE_MAXIMUM_POSIX_THREADS 1
699
700#define CONFIGURE_POSIX_INIT_THREAD_TABLE
701
702#endif /* RTEMS_POSIX_API */
703
704#define CONFIGURE_MAXIMUM_POSIX_KEYS 1
705
706#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
707
708#define CONFIGURE_STACK_CHECKER_ENABLED
709
710#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
711
712#define CONFIGURE_INIT
713
714#include <rtems/confdefs.h>
Note: See TracBrowser for help on using the repository browser.