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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [psxtests/] [psx05/] [init.c] - Blame information for rev 173

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 30 unneback
/*
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
 *  $Id: init.c,v 1.2 2001-09-27 12:02:24 chris Exp $
10
 */
11
 
12
#define CONFIGURE_INIT
13
#include "system.h"
14
#include <errno.h>
15
 
16
#define MUTEX_BAD_ID 0xfffffffe 
17
 
18
void Print_mutexattr(
19
  char                *msg,
20
  pthread_mutexattr_t *attr
21
)
22
{
23
  int status;
24
  int protocol;
25
  int prioceiling;
26
  int pshared;
27
 
28
  /* protocol */
29
 
30
  status = pthread_mutexattr_getprotocol( attr, &protocol );
31
  assert( !status );
32
 
33
  printf( "%smutex protocol is (%d) -- ", msg, protocol );
34
  switch ( protocol ) {
35
    case PTHREAD_PRIO_NONE:
36
      puts( "PTHREAD_PRIO_NONE" );
37
      break;
38
    case PTHREAD_PRIO_INHERIT:
39
      puts( "PTHREAD_PRIO_INHERIT" );
40
      break;
41
    case PTHREAD_PRIO_PROTECT:
42
      puts( "PTHREAD_PRIO_PROTECT" );
43
      break;
44
    default:
45
      puts( "UNKNOWN" );
46
      assert( 0 );
47
      break;
48
  }
49
 
50
  /* priority ceiling */
51
 
52
  status = pthread_mutexattr_getprioceiling( attr, &prioceiling );
53
  assert( !status );
54
  printf( "%smutex priority ceiling is %d\n", msg, prioceiling );
55
 
56
  /* process shared */
57
 
58
  status = pthread_mutexattr_getpshared( attr, &pshared );
59
  assert( !status );
60
  printf( "%smutex process shared is (%d) -- ", msg, pshared );
61
  switch ( pshared ) {
62
    case PTHREAD_PROCESS_PRIVATE:
63
      puts( "PTHREAD_PROCESS_PRIVATE" );
64
      break;
65
    case PTHREAD_PROCESS_SHARED:
66
      puts( "PTHREAD_PROCESS_SHARED" );
67
      break;
68
    default:
69
      puts( "UNKNOWN" );
70
      assert( 0 );
71
      break;
72
  }
73
}
74
 
