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

Last change on this file since ca4602e was ca4602e, checked in by Sebastian Huber <sebastian.huber@…>, on Jan 25, 2016 at 9:03:00 PM

Use linker set for libio initialization

Update #2408.

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