validate.c

linux环境支持psos的操作系统。非常适合进行移植的朋友。

 
    puts( "\n.......... Next Tasks 4, 7, and 10 look for tokens from SEM2" );
    puts( "           in reverse-priority order.  However, SEM2 has only two" );
    puts( "           tokens available, so one task will fail to acquire one.");
    puts( "           Since the tasks did not wait on the semaphore, the");
    puts( "           loser of the race will return an error 0x42");

    err = ev_receive( EVENT4 | EVENT7 | EVENT10, EV_ALL, 0, (ULONG *)NULL );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    else
        printf( "\r\n" );
    tm_wkafter( 2 );
            
    puts( "\n.......... Next Tasks 4, 7, and 10 look for tokens from SEM3" );
    puts( "           in reverse-priority order.  However, SEM3 has only two" );
    puts( "           tokens available, so one task will fail to acquire one.");
    puts( "           Since the tasks do wait on the semaphore, the lowest");
    puts( "           priority task will return an error 0x01");

    puts( "Task 1 enabling Tasks 4, 7, and 10 to consume SEM3 tokens.");
    err = ev_send( task4_id, EVENT4 );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    tm_wkafter( 2 );
    err = ev_send( task7_id, EVENT7 );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    tm_wkafter( 2 );
    err = ev_send( task10_id, EVENT10 );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    tm_wkafter( 2 );

    puts( "Task 1 blocking for handshake from Tasks 4, 7, and 10..." );
    puts( "Task 1 waiting to receive ALL of EVENT4 | EVENT7 | EVENT10." );
    err = ev_receive( EVENT4 | EVENT7 | EVENT10, EV_ALL, 0, (ULONG *)NULL );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    else
        printf( "\r\n" );

    for ( i = 0; i < 2; i++ )
    {
        puts( "Task 1 sending token to semaphore SEM3." );
        err = sm_v( sema43_id );
        if ( err != ERR_NO_ERROR )
            printf( "\nTask 1 send token to SEM3 returned error %lx\r\n", err );
    }
    puts( "Task 1 blocking until Tasks 4, 7, and 10 consume SEM3 tokens." );
    puts( "Task 1 waiting to receive ALL of EVENT4 | EVENT7 | EVENT10." );
    err = ev_receive( EVENT4 | EVENT7 | EVENT10, EV_ALL, 0, (ULONG *)NULL );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    else
        printf( "\r\n" );

    /************************************************************************
    **  Semaphore Deletion Test
    ************************************************************************/

    puts( "\n.......... Next Tasks 4, 7, and 10 look for tokens from SEM2" );
    puts( "           in priority order.  Task 1 will delete SEM1 before any" );
    puts( "           tokens become available.  Tasks 4, 7, and 10 should be" );
    puts( "           awakened and return error 0x43.  sm_delete of SEM1" );
    puts( "           should return error 0x44.  SEM2 will be deleted" );
    puts( "           with no tasks waiting, and should return no error." );
    puts( "           This tests the sm_delete logic." );
    tm_wkafter( 2 );
    puts( "Task 1 deleting semaphore SEM1." );
    err = sm_delete( sema41_id );
        if ( err != ERR_NO_ERROR )
            printf( "\nTask 1 delete of SEM1 returned error %lx\r\n", err );
        else
            printf( "\r\n" );
    puts( "Task 1 deleting semaphore SEM2." );
    err = sm_delete( sema42_id );
        if ( err != ERR_NO_ERROR )
            printf( "\nTask 1 delete of SEM2 returned error %lx\r\n", err );
        else
            printf( "\r\n" );

    puts( "Task 1 blocking until Tasks 4, 7, and 10 complete sm_delete test." );
    puts( "Task 1 waiting to receive ALL of EVENT4 | EVENT7 | EVENT10." );
    err = ev_receive( EVENT4 | EVENT7 | EVENT10, EV_ALL, 0, (ULONG *)NULL );
    if ( err != ERR_NO_ERROR )
         printf( " returned error %lx\r\n", err );
    else
        printf( "\r\n" );

    /************************************************************************
    **  Semaphore Identification and Semaphore-Not-Found Test
    ************************************************************************/

    puts( "\n.......... Finally, we test the sm_ident logic..." );
    puts( "           Then we verify the error codes returned when" );
    puts( "           a non-existent semaphore is specified." );

    err = sm_ident( "SEM3", 0, &my_sema4_id );
    if ( err != ERR_NO_ERROR )
        printf( "\nsm_ident for SEM3 returned error %lx\r\n", err );
    else
        printf( "\nsm_ident for SEM3 returned ID %lx... sema43_id == %lx\r\n",
                 my_sema4_id, sema43_id );

    err = sm_ident( "SEM1", 0, &my_sema4_id );
    if ( err != ERR_NO_ERROR )
        printf( "\nsm_ident for SEM1 returned error %lx\r\n", err );
    else
        printf( "\nsm_ident for SEM1 returned ID %lx sema41_id %lx\r\n",
                  my_sema4_id, sema41_id );

    err = sm_v( sema41_id );
    printf( "\nsm_v for SEM1 returned error %lx\r\n", err );

    err = sm_p( sema41_id, Q_NOWAIT, 0L );
    printf( "\nsm_p for SEM1 (no waiting) returned error %lx\r\n", err );

    err = sm_p( sema41_id, Q_WAIT, 0L );
    printf( "\nsm_p for SEM1 (wait forever) returned error %lx\r\n", err );

    err = sm_delete( sema41_id );
    printf( "\nsm_delete for SEM1 returned error %lx\r\n", err );
}