75
void *POSIX_Init(
76
  void *argument
77
)
78
{
79
  int                  status;
80
  pthread_mutexattr_t  attr;
81
  pthread_mutexattr_t  destroyed_attr;
82
  struct timespec      times;
83
  struct sched_param   param;
84
  int                  pshared;
85
  int                  policy;
86
  int                  protocol;
87
  int                  ceiling;
88
  int                  old_ceiling;
89
 
90
  assert( MUTEX_BAD_ID != PTHREAD_MUTEX_INITIALIZER );
91
  Mutex_bad_id = MUTEX_BAD_ID;
92
 
93
  puts( "\n\n*** POSIX TEST 5 ***" );
94
 
95
  /* set the time of day, and print our buffer in multiple ways */
96
 
97
  set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
98
 
99
  /* get id of this thread */
100
 
101
  Init_id = pthread_self();
102
  printf( "Init's ID is 0x%08x\n", Init_id );
103
 
104
  /* tes pthread_mutex_attr_init */
105
 
106
  puts( "Init: pthread_mutexattr_init - EINVAL (NULL attr)" );
107
  status = pthread_mutexattr_init( NULL );
108
  assert( status == EINVAL );
109
 
110
  puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
111
  status = pthread_mutexattr_init( &attr );
112
  assert( !status );
113
 
114
  Print_mutexattr( "Init: ", &attr );
115
 
116
  /* create an "uninitialized" attribute structure */
117
 
118
  status = pthread_mutexattr_init( &destroyed_attr );
119
  assert( !status );
120
 
121
  puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
122
  status = pthread_mutexattr_destroy( &destroyed_attr );
123
  assert( !status );
124
 
125
  puts( "Init: pthread_mutexattr_destroy - EINVAL (NULL attr)" );
126
  status = pthread_mutexattr_destroy( NULL );
127
  assert( status == EINVAL );
128
 
129
  puts( "Init: pthread_mutexattr_destroy - EINVAL (not initialized)" );
130
  status = pthread_mutexattr_destroy( &destroyed_attr );
131
  assert( status == EINVAL );
132
 
133
  /* error cases for set and get pshared attribute */
134
 
135
  empty_line();
136
 
137
  puts( "Init: pthread_mutexattr_getpshared - EINVAL (NULL attr)" );
138
  status = pthread_mutexattr_getpshared( NULL, &pshared );
139
  assert( status == EINVAL );
140
 
141
  puts( "Init: pthread_mutexattr_getpshared - EINVAL (NULL pshared)" );
142
  status = pthread_mutexattr_getpshared( &attr, NULL );
143
  assert( status == EINVAL );
144
 
145
  puts( "Init: pthread_mutexattr_getpshared - EINVAL (not initialized)" );
146
  status = pthread_mutexattr_getpshared( &destroyed_attr, &pshared );
147
  assert( status == EINVAL );
148
 
149
  pshared = PTHREAD_PROCESS_PRIVATE;
150
  puts( "Init: pthread_mutexattr_setpshared - EINVAL (NULL attr)" );
151
  status = pthread_mutexattr_setpshared( NULL, pshared );
152
  assert( status == EINVAL );
153
 
154
  pshared = PTHREAD_PROCESS_PRIVATE;
155
  puts( "Init: pthread_mutexattr_setpshared - EINVAL (not initialized)" );
156
  status = pthread_mutexattr_setpshared( &destroyed_attr, pshared );
157
  assert( status == EINVAL );
158
 
159
  /* error cases for set and get protocol attribute */
160
 
161
  empty_line();
162
 
163
  puts( "Init: pthread_mutexattr_getprotocol - EINVAL (NULL attr)" );
164
  status = pthread_mutexattr_getprotocol( NULL, &protocol );
165
  assert( status == EINVAL );
166
 
167
  puts( "Init: pthread_mutexattr_getprotocol - EINVAL (NULL protocol)" );
168
  status = pthread_mutexattr_getprotocol( &attr, NULL );
169
  assert( status == EINVAL );
170
 
171
  puts( "Init: pthread_mutexattr_getprotocol - EINVAL (not initialized)" );
172
  status = pthread_mutexattr_getprotocol( &destroyed_attr, &protocol );
173
  assert( status == EINVAL );
174
 
175
  puts( "Init: pthread_mutexattr_setprotocol - EINVAL (NULL attr)" );
176
  status = pthread_mutexattr_setprotocol( NULL, PTHREAD_PRIO_NONE );
177
  assert( status == EINVAL );
178
 
179
  puts( "Init: pthread_mutexattr_setprotocol - EINVAL (invalid protocol)" );
180
  status = pthread_mutexattr_setprotocol( &attr, -1 );
181
  assert( status == EINVAL );
182
 
183
  puts( "Init: pthread_mutexattr_setprotocol - EINVAL (not initialized)" );
184
  status = pthread_mutexattr_setprotocol( &destroyed_attr, -1 );
185
  assert( status == EINVAL );
186
 
187
  /* error cases for set and get prioceiling attribute */
188
 
189
  empty_line();
190
 
191
  puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (NULL attr)" );
192
  status = pthread_mutexattr_getprioceiling( NULL, &ceiling );
193
  assert( status == EINVAL );
194
 
195
  puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (NULL prioceiling)" );
196
  status = pthread_mutexattr_getprioceiling( &attr, NULL );
197
  assert( status == EINVAL );
198
 
199
  puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (not initialized)" );
200
  status = pthread_mutexattr_getprioceiling( &destroyed_attr, &ceiling );
201
  assert( status == EINVAL );
202
 
203
  puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (NULL attr)" );
204
  status = pthread_mutexattr_setprioceiling( NULL, 128 );
205
  assert( status == EINVAL );
206
 
207
  puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (invalid priority)" );
208
  status = pthread_mutexattr_setprioceiling( &attr, 512 );
209
  if ( status != EINVAL )
210
    printf( "status = %d\n", status );
211
  assert( status == EINVAL );
212
 
213
  puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (not initialized)" );
214
  status = pthread_mutexattr_setprioceiling( &destroyed_attr, -1 );
215
  assert( status == EINVAL );
216
 
217
  /* create a thread */
218
 
219
  status = pthread_create( &Task_id, NULL, Task_1, NULL );
220
  assert( !status );
221
 
222
  /* now try some basic mutex operations */
223
 
224
  empty_line();
225
 
226
  puts( "Init: pthread_mutex_init - EINVAL (NULL mutex_id)" );
227
  status = pthread_mutex_init( NULL, &attr );
228
  assert( status == EINVAL );
229
 
230
  puts( "Init: pthread_mutex_init - EINVAL (not initialized attr)" );
231
  status = pthread_mutex_init( &Mutex_id, &destroyed_attr );
232
  assert( status == EINVAL );
233
 
234
  /* must get around error checks in attribute set routines */
235
  attr.protocol = -1;
236
 
237
  puts( "Init: pthread_mutex_init - EINVAL (bad protocol)" );
238
  status = pthread_mutex_init( &Mutex_id, &attr );
239
  assert( status == EINVAL );
240
 
241
  /* must get around error checks in attribute set routines */
242
  attr.protocol = PTHREAD_PRIO_INHERIT;
243
  attr.prio_ceiling = -1;
244
 
245
  puts( "Init: pthread_mutex_init - EINVAL (bad priority ceiling)" );
246
  status = pthread_mutex_init( &Mutex_id, &attr );
247
  assert( status == EINVAL );
248
 
249
  /* now set up for a success pthread_mutex_init */
250
 
251
  puts( "Init: Resetting mutex attributes" );
252
  status = pthread_mutexattr_init( &attr );
253
  assert( !status );
254
 
255
  puts( "Init: Changing mutex attributes" );
256
  status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
257
  assert( !status );
258
 
259
  status = pthread_mutexattr_setprioceiling( &attr, 128 );
260
  assert( !status );
261
 
262
  status = pthread_mutexattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
263
  assert( !status );
264
 
265
  Print_mutexattr( "Init: ", &attr );
266
 
267
  puts( "Init: Resetting mutex attributes" );
268
  status = pthread_mutexattr_init( &attr );
269
  assert( !status );
270
 
271
  /*
272
   *  Set the protocol to priority ceiling so the owner check happens
273
   *  and the EPERM test (later) will work.
274
   */
275
 
276
  status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
277
  assert( !status );
278
 
279
  puts( "Init: pthread_mutex_init - SUCCESSFUL" );
280
  status = pthread_mutex_init( &Mutex_id, &attr );
281
  if ( status )
282
    printf( "status = %d\n", status );
283
  assert( !status );
284
 
285
  /*
286
   *  This is not required to be an error and when it is, there are
287
   *  behavioral conflicts with other implementations.
288
   */
289
  puts( "Init: pthread_mutex_init - EBUSY (reinitialize an existing mutex) - skipped" );
290
 
291
#if 0
292
  status = pthread_mutex_init( &Mutex_id, &attr );
293
  if ( !status )
294
    printf( "status = %d\n", status );
295
  assert( status == EBUSY );
296
#endif
297
 
298
  puts( "Init: pthread_mutex_trylock - EINVAL (illegal ID)" );
299
  status = pthread_mutex_trylock( &Mutex_bad_id );
300
  if ( status != EINVAL )
301
    printf( "status = %d\n", status );
302
  assert( status == EINVAL );
303
 
304
  puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
305
  status = pthread_mutex_trylock( &Mutex_id );
306
  if ( status )
307
    printf( "status = %d\n", status );
308
  assert( !status );
309
 
310
  puts( "Init: pthread_mutex_trylock - EDEADLK (already locked)" );
311
  status = pthread_mutex_trylock( &Mutex_id );
312
  if ( status != EDEADLK )
313
    printf( "status = %d\n", status );
314
  assert( status == EDEADLK );
315
 
316
  puts( "Init: pthread_mutex_lock - EDEADLK (already locked)" );
317
  status = pthread_mutex_lock( &Mutex_id );
318
  if ( status != EDEADLK )
319
    printf( "status = %d\n", status );
320
  assert( status == EDEADLK );
321
 
322
  puts( "Init: Sleep 1 second" );
323
 
324
  sleep( 1 );
325
 
326
     /* switch to task 1 */
327
 
328
  puts( "Init: pthread_mutex_unlock - EINVAL (invalid id)" );
329
  status = pthread_mutex_unlock( &Mutex_bad_id );
330
  if ( status != EINVAL )
331
    printf( "status = %d\n", status );
332
  assert( status == EINVAL );
333
 
334
  puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
335
  status = pthread_mutex_unlock( &Mutex_id );
336
  if ( status )
337
    printf( "status = %d\n", status );
338
  assert( !status );
339
 
340
  puts( "Init: pthread_mutex_unlock - EPERM (not owner)" );
341
  status = pthread_mutex_unlock( &Mutex_id );
342
  if ( status != EPERM )
343
    printf( "status = %d\n", status );
344
  assert( status == EPERM );
345
 
346
  times.tv_sec = 0;
347
  times.tv_nsec = 500000000;
348
  puts( "Init: pthread_mutex_timedlock - time out in 1/2 second" );
349
  status = pthread_mutex_timedlock( &Mutex_id, &times );
350
  if ( status != EAGAIN )
351
    printf( "status = %d\n", status );
352
  assert( status == EAGAIN );
353
 
354
     /* switch to idle */
355
 
356
  puts( "Init: pthread_mutex_timedlock - EAGAIN (timeout)" );
357
 
358
  /* destroy a mutex */
359
 
360
  empty_line();
361
 
362
  puts( "Init: pthread_mutex_init - SUCCESSFUL" );
363
  status = pthread_mutex_init( &Mutex2_id, &attr );
364
  if ( status )
365
    printf( "status = %d\n", status );
366
  assert( !status );
367
 
368
  puts( "Init: pthread_mutex_init - EAGAIN (too many)" );
369
  status = pthread_mutex_init( &Mutex3_id, &attr );
370
  assert( status == EAGAIN );
371
 
372
  puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
373
  status = pthread_mutexattr_destroy( &attr );
374
  assert( !status );
375
 
376
  puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
377
  status = pthread_mutex_destroy( &Mutex2_id );
378
  assert( !status );
379
 
380
  puts( "Init: pthread_mutex_destroy - EINVAL (invalid id)" );
381
  status = pthread_mutex_destroy( &Mutex_bad_id );
382
  assert( status == EINVAL );
383
 
384
  /* destroy a busy mutex */
385
 
386
  empty_line();
387
 
388
  puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
389
  status = pthread_mutexattr_init( &attr );
390
  assert( !status );
391
 
392
  puts( "Init: pthread_mutex_init - SUCCESSFUL" );
393
  status = pthread_mutex_init( &Mutex2_id, &attr );
394
  assert( !status );
395
 
396
  puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
397
  status = pthread_mutex_trylock( &Mutex2_id );
398
  if ( status )
399
    printf( "status = %d\n", status );
400
  assert( !status );
401
 
402
  puts( "Init: pthread_mutex_destroy - EBUSY (already locked)" );
403
  status = pthread_mutex_destroy( &Mutex2_id );
404
  if ( status != EBUSY )
405
    printf( "status = %d\n", status );
406
  assert( status == EBUSY );
407
 
408
  puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
409
  status = pthread_mutex_unlock( &Mutex2_id );
410
  assert( !status );
411
 
412
  puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
413
  status = pthread_mutex_destroy( &Mutex2_id );
414
  assert( !status );
415
 
416
  /* priority inherit mutex */
417
 
418
  empty_line();
419
 
420
  puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
421
  status = pthread_mutexattr_init( &attr );
422
  assert( !status );
423
 
424
  puts(
425
    "Init: pthread_mutexattr_setprotocol - SUCCESSFUL (PTHREAD_PRIO_INHERIT)"
426
  );
427
  status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
428
  assert( !status );
429
 
430
  puts( "Init: pthread_mutex_init - SUCCESSFUL" );
431
  status = pthread_mutex_init( &Mutex2_id, &attr );
432
  assert( !status );
433
 
434
  puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
435
  status = pthread_mutex_trylock( &Mutex2_id );
436
  assert( !status );
437
 
438
  /* create a thread at a lower priority */
439
 
440
  status = pthread_create( &Task2_id, NULL, Task_2, NULL );
441
  assert( !status );
442
 
443
  /* set priority of Task2 to highest priority */
444
 
445
  param.sched_priority = 254;
446
 
447
  puts( "Init: pthread_setschedparam - Setting Task2 priority to highest" );
448
  status = pthread_setschedparam( Task2_id, SCHED_FIFO, &param );
449
  assert( !status );
450
 
451
  /* switching to Task2 */
452
 
453
  status = pthread_getschedparam( pthread_self(), &policy, &param );
454
  assert( !status );
455
  printf( "Init: pthread_getschedparam - priority = %d\n", param.sched_priority);
456
 
457
  puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
458
  status = pthread_mutex_unlock( &Mutex2_id );
459
  assert( !status );
460
 
461
  puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
462
  status = pthread_mutexattr_destroy( &attr );
463
  assert( !status );
464
 
465
  puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
466
  status = pthread_mutex_destroy( &Mutex2_id );
467
  assert( !status );
468
 
469
  /* priority ceiling mutex */
470
 
471
  empty_line();
472
 
473
  puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
474
  status = pthread_mutexattr_init( &attr );
475
  assert( !status );
476
 
477
  puts(
478
    "Init: pthread_mutexattr_setprotocol - SUCCESSFUL (PTHREAD_PRIO_PROTECT)"
479
  );
480
  status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_PROTECT );
