mirror of
https://gitlab.rtems.org/rtems/rtos/rtems.git
synced 2026-09-22 19:39:28 +08:00
libblock: Add sparse disk
This commit is contained in:
Ralf Kirchner
committed by
Sebastian Huber
Sebastian Huber
parent
c18e0ba127
commit
7fab7fc0cf
@@ -1,6 +1,7 @@
|
||||
ACLOCAL_AMFLAGS = -I ../aclocal
|
||||
|
||||
SUBDIRS = POSIX
|
||||
SUBDIRS += sparsedisk01
|
||||
SUBDIRS += block16
|
||||
SUBDIRS += block15
|
||||
SUBDIRS += block14
|
||||
|
||||
@@ -43,6 +43,7 @@ AM_CONDITIONAL(HAS_POSIX,test x"${rtems_cv_RTEMS_POSIX_API}" = x"yes")
|
||||
|
||||
# Explicitly list all Makefiles here
|
||||
AC_CONFIG_FILES([Makefile
|
||||
sparsedisk01/Makefile
|
||||
block16/Makefile
|
||||
mghttpd01/Makefile
|
||||
block15/Makefile
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
rtems_tests_PROGRAMS = sparsedisk01
|
||||
sparsedisk01_SOURCES = init.c
|
||||
|
||||
dist_rtems_tests_DATA = sparsedisk01.scn sparsedisk01.doc
|
||||
|
||||
include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP@.cfg
|
||||
include $(top_srcdir)/../automake/compile.am
|
||||
include $(top_srcdir)/../automake/leaf.am
|
||||
|
||||
AM_CPPFLAGS += -I$(top_srcdir)/../support/include
|
||||
|
||||
LINK_OBJS = $(sparsedisk01_OBJECTS)
|
||||
LINK_LIBS = $(sparsedisk01_LDLIBS)
|
||||
|
||||
sparsedisk01$(EXEEXT): $(sparsedisk01_OBJECTS) $(sparsedisk01_DEPENDENCIES)
|
||||
@rm -f sparsedisk01$(EXEEXT)
|
||||
$(make-exe)
|
||||
|
||||
include $(top_srcdir)/../automake/local.am
|
||||
@@ -0,0 +1,443 @@
|
||||
/*
|
||||
* Copyright (c) 2012 embedded brains GmbH. All rights reserved.
|
||||
*
|
||||
* embedded brains GmbH
|
||||
* Obere Lagerstr. 30
|
||||
* 82178 Puchheim
|
||||
* Germany
|
||||
* <rtems@embedded-brains.de>
|
||||
*
|
||||
* The license and distribution terms for this file may be
|
||||
* found in the file LICENSE in this distribution or at
|
||||
* http://www.rtems.com/license/LICENSE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <rtems/blkdev.h>
|
||||
#include "rtems/sparse-disk.h"
|
||||
|
||||
#include "tmacros.h"
|
||||
|
||||
/* Number of bytes for test pattern within a sparse disk container */
|
||||
#define STATIC_PATTERN_SIZE 4096
|
||||
|
||||
/* Block size used for the sparse disk in a sparse disk container */
|
||||
#define STATIC_BLOCK_SIZE 4096
|
||||
|
||||
/* Number of block allocated for the sparse disk in a sparse disk container */
|
||||
#define STATIC_ALLOCATED_BLOCK_COUNT 1
|
||||
|
||||
/* Blocks simulated by the sparse disk in a disk container */
|
||||
#define STATIC_SIMULATED_BLOCK_COUNT 4096
|
||||
|
||||
/*
|
||||
* Container which cotains a sparse disk + memory for key table and data as would get
|
||||
* allocated by rtems_sparse_disk_create() + memory for a memory test pattern
|
||||
* By using this container white box testing of a sparse disk becomes possible
|
||||
*/
|
||||
typedef struct {
|
||||
rtems_sparse_disk sparse_disk;
|
||||
rtems_sparse_disk_key keytable[STATIC_ALLOCATED_BLOCK_COUNT];
|
||||
uint8_t data[STATIC_BLOCK_SIZE * STATIC_ALLOCATED_BLOCK_COUNT];
|
||||
uint8_t pattern[STATIC_PATTERN_SIZE];
|
||||
} sparse_disk_container;
|
||||
|
||||
/*
|
||||
* Black box test the disk parameters of a sparse disk
|
||||
*/
|
||||
static void test_disk_params(
|
||||
const int file_descriptor,
|
||||
const uint32_t block_size,
|
||||
const uint32_t media_block_size,
|
||||
const rtems_blkdev_bnum block_number )
|
||||
{
|
||||
int rv;
|
||||
uint32_t value = 0;
|
||||
rtems_disk_device *fd_dd = NULL;
|
||||
rtems_blkdev_bnum block_count = 0;
|
||||
|
||||
|
||||
rv = rtems_disk_fd_get_media_block_size( file_descriptor, &value );
|
||||
rtems_test_assert( 0 == rv );
|
||||
rtems_test_assert( media_block_size == value );
|
||||
|
||||
value = 0;
|
||||
rv = rtems_disk_fd_get_block_size( file_descriptor, &value );
|
||||
rtems_test_assert( 0 == rv );
|
||||
rtems_test_assert( block_size == value );
|
||||
|
||||
block_count = 0;
|
||||
rv = rtems_disk_fd_get_block_count( file_descriptor, &block_count );
|
||||
rtems_test_assert( 0 == rv );
|
||||
rtems_test_assert( block_number == block_count );
|
||||
|
||||
rv = rtems_disk_fd_get_disk_device( file_descriptor, &fd_dd );
|
||||
rtems_test_assert( 0 == rv );
|
||||
rtems_test_assert( NULL != fd_dd );
|
||||
}
|
||||
|
||||
/*
|
||||
* Verify that writing to a sparse disk delivers expected results
|
||||
*/
|
||||
static void test_writing(
|
||||
const int file_descriptor,
|
||||
const uint32_t block_size,
|
||||
const rtems_blkdev_bnum blocks_allocated )
|
||||
{
|
||||
int rv;
|
||||
rtems_blkdev_bnum block_count = 0;
|
||||
unsigned int byte_count;
|
||||
off_t file_pos;
|
||||
uint8_t buff[block_size];
|
||||
|
||||
|
||||
/* Write a pattern to all allocated blocks */
|
||||
for ( block_count = 0; block_count < blocks_allocated; block_count++ ) {
|
||||
file_pos = (off_t) block_count * block_size;
|
||||
rv = lseek( file_descriptor, file_pos, SEEK_SET );
|
||||
rtems_test_assert( file_pos == rv );
|
||||
|
||||
rv = read( file_descriptor, buff, block_size );
|
||||
rtems_test_assert( block_size == rv );
|
||||
|
||||
for ( byte_count = 0;
|
||||
byte_count < ( block_size / sizeof( byte_count ) );
|
||||
byte_count++ ) {
|
||||
memcpy( buff + ( byte_count * sizeof( byte_count ) ), &byte_count,
|
||||
sizeof( byte_count ) );
|
||||
}
|
||||
|
||||
rv = lseek( file_descriptor, file_pos, SEEK_SET );
|
||||
rtems_test_assert( file_pos == rv );
|
||||
|
||||
rv = write( file_descriptor, buff, block_size );
|
||||
rtems_test_assert( block_size == rv );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Verify that black box reading for a sparse disk delivers expected results
|
||||
*/
|
||||
static void test_reading(
|
||||
const int file_descriptor,
|
||||
const uint32_t block_size,
|
||||
const rtems_blkdev_bnum blocks_allocated,
|
||||
const uint8_t fill_pattern )
|
||||
{
|
||||
int rv;
|
||||
rtems_blkdev_bnum block_count = 0;
|
||||
unsigned int byte_count;
|
||||
off_t file_pos;
|
||||
uint8_t buff[block_size];
|
||||
uint32_t value = 0;
|
||||
|
||||
|
||||
rv = fsync( file_descriptor );
|
||||
rtems_test_assert( 0 == rv );
|
||||
|
||||
/* Read back the patterns */
|
||||
for ( block_count = 0; block_count < blocks_allocated; block_count++ ) {
|
||||
file_pos = (off_t) block_count * block_size;
|
||||
value = lseek( file_descriptor, file_pos, SEEK_SET );
|
||||
rtems_test_assert( file_pos == value );
|
||||
|
||||
rv = read( file_descriptor, &buff, block_size );
|
||||
rtems_test_assert( block_size <= rv );
|
||||
|
||||
for ( byte_count = 0;
|
||||
byte_count < ( block_size / sizeof( byte_count ) );
|
||||
byte_count++ ) {
|
||||
rv = memcmp( buff + ( byte_count * sizeof( byte_count ) ),
|
||||
&byte_count,
|
||||
sizeof( byte_count ) );
|
||||
rtems_test_assert( 0 == rv );
|
||||
}
|
||||
}
|
||||
|
||||
/* Try to read from unallocated block */
|
||||
file_pos = (off_t) block_count * block_size;
|
||||
rv = lseek( file_descriptor, file_pos, SEEK_SET );
|
||||
rtems_test_assert( file_pos == rv );
|
||||
|
||||
rv = read( file_descriptor, buff, block_size );
|
||||
rtems_test_assert( block_size == rv );
|
||||
|
||||
for ( byte_count = 0; byte_count < block_size; ++byte_count )
|
||||
rtems_test_assert( fill_pattern == buff[byte_count] );
|
||||
}
|
||||
|
||||
/*
|
||||
* Do black box io testing on a sparse disk
|
||||
*/
|
||||
static void test_device_io( const char *device_name,
|
||||
const uint32_t block_size,
|
||||
const uint32_t media_block_size,
|
||||
const rtems_blkdev_bnum block_number,
|
||||
const rtems_blkdev_bnum blocks_allocated,
|
||||
const uint8_t fill_pattern )
|
||||
{
|
||||
int rv;
|
||||
int file_descriptor;
|
||||
|
||||
|
||||
file_descriptor = open( device_name, O_RDWR );
|
||||
rtems_test_assert( 0 <= file_descriptor );
|
||||
|
||||
test_disk_params(
|
||||
file_descriptor,
|
||||
block_size,
|
||||
media_block_size,
|
||||
block_number
|
||||
);
|
||||
|
||||
test_writing(
|
||||
file_descriptor,
|
||||
block_size,
|
||||
blocks_allocated
|
||||
);
|
||||
|
||||
test_reading(
|
||||
file_descriptor,
|
||||
block_size,
|
||||
blocks_allocated,
|
||||
fill_pattern
|
||||
);
|
||||
|
||||
rv = close( file_descriptor );
|
||||
rtems_test_assert( 0 == rv );
|
||||
}
|
||||
|
||||
/*
|
||||
* In white box testing verify the key table of the sparse disk is correct
|
||||
*/
|
||||
static void test_static_key_table(
|
||||
const sparse_disk_container *disk_container,
|
||||
const rtems_blkdev_bnum blocks_allocated,
|
||||
const uint32_t block_size )
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
|
||||
for ( i = 0; i < blocks_allocated; ++i ) {
|
||||
rtems_test_assert( i == disk_container->keytable[i].block );
|
||||
rtems_test_assert(
|
||||
&disk_container->data[i * block_size]
|
||||
== disk_container->keytable[i].data );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Verify the test pattern used in white box testing is as expected
|
||||
*/
|
||||
static void test_static_pattern(
|
||||
const unsigned int pattern_size,
|
||||
const uint8_t *pattern )
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
|
||||
for ( i = 0; i < pattern_size; ++i )
|
||||
rtems_test_assert( ( (uint8_t) ( pattern_size - 1 - i ) ) == pattern[i] );
|
||||
}
|
||||
|
||||
/*
|
||||
* Read write testing with a statically allocated disk. Thus white box testing can be done
|
||||
*/
|
||||
static void test_with_whitebox( const char *device_name )
|
||||
{
|
||||
rtems_status_code sc;
|
||||
int rv;
|
||||
unsigned int i;
|
||||
sparse_disk_container disk_container;
|
||||
int file_descriptor;
|
||||
rtems_blkdev_bnum block_count = 0;
|
||||
unsigned int byte_count;
|
||||
uint8_t fill_pattern = 0;
|
||||
|
||||
|
||||
memset( disk_container.data, 0, sizeof( disk_container.data ) );
|
||||
memset( disk_container.keytable, 0, sizeof( disk_container.keytable ) );
|
||||
|
||||
for ( i = 0; i < STATIC_PATTERN_SIZE; ++i )
|
||||
disk_container.pattern[i] = (uint8_t) ( STATIC_PATTERN_SIZE - 1 - i );
|
||||
|
||||
sc = rtems_sparse_disk_register(
|
||||
"/dev/sda1",
|
||||
&disk_container.sparse_disk,
|
||||
STATIC_BLOCK_SIZE,
|
||||
STATIC_ALLOCATED_BLOCK_COUNT,
|
||||
STATIC_SIMULATED_BLOCK_COUNT,
|
||||
fill_pattern,
|
||||
NULL
|
||||
);
|
||||
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
|
||||
|
||||
test_static_key_table(
|
||||
&disk_container,
|
||||
STATIC_ALLOCATED_BLOCK_COUNT,
|
||||
STATIC_BLOCK_SIZE
|
||||
);
|
||||
|
||||
for ( i = 0; i < ( STATIC_BLOCK_SIZE * STATIC_ALLOCATED_BLOCK_COUNT ); ++i )
|
||||
rtems_test_assert( 0 == disk_container.data[i] );
|
||||
|
||||
test_static_pattern(
|
||||
STATIC_PATTERN_SIZE,
|
||||
&disk_container.pattern[0]
|
||||
);
|
||||
|
||||
file_descriptor = open( device_name, O_RDWR );
|
||||
rtems_test_assert( 0 <= file_descriptor );
|
||||
|
||||
test_disk_params(
|
||||
file_descriptor,
|
||||
STATIC_BLOCK_SIZE,
|
||||
STATIC_BLOCK_SIZE,
|
||||
STATIC_SIMULATED_BLOCK_COUNT
|
||||
);
|
||||
|
||||
test_writing(
|
||||
file_descriptor,
|
||||
STATIC_BLOCK_SIZE,
|
||||
STATIC_ALLOCATED_BLOCK_COUNT
|
||||
);
|
||||
|
||||
test_reading(
|
||||
file_descriptor,
|
||||
STATIC_BLOCK_SIZE,
|
||||
STATIC_ALLOCATED_BLOCK_COUNT,
|
||||
fill_pattern
|
||||
);
|
||||
|
||||
rv = close( file_descriptor );
|
||||
rtems_test_assert( 0 == rv );
|
||||
|
||||
test_static_key_table(
|
||||
&disk_container,
|
||||
STATIC_ALLOCATED_BLOCK_COUNT,
|
||||
STATIC_BLOCK_SIZE
|
||||
);
|
||||
|
||||
for ( block_count = 0;
|
||||
block_count < STATIC_ALLOCATED_BLOCK_COUNT;
|
||||
block_count++ ) {
|
||||
for ( byte_count = 0;
|
||||
byte_count < ( STATIC_BLOCK_SIZE / sizeof( byte_count ) );
|
||||
byte_count++ ) {
|
||||
rv = memcmp( &disk_container.data[byte_count * sizeof( byte_count )],
|
||||
&byte_count,
|
||||
sizeof( byte_count ) );
|
||||
rtems_test_assert( 0 == rv );
|
||||
}
|
||||
}
|
||||
|
||||
test_static_pattern(
|
||||
STATIC_PATTERN_SIZE,
|
||||
&disk_container.pattern[0]
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* The test sequence
|
||||
*/
|
||||
static
|
||||
void test( void )
|
||||
{
|
||||
rtems_status_code sc;
|
||||
int rv;
|
||||
char device_name[] = "/dev/sda1";
|
||||
uint32_t block_size;
|
||||
rtems_blkdev_bnum block_number;
|
||||
rtems_blkdev_bnum blocks_allocated;
|
||||
int file_descriptor;
|
||||
uint8_t fill_pattern = 0;
|
||||
|
||||
|
||||
sc = rtems_disk_io_initialize();
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
block_size = 512;
|
||||
block_number = 4 * 2 * 1024;
|
||||
blocks_allocated = 8;
|
||||
sc = rtems_sparse_disk_create_and_register(
|
||||
"/dev/sda1",
|
||||
block_size,
|
||||
blocks_allocated,
|
||||
block_number,
|
||||
fill_pattern
|
||||
);
|
||||
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
|
||||
|
||||
/* Test reading and writing with sector size 512 and 8 such sectors
|
||||
* allocated. Block size will default to 512 */
|
||||
test_device_io(
|
||||
device_name,
|
||||
block_size,
|
||||
block_size,
|
||||
block_number,
|
||||
blocks_allocated,
|
||||
fill_pattern
|
||||
);
|
||||
|
||||
file_descriptor = open( device_name, O_RDWR );
|
||||
rtems_test_assert( 0 <= file_descriptor );
|
||||
|
||||
rv = rtems_disk_fd_set_block_size( file_descriptor,
|
||||
blocks_allocated * block_size );
|
||||
rtems_test_assert( 0 == rv );
|
||||
|
||||
rv = close( file_descriptor );
|
||||
rtems_test_assert( 0 == rv );
|
||||
|
||||
/* Block size was increased to 4k. Thus all to allocated disk space
|
||||
* corresponds to one block. Repeat the read write tests */
|
||||
test_device_io(
|
||||
device_name,
|
||||
block_size * blocks_allocated,
|
||||
block_size,
|
||||
block_number,
|
||||
1,
|
||||
fill_pattern
|
||||
);
|
||||
|
||||
rv = unlink( device_name );
|
||||
rtems_test_assert( 0 == rv );
|
||||
|
||||
/* Do testing with a statically allocated disk. This permits white box
|
||||
* testing */
|
||||
test_with_whitebox( device_name );
|
||||
}
|
||||
|
||||
static void Init( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
puts( "\n\n*** TEST SPARSEDISK 1 ***" );
|
||||
|
||||
test();
|
||||
|
||||
puts( "*** END OF TEST SPARSEDISK 1 ***" );
|
||||
|
||||
rtems_test_exit( 0 );
|
||||
}
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
|
||||
|
||||
#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
|
||||
#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 4
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
#define CONFIGURE_MAXIMUM_SEMAPHORES 1
|
||||
|
||||
#define CONFIGURE_INIT_TASK_STACK_SIZE ( 16 * 1024 )
|
||||
|
||||
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
|
||||
|
||||
#define CONFIGURE_INIT
|
||||
|
||||
#include <rtems/confdefs.h>
|
||||
@@ -0,0 +1,12 @@
|
||||
This file describes the directives and concepts tested by this test set.
|
||||
|
||||
test set name: sparsedisk01
|
||||
|
||||
directives:
|
||||
|
||||
- rtems_sparse_disk_create()
|
||||
- rtems_sparse_disk_register()
|
||||
|
||||
concepts:
|
||||
|
||||
- Ensures that the sparse disk works.
|
||||
@@ -0,0 +1,2 @@
|
||||
*** TEST SPARSEDISK 1 ***
|
||||
*** END OF TEST SPARSEDISK 1 ***
|
||||
Reference in New Issue
Block a user