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

Last change on this file was bcef89f2, checked in by Sebastian Huber <sebastian.huber@…>, on 05/19/23 at 06:18:25

Update company name

The embedded brains GmbH & Co. KG is the legal successor of embedded
brains GmbH.
  • Property mode set to 100644
File size: 21.9 KB
Line 
1/*
2 * Copyright (C) 2015, 2020 embedded brains GmbH & Co. KG
3 *
4 * The license and distribution terms for this file may be
5 * found in the file LICENSE in this distribution or at
6 * http://www.rtems.com/license/LICENSE.
7 */
8
9#ifdef HAVE_CONFIG_H
10#include "config.h"
11#endif
12
13#include "tmacros.h"
14
15#include <sys/types.h>
16#include <sys/mman.h>
17#include <sys/stat.h>
18
19#include <assert.h>
20#include <fcntl.h>
21#include <mqueue.h>
22#include <pthread.h>
23#include <semaphore.h>
24#include <signal.h>
25#include <stdlib.h>
26#include <string.h>
27#include <time.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#include <rtems/posix/barrierimpl.h>
37#include <rtems/posix/mqueueimpl.h>
38#include <rtems/posix/muteximpl.h>
39#ifdef RTEMS_POSIX_API
40#include <rtems/posix/psignalimpl.h>
41#endif /* RTEMS_POSIX_API */
42#include <rtems/posix/pthreadimpl.h>
43#include <rtems/posix/rwlockimpl.h>
44#include <rtems/posix/semaphoreimpl.h>
45#include <rtems/posix/shmimpl.h>
46#ifdef RTEMS_POSIX_API
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  WORKSPACE_PRE,
69  WORKSPACE_POST,
70  BSP_START_PRE,
71  BSP_START_POST,
72  CPU_COUNTER_PRE,
73  CPU_COUNTER_POST,
74  TARGET_HASH_PRE,
75  TARGET_HASH_POST,
76  INITIAL_EXTENSIONS_PRE,
77  INITIAL_EXTENSIONS_POST,
78  DATA_STRUCTURES_PRE,
79  DATA_STRUCTURES_POST,
80  USER_EXTENSIONS_PRE,
81  USER_EXTENSIONS_POST,
82  CLASSIC_TASKS_PRE,
83  CLASSIC_TASKS_POST,
84  CLASSIC_TIMER_PRE,
85  CLASSIC_TIMER_POST,
86  CLASSIC_MESSAGE_QUEUE_PRE,
87  CLASSIC_MESSAGE_QUEUE_POST,
88  CLASSIC_SEMAPHORE_PRE,
89  CLASSIC_SEMAPHORE_POST,
90  CLASSIC_PARTITION_PRE,
91  CLASSIC_PARTITION_POST,
92  CLASSIC_REGION_PRE,
93  CLASSIC_REGION_POST,
94  CLASSIC_DUAL_PORTED_MEMORY_PRE,
95  CLASSIC_DUAL_PORTED_MEMORY_POST,
96  CLASSIC_RATE_MONOTONIC_PRE,
97  CLASSIC_RATE_MONOTONIC_POST,
98  CLASSIC_BARRIER_PRE,
99  CLASSIC_BARRIER_POST,
100#ifdef RTEMS_POSIX_API
101  POSIX_SIGNALS_PRE,
102  POSIX_SIGNALS_POST,
103#endif /* RTEMS_POSIX_API */
104  POSIX_THREADS_PRE,
105  POSIX_THREADS_POST,
106  POSIX_MESSAGE_QUEUE_PRE,
107  POSIX_MESSAGE_QUEUE_POST,
108  POSIX_SEMAPHORE_PRE,
109  POSIX_SEMAPHORE_POST,
110#ifdef RTEMS_POSIX_API
111  POSIX_TIMER_PRE,
112  POSIX_TIMER_POST,
113#endif /* RTEMS_POSIX_API */
114  POSIX_SHM_PRE,
115  POSIX_SHM_POST,
116  POSIX_KEYS_PRE,
117  POSIX_KEYS_POST,
118  POSIX_CLEANUP_PRE,
119  POSIX_CLEANUP_POST,
120  IDLE_THREADS_PRE,
121  IDLE_THREADS_POST,
122  LIBIO_PRE,
123  LIBIO_POST,
124  USER_ENVIRONMENT_PRE,
125  USER_ENVIRONMENT_POST,
126  ROOT_FILESYSTEM_PRE,
127  ROOT_FILESYSTEM_POST,
128  BSP_PRE_DRIVERS_PRE,
129  BSP_PRE_DRIVERS_POST,
130  DEVICE_DRIVERS_PRE,
131  DEVICE_DRIVERS_POST,
132  CLASSIC_USER_TASKS_PRE,
133  CLASSIC_USER_TASKS_POST,
134  POSIX_USER_THREADS_PRE,
135  POSIX_USER_THREADS_POST,
136  STD_FILE_DESCRIPTORS_PRE,
137  STD_FILE_DESCRIPTORS_POST,
138  LAST_FIRST,
139  LAST_SECOND,
140  LAST_THIRD,
141  LAST_FOURTH,
142  LAST_FIFTH,
143  LAST_SIXTH,
144  LAST_SEVENTH,
145  LAST_EIGHTH,
146  LAST_NINETH,
147  LAST_TENTH,
148  LAST_MIDDLE,
149  LAST_LAST_BUT_9,
150  LAST_LAST_BUT_8,
151  LAST_LAST_BUT_7,
152  LAST_LAST_BUT_6,
153  LAST_LAST_BUT_5,
154  LAST_LAST_BUT_4,
155  LAST_LAST_BUT_3,
156  LAST_LAST_BUT_2,
157  LAST_LAST_BUT_1,
158  LAST_LAST,
159  INIT_TASK,
160  DONE
161} init_step;
162
163#define FIRST(x) \
164  static void x##_first(void); \
165  RTEMS_SYSINIT_ITEM( \
166    x##_first, \
167    x, \
168    RTEMS_SYSINIT_ORDER_FIRST \
169  ); \
170  static void x##_first(void)
171
172#define LAST(x) \
173  static void x##_last(void); \
174  RTEMS_SYSINIT_ITEM( \
175    x##_last, \
176    x, \
177    RTEMS_SYSINIT_ORDER_LAST_BUT_1 \
178  ); \
179  static void x##_last(void)
180
181#define LAST_STEP(x) \
182  static void last_##x(void) \
183  { \
184    next_step(LAST_##x); \
185  } \
186  RTEMS_SYSINIT_ITEM( \
187    last_##x, \
188    RTEMS_SYSINIT_LAST, \
189    RTEMS_SYSINIT_ORDER_##x \
190  )
191
192static init_step step;
193
194static void next_step(init_step expected)
195{
196  assert(step == expected);
197  step = expected + 1;
198}
199
200static bool info_not_init(const Objects_Information *info)
201{
202  return _Chain_Is_empty(&info->Inactive);
203}
204
205static bool info_is_init(const Objects_Information *info, size_t count)
206{
207  return _Chain_Node_count_unprotected(&info->Inactive) == count;
208}
209
210FIRST(RTEMS_SYSINIT_WORKSPACE)
211{
212  assert(_Workspace_Area.area_begin == 0);
213  next_step(WORKSPACE_PRE);
214}
215
216LAST(RTEMS_SYSINIT_WORKSPACE)
217{
218  assert(_Workspace_Area.area_begin != 0);
219  next_step(WORKSPACE_POST);
220}
221
222FIRST(RTEMS_SYSINIT_BSP_START)
223{
224  /*
225   * Since the work performed here is BSP-specific, there is no way to test pre
226   * and post conditions.
227   */
228  next_step(BSP_START_PRE);
229}
230
231LAST(RTEMS_SYSINIT_BSP_START)
232{
233  /*
234   * Some BSPs initialize the printk() support in bsp_start().  So, print begin
235   * of test after bsp_start().
236   */
237  TEST_BEGIN();
238
239  next_step(BSP_START_POST);
240}
241
242FIRST(RTEMS_SYSINIT_CPU_COUNTER)
243{
244  /*
245   * Since the work performed here is BSP-specific, there is no way to test pre
246   * and post conditions.
247   */
248  next_step(CPU_COUNTER_PRE);
249}
250
251LAST(RTEMS_SYSINIT_CPU_COUNTER)
252{
253  next_step(CPU_COUNTER_POST);
254}
255
256FIRST(RTEMS_SYSINIT_TARGET_HASH)
257{
258  /*
259   * Since the work performed here is BSP-specific, there is no way to test pre
260   * and post conditions.
261   */
262  next_step(TARGET_HASH_PRE);
263}
264
265LAST(RTEMS_SYSINIT_TARGET_HASH)
266{
267  next_step(TARGET_HASH_POST);
268}
269
270FIRST(RTEMS_SYSINIT_INITIAL_EXTENSIONS)
271{
272  assert(_Chain_Is_empty(&_User_extensions_Switches_list));
273  next_step(INITIAL_EXTENSIONS_PRE);
274}
275
276LAST(RTEMS_SYSINIT_INITIAL_EXTENSIONS)
277{
278  assert(!_Chain_Is_empty(&_User_extensions_Switches_list));
279  next_step(INITIAL_EXTENSIONS_POST);
280}
281
282FIRST(RTEMS_SYSINIT_DATA_STRUCTURES)
283{
284  assert(info_not_init(&_Thread_Information.Objects));
285  next_step(DATA_STRUCTURES_PRE);
286}
287
288LAST(RTEMS_SYSINIT_DATA_STRUCTURES)
289{
290  assert(info_is_init(&_Thread_Information.Objects, 1));
291  next_step(DATA_STRUCTURES_POST);
292}
293
294FIRST(RTEMS_SYSINIT_USER_EXTENSIONS)
295{
296  assert(info_not_init(&_Extension_Information));
297  next_step(USER_EXTENSIONS_PRE);
298}
299
300LAST(RTEMS_SYSINIT_USER_EXTENSIONS)
301{
302  assert(info_is_init(&_Extension_Information, 1));
303  next_step(USER_EXTENSIONS_POST);
304}
305
306FIRST(RTEMS_SYSINIT_CLASSIC_TASKS)
307{
308  assert(info_not_init(&_RTEMS_tasks_Information.Objects));
309  next_step(CLASSIC_TASKS_PRE);
310}
311
312LAST(RTEMS_SYSINIT_CLASSIC_TASKS)
313{
314  assert(info_is_init(&_RTEMS_tasks_Information.Objects, 2));
315  next_step(CLASSIC_TASKS_POST);
316}
317
318FIRST(RTEMS_SYSINIT_CLASSIC_TIMER)
319{
320  assert(info_not_init(&_Timer_Information));
321  next_step(CLASSIC_TIMER_PRE);
322}
323
324LAST(RTEMS_SYSINIT_CLASSIC_TIMER)
325{
326  assert(info_is_init(&_Timer_Information, 1));
327  next_step(CLASSIC_TIMER_POST);
328}
329
330FIRST(RTEMS_SYSINIT_CLASSIC_MESSAGE_QUEUE)
331{
332  assert(info_not_init(&_Message_queue_Information));
333  next_step(CLASSIC_MESSAGE_QUEUE_PRE);
334}
335
336LAST(RTEMS_SYSINIT_CLASSIC_MESSAGE_QUEUE)
337{
338  assert(info_is_init(&_Message_queue_Information, 1));
339  next_step(CLASSIC_MESSAGE_QUEUE_POST);
340}
341
342FIRST(RTEMS_SYSINIT_CLASSIC_SEMAPHORE)
343{
344  assert(info_not_init(&_Semaphore_Information));
345  next_step(CLASSIC_SEMAPHORE_PRE);
346}
347
348LAST(RTEMS_SYSINIT_CLASSIC_SEMAPHORE)
349{
350  assert(info_is_init(&_Semaphore_Information, 1));
351  next_step(CLASSIC_SEMAPHORE_POST);
352}
353
354FIRST(RTEMS_SYSINIT_CLASSIC_PARTITION)
355{
356  assert(info_not_init(&_Partition_Information));
357  next_step(CLASSIC_PARTITION_PRE);
358}
359
360LAST(RTEMS_SYSINIT_CLASSIC_PARTITION)
361{
362  assert(info_is_init(&_Partition_Information, 1));
363  next_step(CLASSIC_PARTITION_POST);
364}
365
366FIRST(RTEMS_SYSINIT_CLASSIC_REGION)
367{
368  assert(info_not_init(&_Region_Information));
369  next_step(CLASSIC_REGION_PRE);
370}
371
372LAST(RTEMS_SYSINIT_CLASSIC_REGION)
373{
374  assert(info_is_init(&_Region_Information, 1));
375  next_step(CLASSIC_REGION_POST);
376}
377
378FIRST(RTEMS_SYSINIT_CLASSIC_DUAL_PORTED_MEMORY)
379{
380  assert(info_not_init(&_Dual_ported_memory_Information));
381  next_step(CLASSIC_DUAL_PORTED_MEMORY_PRE);
382}
383
384LAST(RTEMS_SYSINIT_CLASSIC_DUAL_PORTED_MEMORY)
385{
386  assert(info_is_init(&_Dual_ported_memory_Information, 1));
387  next_step(CLASSIC_DUAL_PORTED_MEMORY_POST);
388}
389
390FIRST(RTEMS_SYSINIT_CLASSIC_RATE_MONOTONIC)
391{
392  assert(info_not_init(&_Rate_monotonic_Information));
393  next_step(CLASSIC_RATE_MONOTONIC_PRE);
394}
395
396LAST(RTEMS_SYSINIT_CLASSIC_RATE_MONOTONIC)
397{
398  assert(info_is_init(&_Rate_monotonic_Information, 1));
399  next_step(CLASSIC_RATE_MONOTONIC_POST);
400}
401
402FIRST(RTEMS_SYSINIT_CLASSIC_BARRIER)
403{
404  assert(info_not_init(&_Barrier_Information));
405  next_step(CLASSIC_BARRIER_PRE);
406}
407
408LAST(RTEMS_SYSINIT_CLASSIC_BARRIER)
409{
410  assert(info_is_init(&_Barrier_Information, 1));
411  next_step(CLASSIC_BARRIER_POST);
412}
413
414#ifdef RTEMS_POSIX_API
415FIRST(RTEMS_SYSINIT_POSIX_SIGNALS)
416{
417  assert(
418    memcmp(
419      &_POSIX_signals_Vectors,
420      _POSIX_signals_Default_vectors,
421      sizeof(_POSIX_signals_Vectors)
422    ) != 0
423  );
424  next_step(POSIX_SIGNALS_PRE);
425}
426
427LAST(RTEMS_SYSINIT_POSIX_SIGNALS)
428{
429  assert(
430    memcmp(
431      &_POSIX_signals_Vectors,
432      _POSIX_signals_Default_vectors,
433      sizeof(_POSIX_signals_Vectors)
434    ) == 0
435  );
436  next_step(POSIX_SIGNALS_POST);
437}
438#endif /* RTEMS_POSIX_API */
439
440FIRST(RTEMS_SYSINIT_POSIX_THREADS)
441{
442  assert(info_not_init(&_POSIX_Threads_Information.Objects));
443  next_step(POSIX_THREADS_PRE);
444}
445
446LAST(RTEMS_SYSINIT_POSIX_THREADS)
447{
448  assert(info_is_init(&_POSIX_Threads_Information.Objects, 1));
449  next_step(POSIX_THREADS_POST);
450}
451
452FIRST(RTEMS_SYSINIT_POSIX_MESSAGE_QUEUE)
453{
454  assert(info_not_init(&_POSIX_Message_queue_Information));
455  next_step(POSIX_MESSAGE_QUEUE_PRE);
456}
457
458LAST(RTEMS_SYSINIT_POSIX_MESSAGE_QUEUE)
459{
460  assert(info_is_init(&_POSIX_Message_queue_Information, 1));
461  next_step(POSIX_MESSAGE_QUEUE_POST);
462}
463
464FIRST(RTEMS_SYSINIT_POSIX_SEMAPHORE)
465{
466  assert(info_not_init(&_POSIX_Semaphore_Information));
467  next_step(POSIX_SEMAPHORE_PRE);
468}
469
470LAST(RTEMS_SYSINIT_POSIX_SEMAPHORE)
471{
472  assert(info_is_init(&_POSIX_Semaphore_Information, 1));
473  next_step(POSIX_SEMAPHORE_POST);
474}
475
476#ifdef RTEMS_POSIX_API
477FIRST(RTEMS_SYSINIT_POSIX_TIMER)
478{
479  assert(info_not_init(&_POSIX_Timer_Information));
480  next_step(POSIX_TIMER_PRE);
481}
482
483LAST(RTEMS_SYSINIT_POSIX_TIMER)
484{
485  assert(info_is_init(&_POSIX_Timer_Information, 1));
486  next_step(POSIX_TIMER_POST);
487}
488#endif /* RTEMS_POSIX_API */
489
490FIRST(RTEMS_SYSINIT_POSIX_SHM)
491{
492  assert(info_not_init(&_POSIX_Shm_Information));
493  next_step(POSIX_SHM_PRE);
494}
495
496LAST(RTEMS_SYSINIT_POSIX_SHM)
497{
498  assert(info_is_init(&_POSIX_Shm_Information, 1));
499  next_step(POSIX_SHM_POST);
500}
501
502static size_t user_extensions_pre_posix_cleanup;
503
504FIRST(RTEMS_SYSINIT_POSIX_CLEANUP)
505{
506  user_extensions_pre_posix_cleanup =
507    _Chain_Node_count_unprotected(&_User_extensions_List.Active);
508  next_step(POSIX_CLEANUP_PRE);
509}
510
511LAST(RTEMS_SYSINIT_POSIX_CLEANUP)
512{
513  assert(
514    user_extensions_pre_posix_cleanup + 1 ==
515      _Chain_Node_count_unprotected(&_User_extensions_List.Active)
516  );
517  next_step(POSIX_CLEANUP_POST);
518}
519
520FIRST(RTEMS_SYSINIT_POSIX_KEYS)
521{
522  assert(info_not_init(&_POSIX_Keys_Information));
523  next_step(POSIX_KEYS_PRE);
524}
525
526LAST(RTEMS_SYSINIT_POSIX_KEYS)
527{
528  assert(info_is_init(&_POSIX_Keys_Information, 1));
529  next_step(POSIX_KEYS_POST);
530}
531
532FIRST(RTEMS_SYSINIT_IDLE_THREADS)
533{
534  assert(_System_state_Is_before_initialization(_System_state_Get()));
535  next_step(IDLE_THREADS_PRE);
536}
537
538LAST(RTEMS_SYSINIT_IDLE_THREADS)
539{
540  assert(_System_state_Is_before_multitasking(_System_state_Get()));
541  next_step(IDLE_THREADS_POST);
542}
543
544FIRST(RTEMS_SYSINIT_LIBIO)
545{
546  assert(rtems_libio_iop_free_head == NULL);
547  next_step(LIBIO_PRE);
548}
549
550LAST(RTEMS_SYSINIT_LIBIO)
551{
552  assert(rtems_libio_iop_free_head == &rtems_libio_iops[0]);
553  next_step(LIBIO_POST);
554}
555
556static size_t user_extensions_pre_user_env;
557
558FIRST(RTEMS_SYSINIT_USER_ENVIRONMENT)
559{
560  user_extensions_pre_user_env =
561    _Chain_Node_count_unprotected(&_User_extensions_List.Active);
562  next_step(USER_ENVIRONMENT_PRE);
563}
564
565LAST(RTEMS_SYSINIT_USER_ENVIRONMENT)
566{
567  assert(
568    user_extensions_pre_user_env + 1 ==
569      _Chain_Node_count_unprotected(&_User_extensions_List.Active)
570  );
571  next_step(USER_ENVIRONMENT_POST);
572}
573
574FIRST(RTEMS_SYSINIT_ROOT_FILESYSTEM)
575{
576  struct stat st;
577  int rv;
578
579  rv = stat("/", &st);
580  assert(rv == -1);
581  next_step(ROOT_FILESYSTEM_PRE);
582}
583
584LAST(RTEMS_SYSINIT_ROOT_FILESYSTEM)
585{
586  struct stat st;
587  int rv;
588
589  rv = stat("/", &st);
590  assert(rv == 0);
591  next_step(ROOT_FILESYSTEM_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_CLASSIC_USER_TASKS)
621{
622  _Objects_Allocator_lock();
623  assert(_Objects_Active_count(&_RTEMS_tasks_Information.Objects) == 0);
624  _Objects_Allocator_unlock();
625  next_step(CLASSIC_USER_TASKS_PRE);
626}
627
628LAST(RTEMS_SYSINIT_CLASSIC_USER_TASKS)
629{
630  _Objects_Allocator_lock();
631  assert(_Objects_Active_count(&_RTEMS_tasks_Information.Objects) == 1);
632  _Objects_Allocator_unlock();
633  next_step(CLASSIC_USER_TASKS_POST);
634}
635
636FIRST(RTEMS_SYSINIT_POSIX_USER_THREADS)
637{
638  _Objects_Allocator_lock();
639  assert(_Objects_Active_count(&_POSIX_Threads_Information.Objects) == 0);
640  _Objects_Allocator_unlock();
641  next_step(POSIX_USER_THREADS_PRE);
642}
643
644LAST(RTEMS_SYSINIT_POSIX_USER_THREADS)
645{
646  _Objects_Allocator_lock();
647  assert(_Objects_Active_count(&_POSIX_Threads_Information.Objects) == 1);
648  _Objects_Allocator_unlock();
649  next_step(POSIX_USER_THREADS_POST);
650}
651
652FIRST(RTEMS_SYSINIT_STD_FILE_DESCRIPTORS)
653{
654  struct stat st;
655  int rv;
656
657  rv = fstat(0, &st);
658  assert(rv == -1);
659  next_step(STD_FILE_DESCRIPTORS_PRE);
660}
661
662LAST(RTEMS_SYSINIT_STD_FILE_DESCRIPTORS)
663{
664  struct stat st;
665  int rv;
666
667  rv = fstat(0, &st);
668  assert(rv == 0);
669  next_step(STD_FILE_DESCRIPTORS_POST);
670}
671
672LAST_STEP(FIRST);
673LAST_STEP(SECOND);
674LAST_STEP(THIRD);
675LAST_STEP(FOURTH);
676LAST_STEP(FIFTH);
677LAST_STEP(SIXTH);
678LAST_STEP(SEVENTH);
679LAST_STEP(EIGHTH);
680LAST_STEP(NINETH);
681LAST_STEP(TENTH);
682LAST_STEP(MIDDLE);
683LAST_STEP(LAST_BUT_9);
684LAST_STEP(LAST_BUT_8);
685LAST_STEP(LAST_BUT_7);
686LAST_STEP(LAST_BUT_6);
687LAST_STEP(LAST_BUT_5);
688LAST_STEP(LAST_BUT_4);
689LAST_STEP(LAST_BUT_3);
690LAST_STEP(LAST_BUT_2);
691LAST_STEP(LAST_BUT_1);
692LAST_STEP(LAST);
693
694static void do_barrier_create(void)
695{
696  rtems_status_code sc;
697  rtems_id id;
698
699  sc = rtems_barrier_create(
700    rtems_build_name('T', 'E', 'S', 'T'),
701    RTEMS_DEFAULT_ATTRIBUTES,
702    1,
703    &id
704  );
705  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
706
707  sc = rtems_barrier_delete(id);
708  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
709}
710
711static void do_extensions_create(void)
712{
713  rtems_status_code sc;
714  rtems_id id;
715  rtems_extensions_table table;
716
717  memset(&table, 0, sizeof(table));
718  sc = rtems_extension_create(
719    rtems_build_name('T', 'E', 'S', 'T'),
720    &table,
721    &id
722  );
723  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
724
725  sc = rtems_extension_delete(id);
726  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
727}
728
729static void do_message_queue_create(void)
730{
731  rtems_status_code sc;
732  rtems_id id;
733
734  sc = rtems_message_queue_create(
735    rtems_build_name('T', 'E', 'S', 'T'),
736    1,
737    1,
738    RTEMS_DEFAULT_ATTRIBUTES,
739    &id
740  );
741  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
742
743  sc = rtems_message_queue_delete(id);
744  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
745}
746
747static void do_partition_create(void)
748{
749  rtems_status_code sc;
750  rtems_id id;
751  long buf[32];
752
753  sc = rtems_partition_create(
754    rtems_build_name('T', 'E', 'S', 'T'),
755    buf,
756    sizeof(buf),
757    sizeof(buf),
758    RTEMS_DEFAULT_ATTRIBUTES,
759    &id
760  );
761  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
762
763  sc = rtems_partition_delete(id);
764  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
765}
766
767static void do_period_create(void)
768{
769  rtems_status_code sc;
770  rtems_id id;
771
772  sc = rtems_rate_monotonic_create(
773    rtems_build_name('T', 'E', 'S', 'T'),
774    &id
775  );
776  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
777
778  sc = rtems_rate_monotonic_delete(id);
779  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
780}
781
782static void do_port_create(void)
783{
784  rtems_status_code sc;
785  rtems_id id;
786
787  sc = rtems_port_create(
788    rtems_build_name('T', 'E', 'S', 'T'),
789    NULL,
790    NULL,
791    1,
792    &id
793  );
794  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
795
796  sc = rtems_port_delete(id);
797  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
798}
799
800static void do_region_create(void)
801{
802  rtems_status_code sc;
803  rtems_id id;
804  long buf[32];
805
806  sc = rtems_region_create(
807    rtems_build_name('T', 'E', 'S', 'T'),
808    buf,
809    sizeof(buf),
810    1,
811    RTEMS_DEFAULT_ATTRIBUTES,
812    &id
813  );
814  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
815
816  sc = rtems_region_delete(id);
817  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
818}
819
820static void do_semaphore_create(void)
821{
822  rtems_status_code sc;
823  rtems_id id;
824
825  sc = rtems_semaphore_create(
826    rtems_build_name('T', 'E', 'S', 'T'),
827    0,
828    RTEMS_DEFAULT_ATTRIBUTES,
829    0,
830    &id
831  );
832  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
833
834  sc = rtems_semaphore_delete(id);
835  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
836}
837
838static void do_task_create(void)
839{
840  rtems_status_code sc;
841  rtems_id id;
842
843  sc = rtems_task_create(
844    rtems_build_name('T', 'E', 'S', 'T'),
845    1,
846    RTEMS_MINIMUM_STACK_SIZE,
847    RTEMS_DEFAULT_MODES,
848    RTEMS_DEFAULT_ATTRIBUTES,
849    &id
850  );
851  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
852
853  sc = rtems_task_delete(id);
854  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
855}
856
857static void do_timer_create(void)
858{
859  rtems_status_code sc;
860  rtems_id id;
861
862  sc = rtems_timer_create(rtems_build_name('T', 'E', 'S', 'T'), &id);
863  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
864
865  sc = rtems_timer_delete(id);
866  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
867}
868
869static void do_cleanup_push_pop(void)
870{
871  pthread_cleanup_push(NULL, NULL);
872  pthread_cleanup_pop(0);
873}
874
875static void do_posix_key_create(void)
876{
877  pthread_key_t key;
878  int eno;
879
880  eno = pthread_key_create(&key, NULL);
881  rtems_test_assert(eno == 0);
882
883  eno = pthread_key_delete(key);
884  rtems_test_assert(eno == 0);
885}
886
887static void do_posix_mq_open(void)
888{
889  struct mq_attr attr;
890  mqd_t mq;
891  int rv;
892
893  memset(&attr, 0, sizeof(attr));
894  attr.mq_maxmsg = 1;
895  attr.mq_msgsize = 1;
896  mq = mq_open("mq", O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO, &attr);
897  rtems_test_assert(mq != (mqd_t) -1);
898
899  rv = mq_close(mq);
900  rtems_test_assert(rv == 0);
901
902  rv = mq_unlink("mq");
903  rtems_test_assert(rv == 0);
904}
905
906static void do_posix_sem_open(void)
907{
908  sem_t *sem;
909  int rv;
910
911  sem = sem_open("sem", O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO, 0);
912  rtems_test_assert(sem != SEM_FAILED);
913
914  rv = sem_close(sem);
915  rtems_test_assert(rv == 0);
916
917  rv = sem_unlink("sem");
918  rtems_test_assert(rv == 0);
919}
920
921static void do_posix_shm_open(void)
922{
923  int fd;
924  int rv;
925
926  fd = shm_open("/shm", O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO);
927  rtems_test_assert(fd >= 0);
928
929  rv = close(fd);
930  rtems_test_assert(rv == 0);
931
932  rv = shm_unlink("/shm");
933  rtems_test_assert(rv == 0);
934}
935
936static void do_posix_timer_create(void)
937{
938#ifdef RTEMS_POSIX_API
939  int rv;
940  timer_t timer;
941
942  rv = timer_create(CLOCK_REALTIME, NULL, &timer);
943  rtems_test_assert(rv == 0);
944
945  rv = timer_delete(timer);
946  rtems_test_assert(rv == 0);
947#endif /* RTEMS_POSIX_API */
948}
949
950static void check_config(void)
951{
952  const rtems_api_configuration_table *config;
953
954  config = rtems_configuration_get_rtems_api_configuration();
955
956  rtems_test_assert(!config->notepads_enabled);
957  rtems_test_assert(config->maximum_tasks == 2);
958  rtems_test_assert(config->maximum_timers == 1);
959  rtems_test_assert(config->maximum_semaphores == 1);
960  rtems_test_assert(config->maximum_message_queues == 1);
961  rtems_test_assert(config->maximum_partitions == 1);
962  rtems_test_assert(config->maximum_regions == 1);
963  rtems_test_assert(config->maximum_ports == 1);
964  rtems_test_assert(config->maximum_periods == 1);
965  rtems_test_assert(config->maximum_barriers == 1);
966  rtems_test_assert(config->number_of_initialization_tasks == 1);
967  rtems_test_assert(config->User_initialization_tasks_table != NULL);
968}
969
970static void do_use_global_user_env(void)
971{
972  rtems_libio_use_global_env();
973}
974
975static void Init(rtems_task_argument arg)
976{
977  next_step(INIT_TASK);
978  do_barrier_create();
979  do_extensions_create();
980  do_message_queue_create();
981  do_partition_create();
982  do_period_create();
983  do_port_create();
984  do_region_create();
985  do_semaphore_create();
986  do_task_create();
987  do_timer_create();
988  do_cleanup_push_pop();
989  do_posix_key_create();
990  do_posix_mq_open();
991  do_posix_sem_open();
992  do_posix_shm_open();
993  do_posix_timer_create();
994  do_use_global_user_env();
995  check_config();
996  TEST_END();
997  exit(0);
998}
999
1000static void *POSIX_Init(void *arg)
1001{
1002  return NULL;
1003}
1004
1005#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
1006
1007#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
1008
1009#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
1010
1011#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1
1012
1013#define CONFIGURE_MAXIMUM_BARRIERS 1
1014
1015#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 1
1016
1017#define CONFIGURE_MAXIMUM_PARTITIONS 1
1018
1019#define CONFIGURE_MAXIMUM_PERIODS 1
1020
1021#define CONFIGURE_MAXIMUM_PORTS 1
1022
1023#define CONFIGURE_MAXIMUM_REGIONS 1
1024
1025#define CONFIGURE_MAXIMUM_SEMAPHORES 1
1026
1027#define CONFIGURE_MAXIMUM_TASKS 2
1028
1029#define CONFIGURE_MAXIMUM_TIMERS 1
1030
1031#define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES 1
1032
1033#define CONFIGURE_MAXIMUM_POSIX_SEMAPHORES 1
1034
1035#define CONFIGURE_MAXIMUM_POSIX_SHMS 1
1036
1037#ifdef RTEMS_POSIX_API
1038#define CONFIGURE_MAXIMUM_POSIX_TIMERS 1
1039#endif /* RTEMS_POSIX_API */
1040
1041#define CONFIGURE_MAXIMUM_POSIX_THREADS 1
1042
1043#define CONFIGURE_POSIX_INIT_THREAD_TABLE
1044
1045#define CONFIGURE_MAXIMUM_POSIX_KEYS 1
1046
1047#define CONFIGURE_MESSAGE_BUFFER_MEMORY \
1048  CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(1, 1)
1049
1050#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
1051
1052#define CONFIGURE_STACK_CHECKER_ENABLED
1053
1054#define CONFIGURE_VERBOSE_SYSTEM_INITIALIZATION
1055
1056#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
1057
1058#define CONFIGURE_APPLICATION_EXTRA_DRIVERS NULL_DRIVER_TABLE_ENTRY
1059
1060#define CONFIGURE_INIT
1061
1062#include <rtems/confdefs.h>
Note: See TracBrowser for help on using the repository browser.