mirror of
https://gitlab.rtems.org/rtems/rtos/rtems.git
synced 2026-11-16 19:04:53 +08:00
testsuites/libtests: reformat with clang-format
Updates #3860. Updates #5358.
This commit is contained in:
1 parent
71ec6ca8c7
commit
4d1604efb6
332 files changed
+21793
-19150
No files matched your search
@@ -12,12 +12,11 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
int main( void )
|
||||
{
|
||||
void *foo = calloc (42, 43);
|
||||
int rc = (foo != NULL);
|
||||
free(foo);
|
||||
void *foo = calloc( 42, 43 );
|
||||
int rc = ( foo != NULL );
|
||||
free( foo );
|
||||
|
||||
return rc;
|
||||
}
|
||||
@@ -12,10 +12,9 @@
|
||||
|
||||
#include <time.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
int main( void )
|
||||
{
|
||||
struct timespec mytime;
|
||||
|
||||
return clock_gettime(CLOCK_REALTIME,&mytime);
|
||||
return clock_gettime( CLOCK_REALTIME, &mytime );
|
||||
}
|
||||
@@ -12,8 +12,7 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
int main( void )
|
||||
{
|
||||
return close(42);
|
||||
return close( 42 );
|
||||
}
|
||||
@@ -12,11 +12,10 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
int main( void )
|
||||
{
|
||||
int oldfd = 42;
|
||||
int newfd = 43;
|
||||
|
||||
return dup2 (oldfd, newfd);
|
||||
return dup2( oldfd, newfd );
|
||||
}
|
||||
@@ -13,14 +13,14 @@
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
int main (void)
|
||||
int main( void )
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = fcntl (42, 43);
|
||||
rc = fcntl( 42, 43 );
|
||||
(void) rc;
|
||||
|
||||
rc = fcntl (42, 43, 44);
|
||||
|
||||
rc = fcntl( 42, 43, 44 );
|
||||
|
||||
return rc;
|
||||
}
|
||||
@@ -12,10 +12,10 @@
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
FILE *file = NULL;
|
||||
|
||||
flockfile(file);
|
||||
flockfile( file );
|
||||
return 0;
|
||||
}
|
||||
@@ -12,8 +12,7 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
int main( void )
|
||||
{
|
||||
int rc;
|
||||
|
||||
|
||||
@@ -12,10 +12,10 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
void* p;
|
||||
void *p;
|
||||
|
||||
int main (void)
|
||||
int main( void )
|
||||
{
|
||||
free(p);
|
||||
free( p );
|
||||
return 0;
|
||||
}
|
||||
@@ -14,13 +14,13 @@
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main (void)
|
||||
int main( void )
|
||||
{
|
||||
struct stat buf;
|
||||
int fd = 42;
|
||||
int rc;
|
||||
int fd = 42;
|
||||
int rc;
|
||||
|
||||
rc = fstat(fd, &buf);
|
||||
rc = fstat( fd, &buf );
|
||||
|
||||
return rc;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
FILE *file = NULL;
|
||||
int ret;
|
||||
int ret;
|
||||
|
||||
ret = ftrylockfile(file);
|
||||
ret = ftrylockfile( file );
|
||||
return ret;
|
||||
}
|
||||
@@ -12,10 +12,10 @@
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
FILE *file = NULL;
|
||||
|
||||
funlockfile(file);
|
||||
funlockfile( file );
|
||||
return 0;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <dirent.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int status;
|
||||
int fd = 42;
|
||||
|
||||
status = getdents(fd, "/tmp/foo", 0);
|
||||
status = getdents( fd, "/tmp/foo", 0 );
|
||||
return status;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
char *login;
|
||||
|
||||
login = getlogin ();
|
||||
login = getlogin();
|
||||
(void) login;
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -13,11 +13,11 @@
|
||||
#include <sys/types.h>
|
||||
#include <pwd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct passwd *pass;
|
||||
|
||||
pass = getpwnam("root");
|
||||
pass = getpwnam( "root" );
|
||||
|
||||
return (pass != NULL);
|
||||
return ( pass != NULL );
|
||||
}
|
||||
@@ -13,10 +13,10 @@
|
||||
#include <sys/types.h>
|
||||
#include <pwd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct passwd *pass;
|
||||
pass = getpwnam (0);
|
||||
pass = getpwnam( 0 );
|
||||
|
||||
return (pass != NULL);
|
||||
return ( pass != NULL );
|
||||
}
|
||||
@@ -12,10 +12,10 @@
|
||||
|
||||
#include <sys/time.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct timeval tv;
|
||||
struct timeval tv;
|
||||
struct timezone tz;
|
||||
|
||||
return gettimeofday(&tv, &tz);
|
||||
return gettimeofday( &tv, &tz );
|
||||
}
|
||||
@@ -13,10 +13,10 @@
|
||||
#include <unistd.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
uid_t uid;
|
||||
uid = getuid();
|
||||
|
||||
return (uid != 0);
|
||||
return ( uid != 0 );
|
||||
}
|
||||
@@ -12,20 +12,20 @@
|
||||
|
||||
#include <arpa/inet.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
uint32_t u32;
|
||||
uint16_t u16;
|
||||
|
||||
u32 = htonl(0x12345678);
|
||||
u32 = htonl( 0x12345678 );
|
||||
(void) u32;
|
||||
u16 = htons(0x1234);
|
||||
u16 = htons( 0x1234 );
|
||||
(void) u16;
|
||||
|
||||
u32 = ntohl(0x12345678);
|
||||
u32 = ntohl( 0x12345678 );
|
||||
(void) u32;
|
||||
u16 = ntohs(0x1234);
|
||||
u16 = ntohs( 0x1234 );
|
||||
(void) u16;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -12,18 +12,18 @@
|
||||
|
||||
#include <iconv.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
iconv_t cd = NULL;
|
||||
char inbuf[42];
|
||||
size_t isize;
|
||||
char outbuf[42];
|
||||
size_t osize;
|
||||
size_t ret;
|
||||
char inbuf[ 42 ];
|
||||
size_t isize;
|
||||
char outbuf[ 42 ];
|
||||
size_t osize;
|
||||
size_t ret;
|
||||
|
||||
char *i = inbuf;
|
||||
char *o = outbuf;
|
||||
ret = iconv(cd, &i, &isize, &o, &osize);
|
||||
ret = iconv( cd, &i, &isize, &o, &osize );
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -12,12 +12,12 @@
|
||||
|
||||
#include <iconv.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
iconv_t cd = NULL;
|
||||
int ret;
|
||||
int ret;
|
||||
|
||||
ret = iconv_close(cd);
|
||||
ret = iconv_close( cd );
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <iconv.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
iconv_t ret;
|
||||
|
||||
ret = iconv_open("utf8", "ascii" );
|
||||
ret = iconv_open( "utf8", "ascii" );
|
||||
|
||||
return (ret == 0);
|
||||
return ( ret == 0 );
|
||||
}
|
||||
@@ -12,7 +12,7 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int status;
|
||||
status = issetugid();
|
||||
|
||||
@@ -12,18 +12,18 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
pid_t pid = 0;
|
||||
int rc;
|
||||
int rc;
|
||||
|
||||
rc = kill(pid, SIGHUP);
|
||||
rc = kill( pid, SIGHUP );
|
||||
(void) rc;
|
||||
|
||||
rc = kill(pid, SIGKILL);
|
||||
rc = kill( pid, SIGKILL );
|
||||
(void) rc;
|
||||
|
||||
rc = kill(pid, SIGTERM);
|
||||
rc = kill( pid, SIGTERM );
|
||||
|
||||
return rc;
|
||||
}
|
||||
@@ -12,9 +12,9 @@
|
||||
|
||||
#include <setjmp.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
jmp_buf buf;
|
||||
longjmp(buf, 0);
|
||||
longjmp( buf, 0 );
|
||||
return 0;
|
||||
}
|
||||
@@ -13,18 +13,18 @@
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
off_t res;
|
||||
int fd = 42;
|
||||
int fd = 42;
|
||||
|
||||
res = lseek(fd, 0, SEEK_SET);
|
||||
res = lseek( fd, 0, SEEK_SET );
|
||||
(void) res;
|
||||
|
||||
res = lseek(fd, 1, SEEK_CUR);
|
||||
res = lseek( fd, 1, SEEK_CUR );
|
||||
(void) res;
|
||||
|
||||
res = lseek(fd, 2, SEEK_END);
|
||||
res = lseek( fd, 2, SEEK_END );
|
||||
(void) res;
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -14,12 +14,12 @@
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct stat buf;
|
||||
int status;
|
||||
int status;
|
||||
|
||||
status = lstat("/tmp/foo", &buf);
|
||||
status = lstat( "/tmp/foo", &buf );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,9 +12,9 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
void *ptr = malloc(42);
|
||||
void *ptr = malloc( 42 );
|
||||
|
||||
return (ptr != NULL);
|
||||
return ( ptr != NULL );
|
||||
}
|
||||
@@ -12,13 +12,13 @@
|
||||
|
||||
#include <time.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct timespec req = { 0, 42 };
|
||||
struct timespec rem;
|
||||
int status;
|
||||
int status;
|
||||
|
||||
status = nanosleep(&req, &rem);
|
||||
status = nanosleep( &req, &rem );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -14,13 +14,13 @@
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int fd1;
|
||||
int fd2;
|
||||
|
||||
fd1 = open("/tmp/foo1", O_RDWR | O_APPEND);
|
||||
fd2 = open("/tmp/foo2", O_CREAT, S_IWUSR);
|
||||
fd1 = open( "/tmp/foo1", O_RDWR | O_APPEND );
|
||||
fd2 = open( "/tmp/foo2", O_CREAT, S_IWUSR );
|
||||
|
||||
return (fd1 != fd2);
|
||||
return ( fd1 != fd2 );
|
||||
}
|
||||
@@ -12,12 +12,12 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int filedes[2];
|
||||
int filedes[ 2 ];
|
||||
int status;
|
||||
|
||||
status = pipe(filedes);
|
||||
status = pipe( filedes );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,10 +12,10 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
void *a;
|
||||
int ret = posix_memalign(&a, sizeof (void *) * 2, 42);
|
||||
int ret = posix_memalign( &a, sizeof( void * ) * 2, 42 );
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -12,13 +12,13 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int fd = 42;
|
||||
char buf[4];
|
||||
int fd = 42;
|
||||
char buf[ 4 ];
|
||||
ssize_t len;
|
||||
|
||||
len = read(fd, &buf, 4);
|
||||
len = read( fd, &buf, 4 );
|
||||
|
||||
return (len != 0);
|
||||
return ( len != 0 );
|
||||
}
|
||||
@@ -12,13 +12,13 @@
|
||||
|
||||
#include <sys/uio.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct iovec iov = { 0 };
|
||||
int count = 4;
|
||||
ssize_t ret;
|
||||
int count = 4;
|
||||
ssize_t ret;
|
||||
|
||||
ret = readv(0, &iov, count);
|
||||
ret = readv( 0, &iov, count );
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -12,9 +12,9 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
void *p = realloc(NULL, 42);
|
||||
void *p = realloc( NULL, 42 );
|
||||
|
||||
return (p == NULL);
|
||||
return ( p == NULL );
|
||||
}
|
||||
@@ -12,9 +12,9 @@
|
||||
|
||||
#include <setjmp.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
jmp_buf buf;
|
||||
setjmp(buf);
|
||||
setjmp( buf );
|
||||
return 0;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
sigset_t set;
|
||||
int status;
|
||||
status = sigaddset(&set, 21);
|
||||
int status;
|
||||
status = sigaddset( &set, 21 );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
sigset_t set;
|
||||
int status;
|
||||
status = sigdelset(&set, 21);
|
||||
int status;
|
||||
status = sigdelset( &set, 21 );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,10 +12,10 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
sigset_t set;
|
||||
int status = sigemptyset(&set);
|
||||
int status = sigemptyset( &set );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
sigset_t set;
|
||||
int status;
|
||||
status = sigfillset(&set);
|
||||
int status;
|
||||
status = sigfillset( &set );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,11 +12,11 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
sigset_t set = { 0 };
|
||||
int status;
|
||||
status = sigismember(&set, 21);
|
||||
int status;
|
||||
status = sigismember( &set, 21 );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,19 +12,19 @@
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int rc;
|
||||
int rc;
|
||||
sigset_t set1 = { 0 };
|
||||
sigset_t set2 = { 0 };
|
||||
|
||||
rc = sigprocmask(SIG_BLOCK, &set1, &set2);
|
||||
rc = sigprocmask( SIG_BLOCK, &set1, &set2 );
|
||||
(void) rc;
|
||||
|
||||
rc = sigprocmask(SIG_UNBLOCK, &set1, &set2);
|
||||
rc = sigprocmask( SIG_UNBLOCK, &set1, &set2 );
|
||||
(void) rc;
|
||||
|
||||
rc = sigprocmask(SIG_SETMASK, &set1, &set2);
|
||||
rc = sigprocmask( SIG_SETMASK, &set1, &set2 );
|
||||
|
||||
return rc;
|
||||
}
|
||||
@@ -14,12 +14,12 @@
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct stat buf;
|
||||
int status;
|
||||
int status;
|
||||
|
||||
status = stat("/tmp/foo", &buf);
|
||||
status = stat( "/tmp/foo", &buf );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -12,11 +12,10 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
int main( void )
|
||||
{
|
||||
int status;
|
||||
status = unlink("/tmp/foo");
|
||||
status = unlink( "/tmp/foo" );
|
||||
|
||||
return status;
|
||||
}
|
||||
@@ -13,10 +13,10 @@
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
pid_t pid;
|
||||
pid = vfork();
|
||||
|
||||
return (pid != 0);
|
||||
return ( pid != 0 );
|
||||
}
|
||||
@@ -13,11 +13,11 @@
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
int status;
|
||||
int status;
|
||||
pid_t pid;
|
||||
pid = wait(&status);
|
||||
pid = wait( &status );
|
||||
|
||||
return (pid != 0);
|
||||
return ( pid != 0 );
|
||||
}
|
||||
@@ -13,12 +13,11 @@
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
int
|
||||
main(void)
|
||||
int main( void )
|
||||
{
|
||||
int status;
|
||||
int status;
|
||||
pid_t pid;
|
||||
pid = waitpid(-1, &status, WNOHANG);
|
||||
pid = waitpid( -1, &status, WNOHANG );
|
||||
|
||||
return (pid != 0);
|
||||
return ( pid != 0 );
|
||||
}
|
||||
@@ -12,13 +12,13 @@
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
char string[] = "1234";
|
||||
size_t count = 4;
|
||||
char string[] = "1234";
|
||||
size_t count = 4;
|
||||
ssize_t ret;
|
||||
|
||||
ret = write(0, &string, count);
|
||||
ret = write( 0, &string, count );
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -12,13 +12,13 @@
|
||||
|
||||
#include <sys/uio.h>
|
||||
|
||||
int main(void)
|
||||
int main( void )
|
||||
{
|
||||
struct iovec iov = { 0 };
|
||||
int count = 4;
|
||||
ssize_t ret;
|
||||
int count = 4;
|
||||
ssize_t ret;
|
||||
|
||||
ret = writev(0, &iov, count);
|
||||
ret = writev( 0, &iov, count );
|
||||
|
||||
return ret;
|
||||
}
|
||||
+207
-119
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -50,7 +50,7 @@
|
||||
|
||||
const char rtems_test_name[] = "BLOCK 4";
|
||||
|
||||
#define ASSERT_SC(sc) rtems_test_assert((sc) == RTEMS_SUCCESSFUL)
|
||||
#define ASSERT_SC( sc ) rtems_test_assert( ( sc ) == RTEMS_SUCCESSFUL )
|
||||
|
||||
#define PRIORITY_INIT 10
|
||||
|
||||
@@ -70,85 +70,85 @@ static rtems_id task_id_low;
|
||||
|
||||
static rtems_id task_id_high;
|
||||
|
||||
static void task_low(rtems_task_argument arg)
|
||||
static void task_low( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code sc = RTEMS_SUCCESSFUL;
|
||||
rtems_status_code sc = RTEMS_SUCCESSFUL;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
printk("L: try access: 0\n");
|
||||
printk( "L: try access: 0\n" );
|
||||
|
||||
sc = rtems_bdbuf_get(dd, 0, &bd);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_get( dd, 0, &bd );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
printk("L: access: 0\n");
|
||||
printk( "L: access: 0\n" );
|
||||
|
||||
sc = rtems_task_resume(task_id_high);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_task_resume( task_id_high );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_bdbuf_sync(bd);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_sync( bd );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
printk("L: sync done: 0\n");
|
||||
printk( "L: sync done: 0\n" );
|
||||
|
||||
rtems_test_assert(false);
|
||||
rtems_test_assert( false );
|
||||
}
|
||||
|
||||
static void task_high(rtems_task_argument arg)
|
||||
static void task_high( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code sc = RTEMS_SUCCESSFUL;
|
||||
rtems_status_code sc = RTEMS_SUCCESSFUL;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
sc = rtems_task_suspend(RTEMS_SELF);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_task_suspend( RTEMS_SELF );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
printk("H: try access: 0\n");
|
||||
printk( "H: try access: 0\n" );
|
||||
|
||||
sc = rtems_bdbuf_get(dd, 0, &bd);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_get( dd, 0, &bd );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
printk("H: access: 0\n");
|
||||
printk( "H: access: 0\n" );
|
||||
|
||||
printk("H: release: 0\n");
|
||||
printk( "H: release: 0\n" );
|
||||
|
||||
sc = rtems_bdbuf_release(bd);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_release( bd );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
printk("H: release done: 0\n");
|
||||
printk( "H: release done: 0\n" );
|
||||
|
||||
TEST_END();
|
||||
|
||||
exit(0);
|
||||
exit( 0 );
|
||||
}
|
||||
|
||||
static void do_ramdisk_register(
|
||||
uint32_t media_block_size,
|
||||
rtems_blkdev_bnum media_block_count,
|
||||
const char *disk,
|
||||
uint32_t media_block_size,
|
||||
rtems_blkdev_bnum media_block_count,
|
||||
const char *disk,
|
||||
rtems_disk_device **dd
|
||||
)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
int fd;
|
||||
int rv;
|
||||
int fd;
|
||||
int rv;
|
||||
|
||||
sc = ramdisk_register(media_block_size, media_block_count, false, disk);
|
||||
ASSERT_SC(sc);
|
||||
sc = ramdisk_register( media_block_size, media_block_count, false, disk );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
fd = open(disk, O_RDWR);
|
||||
rtems_test_assert(fd >= 0);
|
||||
fd = open( disk, O_RDWR );
|
||||
rtems_test_assert( fd >= 0 );
|
||||
|
||||
rv = rtems_disk_fd_get_disk_device(fd, dd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = rtems_disk_fd_get_disk_device( fd, dd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
rv = close(fd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = close( fd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
}
|
||||
|
||||
static rtems_task Init(rtems_task_argument argument)
|
||||
static rtems_task Init( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
@@ -156,36 +156,36 @@ static rtems_task Init(rtems_task_argument argument)
|
||||
|
||||
TEST_BEGIN();
|
||||
|
||||
do_ramdisk_register(BLOCK_SIZE, BLOCK_COUNT, "/dev/rda", &dd);
|
||||
do_ramdisk_register( BLOCK_SIZE, BLOCK_COUNT, "/dev/rda", &dd );
|
||||
|
||||
sc = rtems_task_create(
|
||||
rtems_build_name(' ', 'L', 'O', 'W'),
|
||||
rtems_build_name( ' ', 'L', 'O', 'W' ),
|
||||
PRIORITY_LOW,
|
||||
0,
|
||||
RTEMS_DEFAULT_MODES,
|
||||
RTEMS_DEFAULT_ATTRIBUTES,
|
||||
&task_id_low
|
||||
);
|
||||
ASSERT_SC(sc);
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_task_start(task_id_low, task_low, 0);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_task_start( task_id_low, task_low, 0 );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_task_create(
|
||||
rtems_build_name('H', 'I', 'G', 'H'),
|
||||
rtems_build_name( 'H', 'I', 'G', 'H' ),
|
||||
PRIORITY_HIGH,
|
||||
0,
|
||||
RTEMS_DEFAULT_MODES,
|
||||
RTEMS_DEFAULT_ATTRIBUTES,
|
||||
&task_id_high
|
||||
);
|
||||
ASSERT_SC(sc);
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_task_start(task_id_high, task_high, 0);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_task_start( task_id_high, task_high, 0 );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_task_suspend(RTEMS_SELF);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_task_suspend( RTEMS_SELF );
|
||||
ASSERT_SC( sc );
|
||||
}
|
||||
|
||||
#define CONFIGURE_INIT
|
||||
@@ -202,14 +202,14 @@ static rtems_task Init(rtems_task_argument argument)
|
||||
|
||||
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
|
||||
|
||||
#define CONFIGURE_INIT_TASK_PRIORITY PRIORITY_INIT
|
||||
#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES
|
||||
#define CONFIGURE_INIT_TASK_PRIORITY PRIORITY_INIT
|
||||
#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES
|
||||
#define CONFIGURE_INIT_TASK_INITIAL_MODES RTEMS_DEFAULT_MODES
|
||||
|
||||
#define CONFIGURE_SWAPOUT_TASK_PRIORITY PRIORITY_SWAPOUT
|
||||
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE BLOCK_SIZE
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE BLOCK_SIZE
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE BLOCK_SIZE
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE BLOCK_SIZE
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE BLOCK_SIZE
|
||||
|
||||
#include <rtems/confdefs.h>
|
||||
+161
-188
File diff suppressed because it is too large.
Load diff
+653
-685
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -51,120 +51,113 @@
|
||||
|
||||
#include "bdbuf_tests.h"
|
||||
|
||||
static rtems_task bdbuf_test1_1_thread1(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test1_1_thread1( rtems_task_argument arg );
|
||||
|
||||
#define TEST_BLK_NUM 10
|
||||
|
||||
void
|
||||
bdbuf_test1_1_main()
|
||||
void bdbuf_test1_1_main()
|
||||
{
|
||||
bdbuf_test_msg msg;
|
||||
bdbuf_test_msg msg;
|
||||
|
||||
TEST_START("Test 1.1");
|
||||
TEST_START( "Test 1.1" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Create working thread that will call rtems_bdbuf_read() function.
|
||||
*/
|
||||
START_THREAD(1, bdbuf_test1_1_thread1);
|
||||
START_THREAD( 1, bdbuf_test1_1_thread1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Check that rtems_bdbuf_read() returns RTEMS_SUCCESSFUL
|
||||
* when device driver returns 0 from ioctl() call and
|
||||
* return RTEMS_SUCCESSFUL status in asynchronous
|
||||
* callback notification.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
SEND_DRV_MSG(0, 0, RTEMS_SUCCESSFUL, 0);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
WAIT_THREAD_SYNC(1);
|
||||
TEST_CHECK_RESULT("2");
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
TEST_CHECK_RESULT( "2" );
|
||||
|
||||
CONTINUE_THREAD(1);
|
||||
CONTINUE_THREAD( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 3:
|
||||
* Check that rtems_bdbuf_read() returns RTEMS_IO_ERROR
|
||||
* return code, when device driver returns -1 from ioctl() call.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
SEND_DRV_MSG(-1, EFAULT, RTEMS_SUCCESSFUL, 0);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
SEND_DRV_MSG( -1, EFAULT, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
WAIT_THREAD_SYNC(1);
|
||||
TEST_CHECK_RESULT("4");
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
TEST_CHECK_RESULT( "4" );
|
||||
|
||||
CONTINUE_THREAD(1);
|
||||
CONTINUE_THREAD( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 5:
|
||||
* Check that rtems_bdbuf_read() returns status obtained
|
||||
* from device driver via asynchonous notification.
|
||||
* On this step device driver returns 0 from ioctl() call,
|
||||
* but notification callback is called with RTEMS_IO_ERROR status.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
SEND_DRV_MSG(0, 0, RTEMS_IO_ERROR, EFAULT);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_IO_ERROR, EFAULT );
|
||||
|
||||
WAIT_THREAD_SYNC(1);
|
||||
TEST_CHECK_RESULT("6");
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
TEST_CHECK_RESULT( "6" );
|
||||
|
||||
CONTINUE_THREAD(1);
|
||||
CONTINUE_THREAD( 1 );
|
||||
|
||||
TEST_STOP();
|
||||
TEST_STOP();
|
||||
}
|
||||
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test1_1_thread1(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test1_1_thread1( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd1 = NULL;
|
||||
rtems_bdbuf_buffer *bd2 = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd1 = NULL;
|
||||
rtems_bdbuf_buffer *bd2 = NULL;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1-2:
|
||||
* Successful read operation.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, 0, &bd1);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_release(bd1);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, 0, &bd1 );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_release( bd1 );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(1);
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 3-4:
|
||||
* Read operation fails with RTEMS_IO_ERROR code.
|
||||
* The function shall not update user pointer.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM, &bd2);
|
||||
if (rc != RTEMS_IO_ERROR || bd2 != NULL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM, &bd2 );
|
||||
if ( rc != RTEMS_IO_ERROR || bd2 != NULL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(1);
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 5-6:
|
||||
* Read operation fails with RTEMS_IO_ERROR code.
|
||||
* The function shall not update user pointer.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM, &bd2);
|
||||
if (rc != RTEMS_IO_ERROR || bd2 != NULL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM, &bd2 );
|
||||
if ( rc != RTEMS_IO_ERROR || bd2 != NULL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(1);
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
THREAD_END();
|
||||
THREAD_END();
|
||||
}
|
||||
@@ -53,86 +53,84 @@
|
||||
|
||||
#include "bdbuf_tests.h"
|
||||
|
||||
static rtems_task bdbuf_test1_2_thread1(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test1_2_thread2(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test1_2_thread1( rtems_task_argument arg );
|
||||
static rtems_task bdbuf_test1_2_thread2( rtems_task_argument arg );
|
||||
|
||||
#define TEST_BLK_NUM 20
|
||||
|
||||
void
|
||||
bdbuf_test1_2_main()
|
||||
void bdbuf_test1_2_main()
|
||||
{
|
||||
bdbuf_test_msg msg;
|
||||
bdbuf_test_msg msg;
|
||||
|
||||
TEST_START("Test 1.2");
|
||||
TEST_START( "Test 1.2" );
|
||||
|
||||
START_THREAD(1, bdbuf_test1_2_thread1);
|
||||
START_THREAD(2, bdbuf_test1_2_thread2);
|
||||
START_THREAD( 1, bdbuf_test1_2_thread1 );
|
||||
START_THREAD( 2, bdbuf_test1_2_thread2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Thread #1 calls rtems_bdbuf_read() and we block
|
||||
* this thread on data transfer operation.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Thread #2 calls rtems_bdbuf_read() for the same
|
||||
* block number, as the result it shall block waiting
|
||||
* on buffer state change.
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
/* Make sure thread #2 managed to block on the buffer. */
|
||||
CHECK_THREAD_BLOCKED(2);
|
||||
/* Make sure thread #2 managed to block on the buffer. */
|
||||
CHECK_THREAD_BLOCKED( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 3:
|
||||
* Unblock thread #1 by reporting data transfer result.
|
||||
*/
|
||||
SEND_DRV_MSG(0, 0, RTEMS_IO_ERROR, EFAULT);
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_IO_ERROR, EFAULT );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Wait for sync from thread #1.
|
||||
*/
|
||||
WAIT_THREAD_SYNC(1);
|
||||
CONTINUE_THREAD(1);
|
||||
TEST_CHECK_RESULT("3");
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
CONTINUE_THREAD( 1 );
|
||||
TEST_CHECK_RESULT( "3" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 4:
|
||||
* For thread #2 bdbuf shall try to re-read data.
|
||||
* As the result we will get read call to device driver.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
|
||||
/* Check that thread #2 is still blocked */
|
||||
CHECK_THREAD_BLOCKED(2);
|
||||
/*
|
||||
/* Check that thread #2 is still blocked */
|
||||
CHECK_THREAD_BLOCKED( 2 );
|
||||
/*
|
||||
* Step 5:
|
||||
* Report an error again from the driver.
|
||||
*/
|
||||
SEND_DRV_MSG(0, 0, RTEMS_IO_ERROR, EFAULT);
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_IO_ERROR, EFAULT );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Wait for sync from thread #2.
|
||||
*/
|
||||
WAIT_THREAD_SYNC(2);
|
||||
CONTINUE_THREAD(2);
|
||||
TEST_CHECK_RESULT("5");
|
||||
WAIT_THREAD_SYNC( 2 );
|
||||
CONTINUE_THREAD( 2 );
|
||||
TEST_CHECK_RESULT( "5" );
|
||||
|
||||
TEST_STOP();
|
||||
TEST_STOP();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test1_2_thread1(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test1_2_thread1( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1 - 3:
|
||||
* Try to read blk #N on thread #1
|
||||
* We will block on this read and meanwhile
|
||||
@@ -141,28 +139,26 @@ bdbuf_test1_2_thread1(rtems_task_argument arg)
|
||||
* driver will notify about an error, and as the
|
||||
* result this call will return an error.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM, &bd);
|
||||
if (rc != RTEMS_IO_ERROR || bd != NULL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM, &bd );
|
||||
if ( rc != RTEMS_IO_ERROR || bd != NULL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(1);
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
THREAD_END();
|
||||
THREAD_END();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test1_2_thread2(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test1_2_thread2( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
WAIT_MAIN_SYNC(2);
|
||||
WAIT_MAIN_SYNC( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Try to read block #N. Right now thread #1 is waiting
|
||||
* on data transfer operation, so we will block here as well.
|
||||
@@ -173,13 +169,12 @@ bdbuf_test1_2_thread2(rtems_task_argument arg)
|
||||
* But main test task will agin tell device driver to return
|
||||
* RTEMS_IO_ERROR data transfer result.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM, &bd);
|
||||
if (rc != RTEMS_IO_ERROR || bd != NULL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM, &bd );
|
||||
if ( rc != RTEMS_IO_ERROR || bd != NULL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(2);
|
||||
CONTINUE_MAIN( 2 );
|
||||
|
||||
THREAD_END();
|
||||
THREAD_END();
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -50,121 +50,114 @@
|
||||
|
||||
#include "bdbuf_tests.h"
|
||||
|
||||
static rtems_task bdbuf_test1_5_thread1(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test1_5_thread2(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test1_5_thread1( rtems_task_argument arg );
|
||||
static rtems_task bdbuf_test1_5_thread2( rtems_task_argument arg );
|
||||
|
||||
#define TEST_BLK_NUM 50
|
||||
|
||||
void
|
||||
bdbuf_test1_5_main()
|
||||
void bdbuf_test1_5_main()
|
||||
{
|
||||
bdbuf_test_msg msg;
|
||||
bdbuf_test_msg msg;
|
||||
|
||||
TEST_START("Test 1.5");
|
||||
TEST_START( "Test 1.5" );
|
||||
|
||||
START_THREAD(1, bdbuf_test1_5_thread1);
|
||||
START_THREAD(2, bdbuf_test1_5_thread2);
|
||||
START_THREAD( 1, bdbuf_test1_5_thread1 );
|
||||
START_THREAD( 2, bdbuf_test1_5_thread2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Thread #1 calls rtems_bdbuf_read() and successfully
|
||||
* get requested buffer.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
SEND_DRV_MSG(0, 0, RTEMS_SUCCESSFUL, 0);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
WAIT_THREAD_SYNC(1);
|
||||
TEST_CHECK_RESULT("1");
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
TEST_CHECK_RESULT( "1" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Thread #2 calls rtems_bdbuf_read() and blocks
|
||||
* on this call because thread #1 owns a buffer.
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
/* Make sure thread #2 managed to block on a read request. */
|
||||
CHECK_THREAD_BLOCKED(2);
|
||||
/* Make sure thread #2 managed to block on a read request. */
|
||||
CHECK_THREAD_BLOCKED( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 3:
|
||||
* Now thread #1 releases a buffer.
|
||||
*/
|
||||
CONTINUE_THREAD(1);
|
||||
CONTINUE_THREAD( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 4:
|
||||
* Thread #2 should unblock now and get the buffer.
|
||||
*/
|
||||
WAIT_THREAD_SYNC(2);
|
||||
TEST_CHECK_RESULT("4");
|
||||
WAIT_THREAD_SYNC( 2 );
|
||||
TEST_CHECK_RESULT( "4" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 5:
|
||||
* Thread #2 release buffer.
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
TEST_STOP();
|
||||
TEST_STOP();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test1_5_thread1(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test1_5_thread1( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* read blk #N on thread #1
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM, &bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
CONTINUE_MAIN(1);
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM, &bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 3:
|
||||
* Release buffer returned on step 1.
|
||||
*/
|
||||
rc = rtems_bdbuf_release(bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
rc = rtems_bdbuf_release( bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test1_5_thread2(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test1_5_thread2( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
WAIT_MAIN_SYNC(2);
|
||||
WAIT_MAIN_SYNC( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Try to read block #N. Right now thread #1 owns
|
||||
* this buffer, so we will block waiting for buffer.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM, &bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
CONTINUE_MAIN(2);
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM, &bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
CONTINUE_MAIN( 2 );
|
||||
|
||||
rc = rtems_bdbuf_release(bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
rc = rtems_bdbuf_release( bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -47,138 +47,131 @@
|
||||
|
||||
#include "bdbuf_tests.h"
|
||||
|
||||
static rtems_task bdbuf_test4_2_thread1(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test4_2_thread2(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test4_2_thread1( rtems_task_argument arg );
|
||||
static rtems_task bdbuf_test4_2_thread2( rtems_task_argument arg );
|
||||
|
||||
/* Block number used in the test */
|
||||
#define TEST_BLK_NUM_N 114
|
||||
|
||||
void
|
||||
bdbuf_test4_2_main()
|
||||
void bdbuf_test4_2_main()
|
||||
{
|
||||
bdbuf_test_msg msg;
|
||||
bdbuf_test_msg msg;
|
||||
|
||||
TEST_START("Test 4.2");
|
||||
TEST_START( "Test 4.2" );
|
||||
|
||||
START_THREAD(1, bdbuf_test4_2_thread1);
|
||||
START_THREAD(2, bdbuf_test4_2_thread2);
|
||||
START_THREAD( 1, bdbuf_test4_2_thread1 );
|
||||
START_THREAD( 2, bdbuf_test4_2_thread2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Call rtems_bdbuf_read(#N) in thread #1.
|
||||
* Wait for read request in disk driver.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
SEND_DRV_MSG(0, 0, RTEMS_SUCCESSFUL, 0);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2, 3:
|
||||
* Call rtems_bdbuf_sync(#N) in thread #1.
|
||||
* As the result buffer is asked to be flashed onto the disk.
|
||||
*/
|
||||
WAIT_DRV_MSG_WR(&msg);
|
||||
TEST_CHECK_RESULT("3");
|
||||
WAIT_DRV_MSG_WR( &msg );
|
||||
TEST_CHECK_RESULT( "3" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 4:
|
||||
* Call rtems_bdbuf_read(#N) in thread #2
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
/* Make sure that thread #2 blocks */
|
||||
CHECK_THREAD_BLOCKED(2);
|
||||
/* Make sure that thread #2 blocks */
|
||||
CHECK_THREAD_BLOCKED( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 5:
|
||||
* Notify bdbuf library about write complete event.
|
||||
*/
|
||||
SEND_DRV_MSG(0, 0, RTEMS_SUCCESSFUL, 0);
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
/* Check that rtems_bdbuf_sync() is unlocked in thread #1 */
|
||||
WAIT_THREAD_SYNC(1);
|
||||
/* Check that rtems_bdbuf_sync() is unlocked in thread #1 */
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 7:
|
||||
* Check that rtems_bdbuf_read(#N) call is unlocked in thread #2.
|
||||
*/
|
||||
WAIT_THREAD_SYNC(2);
|
||||
TEST_CHECK_RESULT("7");
|
||||
WAIT_THREAD_SYNC( 2 );
|
||||
TEST_CHECK_RESULT( "7" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 8:
|
||||
* Release buffer in thread #2
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
/* Exit from thread #1 */
|
||||
CONTINUE_THREAD(1);
|
||||
/* Exit from thread #1 */
|
||||
CONTINUE_THREAD( 1 );
|
||||
|
||||
TEST_STOP();
|
||||
TEST_STOP();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test4_2_thread1(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test4_2_thread1( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Call rtems_bdbuf_read(#N) in thread #1;
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM_N, &bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM_N, &bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Call rtems_bdbuf_sync(#N)
|
||||
*/
|
||||
rc = rtems_bdbuf_sync(bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_sync( bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(1);
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
THREAD_END();
|
||||
THREAD_END();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test4_2_thread2(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test4_2_thread2( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
WAIT_MAIN_SYNC(2);
|
||||
WAIT_MAIN_SYNC( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 4:
|
||||
* In thread #2 call read(#N).
|
||||
* We will block on this call.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM_N, &bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM_N, &bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(2);
|
||||
CONTINUE_MAIN( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Release buffer.
|
||||
*/
|
||||
rc = rtems_bdbuf_release(bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
rc = rtems_bdbuf_release( bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
}
|
||||
@@ -45,134 +45,127 @@
|
||||
|
||||
#include "bdbuf_tests.h"
|
||||
|
||||
static rtems_task bdbuf_test4_3_thread1(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test4_3_thread2(rtems_task_argument arg);
|
||||
static rtems_task bdbuf_test4_3_thread1( rtems_task_argument arg );
|
||||
static rtems_task bdbuf_test4_3_thread2( rtems_task_argument arg );
|
||||
|
||||
/* Block number used in the test */
|
||||
#define TEST_BLK_NUM_N 116
|
||||
|
||||
void
|
||||
bdbuf_test4_3_main()
|
||||
void bdbuf_test4_3_main()
|
||||
{
|
||||
bdbuf_test_msg msg;
|
||||
bdbuf_test_msg msg;
|
||||
|
||||
TEST_START("Test 4.3");
|
||||
TEST_START( "Test 4.3" );
|
||||
|
||||
START_THREAD(1, bdbuf_test4_3_thread1);
|
||||
START_THREAD(2, bdbuf_test4_3_thread2);
|
||||
START_THREAD( 1, bdbuf_test4_3_thread1 );
|
||||
START_THREAD( 2, bdbuf_test4_3_thread2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Call rtems_bdbuf_read(#N) in thread #1.
|
||||
* Wait for read request in disk driver.
|
||||
*/
|
||||
WAIT_DRV_MSG(&msg);
|
||||
SEND_DRV_MSG(0, 0, RTEMS_SUCCESSFUL, 0);
|
||||
WAIT_DRV_MSG( &msg );
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Call rtems_bdbuf_sync(#N) in thread #1.
|
||||
* As the result buffer is asked to be flashed onto the disk.
|
||||
*/
|
||||
WAIT_DRV_MSG_WR(&msg);
|
||||
SEND_DRV_MSG(0, 0, RTEMS_SUCCESSFUL, 0);
|
||||
WAIT_DRV_MSG_WR( &msg );
|
||||
SEND_DRV_MSG( 0, 0, RTEMS_SUCCESSFUL, 0 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 4:
|
||||
* Check that rtems_bdbuf_sync(#N) call is unlocked.
|
||||
*/
|
||||
WAIT_THREAD_SYNC(1);
|
||||
TEST_CHECK_RESULT("4");
|
||||
WAIT_THREAD_SYNC( 1 );
|
||||
TEST_CHECK_RESULT( "4" );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 5:
|
||||
* Call rtems_bdbuf_read(#N) in thread #2.
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 6:
|
||||
* Check that thread #2 successfully got the buffer.
|
||||
*/
|
||||
WAIT_THREAD_SYNC(2);
|
||||
WAIT_THREAD_SYNC( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 7:
|
||||
* Release buffer in thread #2
|
||||
*/
|
||||
CONTINUE_THREAD(2);
|
||||
CONTINUE_THREAD( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Exit from thread #1.
|
||||
*/
|
||||
CONTINUE_THREAD(1);
|
||||
CONTINUE_THREAD( 1 );
|
||||
|
||||
TEST_STOP();
|
||||
TEST_STOP();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test4_3_thread1(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test4_3_thread1( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 1:
|
||||
* Call rtems_bdbuf_read(#N) in thread #1;
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM_N, &bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM_N, &bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 2:
|
||||
* Call rtems_bdbuf_sync(#N)
|
||||
*/
|
||||
rc = rtems_bdbuf_sync(bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_sync( bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(1);
|
||||
CONTINUE_MAIN( 1 );
|
||||
|
||||
THREAD_END();
|
||||
THREAD_END();
|
||||
}
|
||||
|
||||
static rtems_task
|
||||
bdbuf_test4_3_thread2(rtems_task_argument arg)
|
||||
static rtems_task bdbuf_test4_3_thread2( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
(void) arg;
|
||||
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
rtems_status_code rc;
|
||||
rtems_bdbuf_buffer *bd = NULL;
|
||||
|
||||
WAIT_MAIN_SYNC(2);
|
||||
WAIT_MAIN_SYNC( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Step 5:
|
||||
* In thread #2 call rtems_bdbuf_read(#N).
|
||||
* We will block on this call.
|
||||
*/
|
||||
rc = rtems_bdbuf_read(test_dd, TEST_BLK_NUM_N, &bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
rc = rtems_bdbuf_read( test_dd, TEST_BLK_NUM_N, &bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
|
||||
CONTINUE_MAIN(2);
|
||||
CONTINUE_MAIN( 2 );
|
||||
|
||||
/*
|
||||
/*
|
||||
* Release buffer.
|
||||
*/
|
||||
rc = rtems_bdbuf_release(bd);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
rc = rtems_bdbuf_release( bd );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
TEST_FAILED();
|
||||
}
|
||||
THREAD_END();
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -49,7 +49,7 @@
|
||||
|
||||
const char rtems_test_name[] = "BLOCK 8";
|
||||
|
||||
rtems_task Init(rtems_task_argument argument)
|
||||
rtems_task Init( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
@@ -57,5 +57,5 @@ rtems_task Init(rtems_task_argument argument)
|
||||
run_bdbuf_tests();
|
||||
TEST_END();
|
||||
|
||||
exit(0);
|
||||
exit( 0 );
|
||||
}
|
||||
@@ -36,37 +36,35 @@
|
||||
|
||||
#include <bsp.h>
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument argument
|
||||
);
|
||||
rtems_task Init( rtems_task_argument argument );
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
|
||||
#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 28
|
||||
#define CONFIGURE_MAXIMUM_TIMERS 10
|
||||
#define CONFIGURE_MAXIMUM_SEMAPHORES 20
|
||||
#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 10
|
||||
#define CONFIGURE_MAXIMUM_PARTITIONS 1
|
||||
#define CONFIGURE_MAXIMUM_REGIONS 1
|
||||
#define CONFIGURE_MAXIMUM_PERIODS 1
|
||||
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 0
|
||||
#define CONFIGURE_TICKS_PER_TIMESLICE 100
|
||||
#define CONFIGURE_MAXIMUM_TASKS 28
|
||||
#define CONFIGURE_MAXIMUM_TIMERS 10
|
||||
#define CONFIGURE_MAXIMUM_SEMAPHORES 20
|
||||
#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 10
|
||||
#define CONFIGURE_MAXIMUM_PARTITIONS 1
|
||||
#define CONFIGURE_MAXIMUM_REGIONS 1
|
||||
#define CONFIGURE_MAXIMUM_PERIODS 1
|
||||
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 0
|
||||
#define CONFIGURE_TICKS_PER_TIMESLICE 100
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
|
||||
#define CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS 2
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE (512)
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE (512)
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE (512)
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE ( 512 )
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE ( 512 )
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE ( 512 )
|
||||
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
|
||||
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
|
||||
#define CONFIGURE_INIT_TASK_STACK_SIZE (4 * RTEMS_MINIMUM_STACK_SIZE)
|
||||
#define CONFIGURE_INIT_TASK_STACK_SIZE ( 4 * RTEMS_MINIMUM_STACK_SIZE )
|
||||
|
||||
#define CONFIGURE_EXTRA_TASK_STACKS (13 * RTEMS_MINIMUM_STACK_SIZE)
|
||||
#define CONFIGURE_EXTRA_TASK_STACKS ( 13 * RTEMS_MINIMUM_STACK_SIZE )
|
||||
|
||||
#include <rtems/confdefs.h>
|
||||
|
||||
|
||||
@@ -47,113 +47,107 @@
|
||||
static Objects_Id drvq_id = OBJECTS_ID_NONE;
|
||||
static Objects_Id testq_id = OBJECTS_ID_NONE;
|
||||
|
||||
static int
|
||||
test_disk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
|
||||
static int test_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
|
||||
{
|
||||
rtems_status_code rc;
|
||||
bdbuf_test_msg msg;
|
||||
size_t msg_size;
|
||||
rtems_blkdev_request *r;
|
||||
rtems_status_code rc;
|
||||
bdbuf_test_msg msg;
|
||||
size_t msg_size;
|
||||
rtems_blkdev_request *r;
|
||||
|
||||
switch (req)
|
||||
{
|
||||
case RTEMS_BLKIO_REQUEST:
|
||||
{
|
||||
rtems_blkdev_sg_buffer *sg;
|
||||
unsigned int i;
|
||||
switch ( req ) {
|
||||
case RTEMS_BLKIO_REQUEST: {
|
||||
rtems_blkdev_sg_buffer *sg;
|
||||
unsigned int i;
|
||||
|
||||
r = argp;
|
||||
r = argp;
|
||||
|
||||
printf("DISK_DRV: %s ",
|
||||
r->req == RTEMS_BLKDEV_REQ_READ ? "R" :
|
||||
r->req == RTEMS_BLKDEV_REQ_WRITE ? "W" : "?");
|
||||
for (i = 0, sg = r->bufs; i < r->bufnum; i++, sg++)
|
||||
{
|
||||
printf("[%" PRIu32 "] ", sg->block);
|
||||
}
|
||||
printf("\n");
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
return rtems_blkdev_ioctl (dd, req, argp);
|
||||
printf(
|
||||
"DISK_DRV: %s ",
|
||||
r->req == RTEMS_BLKDEV_REQ_READ ? "R"
|
||||
: r->req == RTEMS_BLKDEV_REQ_WRITE ? "W"
|
||||
: "?"
|
||||
);
|
||||
for ( i = 0, sg = r->bufs; i < r->bufnum; i++, sg++ ) {
|
||||
printf( "[%" PRIu32 "] ", sg->block );
|
||||
}
|
||||
printf( "\n" );
|
||||
break;
|
||||
}
|
||||
|
||||
memset(&msg, 0, sizeof(msg));
|
||||
msg.type = BDBUF_TEST_MSG_TYPE_DRIVER_REQ;
|
||||
msg.val.driver_req.dd = dd;
|
||||
msg.val.driver_req.req = req;
|
||||
msg.val.driver_req.argp = argp;
|
||||
default:
|
||||
return rtems_blkdev_ioctl( dd, req, argp );
|
||||
}
|
||||
|
||||
rc = rtems_message_queue_send(testq_id, &msg, sizeof(msg));
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
printf("Error while sending a message to Test task: %u\n", rc);
|
||||
rtems_blkdev_request_done(r, RTEMS_IO_ERROR);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Wait for a reply from the test task */
|
||||
msg_size = sizeof(msg);
|
||||
rc = rtems_message_queue_receive(drvq_id, &msg, &msg_size,
|
||||
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
printf("Error while reading a message from Test task: %u\n", rc);
|
||||
rtems_blkdev_request_done(r, RTEMS_IO_ERROR);
|
||||
return 0;
|
||||
}
|
||||
if (msg.type != BDBUF_TEST_MSG_TYPE_DRIVER_REPLY)
|
||||
{
|
||||
printf("Unexpected message comes to test disk driver: %d\n",
|
||||
msg.type);
|
||||
rtems_blkdev_request_done(r, RTEMS_IO_ERROR);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (msg.val.driver_reply.ret_val != 0)
|
||||
{
|
||||
rtems_blkdev_request_done(r, RTEMS_IO_ERROR);
|
||||
}
|
||||
else
|
||||
{
|
||||
rtems_blkdev_request_done(r, msg.val.driver_reply.res_status);
|
||||
}
|
||||
memset( &msg, 0, sizeof( msg ) );
|
||||
msg.type = BDBUF_TEST_MSG_TYPE_DRIVER_REQ;
|
||||
msg.val.driver_req.dd = dd;
|
||||
msg.val.driver_req.req = req;
|
||||
msg.val.driver_req.argp = argp;
|
||||
|
||||
rc = rtems_message_queue_send( testq_id, &msg, sizeof( msg ) );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
printf( "Error while sending a message to Test task: %u\n", rc );
|
||||
rtems_blkdev_request_done( r, RTEMS_IO_ERROR );
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Wait for a reply from the test task */
|
||||
msg_size = sizeof( msg );
|
||||
rc = rtems_message_queue_receive(
|
||||
drvq_id,
|
||||
&msg,
|
||||
&msg_size,
|
||||
RTEMS_WAIT,
|
||||
RTEMS_NO_TIMEOUT
|
||||
);
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
printf( "Error while reading a message from Test task: %u\n", rc );
|
||||
rtems_blkdev_request_done( r, RTEMS_IO_ERROR );
|
||||
return 0;
|
||||
}
|
||||
if ( msg.type != BDBUF_TEST_MSG_TYPE_DRIVER_REPLY ) {
|
||||
printf( "Unexpected message comes to test disk driver: %d\n", msg.type );
|
||||
rtems_blkdev_request_done( r, RTEMS_IO_ERROR );
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ( msg.val.driver_reply.ret_val != 0 ) {
|
||||
rtems_blkdev_request_done( r, RTEMS_IO_ERROR );
|
||||
} else {
|
||||
rtems_blkdev_request_done( r, msg.val.driver_reply.res_status );
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
rtems_status_code
|
||||
test_disk_initialize(void)
|
||||
rtems_status_code test_disk_initialize( void )
|
||||
{
|
||||
rtems_status_code rc;
|
||||
rtems_status_code rc;
|
||||
|
||||
rc = rtems_blkdev_create(TEST_DISK_NAME,
|
||||
TEST_DISK_BLOCK_SIZE, TEST_DISK_BLOCK_NUM,
|
||||
test_disk_ioctl,
|
||||
NULL);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
printf("Failed to create %s disk\n", TEST_DISK_NAME);
|
||||
return rc;
|
||||
}
|
||||
rc = rtems_blkdev_create(
|
||||
TEST_DISK_NAME,
|
||||
TEST_DISK_BLOCK_SIZE,
|
||||
TEST_DISK_BLOCK_NUM,
|
||||
test_disk_ioctl,
|
||||
NULL
|
||||
);
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
printf( "Failed to create %s disk\n", TEST_DISK_NAME );
|
||||
return rc;
|
||||
}
|
||||
|
||||
rc = bdbuf_test_create_drv_rx_queue(&drvq_id);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
printf("%s() Failed to create Msg Queue for RX: %u\n",
|
||||
__FUNCTION__, rc);
|
||||
return rc;
|
||||
}
|
||||
rc = bdbuf_test_create_drv_rx_queue( &drvq_id );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
printf( "%s() Failed to create Msg Queue for RX: %u\n", __FUNCTION__, rc );
|
||||
return rc;
|
||||
}
|
||||
|
||||
rc = bdbuf_test_create_drv_tx_queue(&testq_id);
|
||||
if (rc != RTEMS_SUCCESSFUL)
|
||||
{
|
||||
printf("%s() Failed to get Msg Queue for TX: %u\n",
|
||||
__FUNCTION__, rc);
|
||||
return rc;
|
||||
}
|
||||
rc = bdbuf_test_create_drv_tx_queue( &testq_id );
|
||||
if ( rc != RTEMS_SUCCESSFUL ) {
|
||||
printf( "%s() Failed to get Msg Queue for TX: %u\n", __FUNCTION__, rc );
|
||||
return rc;
|
||||
}
|
||||
|
||||
printf("TEST DISK - OK\n");
|
||||
return RTEMS_SUCCESSFUL;
|
||||
printf( "TEST DISK - OK\n" );
|
||||
return RTEMS_SUCCESSFUL;
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
+173
-176
File diff suppressed because it is too large.
Load diff
+162
-243
File diff suppressed because it is too large.
Load diff
@@ -47,101 +47,95 @@ const char rtems_test_name[] = "BLOCK 12";
|
||||
|
||||
#define DISK_PATH "/disk"
|
||||
|
||||
static int block_access_counts [BLOCK_COUNT];
|
||||
static int block_access_counts[ BLOCK_COUNT ];
|
||||
|
||||
static int expected_block_access_counts [BLOCK_COUNT] = {
|
||||
2, 0, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 0, 2
|
||||
};
|
||||
static int expected_block_access_counts[ BLOCK_COUNT ] =
|
||||
{ 2, 0, 2, 0, 2, 0, 2, 2, 2, 0, 2, 0, 2, 0, 2 };
|
||||
|
||||
static const rtems_blkdev_bnum read_sequence [] = {
|
||||
0, 2, 4, 6, 8, 10, 12, 14, 7
|
||||
};
|
||||
static const rtems_blkdev_bnum read_sequence[] =
|
||||
{ 0, 2, 4, 6, 8, 10, 12, 14, 7 };
|
||||
|
||||
static int test_disk_ioctl(rtems_disk_device *dd, uint32_t req, void *arg)
|
||||
static int test_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *arg )
|
||||
{
|
||||
int rv = 0;
|
||||
|
||||
if (req == RTEMS_BLKIO_REQUEST) {
|
||||
rtems_blkdev_request *breq = arg;
|
||||
if ( req == RTEMS_BLKIO_REQUEST ) {
|
||||
rtems_blkdev_request *breq = arg;
|
||||
rtems_blkdev_sg_buffer *sg = breq->bufs;
|
||||
uint32_t i;
|
||||
uint32_t i;
|
||||
|
||||
rtems_test_assert(breq->req == RTEMS_BLKDEV_REQ_READ);
|
||||
rtems_test_assert( breq->req == RTEMS_BLKDEV_REQ_READ );
|
||||
|
||||
for (i = 0; i < breq->bufnum; ++i) {
|
||||
rtems_blkdev_bnum block = sg [i].block;
|
||||
for ( i = 0; i < breq->bufnum; ++i ) {
|
||||
rtems_blkdev_bnum block = sg[ i ].block;
|
||||
|
||||
rtems_test_assert(block < BLOCK_COUNT);
|
||||
rtems_test_assert( block < BLOCK_COUNT );
|
||||
|
||||
++block_access_counts [block];
|
||||
++block_access_counts[ block ];
|
||||
}
|
||||
|
||||
rtems_blkdev_request_done(breq, RTEMS_SUCCESSFUL);
|
||||
rtems_blkdev_request_done( breq, RTEMS_SUCCESSFUL );
|
||||
} else {
|
||||
rv = rtems_blkdev_ioctl(dd, req, arg);
|
||||
rv = rtems_blkdev_ioctl( dd, req, arg );
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
static void do_read_sequence(rtems_disk_device *dd)
|
||||
static void do_read_sequence( rtems_disk_device *dd )
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < sizeof(read_sequence) / sizeof(read_sequence [0]); ++i) {
|
||||
rtems_status_code sc;
|
||||
for (
|
||||
i = 0; i < sizeof( read_sequence ) / sizeof( read_sequence[ 0 ] ); ++i
|
||||
) {
|
||||
rtems_status_code sc;
|
||||
rtems_bdbuf_buffer *bd;
|
||||
|
||||
sc = rtems_bdbuf_read(dd, read_sequence [i], &bd);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_bdbuf_read( dd, read_sequence[ i ], &bd );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
sc = rtems_bdbuf_release(bd);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_bdbuf_release( bd );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
}
|
||||
}
|
||||
|
||||
static void test(void)
|
||||
static void test( void )
|
||||
{
|
||||
rtems_status_code sc;
|
||||
int fd;
|
||||
int rv;
|
||||
rtems_status_code sc;
|
||||
int fd;
|
||||
int rv;
|
||||
rtems_disk_device *dd;
|
||||
|
||||
sc = rtems_blkdev_create(
|
||||
DISK_PATH,
|
||||
1,
|
||||
BLOCK_COUNT,
|
||||
test_disk_ioctl,
|
||||
NULL
|
||||
);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_blkdev_create( DISK_PATH, 1, BLOCK_COUNT, test_disk_ioctl, NULL );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
fd = open(DISK_PATH, O_RDWR);
|
||||
rtems_test_assert(fd >= 0);
|
||||
fd = open( DISK_PATH, O_RDWR );
|
||||
rtems_test_assert( fd >= 0 );
|
||||
|
||||
rv = rtems_disk_fd_get_disk_device(fd, &dd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = rtems_disk_fd_get_disk_device( fd, &dd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
rv = close(fd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = close( fd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
do_read_sequence(dd);
|
||||
rtems_bdbuf_purge_dev(dd);
|
||||
do_read_sequence(dd);
|
||||
do_read_sequence( dd );
|
||||
rtems_bdbuf_purge_dev( dd );
|
||||
do_read_sequence( dd );
|
||||
|
||||
rtems_test_assert(
|
||||
memcmp(
|
||||
block_access_counts,
|
||||
expected_block_access_counts,
|
||||
sizeof(block_access_counts)
|
||||
sizeof( block_access_counts )
|
||||
) == 0
|
||||
);
|
||||
|
||||
rv = unlink(DISK_PATH);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = unlink( DISK_PATH );
|
||||
rtems_test_assert( rv == 0 );
|
||||
}
|
||||
|
||||
static void Init(rtems_task_argument arg)
|
||||
static void Init( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
|
||||
@@ -151,7 +145,7 @@ static void Init(rtems_task_argument arg)
|
||||
|
||||
TEST_END();
|
||||
|
||||
rtems_test_exit(0);
|
||||
rtems_test_exit( 0 );
|
||||
}
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
@@ -160,8 +154,8 @@ static void Init(rtems_task_argument arg)
|
||||
|
||||
#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
|
||||
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE 1
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE BLOCK_COUNT
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
|
||||
+135
-105
File diff suppressed because it is too large.
Load diff
+108
-119
File diff suppressed because it is too large.
Load diff
@@ -59,93 +59,94 @@ const char rtems_test_name[] = "BLOCK 15";
|
||||
|
||||
#define DISK_PATH "/disk"
|
||||
|
||||
static const rtems_blkdev_bnum action_sequence [ACTION_COUNT] = {
|
||||
2, 1, 0, 4, 5, 6, 7, 9
|
||||
};
|
||||
static const rtems_blkdev_bnum action_sequence[ ACTION_COUNT ] =
|
||||
{ 2, 1, 0, 4, 5, 6, 7, 9 };
|
||||
|
||||
static size_t request_index;
|
||||
|
||||
static const uint32_t expected_request_bufnums [REQUEST_COUNT] = {
|
||||
3, 3, 1, 1
|
||||
};
|
||||
static const uint32_t expected_request_bufnums[ REQUEST_COUNT ] =
|
||||
{ 3, 3, 1, 1 };
|
||||
|
||||
static size_t write_index;
|
||||
|
||||
static const rtems_blkdev_bnum expected_write_blocks [WRITE_COUNT] = {
|
||||
0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 18, 19
|
||||
};
|
||||
static const rtems_blkdev_bnum expected_write_blocks[ WRITE_COUNT ] =
|
||||
{ 0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 18, 19 };
|
||||
|
||||
static int test_disk_ioctl(rtems_disk_device *dd, uint32_t req, void *arg)
|
||||
static int test_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *arg )
|
||||
{
|
||||
int rv = 0;
|
||||
|
||||
if (req == RTEMS_BLKIO_REQUEST) {
|
||||
if ( req == RTEMS_BLKIO_REQUEST ) {
|
||||
rtems_blkdev_request *breq = arg;
|
||||
uint32_t i;
|
||||
uint32_t i;
|
||||
|
||||
printf("REQ %" PRIu32 "\n", breq->bufnum);
|
||||
printf( "REQ %" PRIu32 "\n", breq->bufnum );
|
||||
|
||||
rtems_test_assert(breq->req == RTEMS_BLKDEV_REQ_WRITE);
|
||||
rtems_test_assert(breq->bufnum == expected_request_bufnums [request_index]);
|
||||
rtems_test_assert( breq->req == RTEMS_BLKDEV_REQ_WRITE );
|
||||
rtems_test_assert(
|
||||
breq->bufnum == expected_request_bufnums[ request_index ]
|
||||
);
|
||||
++request_index;
|
||||
|
||||
for (i = 0; i < breq->bufnum; ++i) {
|
||||
rtems_blkdev_sg_buffer *sg = &breq->bufs [i];
|
||||
rtems_blkdev_bnum j;
|
||||
for ( i = 0; i < breq->bufnum; ++i ) {
|
||||
rtems_blkdev_sg_buffer *sg = &breq->bufs[ i ];
|
||||
rtems_blkdev_bnum j;
|
||||
|
||||
printf("W %" PRIu32 "\n", sg->block);
|
||||
printf( "W %" PRIu32 "\n", sg->block );
|
||||
|
||||
rtems_test_assert(sg->block < BLOCK_COUNT);
|
||||
rtems_test_assert(sg->length == BLOCK_SIZE);
|
||||
rtems_test_assert( sg->block < BLOCK_COUNT );
|
||||
rtems_test_assert( sg->length == BLOCK_SIZE );
|
||||
|
||||
for (j = 0; j < BLOCK_SIZE / MEDIA_BLOCK_SIZE; ++j) {
|
||||
rtems_test_assert(expected_write_blocks [write_index] == sg->block + j);
|
||||
for ( j = 0; j < BLOCK_SIZE / MEDIA_BLOCK_SIZE; ++j ) {
|
||||
rtems_test_assert(
|
||||
expected_write_blocks[ write_index ] == sg->block + j
|
||||
);
|
||||
++write_index;
|
||||
}
|
||||
}
|
||||
|
||||
rtems_blkdev_request_done(breq, RTEMS_SUCCESSFUL);
|
||||
} else if (req == RTEMS_BLKIO_CAPABILITIES) {
|
||||
rtems_blkdev_request_done( breq, RTEMS_SUCCESSFUL );
|
||||
} else if ( req == RTEMS_BLKIO_CAPABILITIES ) {
|
||||
*(uint32_t *) arg = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT;
|
||||
} else {
|
||||
rv = rtems_blkdev_ioctl(dd, req, arg);
|
||||
rv = rtems_blkdev_ioctl( dd, req, arg );
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
static void test_write_requests(rtems_disk_device *dd)
|
||||
static void test_write_requests( rtems_disk_device *dd )
|
||||
{
|
||||
rtems_status_code sc;
|
||||
int i;
|
||||
int i;
|
||||
|
||||
sc = rtems_bdbuf_set_block_size(dd, BLOCK_SIZE, true);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_bdbuf_set_block_size( dd, BLOCK_SIZE, true );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
for (i = 0; i < ACTION_COUNT; ++i) {
|
||||
rtems_blkdev_bnum block = action_sequence [i];
|
||||
for ( i = 0; i < ACTION_COUNT; ++i ) {
|
||||
rtems_blkdev_bnum block = action_sequence[ i ];
|
||||
rtems_bdbuf_buffer *bd;
|
||||
|
||||
sc = rtems_bdbuf_get(dd, block, &bd);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_bdbuf_get( dd, block, &bd );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
sc = rtems_bdbuf_release_modified(bd);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_bdbuf_release_modified( bd );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
}
|
||||
|
||||
sc = rtems_bdbuf_syncdev(dd);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
sc = rtems_bdbuf_syncdev( dd );
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
rtems_test_assert(request_index == REQUEST_COUNT);
|
||||
rtems_test_assert(write_index == WRITE_COUNT);
|
||||
rtems_test_assert( request_index == REQUEST_COUNT );
|
||||
rtems_test_assert( write_index == WRITE_COUNT );
|
||||
}
|
||||
|
||||
static void test(void)
|
||||
static void test( void )
|
||||
{
|
||||
rtems_status_code sc;
|
||||
rtems_status_code sc;
|
||||
rtems_disk_device *dd;
|
||||
int fd;
|
||||
int rv;
|
||||
int fd;
|
||||
int rv;
|
||||
|
||||
sc = rtems_blkdev_create(
|
||||
DISK_PATH,
|
||||
@@ -154,24 +155,24 @@ static void test(void)
|
||||
test_disk_ioctl,
|
||||
NULL
|
||||
);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
|
||||
|
||||
fd = open(DISK_PATH, O_RDWR);
|
||||
rtems_test_assert(fd >= 0);
|
||||
fd = open( DISK_PATH, O_RDWR );
|
||||
rtems_test_assert( fd >= 0 );
|
||||
|
||||
rv = rtems_disk_fd_get_disk_device(fd, &dd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = rtems_disk_fd_get_disk_device( fd, &dd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
rv = close(fd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = close( fd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
test_write_requests(dd);
|
||||
test_write_requests( dd );
|
||||
|
||||
rv = unlink(DISK_PATH);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = unlink( DISK_PATH );
|
||||
rtems_test_assert( rv == 0 );
|
||||
}
|
||||
|
||||
static void Init(rtems_task_argument arg)
|
||||
static void Init( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
|
||||
@@ -181,7 +182,7 @@ static void Init(rtems_task_argument arg)
|
||||
|
||||
TEST_END();
|
||||
|
||||
rtems_test_exit(0);
|
||||
rtems_test_exit( 0 );
|
||||
}
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
@@ -190,10 +191,10 @@ static void Init(rtems_task_argument arg)
|
||||
|
||||
#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
|
||||
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE 4
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE (BLOCK_COUNT * BLOCK_SIZE)
|
||||
#define CONFIGURE_BDBUF_MAX_WRITE_BLOCKS MAX_WRITE_BLOCKS
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE 4
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE ( BLOCK_COUNT * BLOCK_SIZE )
|
||||
#define CONFIGURE_BDBUF_MAX_WRITE_BLOCKS MAX_WRITE_BLOCKS
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
|
||||
|
||||
@@ -43,30 +43,30 @@
|
||||
|
||||
const char rtems_test_name[] = "BLOCK 16";
|
||||
|
||||
#define ASSERT_SC(sc) rtems_test_assert((sc) == RTEMS_SUCCESSFUL)
|
||||
#define ASSERT_SC( sc ) rtems_test_assert( ( sc ) == RTEMS_SUCCESSFUL )
|
||||
|
||||
static void test(void)
|
||||
static void test( void )
|
||||
{
|
||||
static const char device [] = "/dev/rda";
|
||||
rtems_status_code sc;
|
||||
int fd;
|
||||
int rv;
|
||||
rtems_disk_device *dd;
|
||||
ramdisk *rd;
|
||||
unsigned char buf [8];
|
||||
uint32_t media_block_size = sizeof(buf [0]);
|
||||
rtems_blkdev_bnum media_block_count = sizeof(buf) / sizeof(buf [0]);
|
||||
rtems_blkdev_bnum media_size = media_block_size * media_block_count;
|
||||
rtems_bdbuf_buffer *media_bd [media_block_count];
|
||||
static const char device[] = "/dev/rda";
|
||||
rtems_status_code sc;
|
||||
int fd;
|
||||
int rv;
|
||||
rtems_disk_device *dd;
|
||||
ramdisk *rd;
|
||||
unsigned char buf[ 8 ];
|
||||
uint32_t media_block_size = sizeof( buf[ 0 ] );
|
||||
rtems_blkdev_bnum media_block_count = sizeof( buf ) / sizeof( buf[ 0 ] );
|
||||
rtems_blkdev_bnum media_size = media_block_size * media_block_count;
|
||||
rtems_bdbuf_buffer *media_bd[ media_block_count ];
|
||||
rtems_bdbuf_buffer *large_bd;
|
||||
rtems_blkdev_bnum i;
|
||||
rtems_blkdev_bnum i;
|
||||
|
||||
for (i = 0; i < media_block_count; ++i) {
|
||||
buf [i] = i;
|
||||
for ( i = 0; i < media_block_count; ++i ) {
|
||||
buf[ i ] = i;
|
||||
}
|
||||
|
||||
rd = ramdisk_allocate(buf, media_block_size, media_block_count, false);
|
||||
rtems_test_assert(rd != NULL);
|
||||
rd = ramdisk_allocate( buf, media_block_size, media_block_count, false );
|
||||
rtems_test_assert( rd != NULL );
|
||||
|
||||
sc = rtems_blkdev_create(
|
||||
device,
|
||||
@@ -75,65 +75,71 @@ static void test(void)
|
||||
ramdisk_ioctl,
|
||||
rd
|
||||
);
|
||||
ASSERT_SC(sc);
|
||||
ASSERT_SC( sc );
|
||||
|
||||
fd = open(device, O_RDWR);
|
||||
rtems_test_assert(fd >= 0);
|
||||
fd = open( device, O_RDWR );
|
||||
rtems_test_assert( fd >= 0 );
|
||||
|
||||
rv = rtems_disk_fd_get_disk_device(fd, &dd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = rtems_disk_fd_get_disk_device( fd, &dd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
for (i = 0; i < media_block_count; ++i) {
|
||||
sc = rtems_bdbuf_read(dd, i, &media_bd [i]);
|
||||
ASSERT_SC(sc);
|
||||
for ( i = 0; i < media_block_count; ++i ) {
|
||||
sc = rtems_bdbuf_read( dd, i, &media_bd[ i ] );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
rtems_test_assert(media_bd [i]->buffer [0] == buf [i]);
|
||||
rtems_test_assert( media_bd[ i ]->buffer[ 0 ] == buf[ i ] );
|
||||
}
|
||||
|
||||
for (i = 0; i < media_block_count; ++i) {
|
||||
media_bd [i]->buffer [0] += media_block_count;
|
||||
for ( i = 0; i < media_block_count; ++i ) {
|
||||
media_bd[ i ]->buffer[ 0 ] += media_block_count;
|
||||
|
||||
sc = rtems_bdbuf_release_modified(media_bd [i]);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_release_modified( media_bd[ i ] );
|
||||
ASSERT_SC( sc );
|
||||
}
|
||||
|
||||
for (i = 0; i < media_block_count; i += 2) {
|
||||
sc = rtems_bdbuf_read(dd, i, &media_bd [i]);
|
||||
ASSERT_SC(sc);
|
||||
for ( i = 0; i < media_block_count; i += 2 ) {
|
||||
sc = rtems_bdbuf_read( dd, i, &media_bd[ i ] );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
rtems_test_assert(media_bd [i]->buffer [0] == buf [i] + media_block_count);
|
||||
rtems_test_assert(
|
||||
media_bd[ i ]->buffer[ 0 ] == buf[ i ] + media_block_count
|
||||
);
|
||||
}
|
||||
|
||||
sc = rtems_bdbuf_set_block_size(dd, media_size, true);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_set_block_size( dd, media_size, true );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
for (i = 0; i < media_block_count; i += 2) {
|
||||
rtems_test_assert(media_bd [i]->state == RTEMS_BDBUF_STATE_ACCESS_PURGED);
|
||||
rtems_test_assert(media_bd [i + 1]->state == RTEMS_BDBUF_STATE_FREE);
|
||||
for ( i = 0; i < media_block_count; i += 2 ) {
|
||||
rtems_test_assert(
|
||||
media_bd[ i ]->state == RTEMS_BDBUF_STATE_ACCESS_PURGED
|
||||
);
|
||||
rtems_test_assert( media_bd[ i + 1 ]->state == RTEMS_BDBUF_STATE_FREE );
|
||||
|
||||
rtems_test_assert(media_bd [i]->buffer [0] == buf [i] + media_block_count);
|
||||
rtems_test_assert(media_bd [i + 1]->buffer [0] == buf [i + 1]);
|
||||
rtems_test_assert(
|
||||
media_bd[ i ]->buffer[ 0 ] == buf[ i ] + media_block_count
|
||||
);
|
||||
rtems_test_assert( media_bd[ i + 1 ]->buffer[ 0 ] == buf[ i + 1 ] );
|
||||
|
||||
sc = rtems_bdbuf_release(media_bd [i]);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_release( media_bd[ i ] );
|
||||
ASSERT_SC( sc );
|
||||
}
|
||||
|
||||
sc = rtems_bdbuf_read(dd, 0, &large_bd);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_read( dd, 0, &large_bd );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
rtems_test_assert(memcmp(buf, large_bd->buffer, media_size) == 0);
|
||||
rtems_test_assert( memcmp( buf, large_bd->buffer, media_size ) == 0 );
|
||||
|
||||
sc = rtems_bdbuf_release(large_bd);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_bdbuf_release( large_bd );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
rv = close(fd);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = close( fd );
|
||||
rtems_test_assert( rv == 0 );
|
||||
|
||||
rv = unlink(device);
|
||||
rtems_test_assert(rv == 0);
|
||||
rv = unlink( device );
|
||||
rtems_test_assert( rv == 0 );
|
||||
}
|
||||
|
||||
static void Init(rtems_task_argument arg)
|
||||
static void Init( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
|
||||
@@ -143,15 +149,15 @@ static void Init(rtems_task_argument arg)
|
||||
|
||||
TEST_END();
|
||||
|
||||
rtems_test_exit(0);
|
||||
rtems_test_exit( 0 );
|
||||
}
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
|
||||
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE 8
|
||||
#define CONFIGURE_BDBUF_BUFFER_MIN_SIZE 1
|
||||
#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE 8
|
||||
#define CONFIGURE_BDBUF_CACHE_MEMORY_SIZE 8
|
||||
|
||||
#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
|
||||
|
||||
@@ -36,18 +36,18 @@
|
||||
|
||||
const char rtems_test_name[] = "BLOCK 17";
|
||||
|
||||
static void test(void)
|
||||
static void test( void )
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_bdbuf_init();
|
||||
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
|
||||
rtems_test_assert( sc == RTEMS_INVALID_NUMBER );
|
||||
|
||||
sc = rtems_blkdev_create(NULL, 0, 0, NULL, NULL);
|
||||
rtems_test_assert(sc == RTEMS_INCORRECT_STATE);
|
||||
sc = rtems_blkdev_create( NULL, 0, 0, NULL, NULL );
|
||||
rtems_test_assert( sc == RTEMS_INCORRECT_STATE );
|
||||
}
|
||||
|
||||
static void Init(rtems_task_argument arg)
|
||||
static void Init( rtems_task_argument arg )
|
||||
{
|
||||
(void) arg;
|
||||
|
||||
@@ -57,14 +57,14 @@ static void Init(rtems_task_argument arg)
|
||||
|
||||
TEST_END();
|
||||
|
||||
rtems_test_exit(0);
|
||||
rtems_test_exit( 0 );
|
||||
}
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
|
||||
#define CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS (64UL * 1024UL)
|
||||
#define CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS ( 64UL * 1024UL )
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
|
||||
|
||||
@@ -36,16 +36,16 @@
|
||||
const char rtems_test_name[] = "BSPCMDLINE 1";
|
||||
|
||||
/* forward declarations to avoid warnings */
|
||||
rtems_task Init(rtems_task_argument argument);
|
||||
void test_errors(void);
|
||||
void test_search(bool null_expected, const char *cmdline, const char *param);
|
||||
rtems_task Init( rtems_task_argument argument );
|
||||
void test_errors( void );
|
||||
void test_search( bool null_expected, const char *cmdline, const char *param );
|
||||
|
||||
extern const char *bsp_boot_cmdline;
|
||||
|
||||
void test_errors(void)
|
||||
void test_errors( void )
|
||||
{
|
||||
const char *p;
|
||||
char result[32];
|
||||
char result[ 32 ];
|
||||
|
||||
bsp_boot_cmdline = NULL;
|
||||
|
||||
@@ -72,36 +72,34 @@ void test_errors(void)
|
||||
rtems_test_assert( p == NULL );
|
||||
|
||||
puts(
|
||||
"rtems_bsp_cmdline_get_param_raw - bsp_boot_cmdline=NULL - returns NULL" );
|
||||
"rtems_bsp_cmdline_get_param_raw - bsp_boot_cmdline=NULL - returns NULL"
|
||||
);
|
||||
p = rtems_bsp_cmdline_get_param_raw( "name" );
|
||||
rtems_test_assert( p == NULL );
|
||||
|
||||
|
||||
bsp_boot_cmdline = "edit";
|
||||
puts (
|
||||
puts(
|
||||
"rtems_bsp_cmdline_get_param - bsp_boot_cmdline = edit name = "
|
||||
"edit -no error" );
|
||||
p = rtems_bsp_cmdline_get_param("edit", result, 5);
|
||||
"edit -no error"
|
||||
);
|
||||
p = rtems_bsp_cmdline_get_param( "edit", result, 5 );
|
||||
rtems_test_assert( p != NULL );
|
||||
|
||||
bsp_boot_cmdline = "joel=123456789";
|
||||
puts( "rtems_bsp_cmdline_get_param - too short buffer" );
|
||||
p = rtems_bsp_cmdline_get_param("joel", result, 5);
|
||||
p = rtems_bsp_cmdline_get_param( "joel", result, 5 );
|
||||
rtems_test_assert( p != NULL );
|
||||
|
||||
bsp_boot_cmdline = "--arg1=X`";
|
||||
puts( "rtems_bsp_cmdline_get_param_rhs - short match" );
|
||||
p = rtems_bsp_cmdline_get_param_rhs("arg", result, 10);
|
||||
p = rtems_bsp_cmdline_get_param_rhs( "arg", result, 10 );
|
||||
rtems_test_assert( p == NULL );
|
||||
}
|
||||
|
||||
void test_search(
|
||||
bool null_expected,
|
||||
const char *cmdline,
|
||||
const char *param
|
||||
)
|
||||
void test_search( bool null_expected, const char *cmdline, const char *param )
|
||||
{
|
||||
const char *p;
|
||||
char value[80];
|
||||
char value[ 80 ];
|
||||
size_t length;
|
||||
|
||||
bsp_boot_cmdline = cmdline;
|
||||
@@ -111,53 +109,58 @@ void test_search(
|
||||
"Testing for param=(%s)%s\n"
|
||||
" Command Line : (%s)\n",
|
||||
param,
|
||||
((null_expected) ? " - Expect NULL" : ""),
|
||||
( ( null_expected ) ? " - Expect NULL" : "" ),
|
||||
cmdline
|
||||
);
|
||||
|
||||
printf( "rtems_bsp_cmdline_get_param_raw(%s)\n", param );
|
||||
p = rtems_bsp_cmdline_get_param_raw( param );
|
||||
if ( null_expected ) {
|
||||
if ( p )
|
||||
if ( p ) {
|
||||
puts( "ERROR - rtems_bsp_cmdline_get_param_raw did not return NULL" );
|
||||
else
|
||||
} else {
|
||||
printf( "rtems_bsp_cmdline_get_param_raw(%s) returned NULL\n", param );
|
||||
}
|
||||
rtems_test_assert( !p );
|
||||
} else {
|
||||
if ( p )
|
||||
printf( "rtems_bsp_cmdline_get_param_raw(%s) returned (%s)\n", param, p );
|
||||
else
|
||||
if ( p ) {
|
||||
printf(
|
||||
"rtems_bsp_cmdline_get_param_raw(%s) returned (%s)\n",
|
||||
param,
|
||||
p
|
||||
);
|
||||
} else {
|
||||
printf( "rtems_bsp_cmdline_get_param_raw(%s) returned NULL\n", param );
|
||||
}
|
||||
|
||||
rtems_test_assert( p );
|
||||
}
|
||||
|
||||
printf( "rtems_bsp_cmdline_get_param_rhs(%s)\n", param );
|
||||
length = sizeof(value);
|
||||
length = sizeof( value );
|
||||
p = rtems_bsp_cmdline_get_param_rhs( param, value, length );
|
||||
if ( null_expected ) {
|
||||
if ( p )
|
||||
if ( p ) {
|
||||
puts( "ERROR - rtems_bsp_cmdline_get_param_rhs did not return NULL" );
|
||||
else
|
||||
} else {
|
||||
printf( "rtems_bsp_cmdline_get_param_rhs(%s) returned NULL\n", param );
|
||||
}
|
||||
rtems_test_assert( !p );
|
||||
} else {
|
||||
if ( !p )
|
||||
if ( !p ) {
|
||||
puts( "ERROR - rtems_bsp_cmdline_get_param_rhs returned NULL" );
|
||||
}
|
||||
rtems_test_assert( p );
|
||||
printf(
|
||||
"rtems_bsp_cmdline_get_param_rhs(%s) returned (%s) value=(%s)\n",
|
||||
param,
|
||||
((*p == '\0') ? "ZERO_LENGTH_STRING" : p ),
|
||||
((*value == '\0') ? "ZERO_LENGTH_STRING" : value )
|
||||
( ( *p == '\0' ) ? "ZERO_LENGTH_STRING" : p ),
|
||||
( ( *value == '\0' ) ? "ZERO_LENGTH_STRING" : value )
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument ignored
|
||||
)
|
||||
rtems_task Init( rtems_task_argument ignored )
|
||||
{
|
||||
(void) ignored;
|
||||
|
||||
@@ -187,10 +190,10 @@ rtems_task Init(
|
||||
false,
|
||||
"--ip=192.168.1.151 --name=\"joel and michele\" --cpu=fast",
|
||||
"-name"
|
||||
);
|
||||
);
|
||||
|
||||
TEST_END();
|
||||
rtems_test_exit(0);
|
||||
rtems_test_exit( 0 );
|
||||
}
|
||||
|
||||
/* configuration information */
|
||||
@@ -198,7 +201,7 @@ rtems_task Init(
|
||||
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
|
||||
#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
|
||||
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
|
||||
|
||||
@@ -47,44 +47,43 @@
|
||||
#include <assert.h>
|
||||
#include <tmacros.h>
|
||||
|
||||
#define ASSERT_SC(sc) assert((sc) == RTEMS_SUCCESSFUL)
|
||||
#define ASSERT_SC( sc ) assert( ( sc ) == RTEMS_SUCCESSFUL )
|
||||
|
||||
/* forward declarations to avoid warnings */
|
||||
rtems_task Init(rtems_task_argument argument);
|
||||
rtems_task Init( rtems_task_argument argument );
|
||||
|
||||
const char rtems_test_name[] = "CAPTURE 1";
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument ignored
|
||||
)
|
||||
rtems_task Init( rtems_task_argument ignored )
|
||||
{
|
||||
(void) ignored;
|
||||
|
||||
rtems_status_code sc;
|
||||
rtems_task_priority old_priority;
|
||||
rtems_mode old_mode;
|
||||
rtems_name to_name = rtems_build_name('I', 'D', 'L', 'E');;
|
||||
rtems_name to_name = rtems_build_name( 'I', 'D', 'L', 'E' );
|
||||
;
|
||||
|
||||
rtems_print_printer_fprintf_putc(&rtems_test_printer);
|
||||
rtems_print_printer_fprintf_putc( &rtems_test_printer );
|
||||
|
||||
TEST_BEGIN();
|
||||
|
||||
rtems_task_set_priority(RTEMS_SELF, 20, &old_priority);
|
||||
rtems_task_mode(RTEMS_PREEMPT, RTEMS_PREEMPT_MASK, &old_mode);
|
||||
rtems_task_set_priority( RTEMS_SELF, 20, &old_priority );
|
||||
rtems_task_mode( RTEMS_PREEMPT, RTEMS_PREEMPT_MASK, &old_mode );
|
||||
|
||||
sc = rtems_capture_open (5000, NULL);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_capture_open( 5000, NULL );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_capture_watch_ceiling (100);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_capture_watch_ceiling( 100 );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_capture_watch_floor (102);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_capture_watch_floor( 102 );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_capture_watch_global (true);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_capture_watch_global( true );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
sc = rtems_capture_set_trigger (
|
||||
sc = rtems_capture_set_trigger(
|
||||
0,
|
||||
0,
|
||||
to_name,
|
||||
@@ -92,20 +91,20 @@ rtems_task Init(
|
||||
rtems_capture_from_any,
|
||||
rtems_capture_switch
|
||||
);
|
||||
ASSERT_SC(sc);
|
||||
ASSERT_SC( sc );
|
||||
|
||||
rtems_capture_print_watch_list();
|
||||
|
||||
sc = rtems_capture_set_control (true);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_capture_set_control( true );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
capture_test_1();
|
||||
|
||||
sc = rtems_capture_set_control (false);
|
||||
ASSERT_SC(sc);
|
||||
sc = rtems_capture_set_control( false );
|
||||
ASSERT_SC( sc );
|
||||
|
||||
rtems_capture_print_trace_records ( 22, false );
|
||||
rtems_capture_print_trace_records ( 22, false );
|
||||
rtems_capture_print_trace_records( 22, false );
|
||||
rtems_capture_print_trace_records( 22, false );
|
||||
|
||||
TEST_END();
|
||||
exit( 0 );
|
||||
|
||||
@@ -35,11 +35,9 @@
|
||||
|
||||
/* functions */
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument argument
|
||||
);
|
||||
rtems_task Init( rtems_task_argument argument );
|
||||
|
||||
void capture_test_1(void);
|
||||
void capture_test_1( void );
|
||||
|
||||
/* configuration information */
|
||||
|
||||
@@ -50,12 +48,13 @@ void capture_test_1(void);
|
||||
|
||||
#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT
|
||||
|
||||
#define TASK_ALLOCATION_SIZE (5)
|
||||
#define CONFIGURE_MAXIMUM_TASKS rtems_resource_unlimited(TASK_ALLOCATION_SIZE)
|
||||
#define CONFIGURE_EXTRA_TASK_STACKS (75 * RTEMS_MINIMUM_STACK_SIZE)
|
||||
#define TASK_ALLOCATION_SIZE ( 5 )
|
||||
#define CONFIGURE_MAXIMUM_TASKS \
|
||||
rtems_resource_unlimited( TASK_ALLOCATION_SIZE )
|
||||
#define CONFIGURE_EXTRA_TASK_STACKS ( 75 * RTEMS_MINIMUM_STACK_SIZE )
|
||||
#define CONFIGURE_MAXIMUM_SEMAPHORES 1
|
||||
|
||||
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS (5)
|
||||
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS ( 5 )
|
||||
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -19,6 +19,6 @@
|
||||
#endif
|
||||
|
||||
#define FTYPE double
|
||||
#define PRI "%f"
|
||||
#define PRI "%f"
|
||||
|
||||
#include "docomplex.h"
|
||||
File diff suppressed because it is too large.
Load diff
@@ -19,7 +19,7 @@
|
||||
#endif
|
||||
|
||||
#define SUFFIX f
|
||||
#define FTYPE float
|
||||
#define PRI "%f"
|
||||
#define FTYPE float
|
||||
#define PRI "%f"
|
||||
|
||||
#include "docomplex.h"
|
||||
@@ -22,7 +22,7 @@
|
||||
#endif
|
||||
|
||||
#define SUFFIX l
|
||||
#define FTYPE long double
|
||||
#define PRI "%Lf"
|
||||
#define FTYPE long double
|
||||
#define PRI "%Lf"
|
||||
|
||||
#include "docomplex.h"
|
||||
@@ -44,9 +44,9 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
extern void docomplex(void);
|
||||
extern void docomplexf(void);
|
||||
extern void docomplexl(void);
|
||||
extern void docomplex( void );
|
||||
extern void docomplexf( void );
|
||||
extern void docomplexl( void );
|
||||
|
||||
#if __rtems__
|
||||
#include <tmacros.h>
|
||||
@@ -57,19 +57,17 @@ const char rtems_test_name[] = "COMPLEX";
|
||||
#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
#define CONFIGURE_MAXIMUM_TASKS 1
|
||||
|
||||
#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
|
||||
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
|
||||
|
||||
#define CONFIGURE_INIT
|
||||
#include <rtems/confdefs.h>
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument ignored
|
||||
)
|
||||
rtems_task Init( rtems_task_argument ignored )
|
||||
#else
|
||||
int main( void )
|
||||
#endif
|
||||
@@ -77,7 +75,7 @@ int main( void )
|
||||
#if __rtems__
|
||||
(void) ignored;
|
||||
|
||||
rtems_print_printer_fprintf_putc(&rtems_test_printer);
|
||||
rtems_print_printer_fprintf_putc( &rtems_test_printer );
|
||||
TEST_BEGIN();
|
||||
#endif
|
||||
|
||||
|
||||
@@ -44,20 +44,18 @@
|
||||
const char rtems_test_name[] = "CPUUSE";
|
||||
|
||||
rtems_extensions_table Extensions = {
|
||||
.thread_create = NULL, /* task create user extension */
|
||||
.thread_start = NULL, /* task start user extension */
|
||||
.thread_restart = NULL, /* task restart user extension */
|
||||
.thread_delete = NULL, /* task delete user extension */
|
||||
.thread_switch = Task_switch, /* task switch user extension */
|
||||
.thread_begin = NULL, /* task begin user extension */
|
||||
.thread_exitted = NULL, /* task exitted user extension */
|
||||
.fatal = NULL, /* fatal error user extension */
|
||||
.thread_terminate = NULL /* fatal error user extension */
|
||||
.thread_create = NULL, /* task create user extension */
|
||||
.thread_start = NULL, /* task start user extension */
|
||||
.thread_restart = NULL, /* task restart user extension */
|
||||
.thread_delete = NULL, /* task delete user extension */
|
||||
.thread_switch = Task_switch, /* task switch user extension */
|
||||
.thread_begin = NULL, /* task begin user extension */
|
||||
.thread_exitted = NULL, /* task exitted user extension */
|
||||
.fatal = NULL, /* fatal error user extension */
|
||||
.thread_terminate = NULL /* fatal error user extension */
|
||||
};
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument argument
|
||||
)
|
||||
rtems_task Init( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
@@ -70,7 +68,7 @@ rtems_task Init(
|
||||
status = rtems_clock_set( &time );
|
||||
directive_failed( status, "rtems_clock_set" );
|
||||
|
||||
Extension_name[ 1 ] = rtems_build_name( 'E', 'X', 'T', ' ' );
|
||||
Extension_name[ 1 ] = rtems_build_name( 'E', 'X', 'T', ' ' );
|
||||
|
||||
status = rtems_extension_create(
|
||||
Extension_name[ 1 ],
|
||||
@@ -79,41 +77,41 @@ rtems_task Init(
|
||||
);
|
||||
directive_failed( status, "rtems_extension_create" );
|
||||
|
||||
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
|
||||
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
|
||||
Task_name[ 3 ] = rtems_build_name( 'T', 'A', '3', ' ' );
|
||||
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
|
||||
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
|
||||
Task_name[ 3 ] = rtems_build_name( 'T', 'A', '3', ' ' );
|
||||
|
||||
Run_count[ 1 ] = 0;
|
||||
Run_count[ 2 ] = 0;
|
||||
Run_count[ 3 ] = 0;
|
||||
|
||||
status = rtems_task_create(
|
||||
Task_name[ 1 ],
|
||||
1,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_TIMESLICE,
|
||||
RTEMS_FLOATING_POINT,
|
||||
&Task_id[ 1 ]
|
||||
Task_name[ 1 ],
|
||||
1,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_TIMESLICE,
|
||||
RTEMS_FLOATING_POINT,
|
||||
&Task_id[ 1 ]
|
||||
);
|
||||
directive_failed( status, "rtems_task_create of TA1" );
|
||||
|
||||
status = rtems_task_create(
|
||||
Task_name[ 2 ],
|
||||
1,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_TIMESLICE,
|
||||
RTEMS_FLOATING_POINT,
|
||||
&Task_id[ 2 ]
|
||||
Task_name[ 2 ],
|
||||
1,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_TIMESLICE,
|
||||
RTEMS_FLOATING_POINT,
|
||||
&Task_id[ 2 ]
|
||||
);
|
||||
directive_failed( status, "rtems_task_create of TA2" );
|
||||
|
||||
status = rtems_task_create(
|
||||
Task_name[ 3 ],
|
||||
1,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_TIMESLICE,
|
||||
RTEMS_FLOATING_POINT,
|
||||
&Task_id[ 3 ]
|
||||
Task_name[ 3 ],
|
||||
1,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_TIMESLICE,
|
||||
RTEMS_FLOATING_POINT,
|
||||
&Task_id[ 3 ]
|
||||
);
|
||||
directive_failed( status, "rtems_task_create of TA3" );
|
||||
|
||||
|
||||
@@ -35,35 +35,24 @@
|
||||
|
||||
/* functions */
|
||||
|
||||
rtems_task Init(
|
||||
rtems_task_argument argument
|
||||
);
|
||||
rtems_task Init( rtems_task_argument argument );
|
||||
|
||||
rtems_task Task_1(
|
||||
rtems_task_argument argument
|
||||
);
|
||||
rtems_task Task_1( rtems_task_argument argument );
|
||||
|
||||
rtems_task Task_2(
|
||||
rtems_task_argument argument
|
||||
);
|
||||
rtems_task Task_2( rtems_task_argument argument );
|
||||
|
||||
rtems_task Task_3(
|
||||
rtems_task_argument argument
|
||||
);
|
||||
rtems_task Task_3( rtems_task_argument argument );
|
||||
|
||||
void Task_switch(
|
||||
rtems_tcb *unused,
|
||||
rtems_tcb *heir
|
||||
);
|
||||
void Task_switch( rtems_tcb *unused, rtems_tcb *heir );
|
||||
|
||||
/* configuration information */
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
|
||||
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1
|
||||
#define CONFIGURE_MAXIMUM_TASKS 4
|
||||
#define CONFIGURE_TICKS_PER_TIMESLICE 100
|
||||
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1
|
||||
#define CONFIGURE_MAXIMUM_TASKS 4
|
||||
#define CONFIGURE_TICKS_PER_TIMESLICE 100
|
||||
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
|
||||
@@ -73,14 +62,14 @@ void Task_switch(
|
||||
|
||||
/* global variables */
|
||||
|
||||
TEST_EXTERN rtems_id Task_id[ 4 ]; /* array of task ids */
|
||||
TEST_EXTERN rtems_name Task_name[ 4 ]; /* array of task names */
|
||||
TEST_EXTERN rtems_id Task_id[ 4 ]; /* array of task ids */
|
||||
TEST_EXTERN rtems_name Task_name[ 4 ]; /* array of task names */
|
||||
|
||||
TEST_EXTERN rtems_id Extension_id[ 4 ];
|
||||
TEST_EXTERN rtems_name Extension_name[ 4 ]; /* array of task names */
|
||||
TEST_EXTERN rtems_name Extension_name[ 4 ]; /* array of task names */
|
||||
|
||||
/* array of task run counts */
|
||||
TEST_EXTERN volatile uint32_t Run_count[ 4 ];
|
||||
TEST_EXTERN volatile uint32_t Run_count[ 4 ];
|
||||
|
||||
/*
|
||||
* Keep track of task switches
|
||||
@@ -92,8 +81,7 @@ struct taskSwitchLog {
|
||||
};
|
||||
|
||||
extern struct taskSwitchLog taskSwitchLog[];
|
||||
extern int taskSwitchLogIndex;
|
||||
extern volatile int testsFinished;
|
||||
|
||||
extern int taskSwitchLogIndex;
|
||||
extern volatile int testsFinished;
|
||||
|
||||
/* end of include file */
|
||||
@@ -41,19 +41,17 @@
|
||||
|
||||
#include "system.h"
|
||||
|
||||
rtems_task Task_1(
|
||||
rtems_task_argument argument
|
||||
)
|
||||
rtems_task Task_1( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
uint32_t seconds;
|
||||
uint32_t old_seconds;
|
||||
uint32_t seconds;
|
||||
uint32_t old_seconds;
|
||||
rtems_mode previous_mode;
|
||||
rtems_time_of_day time;
|
||||
rtems_status_code status;
|
||||
uint32_t start_time;
|
||||
uint32_t end_time;
|
||||
uint32_t start_time;
|
||||
uint32_t end_time;
|
||||
|
||||
puts( "TA1 - rtems_task_suspend - on Task 2" );
|
||||
status = rtems_task_suspend( Task_id[ 2 ] );
|
||||
@@ -68,12 +66,13 @@ rtems_task Task_1(
|
||||
|
||||
puts( "TA1 - killing time" );
|
||||
|
||||
for ( ; ; ) {
|
||||
for ( ;; ) {
|
||||
status = rtems_clock_get_seconds_since_epoch( &end_time );
|
||||
directive_failed( status, "rtems_clock_get_seconds_since_epoch" );
|
||||
|
||||
if ( end_time > (start_time + 2) )
|
||||
if ( end_time > ( start_time + 2 ) ) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
puts( "TA1 - rtems_task_resume - on Task 2" );
|
||||
@@ -100,7 +99,7 @@ rtems_task Task_1(
|
||||
|
||||
old_seconds = time.second;
|
||||
|
||||
for ( seconds = 0 ; seconds < 6 ; ) {
|
||||
for ( seconds = 0; seconds < 6; ) {
|
||||
status = rtems_clock_get_tod( &time );
|
||||
directive_failed( status, "rtems_clock_get_tod" );
|
||||
|
||||
|
||||
@@ -43,27 +43,24 @@
|
||||
|
||||
#include <rtems/cpuuse.h>
|
||||
|
||||
static void
|
||||
showTaskSwitches (void)
|
||||
static void showTaskSwitches( void )
|
||||
{
|
||||
int i;
|
||||
int switches = taskSwitchLogIndex;
|
||||
|
||||
for (i = 0 ; i < switches ; i++) {
|
||||
put_name( Task_name[taskSwitchLog[i].taskIndex], FALSE );
|
||||
print_time( "- ", &taskSwitchLog[i].when, "\n" );
|
||||
for ( i = 0; i < switches; i++ ) {
|
||||
put_name( Task_name[ taskSwitchLog[ i ].taskIndex ], FALSE );
|
||||
print_time( "- ", &taskSwitchLog[ i ].when, "\n" );
|
||||
}
|
||||
}
|
||||
|
||||
rtems_task Task_2(
|
||||
rtems_task_argument argument
|
||||
)
|
||||
rtems_task Task_2( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
while ( !testsFinished );
|
||||
|
||||
showTaskSwitches ();
|
||||
showTaskSwitches();
|
||||
puts( "" );
|
||||
rtems_cpu_usage_report();
|
||||
puts( "" );
|
||||
|
||||
@@ -41,11 +41,9 @@
|
||||
|
||||
#include "system.h"
|
||||
|
||||
rtems_task Task_3(
|
||||
rtems_task_argument argument
|
||||
)
|
||||
rtems_task Task_3( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
while( FOREVER );
|
||||
while ( FOREVER );
|
||||
}
|
||||
@@ -46,41 +46,44 @@
|
||||
/*
|
||||
* Only require 8 task switches on sis/gdb. --joel 2 Feb 2011
|
||||
*/
|
||||
struct taskSwitchLog taskSwitchLog[25];
|
||||
int taskSwitchLogIndex;
|
||||
volatile int testsFinished;
|
||||
struct taskSwitchLog taskSwitchLog[ 25 ];
|
||||
int taskSwitchLogIndex;
|
||||
volatile int testsFinished;
|
||||
|
||||
void Task_switch(
|
||||
rtems_tcb *unused,
|
||||
rtems_tcb *heir
|
||||
)
|
||||
void Task_switch( rtems_tcb *unused, rtems_tcb *heir )
|
||||
{
|
||||
(void) unused;
|
||||
|
||||
uint32_t index;
|
||||
uint32_t index;
|
||||
rtems_time_of_day time;
|
||||
rtems_status_code status;
|
||||
|
||||
index = task_number( heir->Object.id );
|
||||
|
||||
switch( index ) {
|
||||
switch ( index ) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
Run_count[ index ] += 1;
|
||||
|
||||
status = rtems_clock_get_tod( &time );
|
||||
fatal_directive_check_status_only( status, RTEMS_SUCCESSFUL,
|
||||
"rtems_clock_get_tod" );
|
||||
fatal_directive_check_status_only(
|
||||
status,
|
||||
RTEMS_SUCCESSFUL,
|
||||
"rtems_clock_get_tod"
|
||||
);
|
||||
|
||||
if ((size_t) taskSwitchLogIndex <
|
||||
(sizeof taskSwitchLog / sizeof taskSwitchLog[0])) {
|
||||
taskSwitchLog[taskSwitchLogIndex].taskIndex = index;
|
||||
taskSwitchLog[taskSwitchLogIndex].when = time;
|
||||
if (
|
||||
(size_t) taskSwitchLogIndex <
|
||||
( sizeof taskSwitchLog / sizeof taskSwitchLog[ 0 ] )
|
||||
) {
|
||||
taskSwitchLog[ taskSwitchLogIndex ].taskIndex = index;
|
||||
taskSwitchLog[ taskSwitchLogIndex ].when = time;
|
||||
taskSwitchLogIndex++;
|
||||
}
|
||||
if ( time.second >= 16 )
|
||||
if ( time.second >= 16 ) {
|
||||
testsFinished = 1;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
@@ -89,4 +92,3 @@ void Task_switch(
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -40,26 +40,29 @@
|
||||
|
||||
#include "system.h"
|
||||
|
||||
static void test(void)
|
||||
static void test( void )
|
||||
{
|
||||
rtems_test_assert(rtems_debugger_start("test", "something",
|
||||
3, 10, &rtems_test_printer) < 0);
|
||||
rtems_test_assert(rtems_debugger_register_test_remote() == 0);
|
||||
rtems_test_assert(rtems_debugger_start("test", "something",
|
||||
3, 10, &rtems_test_printer) == 0);
|
||||
rtems_debugger_set_verbose(true);
|
||||
rtems_test_assert(rtems_debugger_remote_debug(true) == 0);
|
||||
rtems_test_assert(
|
||||
rtems_debugger_start( "test", "something", 3, 10, &rtems_test_printer ) < 0
|
||||
);
|
||||
rtems_test_assert( rtems_debugger_register_test_remote() == 0 );
|
||||
rtems_test_assert(
|
||||
rtems_debugger_start( "test", "something", 3, 10, &rtems_test_printer ) ==
|
||||
0
|
||||
);
|
||||
rtems_debugger_set_verbose( true );
|
||||
rtems_test_assert( rtems_debugger_remote_debug( true ) == 0 );
|
||||
|
||||
/*
|
||||
* This thread is suspended when the debugger is active until the debugger
|
||||
* disconnects.
|
||||
*/
|
||||
sleep(1);
|
||||
sleep( 1 );
|
||||
}
|
||||
|
||||
const char rtems_test_name[] = "DEBUGGER01";
|
||||
|
||||
rtems_task Init(rtems_task_argument argument)
|
||||
rtems_task Init( rtems_task_argument argument )
|
||||
{
|
||||
(void) argument;
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
Loaded 100 of 332 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user