Files
rtems/testsuites/libtests/block06/init.c
T
2026-03-02 23:21:49 +01:00

1781 lines
41 KiB
C

/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright 2008 Chris Johns (chrisj@rtems.org)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* BD Buffer test.
*
* Please add more tests
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <errno.h>
#include <fcntl.h>
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <inttypes.h>
#include <unistd.h>
#include <rtems.h>
#include <rtems/chain.h>
#include <rtems/error.h>
#include <rtems/bdbuf.h>
#include <bsp.h>
#include "tmacros.h"
const char rtems_test_name[] = "BLOCK 6";
/* forward declarations to avoid warnings */
static rtems_task Init( rtems_task_argument argument );
#define BDBUF_DISKS 2
#define BDBUF_SIZE 1024
#if 0
const rtems_bdbuf_config rtems_bdbuf_configuration =
{
5, /* max_read_ahead_blocks */
5, /* max_write_blocks */
15, /* swapout_priority */
250, /* swapout_period */
1000, /* swap_block_hold */
0, /* swapout_workers */
15, /* swapout_worker_priority */
1024 * 1024, /* size */
512, /* buffer_min */
4096 /* buffer_max */
};
#endif
/**
* The bdbuf disk driver base name.
*/
#define BDBUF_DISK_DEVICE_BASE_NAME "/dev/bddisk"
/**
* The actions the disk driver handles.
*/
typedef enum bdbuf_disk_action {
BDBUF_DISK_NOOP,
BDBUF_DISK_WAIT,
BDBUF_DISK_SLEEP,
BDBUF_DISK_BLOCKS_INORDER
} bdbuf_disk_action;
/**
* The BDBUF Disk driver.
*/
typedef struct bdbuf_disk {
const char *name;
uint32_t minor;
rtems_id lock;
uint32_t block_size;
uint32_t block_count;
bdbuf_disk_action driver_action;
const char *watcher_name;
rtems_id watcher;
int watch_count;
const char *waiting_name;
rtems_id waiting;
uint32_t driver_sleep;
rtems_disk_device *dd;
} bdbuf_disk;
/*
* A disk drive for each pool.
*/
static bdbuf_disk bdbuf_disks[ BDBUF_DISKS ];
/**
* Task control.
*/
typedef struct bdbuf_task_control {
bool die;
const char *name;
rtems_id task;
rtems_id master;
int test;
bdbuf_disk *bdd;
bool passed;
} bdbuf_task_control;
#define BDBUF_TEST_TASKS ( 3 )
#define BDBUF_TEST_STACK_SIZE ( 2 * RTEMS_MINIMUM_STACK_SIZE )
/**
* Seconds as milli-seconds.
*/
#define BDBUF_SECONDS( msec ) ( ( msec ) * 1000UL )
/**
* Print the status code description and return true if true.
*
* @param sc The RTEMS status code.
* @retval true The status code is successful.
* @retval false The status code is not successful.
*/
static bool bdbuf_test_print_sc( rtems_status_code sc, bool newline )
{
if ( newline ) {
printf( "%s\n", rtems_status_text( sc ) );
} else {
printf( "%s", rtems_status_text( sc ) );
}
return sc == RTEMS_SUCCESSFUL;
}
/**
* BDBuf disk device driver lock.
*/
static bool bdbuf_disk_lock( bdbuf_disk *bdd )
{
rtems_status_code sc;
sc = rtems_semaphore_obtain( bdd->lock, RTEMS_WAIT, 0 );
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "disk ioctl: lock failed: " );
bdbuf_test_print_sc( sc, true );
return false;
}
return true;
}
/**
* BDBuf disk device driver unlock.
*/
static bool bdbuf_disk_unlock( bdbuf_disk *bdd )
{
rtems_status_code sc;
sc = rtems_semaphore_release( bdd->lock );
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "disk ioctl: unlock failed: " );
bdbuf_test_print_sc( sc, true );
return false;
}
return true;
}
/**
* BDBUf wait for the wait event.
*/
static rtems_status_code bdbuf_wait( const char *who, unsigned long timeout )
{
rtems_status_code sc;
rtems_event_set out;
sc = rtems_event_receive(
RTEMS_EVENT_0,
RTEMS_WAIT | RTEMS_EVENT_ANY,
RTEMS_MICROSECONDS_TO_TICKS( timeout * 1000 ),
&out
);
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "%s: wait: receive failed: ", who );
bdbuf_test_print_sc( sc, true );
} else if ( ( out & RTEMS_EVENT_0 ) == 0 ) {
printf(
"%s: wait: received wrong event: %08" PRIxrtems_event_set,
who,
out
);
}
return sc;
}
/**
* BDBUf send wait event.
*/
static bool bdbuf_send_wait_event(
const char *task,
const char *msg,
rtems_id id
)
{
printf( "%s: %s: %08" PRIxrtems_id ": ", task, msg, id );
return bdbuf_test_print_sc( rtems_event_send( id, RTEMS_EVENT_0 ), true );
}
/**
* BDBUf wait for the wait event.
*/
static rtems_status_code bdbuf_watch( unsigned long timeout )
{
rtems_status_code sc;
rtems_event_set out;
sc = rtems_event_receive(
RTEMS_EVENT_1,
RTEMS_WAIT | RTEMS_EVENT_ANY,
RTEMS_MICROSECONDS_TO_TICKS( timeout * 1000 ),
&out
);
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "watch: receive failed: " );
bdbuf_test_print_sc( sc, true );
} else if ( ( out & RTEMS_EVENT_1 ) == 0 ) {
printf( "watch: received wrong event: %08" PRIxrtems_event_set, out );
}
return sc;
}
/**
* BDBUf send wait event.
*/
static bool bdbuf_send_watch_event(
const char *task,
const char *msg,
rtems_id id
)
{
printf( "%s: %s: %08" PRIxrtems_id ": ", task, msg, id );
return bdbuf_test_print_sc( rtems_event_send( id, RTEMS_EVENT_1 ), true );
}
/**
* Set up a disk driver watch.
*/
static void bdbuf_set_disk_driver_watch( bdbuf_task_control *tc, int count )
{
/*
* Set up a disk watch and wait for the write to happen.
*/
bdbuf_disk_lock( tc->bdd );
tc->bdd->watcher_name = tc->name;
tc->bdd->watcher = tc->task;
tc->bdd->watch_count = count;
bdbuf_disk_unlock( tc->bdd );
}
/**
* Clear the disk driver watch.
*/
static void bdbuf_clear_disk_driver_watch( bdbuf_task_control *tc )
{
/*
* Set up a disk watch and wait for the write to happen.
*/
bdbuf_disk_lock( tc->bdd );
tc->bdd->watcher_name = 0;
tc->bdd->watcher = 0;
tc->bdd->watch_count = 0;
bdbuf_disk_unlock( tc->bdd );
}
/**
* Wait for the disk driver watch.
*/
static bool bdbuf_disk_driver_watch_wait(
bdbuf_task_control *tc,
unsigned long msecs
)
{
bool passed = true;
rtems_status_code sc = bdbuf_watch( msecs );
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "%s: driver watch: driver wait: ", tc->name );
passed = bdbuf_test_print_sc( sc, true );
}
bdbuf_clear_disk_driver_watch( tc );
return passed;
}
/**
* Set the disk driver action.
*/
static void bdbuf_set_disk_driver_action(
bdbuf_task_control *tc,
bdbuf_disk_action action
)
{
/*
* Set up a disk action.
*/
bdbuf_disk_lock( tc->bdd );
tc->bdd->driver_action = action;
bdbuf_disk_unlock( tc->bdd );
}
/**
* BDBUF Sleep.
*/
static bool bdbuf_sleep( unsigned long msecs )
{
rtems_status_code sc;
sc = rtems_task_wake_after( RTEMS_MICROSECONDS_TO_TICKS( msecs * 1000 ) );
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "sleep wake after failed: " );
bdbuf_test_print_sc( sc, true );
return false;
}
return true;
}
/**
* Initialise a task control.
*/
static void bdbuf_task_control_init(
int task,
bdbuf_task_control *tc,
rtems_id master
)
{
char name[ 6 ];
sprintf( name, "bdt%d", task );
tc->die = false;
tc->name = strdup( name ); /* leaks */
tc->task = 0;
tc->master = master;
tc->test = 0;
tc->bdd = NULL;
tc->passed = false;
}
static bool bdbuf_disk_ioctl_watcher( bdbuf_disk *bdd, int update )
{
/*
* Always wake the watcher.
*/
if ( bdd->watcher ) {
if ( bdd->watch_count ) {
if ( update > bdd->watch_count ) {
bdd->watch_count -= update;
} else {
bdd->watch_count = 0;
}
}
if ( bdd->watch_count == 0 ) {
bdbuf_send_watch_event(
bdd->watcher_name,
"disk ioctl: wake watcher",
bdd->watcher
);
bdd->watcher = 0;
}
}
return true;
}
static bool bdbuf_disk_ioctl_process(
bdbuf_disk *bdd,
rtems_blkdev_request *req
)
{
bool result = true;
uint32_t b;
/*
* Perform the requested action.
*/
switch ( bdd->driver_action ) {
case BDBUF_DISK_NOOP:
break;
case BDBUF_DISK_WAIT:
if ( bdd->waiting ) {
printf(
"disk ioctl: bad waiter: %s:%08" PRIxrtems_id "\n",
bdd->waiting_name,
bdd->waiting
);
}
bdd->waiting_name = "bdd";
bdd->waiting = rtems_task_self();
if ( bdbuf_disk_unlock( bdd ) ) {
result = bdbuf_wait( bdd->name, 0 ) == RTEMS_SUCCESSFUL;
} else {
result = false;
}
/*
* Ignore any error if one happens.
*/
bdbuf_disk_lock( bdd );
break;
case BDBUF_DISK_SLEEP:
printf( "disk ioctl: sleeping: %" PRId32 " msecs\n", bdd->driver_sleep );
result = bdbuf_sleep( bdd->driver_sleep );
break;
case BDBUF_DISK_BLOCKS_INORDER:
printf(
"disk ioctl: multi-block order check: count = %" PRId32 "\n",
req->bufnum
);
for ( b = 0; b < ( req->bufnum - 1 ); b++ ) {
if ( req->bufs[ b ].block >= req->bufs[ b + 1 ].block ) {
printf(
"disk ioctl: out of order: index:%d "
"(%" PRIdrtems_blkdev_bnum " >= %" PRIdrtems_blkdev_bnum "\n",
b,
req->bufs[ b ].block,
req->bufs[ b + 1 ].block
);
}
}
break;
default:
printf( "disk ioctl: invalid action: %d\n", bdd->driver_action );
result = false;
break;
}
return result;
}
static bool bdbuf_disk_ioctl_leave( bdbuf_disk *bdd, int buffer_count )
{
/*
* Handle the watcher.
*/
bdbuf_disk_ioctl_watcher( bdd, buffer_count );
return true;
}
/**
* BDBuf disk IOCTL handler.
*
* @param dd Disk device.
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int bdbuf_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
{
rtems_blkdev_request *r = argp;
bdbuf_disk *bdd = rtems_disk_get_driver_data( dd );
errno = 0;
if ( !bdbuf_disk_lock( bdd ) ) {
errno = EIO;
} else {
switch ( req ) {
case RTEMS_BLKIO_REQUEST:
switch ( r->req ) {
case RTEMS_BLKDEV_REQ_READ:
if ( !bdbuf_disk_ioctl_process( bdd, r ) ) {
rtems_blkdev_request_done( r, RTEMS_IO_ERROR );
} else {
rtems_blkdev_sg_buffer *sg = r->bufs;
uint32_t block = RTEMS_BLKDEV_START_BLOCK( r );
uint32_t b;
for ( b = 0; b < r->bufnum; b++, block++, sg++ ) {
uint32_t length = sg->length;
if ( sg->length != bdd->block_size ) {
if ( length > bdd->block_size ) {
length = bdd->block_size;
}
}
memset( sg->buffer, block, length );
}
rtems_blkdev_request_done( r, RTEMS_SUCCESSFUL );
}
bdbuf_disk_ioctl_leave( bdd, r->bufnum );
break;
case RTEMS_BLKDEV_REQ_WRITE:
if ( !bdbuf_disk_ioctl_process( bdd, r ) ) {
rtems_blkdev_request_done( r, RTEMS_IO_ERROR );
} else {
rtems_blkdev_request_done( r, RTEMS_SUCCESSFUL );
}
bdbuf_disk_ioctl_leave( bdd, r->bufnum );
break;
default:
errno = EINVAL;
break;
}
break;
default:
rtems_blkdev_ioctl( dd, req, argp );
break;
}
if ( !bdbuf_disk_unlock( bdd ) ) {
errno = EIO;
}
}
return errno == 0 ? 0 : -1;
}
static rtems_status_code bdbuf_disk_initialize( void )
{
uint32_t minor;
printf( "register disks\n" );
for ( minor = 0; minor < BDBUF_DISKS; minor++ ) {
char name[ sizeof( BDBUF_DISK_DEVICE_BASE_NAME ) + 10 ];
bdbuf_disk *bdd = &bdbuf_disks[ minor ];
rtems_status_code sc;
int fd;
int rv;
snprintf(
name,
sizeof( name ),
BDBUF_DISK_DEVICE_BASE_NAME "%" PRIu32,
minor
);
bdd->name = strdup( name );
bdd->minor = minor;
printf( "disk init: %s\n", bdd->name );
printf( "disk lock: " );
sc = rtems_semaphore_create(
rtems_build_name( 'B', 'D', 'D', 'K' ),
1,
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&bdd->lock
);
if ( !bdbuf_test_print_sc( sc, true ) ) {
return RTEMS_IO_ERROR;
}
bdd->block_size = 512 * ( minor + 1 );
bdd->block_count = BDBUF_SIZE * ( minor + 1 );
sc = rtems_blkdev_create(
name,
bdd->block_size,
bdd->block_count,
bdbuf_disk_ioctl,
bdd
);
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "disk init: create phys failed: " );
bdbuf_test_print_sc( sc, true );
return sc;
}
fd = open( name, O_RDWR );
rtems_test_assert( fd >= 0 );
rv = rtems_disk_fd_get_disk_device( fd, &bdd->dd );
rtems_test_assert( rv == 0 );
rv = close( fd );
rtems_test_assert( rv == 0 );
}
return RTEMS_SUCCESSFUL;
}
static bool bdbuf_tests_create_task(
bdbuf_task_control *tc,
rtems_task_priority priority,
rtems_task_entry entry_point
)
{
rtems_status_code sc;
printf(
"creating task: %s: priority: %" PRIdrtems_task_priority ": ",
tc->name,
priority
);
sc = rtems_task_create(
rtems_build_name(
tc->name[ 0 ],
tc->name[ 1 ],
tc->name[ 2 ],
tc->name[ 3 ]
),
priority,
BDBUF_TEST_STACK_SIZE,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
&tc->task
);
if ( !bdbuf_test_print_sc( sc, true ) ) {
return false;
}
printf( "starting task: %s: ", tc->name );
sc = rtems_task_start( tc->task, entry_point, (rtems_task_argument) tc );
return bdbuf_test_print_sc( sc, true );
}
/**
* Get the block 0 buffer twice. The first time it is requested it
* will be taken from the empty list and returned to the LRU list.
* The second time it will be removed from the LRU list.
*/
static void bdbuf_tests_task_0_test_1( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
int i;
rtems_bdbuf_buffer *bd;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
for ( i = 0; ( i < 2 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_get[0]: ", tc->name );
sc = rtems_bdbuf_get( tc->bdd->dd, 0, &bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
break;
}
printf( "%s: rtems_bdbuf_release[0]: ", tc->name );
sc = rtems_bdbuf_release( bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
break;
}
}
tc->passed = passed;
tc->test = 0;
}
/**
* Get the blocks 0 -> 4 and hold them. Wake the master to tell it was have the
* buffers then wait for the master to tell us to release a single buffer.
* Task 1 will be block waiting for each buffer. It is a higher priority.
*/
static void bdbuf_tests_task_0_test_2( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
int i;
rtems_bdbuf_buffer *bd;
rtems_chain_control buffers;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
/*
* Get the blocks 0 -> 4 and hold them.
*/
rtems_chain_initialize_empty( &buffers );
for ( i = 0; ( i < 5 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_get[%d]: ", tc->name, i );
sc = rtems_bdbuf_get( tc->bdd->dd, i, &bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
}
rtems_chain_append( &buffers, &bd->link );
}
/*
* Wake the master to tell it we have the buffers.
*/
bdbuf_send_wait_event( tc->name, "wake master", tc->master );
if ( passed ) {
/*
* For each buffer we hold wait until the master wakes us
* and then return it. Task 2 will block waiting for this
* buffer. It is a higher priority task.
*/
for ( i = 0; ( i < 5 ) && passed; i++ ) {
sc = bdbuf_wait( tc->name, BDBUF_SECONDS( 5 ) );
if ( sc != RTEMS_SUCCESSFUL ) {
printf( "%s: wait failed: ", tc->name );
bdbuf_test_print_sc( sc, true );
passed = false;
break;
} else {
printf(
"%s: rtems_bdbuf_release[%d]: unblocks task 1\n",
tc->name,
i
);
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
sc = rtems_bdbuf_release( bd );
printf( "%s: rtems_bdbuf_release[%d]: ", tc->name, i );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
break;
}
}
}
}
tc->passed = passed;
tc->test = 0;
}
/**
* Read the block 5 from the disk modify it then release it modified.
*/
static void bdbuf_tests_task_0_test_3( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
rtems_bdbuf_buffer *bd;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
bdbuf_disk_lock( tc->bdd );
tc->bdd->driver_action = BDBUF_DISK_NOOP;
bdbuf_disk_unlock( tc->bdd );
/*
* Read the buffer and then release it.
*/
printf( "%s: rtems_bdbuf_read[5]: ", tc->name );
sc = rtems_bdbuf_read( tc->bdd->dd, 5, &bd );
if (( passed = bdbuf_test_print_sc( sc, true ) )) {
printf( "%s: rtems_bdbuf_release_modified[5]: ", tc->name );
sc = rtems_bdbuf_release_modified( bd );
passed = bdbuf_test_print_sc( sc, true );
}
/*
* Read the buffer again and then just release. The buffer should
* be maintained as modified.
*/
printf( "%s: rtems_bdbuf_read[5]: ", tc->name );
sc = rtems_bdbuf_read( tc->bdd->dd, 5, &bd );
if (( passed = bdbuf_test_print_sc( sc, true ) )) {
printf( "%s: rtems_bdbuf_release[5]: ", tc->name );
sc = rtems_bdbuf_release( bd );
passed = bdbuf_test_print_sc( sc, true );
}
/*
* Set up a disk watch and wait for the write to happen.
*/
bdbuf_set_disk_driver_watch( tc, 1 );
passed = bdbuf_disk_driver_watch_wait( tc, BDBUF_SECONDS( 5 ) );
tc->passed = passed;
tc->test = 0;
}
static size_t bdbuf_test_buffer_count( void )
{
return rtems_bdbuf_configuration.size / rtems_bdbuf_configuration.buffer_min;
}
/**
* Get all the blocks in the pool and hold them. Wake the master to tell it was
* have the buffers then wait for the master to tell us to release them.
*/
static void bdbuf_tests_task_0_test_4( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
size_t i;
rtems_bdbuf_buffer *bd;
rtems_chain_control buffers;
size_t num = bdbuf_test_buffer_count();
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
/*
* Clear any disk settings.
*/
bdbuf_clear_disk_driver_watch( tc );
bdbuf_set_disk_driver_action( tc, BDBUF_DISK_NOOP );
/*
* Get the blocks 0 -> 4 and hold them.
*/
rtems_chain_initialize_empty( &buffers );
for ( i = 0; ( i < num ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_read[%zd]: ", tc->name, i );
sc = rtems_bdbuf_read( tc->bdd->dd, i, &bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
}
rtems_chain_append( &buffers, &bd->link );
}
/*
* Wake the master to tell it we have the buffers.
*/
bdbuf_send_wait_event( tc->name, "wake master", tc->master );
if ( passed ) {
bdbuf_sleep( 250 );
bdbuf_set_disk_driver_watch( tc, num / 2 );
/*
* Release half the buffers, wait 500msecs then release the
* remainder. This tests the swap out timer on each buffer.
*/
printf(
"%s: rtems_bdbuf_release_modified[0]: unblocks task 1\n",
tc->name
);
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
sc = rtems_bdbuf_release_modified( bd );
printf( "%s: rtems_bdbuf_release_modified[0]: ", tc->name );
passed = bdbuf_test_print_sc( sc, true );
if ( passed ) {
for ( i = 1; ( i < ( num / 2 ) ) && passed; i++ ) {
printf(
"%s: rtems_bdbuf_release_modified[%zd]: "
"unblocks task 1\n",
tc->name,
i
);
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
sc = rtems_bdbuf_release_modified( bd );
printf( "%s: rtems_bdbuf_release_modified[%zd]: ", tc->name, i );
passed = bdbuf_test_print_sc( sc, true );
if ( !passed ) {
break;
}
}
if ( passed ) {
passed = bdbuf_disk_driver_watch_wait( tc, BDBUF_SECONDS( 5 ) );
if ( passed ) {
bdbuf_sleep( 500 );
bdbuf_set_disk_driver_watch( tc, num / 2 );
for ( i = 0; ( i < ( num / 2 ) ) && passed; i++ ) {
printf(
"%s: rtems_bdbuf_release_modified[%zd]: ",
tc->name,
i + ( num / 2 )
);
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
passed = bdbuf_test_print_sc(
rtems_bdbuf_release_modified( bd ),
true
);
if ( !passed ) {
break;
}
}
passed = bdbuf_disk_driver_watch_wait( tc, BDBUF_SECONDS( 5 ) );
if ( passed ) {
if ( !rtems_chain_is_empty( &buffers ) ) {
passed = false;
printf( "%s: buffer chain not empty\n", tc->name );
}
}
}
}
}
}
tc->passed = passed;
tc->test = 0;
}
static void bdbuf_tests_task_0_test_5( bdbuf_task_control *tc )
{
bdbuf_tests_task_0_test_4( tc );
}
static void bdbuf_tests_task_0_test_6( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
int i;
rtems_bdbuf_buffer *bd;
rtems_chain_control buffers;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
/*
* Clear any disk settings.
*/
bdbuf_clear_disk_driver_watch( tc );
bdbuf_set_disk_driver_action( tc, BDBUF_DISK_NOOP );
/*
* Get the blocks 0 -> 4 and hold them.
*/
rtems_chain_initialize_empty( &buffers );
for ( i = 0; ( i < 5 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_read[%d]: ", tc->name, i );
sc = rtems_bdbuf_get( tc->bdd->dd, i, &bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
}
rtems_chain_append( &buffers, &bd->link );
}
for ( i = 0; ( i < 4 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i );
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
passed = bdbuf_test_print_sc( rtems_bdbuf_release_modified( bd ), true );
}
if ( passed ) {
printf( "%s: rtems_bdbuf_sync[%d]: ", tc->name, i );
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
passed = bdbuf_test_print_sc( rtems_bdbuf_sync( bd ), true );
}
tc->passed = passed;
tc->test = 0;
}
static void bdbuf_tests_task_0_test_7( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
int i;
rtems_bdbuf_buffer *bd;
rtems_chain_control buffers;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
/*
* Clear any disk settings.
*/
bdbuf_clear_disk_driver_watch( tc );
bdbuf_set_disk_driver_action( tc, BDBUF_DISK_NOOP );
/*
* Get the blocks 0 -> 4 and hold them.
*/
rtems_chain_initialize_empty( &buffers );
for ( i = 0; ( i < 5 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_read[%d]: ", tc->name, i );
sc = rtems_bdbuf_get( tc->bdd->dd, i, &bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
}
rtems_chain_append( &buffers, &bd->link );
}
for ( i = 0; ( i < 5 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i );
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
passed = bdbuf_test_print_sc( rtems_bdbuf_release_modified( bd ), true );
}
if ( passed ) {
printf(
"%s: rtems_bdbuf_syncdev[%" PRIu32 ": ",
tc->name,
tc->bdd->minor
);
passed = bdbuf_test_print_sc( rtems_bdbuf_syncdev( tc->bdd->dd ), true );
}
tc->passed = passed;
tc->test = 0;
}
static void bdbuf_tests_task_0_test_8( bdbuf_task_control *tc )
{
rtems_status_code sc;
bool passed;
int i;
rtems_bdbuf_buffer *bd;
rtems_chain_control buffers;
rtems_chain_node *node;
rtems_chain_node *pnode;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
/*
* Clear any disk settings.
*/
bdbuf_clear_disk_driver_watch( tc );
bdbuf_set_disk_driver_action( tc, BDBUF_DISK_NOOP );
/*
* Get the blocks 0 -> 4 and hold them.
*/
rtems_chain_initialize_empty( &buffers );
for ( i = 0; ( i < 5 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_read[%d]: ", tc->name, i );
sc = rtems_bdbuf_get( tc->bdd->dd, i, &bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
}
rtems_chain_append( &buffers, &bd->link );
}
node = rtems_chain_tail( &buffers );
node = node->previous;
bd = (rtems_bdbuf_buffer *) node;
pnode = node->previous;
rtems_chain_extract( node );
node = pnode;
printf( "%s: rtems_bdbuf_release_modified[4]: ", tc->name );
passed = bdbuf_test_print_sc( rtems_bdbuf_release_modified( bd ), true );
bd = (rtems_bdbuf_buffer *) node;
pnode = node->previous;
rtems_chain_extract( node );
node = pnode;
printf( "%s: rtems_bdbuf_release_modified[3]: ", tc->name );
passed = bdbuf_test_print_sc( rtems_bdbuf_release_modified( bd ), true );
for ( i = 0; ( i < 3 ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i );
bd = (rtems_bdbuf_buffer *) rtems_chain_get( &buffers );
passed = bdbuf_test_print_sc( rtems_bdbuf_release_modified( bd ), true );
}
if ( passed ) {
/*
* Check the block order.
*/
bdbuf_set_disk_driver_action( tc, BDBUF_DISK_BLOCKS_INORDER );
printf(
"%s: rtems_bdbuf_syncdev[%" PRIu32 "]: checking order\n",
tc->name,
tc->bdd->minor
);
sc = rtems_bdbuf_syncdev( tc->bdd->dd );
printf(
"%s: rtems_bdbuf_syncdev[%" PRIu32 "]: ",
tc->name,
tc->bdd->minor
);
passed = bdbuf_test_print_sc( sc, true );
}
tc->passed = passed;
tc->test = 0;
}
static void bdbuf_tests_task_0( rtems_task_argument arg )
{
(void) arg;
bdbuf_task_control *tc = (bdbuf_task_control *) arg;
while ( !tc->die ) {
switch ( tc->test ) {
case 0:
/*
* Wait for the next test.
*/
bdbuf_wait( tc->name, 0 );
break;
case 1:
bdbuf_tests_task_0_test_1( tc );
break;
case 2:
bdbuf_tests_task_0_test_2( tc );
break;
case 3:
bdbuf_tests_task_0_test_3( tc );
break;
case 4:
bdbuf_tests_task_0_test_4( tc );
break;
case 5:
bdbuf_tests_task_0_test_5( tc );
break;
case 6:
bdbuf_tests_task_0_test_6( tc );
break;
case 7:
bdbuf_tests_task_0_test_7( tc );
break;
case 8:
bdbuf_tests_task_0_test_8( tc );
break;
default:
/*
* Invalid test for this task. An error.
*/
printf( "%s: invalid test: %d\n", tc->name, tc->test );
tc->passed = false;
tc->test = 0;
break;
}
}
printf( "%s: delete task\n", tc->name );
rtems_task_exit();
}
/**
* Get the blocks 0 -> 4 and release them. Task 0 should be holding
* each one.
*/
static void bdbuf_tests_ranged_get_release(
bdbuf_task_control *tc,
bool wake_master,
int lower,
int upper
)
{
rtems_status_code sc;
bool passed;
int i;
rtems_bdbuf_buffer *bd;
/*
* Set task control's passed to false to handle a timeout.
*/
tc->passed = false;
passed = true;
for ( i = lower; ( i < upper ) && passed; i++ ) {
printf( "%s: rtems_bdbuf_get[%d]: blocking ...\n", tc->name, i );
sc = rtems_bdbuf_get( tc->bdd->dd, i, &bd );
printf( "%s: rtems_bdbuf_get[%d]: ", tc->name, i );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
break;
}
printf( "%s: rtems_bdbuf_release[%d]: ", tc->name, i );
sc = rtems_bdbuf_release( bd );
if ( !bdbuf_test_print_sc( sc, true ) ) {
passed = false;
break;
}
/*
* Wake the master to tell it we have finished.
*/
if ( wake_master ) {
bdbuf_send_wait_event( tc->name, "wake master", tc->master );
}
}
tc->passed = passed;
tc->test = 0;
}
static void bdbuf_tests_task_1( rtems_task_argument arg )
{
(void) arg;
bdbuf_task_control *tc = (bdbuf_task_control *) arg;
while ( !tc->die ) {
switch ( tc->test ) {
case 0:
/*
* Wait for the next test.
*/
bdbuf_wait( tc->name, 0 );
break;
case 2:
bdbuf_tests_ranged_get_release( tc, false, 0, 5 );
break;
case 4:
bdbuf_tests_ranged_get_release( tc, false, 0, 9 );
break;
case 5:
bdbuf_tests_ranged_get_release( tc, false, 20, 25 );
break;
default:
/*
* Invalid test for this task. An error.
*/
printf( "%s: invalid test: %d\n", tc->name, tc->test );
tc->passed = false;
tc->test = 0;
break;
}
}
printf( "%s: delete task\n", tc->name );
rtems_task_exit();
}
/**
* Get the blocks 0 -> 4 and release them. Task 0 should be holding
* each one.
*/
static void bdbuf_tests_task_2_test_2( bdbuf_task_control *tc )
{
/*
* Use task 1's test 2. They are the same.
*/
bdbuf_tests_ranged_get_release( tc, true, 0, 5 );
}
static void bdbuf_tests_task_2( rtems_task_argument arg )
{
(void) arg;
bdbuf_task_control *tc = (bdbuf_task_control *) arg;
while ( !tc->die ) {
switch ( tc->test ) {
case 0:
/*
* Wait for the next test.
*/
bdbuf_wait( tc->name, 0 );
break;
case 2:
bdbuf_tests_task_2_test_2( tc );
break;
default:
/*
* Invalid test for this task. An error.
*/
printf( "%s: invalid test: %d\n", tc->name, tc->test );
tc->passed = false;
tc->test = 0;
break;
}
}
printf( "%s: delete task\n", tc->name );
rtems_task_exit();
}
/**
* Table of task entry points.
*/
static rtems_task_entry bdbuf_test_tasks[] =
{ bdbuf_tests_task_0, bdbuf_tests_task_1, bdbuf_tests_task_2 };
#define BDBUF_TESTS_PRI_HIGH ( 30 )
/**
* Wait for the all tests to finish. This is signalled by the test
* number becoming 0.
*/
static bool bdbuf_tests_finished( bdbuf_task_control *tasks )
{
uint32_t time = 0;
bool finished = false;
while ( time < ( 10 * 4 ) ) {
int t;
finished = true;
for ( t = 0; t < BDBUF_TEST_TASKS; t++ ) {
if ( tasks[ t ].test ) {
finished = false;
break;
}
}
if ( finished ) {
break;
}
bdbuf_sleep( 250 );
time++;
}
if ( !finished ) {
printf( "master: test timed out\n" );
} else {
int t;
for ( t = 0; t < BDBUF_TEST_TASKS; t++ ) {
if ( !tasks[ 0 ].passed ) {
finished = false;
break;
}
}
}
return finished;
}
/**
* Test 1.
*
* # Get task 0 to get buffer 0 from the pool then release it twice.
*/
static bool bdbuf_test_1( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 1;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* Test 2.
*
* # Get task 0 to get buffers 0 -> 4 from the pool hold them. Then get
* task 1 and task 2 to get them with blocking. The 2 tasks tests the
* priority blocking on the buffer.
*/
static bool bdbuf_test_2( bdbuf_task_control *tasks )
{
int i;
tasks[ 0 ].test = 2;
tasks[ 1 ].test = 2;
tasks[ 2 ].test = 2;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
tasks[ 1 ].bdd = &bdbuf_disks[ 0 ];
tasks[ 2 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0 and wait for it to have all the buffers.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
if ( bdbuf_wait( "master", BDBUF_SECONDS( 5 ) ) != RTEMS_SUCCESSFUL ) {
return false;
}
/*
* Wake task 1.
*/
bdbuf_send_wait_event( "master", "wake task 1", tasks[ 1 ].task );
/*
* Wake task 2.
*/
bdbuf_send_wait_event( "master", "wake task 2", tasks[ 2 ].task );
for ( i = 0; i < 5; i++ ) {
/*
* Wake task 0 and watch task 2 then task 1 get the released buffer.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
/*
* Wait until task 2 has the buffer.
*/
if ( bdbuf_wait( "master", BDBUF_SECONDS( 5 ) ) != RTEMS_SUCCESSFUL ) {
return false;
}
}
/*
* Wait for the tests to finish.
*/
return bdbuf_tests_finished( tasks );
}
/**
* Test 3.
*
* # Read a block from disk into the buffer, modify the block and release
* it modified. Use a block great then 4 because 0 -> 4 are in the cache.
*/
static bool bdbuf_test_3( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 3;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* Test 4.
*
* # Read every buffer in the pool and hold. Then get task 1 to ask for another
* buffer that is being accessed. It will block waiting for it to appear.
*/
static bool bdbuf_test_4( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 4;
tasks[ 1 ].test = 4;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
tasks[ 1 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
/*
* Wait for the buffers in the pool to be taken.
*/
if ( bdbuf_wait( "master", BDBUF_SECONDS( 5 ) ) != RTEMS_SUCCESSFUL ) {
return false;
}
bdbuf_sleep( 100 );
/*
* Wake task 1 to read another one and have to block.
*/
bdbuf_send_wait_event( "master", "wake task 1", tasks[ 1 ].task );
bdbuf_sleep( 100 );
/*
* Wake task 0 to release it buffers.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* Test 5.
*
* # Read every buffer in the pool and hold. Then get task 1 to ask for a new
* buffer. It will block waiting for one to appear.
*/
static bool bdbuf_test_5( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 5;
tasks[ 1 ].test = 5;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
tasks[ 1 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
/*
* Wait for the buffers in the pool to be taken.
*/
if ( bdbuf_wait( "master", BDBUF_SECONDS( 5 ) ) != RTEMS_SUCCESSFUL ) {
return false;
}
bdbuf_sleep( 100 );
/*
* Wake task 1 to read another one and have to block.
*/
bdbuf_send_wait_event( "master", "wake task 1", tasks[ 1 ].task );
bdbuf_sleep( 100 );
/*
* Wake task 0 to release it buffers.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* Test 6.
*
* # Get 5 buffers, release modify 4 then sync the last.
*/
static bool bdbuf_test_6( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 6;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* Test 7.
*
* # Get 5 buffers, release modify them all then sync the device.
*/
static bool bdbuf_test_7( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 7;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* Test 8.
*
* # Get 5 buffers, release modify the last 2 then the reset from 0.
*/
static bool bdbuf_test_8( bdbuf_task_control *tasks )
{
tasks[ 0 ].test = 8;
/*
* Use pool 0.
*/
tasks[ 0 ].bdd = &bdbuf_disks[ 0 ];
/*
* Wake task 0.
*/
bdbuf_send_wait_event( "master", "wake task 0", tasks[ 0 ].task );
return bdbuf_tests_finished( tasks );
}
/**
* A test.
*/
typedef bool ( *bdbuf_test )( bdbuf_task_control *tasks );
/**
* A test name and function.
*/
typedef struct bdbuf_test_ident {
const char *label;
bdbuf_test test;
} bdbuf_test_ident;
/**
* Table of tests.
*/
static bdbuf_test_ident bdbuf_tests[] = {
{ "Task 0 get buffer 0 from pool 0", bdbuf_test_1 },
{ "Task 0 get buffer 0 -> 4 from pool 0, task 2 and 1 block getting",
bdbuf_test_2 },
{ "Task 0 read buffer 5, modify and release modified", bdbuf_test_3 },
{ "Task 0 read all buffers, task 1 blocks waiting for acessed buffer",
bdbuf_test_4 },
{ "Task 0 read all buffers, task 1 blocks waiting for new buffer",
bdbuf_test_5 },
{ "Task 0 release modified 4 buffers then syncs a 5th buffer",
bdbuf_test_6 },
{ "Task 0 release modified 5 buffers then sync the device", bdbuf_test_7 },
{ "Task 0 releases modified 5 buffers is out or order sequence and the"
" driver checks the buffers are in order",
bdbuf_test_8 }
};
#define BDBUF_TEST_NUM ( sizeof( bdbuf_tests ) / sizeof( bdbuf_test_ident ) )
/**
* Test the BD Buffering code.
*/
static void bdbuf_tester( void )
{
bdbuf_task_control tasks[ BDBUF_TEST_TASKS ];
rtems_task_priority old_priority;
size_t t;
bool passed = true;
rtems_status_code sc;
sc = bdbuf_disk_initialize();
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
/*
* Change priority to a lower one.
*/
printf( "lower priority to %d: ", BDBUF_TESTS_PRI_HIGH + 1 );
bdbuf_test_print_sc(
rtems_task_set_priority(
RTEMS_SELF,
BDBUF_TESTS_PRI_HIGH + 1,
&old_priority
),
true
);
/*
* Make sure the swapout task has run. The user could block
* the swapout task from running until later. This is not
* tested.
*/
bdbuf_sleep( 100 );
/*
* Start the test tasks used to test the threading parts
* of the bdbuf code.
*/
for ( t = 0; t < BDBUF_TEST_TASKS; t++ ) {
bdbuf_task_control_init( t, &tasks[ t ], rtems_task_self() );
if ( !bdbuf_tests_create_task(
&tasks[ t ],
BDBUF_TESTS_PRI_HIGH - t,
bdbuf_test_tasks[ t ]
) ) {
return;
}
}
/*
* Let the test tasks run if they have not already done so.
*/
bdbuf_sleep( 100 );
/*
* Perform each test.
*/
for ( t = 0; ( t < BDBUF_TEST_NUM ) && passed; t++ ) {
printf( "test %zu: %s\n", t + 1, bdbuf_tests[ t ].label );
passed = bdbuf_tests[ t ].test( tasks );
printf( "test %zu: %s\n", t + 1, passed ? "passed" : "failed" );
}
}
static rtems_task Init( rtems_task_argument argument )
{
(void) argument;
TEST_BEGIN();
bdbuf_tester();
TEST_END();
exit( 0 );
}
#define CONFIGURE_INIT
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
#define CONFIGURE_BDBUF_TASK_STACK_SIZE BDBUF_TEST_STACK_SIZE
#define CONFIGURE_MAXIMUM_TASKS ( 1 + BDBUF_TEST_TASKS )
#define CONFIGURE_MAXIMUM_SEMAPHORES 2
#define CONFIGURE_EXTRA_TASK_STACKS \
( BDBUF_TEST_TASKS * BDBUF_TEST_STACK_SIZE )
#define CONFIGURE_INIT_TASK_STACK_SIZE BDBUF_TEST_STACK_SIZE
#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
#include <rtems/confdefs.h>