481
  assert( !status );
482
 
483
  puts( "Init: pthread_mutex_init - SUCCESSFUL" );
484
  status = pthread_mutex_init( &Mutex2_id, &attr );
485
  assert( !status );
486
 
487
  puts( "Init: pthread_mutex_getprioceiling - EINVAL (invalid id)" );
488
  status = pthread_mutex_getprioceiling( &Mutex_bad_id, &ceiling );
489
  assert( status == EINVAL );
490
 
491
  puts( "Init: pthread_mutex_getprioceiling - EINVAL (NULL ceiling)" );
492
  status = pthread_mutex_getprioceiling( &Mutex2_id, NULL );
493
  assert( status == EINVAL );
494
 
495
  status = pthread_mutex_getprioceiling( &Mutex2_id, &ceiling );
496
  assert( !status );
497
  printf( "Init: pthread_mutex_getprioceiling - %d\n", ceiling );
498
 
499
  puts( "Init: pthread_mutex_setprioceiling - EINVAL (invalid id)" );
500
  status = pthread_mutex_setprioceiling( &Mutex_bad_id, 200, &old_ceiling );
501
  assert( status == EINVAL );
502
 
503
  puts( "Init: pthread_mutex_setprioceiling - EINVAL (illegal priority)" );
504
  status = pthread_mutex_setprioceiling( &Mutex2_id, 512, &old_ceiling );
