validate.c

将将基于VXWORKS的应用转换成LINUX的关键库源代码

    {
        errno = 0;
        err = msgQReceive( queue1_id, msg.blk, 16, 100 );
        if ( err != ERROR )
        {
            printf( "\r\nTask 9 rcvd Test Cycle %d Msg No. %d from %s\r\n",
                    msg.msg.t_cycle, msg.msg.msg_no, msg.msg.qname );
        }
        else
        {
            printf( "\nTask 9 msgQReceive on MSQ1 returned error %x\r\n",
                    errno );
            break;
        }
    }
    puts( "Signalling complt9 to Task 1 - Task 9 finished msgQDelete test." );
    errno = 0;
    err = semGive( complt9 );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /*
    **  Tests all done... delete our own task.
    */
    puts( "\n.......... Task 9 deleting itself." );
    errno = 0;
    err = taskDelete( 0 );

    return( 0 );
}

/*****************************************************************************
**  task8
*****************************************************************************/
int task8( int dummy0, int dummy1, int dummy2, int dummy3, int dummy4,
           int dummy5, int dummy6, int dummy7, int dummy8, int dummy9 )
{
    STATUS err;

    /************************************************************************
    **  First wait on empty MSQ1 in pre-determined task order to test
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 8 waiting on enable8 to begin testing Watchdog 2" );

    while ( 1 )
    {
        errno = 0;
        err = semTake( enable8, WAIT_FOREVER );
        if ( err == OK )
        {
             printf( "\r\nWatchdog 2 count %d msec", wdog2_cycle );
        }
        else
        {
             printf( " returned error %x\r\n", errno );
        }
    }

    return( 0 );
}

/*****************************************************************************
**  task7
*****************************************************************************/
int task7( int dummy0, int dummy1, int dummy2, int dummy3, int dummy4,
           int dummy5, int dummy6, int dummy7, int dummy8, int dummy9 )
{
    STATUS err;

    /************************************************************************
    **  First wait on empty enable1 in pre-determined task order to test
    **  semaphore flush task waking order.
    ************************************************************************/
    puts( "\nTask 7 waiting on enable7 to begin acquiring token from enable1" );
    errno = 0;
    err = semTake( enable7, WAIT_FOREVER );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /*
    **  Consume one token from enable1.
    */
    puts( "\nTask 7 waiting indefinitely to acquire token from enable1" );
    errno = 0;
    if ( (err = semTake( enable1, WAIT_FOREVER )) == OK )
        printf( "\r\nTask 7 acquired token from enable1\r\n" );
    else
        printf( "\nTask 7 semTake on enable1 returned error %x\r\n", errno );

    puts( "Signalling complt7 to Task 1 - Task 7 ready to test SEM_Q_FIFO." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x", errno );
    }

    /************************************************************************
    **  Next wait on empty SEM1 in pre-determined task order to test
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 7 waiting on enable7 to begin acquiring token from SEM1" );
    errno = 0;
    err = semTake( enable7, WAIT_FOREVER );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    puts( "Task 7 signalling complt7 to Task 1 to indicate Task 7 ready." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume one token from SEM1.
    */
    puts( "\nTask 7 waiting indefinitely to acquire token from SEM1" );
    errno = 0;
    if ( (err = semTake( sema41_id, WAIT_FOREVER )) == OK )
        printf( "\r\nTask 7 acquired token from SEM1\r\n" );
    else
        printf( "\nTask 7 semTake on SEM1 returned error %x\r\n", errno );

    /************************************************************************
    **  Next wait on SEM2 to demonstrate semTake without wait.
    ************************************************************************/
    puts( "Signalling complt7 to Task 1 - Task 7 ready to test NO_WAIT." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x", errno );
    }

    puts( "\nTask 7 waiting on enable7 to begin acquiring token from SEM2" );
    errno = 0;
    err = semTake( enable7, WAIT_FOREVER );
    if ( err == ERROR )
    { 
        printf( " returned error %x\r\n", errno );
    }

    /*
    **  Consume a token from SEM2 without waiting.
    */
    puts( "\nTask 7 attempting to acquire token from SEM2 without waiting." );
    errno = 0;
    if ( (err = semTake( sema42_id, NO_WAIT )) == OK )
        printf( "\r\nTask 7 acquired token from SEM2\r\n" );
    else
        printf( "\nTask 7 semTake on SEM2 returned error %x\r\n", errno );
    puts( "Signalling complt7 to Task 1 - Task 7 ready to test SEM_Q_PRIORITY." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /************************************************************************
    **  Next wait on SEM3 in pre-determined task order to test priority-based
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 7 waiting on enable7 to begin acquiring token from SEM3" );
    errno = 0;
    err = semTake( enable7, WAIT_FOREVER );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    puts( "Task 7 signalling complt7 to Task 1 to indicate Task 7 ready." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume one token from SEM3.
    */
    puts( "\nTask 7 waiting up to 1 second to acquire token from SEM3" );
    if ( (err = semTake( sema43_id, 100 )) == OK )
        printf( "\r\nTask 7 acquired token from SEM3\r\n" );
    else
        printf( "\nTask 7 semTake on SEM3 returned error %x\r\n", errno );

    puts( "Signalling complt7 to Task 1 - Task 7 ready for semDelete test." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Consume one token from SEM1.
    */
    puts( "\nTask 7 waiting indefinitely to acquire token from SEM1" );
    errno = 0;
    if ( (err = semTake( sema41_id, WAIT_FOREVER )) == OK )
        printf( "\r\nTask 7 acquired token from SEM1\r\n" );
    else
        printf( "\nTask 7 semTake on SEM1 returned error %x\r\n", errno );

    puts( "Signalling complt7 to Task 1 - Task 7 finished semDelete test." );
    errno = 0;
    err = semGive( complt7 );
    if ( err == ERROR )
    {
        printf( " returned error %x", errno );
    }

    /*
    **  Tests all done... delete our own task.
    */
    puts( "\n.......... Task 7 deleting itself." );
    errno = 0;
    err = taskDelete( 0 );

    return( 0 );
}

/*****************************************************************************
**  task6
*****************************************************************************/
int task6( int dummy0, int dummy1, int dummy2, int dummy3, int dummy4,
           int dummy5, int dummy6, int dummy7, int dummy8, int dummy9 )
{
    STATUS err;
    msgblk_t msg;
    union
    {
        char     blk[128];
        my_qmsg_t msg;
    } bigmsg;
    int i;

    /************************************************************************
    **  First wait on empty MSQ1 in pre-determined task order to test
    **  task wait-queueing order ( FIFO vs. PRIORITY ).
    ************************************************************************/
    puts( "\nTask 6 waiting on enable6 to begin receive on MSQ1" );
    errno = 0;
    err = semTake( enable6, WAIT_FOREVER );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /*
    **  Consume 3 messages from MSQ1.
    */
    puts( "\nTask 6 waiting indefinitely to receive 3 msgs on MSQ1" );
    for ( i = 0; i < 3; i++ )
    {
        errno = 0;
        err = msgQReceive( queue1_id, msg.blk, 16, WAIT_FOREVER );
        if ( err != ERROR )
        {
            printf( "\r\nTask 6 rcvd Test Cycle %d Msg No. %d from %s\r\n",
                    msg.msg.t_cycle, msg.msg.msg_no, msg.msg.qname );
        }
        else
        {
            printf( "\nTask 6 msgQReceive on MSQ1 returned error %x\r\n",
                    errno );
            break;
        }
    }
    puts( "Signalling complt6 to Task 1 - Task 6 finished queuing order test." );
    errno = 0;
    err = semGive( complt6 );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /************************************************************************
    **  Now wait along with other tasks on empty MSQ1 to demonstrate
    **  queue delete behavior.
    ************************************************************************/
    puts( "\nTask 6 waiting on enable6 to begin receive on MSQ1" );
    errno = 0;
    err = semTake( enable6, WAIT_FOREVER );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    puts( "Task 6 signalling complt6 to Task 1 to indicate Task 6 ready." );
    errno = 0;
    err = semGive( complt6 );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /*
    **  Consume messages until 1 second elapses without an available message.
    */
    puts( "\nTask 6 waiting up to 1 sec to receive msgs on MSQ1" );
    while( 1 )
    {
        errno = 0;
        err = msgQReceive( queue1_id, msg.blk, 16, 100 );
        if ( err != ERROR )
        {
            printf( "\r\nTask 6 rcvd Test Cycle %d Msg No. %d from %s\r\n",
                    msg.msg.t_cycle, msg.msg.msg_no, msg.msg.qname );
        }
        else
        {
            printf( "\nTask 6 msgQReceive on MSQ1 returned error %x\r\n",
                    errno );
            break;
        }
    }
    puts( "Signalling complt6 to Task 1 - Task 6 finished msgQDelete test." );
    errno = 0;
    err = semGive( complt6 );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    /************************************************************************
    **  Now send a message to MSQ3 to demonstrate wait-to-send behavior
    **  during queue deletion.
    ************************************************************************/
    puts( "\nTask 6 waiting on enable6 to send msg to MSQ3" );
    errno = 0;
    err = semTake( enable6, WAIT_FOREVER );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    puts( "Task 6 signalling complt6 to Task 1 to indicate Task 6 ready." );
    errno = 0;
    err = semGive( complt6 );
    if ( err == ERROR )
    {
        printf( " returned error %x\r\n", errno );
    }

    msg.msg.msg_no = 13;
    msg.msg.qname[3] = '3';
    printf( "\r\nTask 6 waiting indefinitely to send msg 13 to MSQ3\r\n" );
    errno = 0;
    err =