source: rtems/testsuites/sptests/spsysinit01/init.c @ 6f6da82c

5
Last change on this file since 6f6da82c was 6f6da82c, checked in by Sebastian Huber <sebastian.huber@…>, on 01/26/17 at 10:06:50

score: Fix user extensions order

Use forward and reverse order for initial and dynamic extensions. This
is the behaviour documented in the C Users Guide. Change thread
terminate order to backward to be in line with the thread delete order.
Change fatal error order to forward to ensure that initial extensions
are called first due the peculiar execution context of fatal error
extensions, see _Terminate() documentation.

Update #2692.

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