505
  assert( status == EINVAL );
506
 
507
  puts( "Init: pthread_mutex_setprioceiling - EINVAL (NULL ceiling)" );
508
  status = pthread_mutex_setprioceiling( &Mutex2_id, 128, NULL );
509
  assert( status == EINVAL );
510
 
511
  /* normal cases of set priority ceiling */
512
 
513
  puts( "Init: pthread_mutex_setprioceiling - new ceiling = 200" );
514
  status = pthread_mutex_setprioceiling( &Mutex2_id, 200, &old_ceiling );
515
  assert( !status );
516
  printf(
517
    "Init: pthread_mutex_setprioceiling - old ceiling = %d\n",old_ceiling
518
  );
519
 
520
  status = pthread_getschedparam( pthread_self(), &policy, &param );
521
  assert( !status );
522
  printf(
523
    "Init: pthread_getschedparam - priority = %d\n", param.sched_priority
524
  );
525
 
526
  puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
527
  status = pthread_mutex_trylock( &Mutex2_id );
528
  assert( !status );
529
 
530
  status = pthread_getschedparam( pthread_self(), &policy, &param );
531
  assert( !status );
532
  printf(
533
    "Init: pthread_getschedparam - priority = %d\n", param.sched_priority
534
  );
535
 
536
  /* create a thread at a higher priority */
