OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rtems-20020807/] [c/] [src/] [tests/] [psxtests/] [psx01/] [init.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1026 ivang
/*
2
 *  COPYRIGHT (c) 1989-1999.
3
 *  On-Line Applications Research Corporation (OAR).
4
 *
5
 *  The license and distribution terms for this file may be
6
 *  found in the file LICENSE in this distribution or at
7
 *  http://www.OARcorp.com/rtems/license.html.
8
 *
9
 *  init.c,v 1.26 1999/11/17 17:51:31 joel Exp
10
 */
11
 
12
#define CONFIGURE_INIT
13
#include "system.h"
14
#include <sched.h>
15
#include <sys/utsname.h>
16
 
17
void *POSIX_Init(
18
  void *argument
19
)
20
{
21
  struct timespec tv;
22
  struct timespec tr;
23
  int             status;
24
  int             priority;
25
  pthread_t       thread_id;
26
  time_t          seconds;
27
  time_t          seconds1;
28
  time_t          remaining;
29
  struct tm       tm;
30
  struct utsname  uts;
31
 
32
  puts( "\n\n*** POSIX TEST 1 ***" );
33
 
34
  build_time( &tm, TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
35
 
36
  /* print some system information */
37
 
38
  puts( "Init: uname - EFAULT (invalid uts pointer argument)" );
39
  status = uname( NULL );
40
  assert( status == -1 );
41
  assert( errno == EFAULT );
42
 
43
  status = uname( &uts );
44
  assert( !status );
45
  printf( "Init: uts.sysname: %s\n", uts.sysname );
46
  printf( "Init: uts.nodename: %s\n", uts.nodename );
47
  printf( "Init: uts.release: %s\n", uts.release );
48
  printf( "Init: uts.version: %s\n", uts.version );
49
  printf( "Init: uts.machine: %s\n", uts.machine );
50
  puts("");
51
 
52
  /* error cases in clock_gettime and clock_settime */
53
 
54
  puts( "Init: clock_gettime - EINVAL (invalid clockid)" );
55
  status = clock_settime( -1, &tv );
56
  assert( status == -1 );
57
  assert( errno == EINVAL );
58
 
59
  puts( "Init: clock_settime - EINVAL (invalid clockid)" );
60
  status = clock_settime( -1, &tv );
61
  assert( status == -1 );
62
  assert( errno == EINVAL );
63
 
64
  /* exercise clock_getres */
65
 
66
  puts( "Init: clock_getres - EINVAL (invalid clockid)" );
67
  status = clock_getres( -1, &tv );
68
  assert( status == -1 );
69
  assert( errno == EINVAL );
70
 
71
  puts( "Init: clock_getres - EINVAL (NULL resolution)" );
72
  status = clock_getres( CLOCK_REALTIME, NULL );
73
  assert( status == -1 );
74
  assert( errno == EINVAL );
75
 
76
  puts( "Init: clock_getres - SUCCESSFUL" );
77
  status = clock_getres( CLOCK_REALTIME, &tv );
78
  printf( "Init: resolution = sec (%ld), nsec (%ld)\n", tv.tv_sec, tv.tv_nsec );
79
  assert( !status );
80
 
81
  /* set the time of day, and print our buffer in multiple ways */
82
 
83
  tv.tv_sec = mktime( &tm );
84
  assert( tv.tv_sec != -1 );
85
 
86
  tv.tv_nsec = 0;
87
 
88
  /* now set the time of day */
89
 
90
  empty_line();
91
 
92
  printf( asctime( &tm ) );
93
  puts( "Init: clock_settime - SUCCESSFUL" );
94
  status = clock_settime( CLOCK_REALTIME, &tv );
95
  assert( !status );
96
 
97
  printf( asctime( &tm ) );
98
  printf( ctime( &tv.tv_sec ) );
99
 
100
  /* use sleep to delay */
101
 
102
  remaining = sleep( 3 );
103
  assert( !remaining );
104
 
105
  /* print new times to make sure it has changed and we can get the realtime */
106
 
107
  status = clock_gettime( CLOCK_REALTIME, &tv );
108
  assert( !status );
109
 
110
  printf( ctime( &tv.tv_sec ) );
111
 
112
  seconds = time( NULL );
113
  printf( ctime( &seconds ) );
114
 
115
  /*  just to have the value copied out through the parameter */
116
 
117
  seconds = time( &seconds1 );
118
  assert( seconds == seconds1 );
119
 
120
  /* check the time remaining */
121
 
122
  printf( "Init: seconds remaining (%d)\n", (int)remaining );
123
  assert( !remaining );
124
 
125
  /* error cases in nanosleep */
126
 
127
  empty_line();
128
  puts( "Init: nanosleep - EINVAL (NULL time)" );
129
  status = nanosleep ( NULL, &tr );
130
  assert( status == -1 );
131
  assert( errno == EINVAL );
132
 
133
  tv.tv_sec = 0;
134
  tv.tv_nsec = TOD_NANOSECONDS_PER_SECOND * 2;
135
  puts( "Init: nanosleep - EINVAL (too many nanoseconds)" );
136
  status = nanosleep ( &tv, &tr );
137
  assert( status == -1 );
138
  assert( errno == EINVAL );
139
 
140
  /* this is actually a small delay or yield */
141
  tv.tv_sec = -1;
142
  tv.tv_nsec = 0;
143
  puts( "Init: nanosleep - negative seconds small delay " );
144
  status = nanosleep ( &tv, &tr );
145
  assert( !status );
146
 
147
  /* use nanosleep to yield */
148
 
149
  tv.tv_sec = 0;
150
  tv.tv_nsec = 0;
151
 
152
  puts( "Init: nanosleep - yield" );
153
  status = nanosleep ( &tv, &tr );
154
  assert( !status );
155
  assert( !tr.tv_sec );
156
  assert( !tr.tv_nsec );
157
 
158
  /* use nanosleep to delay */
159
 
160
  tv.tv_sec = 3;
161
  tv.tv_nsec = 500000;
162
 
163
  puts( "Init: nanosleep - 3.05 seconds" );
164
  status = nanosleep ( &tv, &tr );
165
  assert( !status );
166
 
167
  /* print the current real time again */
168
 
169
  status = clock_gettime( CLOCK_REALTIME, &tv );
170
  assert( !status );
171
 
172
  printf( ctime( &tv.tv_sec ) );
173
 
174
  /* check the time remaining */
175
 
176
  printf( "Init: sec (%ld), nsec (%ld) remaining\n", tr.tv_sec, tr.tv_nsec );
177
  assert( !tr.tv_sec && !tr.tv_nsec );
178
 
179
  /* get id of this thread */
180
 
181
  Init_id = pthread_self();
182
  printf( "Init: ID is 0x%08x\n", Init_id );
183
 
184
  /* exercise get minimum priority */
185
 
186
  priority = sched_get_priority_min( SCHED_FIFO );
187
  printf( "Init: sched_get_priority_min (SCHED_FIFO) -- %d\n", priority );
188
  assert( priority != -1 );
189
 
190
  puts( "Init: sched_get_priority_min -- EINVAL (invalid policy)" );
191
  priority = sched_get_priority_min( -1 );
192
  assert( priority == -1 );
193
  assert( errno == EINVAL );
194
 
195
  /* exercise get maximum priority */
196
 
197
  priority = sched_get_priority_max( SCHED_FIFO );
198
  printf( "Init: sched_get_priority_max (SCHED_FIFO) -- %d\n", priority );
199
  assert( priority != -1 );
200
 
201
  puts( "Init: sched_get_priority_min -- EINVAL (invalid policy)" );
202
  priority = sched_get_priority_min( -1 );
203
  assert( priority == -1 );
204
  assert( errno == EINVAL );
205
 
206
  /* print the round robin time quantum */
207
 
208
  status = sched_rr_get_interval( getpid(), &tr );
209
  printf(
210
    "Init: Round Robin quantum is %ld seconds, %ld nanoseconds\n",
211
    tr.tv_sec,
212
    tr.tv_nsec
213
  );
214
  assert( !status );
215
 
216
  /* create a thread */
217
 
218
  puts( "Init: pthread_create - SUCCESSFUL" );
219
  status = pthread_create( &thread_id, NULL, Task_1_through_3, NULL );
220
  assert( !status );
221
 
222
  /* too may threads error */
223
 
224
  puts( "Init: pthread_create - EAGAIN (too many threads)" );
225
  status = pthread_create( &thread_id, NULL, Task_1_through_3, NULL );
226
  assert( status == EAGAIN );
227
 
228
  puts( "Init: sched_yield to Task_1" );
229
  status = sched_yield();
230
  assert( !status );
231
 
232
    /* switch to Task_1 */
233
 
234
  /* exit this thread */
235
 
236
  puts( "Init: pthread_exit" );
237
  pthread_exit( NULL );
238
 
239
    /* switch to Task_1 */
240
 
241
  return NULL; /* just so the compiler thinks we returned something */
242
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.