mirror of
https://gitlab.rtems.org/rtems/rtos/rtems.git
synced 2026-11-18 01:04:56 +08:00
Fix this warning. Signed-off-by: Sebastian Huber <sebastian.huber@embedded-brains.de>
1781 lines
41 KiB
C
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>
|