537
 
538
  status = pthread_create( &Task3_id, NULL, Task_3, NULL );
539
  assert( !status );
540
 
541
  /* set priority of Task3 to highest priority */
542
 
543
  param.sched_priority = 199;
544
 
545
  status = pthread_setschedparam( Task3_id, SCHED_FIFO, &param );
546
  assert( !status );
547
  puts( "Init: pthread_setschedparam - set Task3 priority to highest" );
548
 
549
  /* DOES NOT SWITCH to Task3 */
550
 
551
  puts( "Init: Sleep 1 second" );
552
  assert( !status );
553
  sleep( 1 );
554
 
555
  /* switch to task 3 */
556
 
557
  puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
558
  status = pthread_mutex_unlock( &Mutex2_id );
559
  assert( !status );
560
 
561
  status = pthread_mutex_getprioceiling( &Mutex2_id, &ceiling );
562
  assert( !status );
563
  printf( "Init: pthread_mutex_getprioceiling- ceiling = %d\n", ceiling );
564
 
565
  /* set priority of Init to highest priority */
566
 
567
  param.sched_priority = 254;
568
 
569
  status = pthread_setschedparam( Init_id, SCHED_FIFO, &param );
570
  assert( !status );
571
  puts( "Init: pthread_setschedparam - set Init priority to highest" );
572
 
573
  puts( "Init: pthread_mutex_lock - EINVAL (priority ceiling violation)" );
574
  status = pthread_mutex_lock( &Mutex2_id );
575
  if ( status != EINVAL )
576
    printf( "status = %d\n", status );
577
  assert( status == EINVAL );
578
 
579
  puts( "*** END OF POSIX TEST 5 ***" );
580
  exit( 0 );
581
 
582
  return NULL; /* just so the compiler thinks we returned something */
583
}

powered by: WebSVN 2.1.0

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