/*****************************************************************************
**  validate_partitions
**         This function sequences through a series of actions to exercise
**         the various features and characteristics of p2pthread partitions
**
*****************************************************************************/
void validate_partitions( void )
{
    ULONG err;
    ULONG my_partn_id;
    int i;

    void *buffer;
    char *buf1addr[32];
    char *buf2addr[32];
    char *buf3addr[32];

    puts( "\r\n********** Partition validation:" );

    /************************************************************************
    **  Partition Creation Test
    ************************************************************************/
    puts( "\n.......... First we create three partitions:" );
    puts( "           Test the block size restrictions first." );
    puts( "           Block size must be >= 4 bytes and a power of two." );
  
    printf( "\r\nCreating Partition 1 with block size not a power of two." );
    err = pt_create( "PRT1", partition_1, partition_1, 512,
                     15, PT_DEL, &partn1_id, &part1_numblks );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_create returned error %lx\r\n", err );
    else
        printf( "\r\n" );

    printf( "\r\nCreating Partition 1 with block size < 4 bytes." );
    err = pt_create( "PRT1", partition_1, partition_1, 512,
                     2, PT_DEL, &partn1_id, &part1_numblks );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_create returned error %lx\r\n", err );
    else
        printf( "\r\n" );

    printf( "\r\nCreating Partition 1 with 32 16-byte buffers" );
    err = pt_create( "PRT1", partition_1, partition_1, 512,
                     16, PT_DEL, &partn1_id, &part1_numblks );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_create returned error %lx\r\n", err );
    else
        printf( "\npt_create created %ld 16-byte buffers\r\n", part1_numblks );

    printf( "\r\nCreating Partition 2 with 32 32-byte buffers" );
    err = pt_create( "PRT2", partition_2, partition_2, 1024,
                     32, PT_NODEL, &partn2_id, &part2_numblks );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_create returned error %lx\r\n", err );
    else
        printf( "\npt_create created %ld 32-byte buffers\r\n", part2_numblks );

    printf( "\r\nCreating Partition 3 with 16 128-byte buffers" );
    err = pt_create( "PRT3", partition_3, partition_3, 2048,
                     128, PT_DEL, &partn3_id, &part3_numblks );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_create returned error %lx\r\n", err );
    else
        printf( "\npt_create created %ld 128-byte buffers\r\n", part3_numblks );

    /************************************************************************
    **  Partition Buffer Allocation, Use, and Release Test
    ************************************************************************/

    puts( "\n.......... Next we allocate 32 buffers from each partition:" );
    puts( "           PRT3 should return error 0x2c for the last 16 buffers." );
    puts( "           An ID string is written into each buffer obtained." );
    for ( i = 0; i < 32; i++ )
    {
        printf( "\r\nAllocating buffer %d from PRT1", i + 1 );
        err = pt_getbuf( partn1_id, (void **)&(buf1addr[i]) );
        if ( err != ERR_NO_ERROR )
            printf( "\npt_getbuf on PRT1 returned error %lx\r\n", err );
        else
            sprintf( buf1addr[i], "PRT1 buffer %d", i + 1 );

        printf( "\r\nAllocating buffer %d from PRT2", i + 1 );
        err = pt_getbuf( partn2_id, (void **)&(buf2addr[i]) );
        if ( err != ERR_NO_ERROR )
            printf( "\npt_getbuf on PRT2 returned error %lx\r\n", err );
        else
            sprintf( buf2addr[i], "PRT2 buffer %d", i + 1 );

        printf( "\r\nAllocating buffer %d from PRT3", i + 1 );
        err = pt_getbuf( partn3_id, (void **)&(buf3addr[i]) );
        if ( err != ERR_NO_ERROR )
            printf( "\npt_getbuf on PRT3 returned error %lx\r\n", err );
        else
            sprintf( buf3addr[i], "PRT3 buffer %d", i + 1 );
    }

    puts( "           Next print the ID strings from the first and last " );
    puts( "           buffers allocated from each partition.  This proves" );
    puts( "           that the buffers and partitions are unique." );
    puts( buf1addr[0] );
    puts( buf1addr[31] );
    puts( buf2addr[0] );
    puts( buf2addr[31] );
    puts( buf3addr[0] );
    puts( buf3addr[15] );

    puts( "           Now try to return a buffer from PRT2 to PRT1." );
    puts( "           This should return error 0x2d." );
    err = pt_retbuf( partn1_id, (void *)buf2addr[0] );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_retbuf on PRT1 returned error %lx\r\n", err );
    else
        printf( "\nReturned buffer %d  @ %p to PRT1\r\n", 1, buf2addr[0] );

    puts( "           Now try to return a buffer from PRT2 more than once." );
    puts( "           This should return error 0x2f on the second pt_retbuf." );
    err = pt_retbuf( partn2_id, (void *)buf2addr[0] );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_retbuf on PRT2 returned error %lx\r\n", err );
    else
        printf( "\nReturned buffer %d  @ %p to PRT2\r\n", 1, buf2addr[0] );

    err = pt_retbuf( partn2_id, (void *)buf2addr[0] );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_retbuf on PRT2 returned error %lx\r\n", err );
    else
        printf( "\nReturned buffer %d  @ %p to PRT2\r\n", 1, buf2addr[0] );

    /************************************************************************
    **  Partition Deletion Test
    ************************************************************************/
    puts( "\n.......... Now we delete partitions 1 and 2:" );
    puts( "           Partitions 1 and 3 were created with the PT_DEL option.");
    puts( "           They can be deleted even with buffers still allocated.");
    puts( "           Partition 2 was created with the PT_NODEL option.");
    puts( "           It cannot be deleted while buffers are still allocated.");

    printf( "\r\nDeleting Partition 1 with buffers allocated" );
    err = pt_delete( partn1_id );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_delete of PRT1 returned error %lx\r\n", err );
    else
        printf( "\r\n" );
  
    printf( "\r\nDeleting Partition 2 with buffers allocated" );
    err = pt_delete( partn2_id );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_delete of PRT2 returned error %lx\r\n", err );
    else
        printf( "\r\n" );

    puts( "Returning all buffers to PRT2" );
    for ( i = 1; i < 32; i++ )
    {
        err = pt_retbuf( partn2_id, (void *)buf2addr[i] );
        if ( err != ERR_NO_ERROR )
            printf( "\npt_retbuf on PRT2 returned error %lx\r\n", err );
    }
  
    printf( "\r\nDeleting Partition 2 with no buffers allocated" );
    err = pt_delete( partn2_id );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_delete of PRT2 returned error %lx\r\n", err );
    else
        printf( "\r\n" );
  
    /************************************************************************
    **  Partition Identification and Partition-Not-Found Test
    ************************************************************************/

    puts( "\n.......... Finally, we test the pt_ident logic..." );
    puts( "           Then we verify the error codes returned when" );
    puts( "           a non-existent partition is specified." );

    err = pt_ident( "PRT3", 0, &my_partn_id );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_ident for PRT3 returned error %lx\r\n", err );
    else
        printf( "\npt_ident for PRT3 returned ID %lx... partn3_id == %lx\r\n",
                 my_partn_id, partn3_id );

    err = pt_ident( "PRT1", 0, &my_partn_id );
    if ( err != ERR_NO_ERROR )
        printf( "\npt_ident for PRT1 returned error %lx\r\n", err );