mirror of
https://github.com/peteratebs/tinyfatfs.git
synced 2025-06-18 16:55:42 -04:00
323 lines
7.9 KiB
C
323 lines
7.9 KiB
C
/*
|
|
* EBS - RTFS (Real Time File Manager)
|
|
*
|
|
* Copyright EBS Inc. 1987-2012
|
|
* All rights reserved.
|
|
* This code may not be redistributed in source or linkable object form
|
|
* without the consent of its author.
|
|
*/
|
|
|
|
#include "rtfslite.h"
|
|
#include "rtfslitetests.h"
|
|
#include "stdlib.h"
|
|
|
|
#define MAXTESTFRAGS 128
|
|
#if (RTFSL_INCLUDE_WRITE_SUPPORT)
|
|
int rtfsltest_file_fill_drive(unsigned char*filename)
|
|
{
|
|
int rval;
|
|
unsigned char filename_indexed[12];
|
|
char index = 'A';
|
|
int pos=8;
|
|
strcpy((char*)filename_indexed,(char*)filename);
|
|
for(;;)
|
|
{
|
|
filename_indexed[pos] = index;
|
|
if (index == 'Z')
|
|
{
|
|
pos += 1;
|
|
index = 'A';
|
|
}
|
|
index++;
|
|
|
|
rval=rtfsl_create(filename_indexed,0);
|
|
if (rval==0)
|
|
{
|
|
int fd;
|
|
unsigned long i;
|
|
fd = rtfsl_open(filename_indexed);
|
|
if(fd<0)
|
|
{
|
|
rval=fd;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
for(i=0;i<1024*1024*1024;i+=1024*1024)
|
|
{
|
|
if ((i % 1024*1024*4)==0)
|
|
{
|
|
PRINTF("Fill : %8.8ld\r", i);
|
|
}
|
|
rval=rtfsl_write(fd,0,1024*1024);
|
|
if (rval!=1024*1024)
|
|
{
|
|
for(;i<1024*1024*1024;i+=512)
|
|
{
|
|
PRINTF("Fill : %8.8ld\r", i);
|
|
rval=rtfsl_write(fd,0,512);
|
|
if (rval!=512)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
rtfsl_flush(fd);
|
|
rtfsl_close(fd);
|
|
}
|
|
}
|
|
if (rval!=512)
|
|
break;
|
|
}
|
|
rtfsl_flush_all_buffers();
|
|
|
|
return rval;
|
|
}
|
|
int rtfsltest_file_sequential_write(unsigned char*filename, int file_fraglen, int gap_fraglen, int numlongs, int test_append)
|
|
{
|
|
int rval,numfrags;
|
|
struct rtfsl_statstructure statstruct;
|
|
unsigned long fragrecord[MAXTESTFRAGS];
|
|
|
|
numfrags=((numlongs*4)+rtfsl.current_dr.bytespcluster-1)/rtfsl.current_dr.bytespcluster;
|
|
rval=rtfsl_create(filename,0);
|
|
if (rval==0)
|
|
{
|
|
int fd;
|
|
unsigned long i;
|
|
if (gap_fraglen)
|
|
{
|
|
rval=ut_create_fragments(file_fraglen, gap_fraglen, numfrags, fragrecord);
|
|
if (rval<0)
|
|
return rval;
|
|
}
|
|
fd = rtfsl_open(filename);
|
|
if(fd<0)
|
|
rval=fd;
|
|
else
|
|
for(i=0;i<(unsigned long)numlongs;i++)
|
|
{
|
|
rval=rtfsl_write(fd, (unsigned char*)&i,4);
|
|
if (rval!= 4)
|
|
{
|
|
break;
|
|
}
|
|
if (test_append && (i&0x3ff)==0)
|
|
{
|
|
rtfsl_flush(fd);
|
|
rtfsl_close(fd);
|
|
fd = rtfsl_open(filename);
|
|
if (fd<0)
|
|
rval=fd;
|
|
else
|
|
rval=(int)rtfsl_lseek(fd,0,PSEEK_END);
|
|
if (rval< 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(rval>=0)
|
|
{
|
|
rtfsl_fstat(fd,&statstruct);
|
|
if (statstruct.st_size!=(unsigned long)numlongs*4)
|
|
rval=RTFSL_ERROR_TEST;
|
|
else
|
|
rval=0;
|
|
}
|
|
if(rval>=0)
|
|
rval=rtfsl_flush(fd);
|
|
rtfsl_close(fd);
|
|
if (gap_fraglen)
|
|
{
|
|
rval=ut_release_fragments(file_fraglen, gap_fraglen, numfrags, fragrecord);
|
|
if (rval<0)
|
|
return rval;
|
|
}
|
|
}
|
|
return rval;
|
|
}
|
|
#endif
|
|
int rtfsltest_file_sequential_read(unsigned char*filename)
|
|
{
|
|
int fd,rval;
|
|
struct rtfsl_statstructure statstruct;
|
|
|
|
|
|
fd = rtfsl_open((unsigned char*)filename);
|
|
if (fd>=0)
|
|
{
|
|
unsigned long i,j;
|
|
rtfsl_fstat(fd,&statstruct);
|
|
for(i=0;i<(unsigned long)statstruct.st_size/4;i++)
|
|
{
|
|
rval=rtfsl_read(fd, (unsigned char*)&j,4);
|
|
if (rval!= 4)
|
|
{
|
|
PRINTF("Seq: Read Failed at offset == %lu \n",i*4);\
|
|
return rval;
|
|
}
|
|
if (j != i)
|
|
{
|
|
PRINTF("Seq: Compare falied at offset == %lu \n",i);
|
|
return RTFSL_ERROR_TEST;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
int rtfsltest_file_random_read(unsigned char*filename)
|
|
{
|
|
struct rtfsl_statstructure statstruct;
|
|
int fd;
|
|
unsigned long seekoffset;
|
|
unsigned long r;
|
|
|
|
fd = rtfsl_open(filename);
|
|
if(fd<0)
|
|
return fd;
|
|
rtfsl_fstat(fd,&statstruct);
|
|
PRINTF("Seek read test. Takes a long time to complete \n");
|
|
for (seekoffset=statstruct.st_size-1;seekoffset>0;seekoffset--)
|
|
{
|
|
rtfsl_lseek(fd,0,PSEEK_SET);
|
|
rtfsl_read(fd,test_buffer,4);
|
|
rtfsl_lseek(fd,(seekoffset/4)*4,PSEEK_SET);
|
|
rtfsl_read(fd,(unsigned char *)&r,4);
|
|
if (r!= seekoffset/4)
|
|
{
|
|
PRINTF("\nreade seek test compare error at unsigned long offset %lu\n",seekoffset/4);
|
|
return RTFSL_ERROR_TEST;
|
|
}
|
|
}
|
|
rtfsl_close(fd);
|
|
return 0;
|
|
}
|
|
#if (RTFSL_INCLUDE_WRITE_SUPPORT)
|
|
int rtfsltest_file_random_write(unsigned char*filename)
|
|
{
|
|
struct rtfsl_statstructure statstruct;
|
|
int fd;
|
|
unsigned long seekoffset;
|
|
unsigned long l,r;
|
|
unsigned char *pl = (unsigned char *)&l;
|
|
|
|
fd = rtfsl_open(filename);
|
|
if(fd<0)
|
|
return fd;
|
|
rtfsl_fstat(fd,&statstruct);
|
|
PRINTF("Seek write test. Takes a long time to complete \n");
|
|
for (seekoffset=statstruct.st_size-1;seekoffset>0;seekoffset--)
|
|
{
|
|
if ((seekoffset & 0xf) == 0)
|
|
{
|
|
PRINTF("seek write test pass %8.8lu\r", seekoffset);
|
|
}
|
|
/* Read from the beginning of file to be sure we are seeking */
|
|
rtfsl_lseek(fd,0,PSEEK_SET);
|
|
rtfsl_read(fd,test_buffer,4);
|
|
/* Write one byte of the current unsigned long flipped */
|
|
rtfsl_lseek(fd,seekoffset,PSEEK_SET);
|
|
l=(seekoffset/4);
|
|
pl = (unsigned char *)&l;
|
|
{
|
|
*(pl+(seekoffset&0x3)) = ~*(pl+(seekoffset&0x3));
|
|
rtfsl_write(fd,pl+(seekoffset&0x3),1);
|
|
}
|
|
/* Read from the beginning of file to be sure we are seeking */
|
|
rtfsl_lseek(fd,0,PSEEK_SET);
|
|
rtfsl_read(fd,test_buffer,4);
|
|
/* Read the byte and make sure it's what we wrote */
|
|
rtfsl_lseek(fd,seekoffset,PSEEK_SET);
|
|
rtfsl_read(fd,test_buffer,1);
|
|
if (test_buffer[0]!=*(pl+(seekoffset&0x3)))
|
|
{
|
|
PRINTF("\nWrite seek test compare error at byte offset %lu\n",seekoffset);
|
|
return RTFSL_ERROR_TEST;
|
|
}
|
|
/* toggle it again and write it back */
|
|
rtfsl_lseek(fd,seekoffset,PSEEK_SET);
|
|
*(pl+(seekoffset&0x3)) = ~*(pl+(seekoffset&0x3));
|
|
rtfsl_write(fd,pl+(seekoffset&0x3),1);
|
|
|
|
/* Read from the beginning of file to be sure we are seeking */
|
|
rtfsl_lseek(fd,0,PSEEK_SET);
|
|
rtfsl_read(fd,test_buffer,4);
|
|
rtfsl_lseek(fd,(seekoffset/4)*4,PSEEK_SET);
|
|
rtfsl_read(fd,(unsigned char *)&r,4);
|
|
if (r!= seekoffset/4)
|
|
{
|
|
PRINTF("\nWrite seek test compare error at unsigned long offset %lu\n",seekoffset/4);
|
|
return RTFSL_ERROR_TEST;
|
|
}
|
|
}
|
|
rtfsl_flush(fd);
|
|
rtfsl_close(fd);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if (0)
|
|
|
|
#if (DOBOOTFILEEST)
|
|
{
|
|
int fd;
|
|
void * load_address = malloc(1000000);
|
|
rtfsl_load_file(&tdrive,(unsigned char *)BOOTFILENAME, (unsigned long) load_address);
|
|
#if (DOFILIOREADAPITEST)
|
|
fd=rtfsl_open((byte*)BOOTFILENAME);
|
|
if (fd>=0)
|
|
{
|
|
int nread;
|
|
unsigned long total=0;
|
|
unsigned char *loadimage=(unsigned char *)load_address;
|
|
rtfsl_fstat(fd,&statstruct);
|
|
do
|
|
{
|
|
nread=rtfsl_read(fd,test_buffer,tdrive.bytespsector);
|
|
if (nread>0)
|
|
{
|
|
total+=nread;
|
|
if (ANSImemcmp(test_buffer, loadimage, nread)!=0)
|
|
{
|
|
PRINTF("Compare failed\n");
|
|
}
|
|
loadimage += nread;
|
|
}
|
|
} while (nread > 0);
|
|
if (statstruct.st_size!=total)
|
|
{
|
|
PRINTF("filesize == %lu total read == %lu\n",statstruct.st_size,total);
|
|
}
|
|
for (seekoffset=1;seekoffset<7;seekoffset++)
|
|
{
|
|
for (seekpointer=0; seekpointer<statstruct.st_size;seekpointer += seekoffset)
|
|
{
|
|
loadimage=(unsigned char *)load_address;
|
|
if ((seekpointer & 0x3ff) == 0)
|
|
{
|
|
PRINTF("seek test pass %lu pointer: %8.8lu\r", seekoffset, seekpointer);
|
|
}
|
|
rtfsl_lseek(fd,0,PSEEK_SET);
|
|
rtfsl_lseek(fd,seekpointer,PSEEK_SET);
|
|
rtfsl_read(fd,test_buffer,1);
|
|
if (test_buffer[0] != *(loadimage+seekpointer))
|
|
{
|
|
PRINTF("\nSeek test compare error at %lu\n",seekpointer);
|
|
}
|
|
}
|
|
}
|
|
PRINTF("load-sequential read-seek-read test completed %lu bytes read and verified\n",statstruct.st_size);
|
|
}
|
|
#endif // #if (DOFILIOREADAPITEST)
|
|
free(load_address);
|
|
}
|
|
#endif
|
|
#if (DOFAILSAFEFLUSHTEST&&RTFSL_INCLUDE_FAILSAFE_SUPPORT)
|
|
rtfslfs_flush();
|
|
#endif
|
|
}
|
|
#endif
|