int check_pattern_file(char *fn)
{
int h;
int marker;
int i;
int size;
int ok = 1;
h = yaffs_open(fn, O_RDWR,0);
size = yaffs_lseek(h,0,SEEK_END);
for(i = 0; i < size; i+=256)
{
yaffs_lseek(h,i,SEEK_SET);
yaffs_read(h,&marker,sizeof(marker));
ok = (marker == ~i);
if(!ok)
{
printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x\n",
fn,size,i,marker,~i);
}
}
yaffs_close(h);
return ok;
}
UINT32 V5M_flen (V5MF_HANDLE file)
{
UINT32 count;
count = (UINT32) yaffs_lseek(file, 0, SEEK_END);
yaffs_lseek(file, 0, SEEK_SET);
return count;
}
void write_200k_file(const char *fn, const char *fdel, const char *fdel1)
{
int h1;
int i;
int offs;
h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
for(i = 0; i < 100000; i+= 10000)
{
write_10k(h1);
}
offs = yaffs_lseek(h1,0,SEEK_CUR);
if( offs != 100000)
{
printf("Could not write file\n");
}
yaffs_unlink(fdel);
for(i = 0; i < 100000; i+= 10000)
{
write_10k(h1);
}
offs = yaffs_lseek(h1,0,SEEK_CUR);
if( offs != 200000)
{
printf("Could not write file\n");
}
yaffs_close(h1);
yaffs_unlink(fdel1);
}
void random_truncate(int h, char * name)
{
int n;
int flen;
n = random() & 0xFFFFF;
flen = yaffs_lseek(h,0,SEEK_END);
if(n > flen)
n = flen / 2;
yaffs_ftruncate(h,n);
yaffs_lseek(h,n,SEEK_SET);
}
int cache_bypass_bug_test(void)
{
// This test reporoduces a bug whereby YAFFS caching *was* buypassed
// resulting in erroneous reads after writes.
// This bug has been fixed.
int a;
int i;
char buffer1[1000];
char buffer2[1000];
memset(buffer1,0,sizeof(buffer1));
memset(buffer2,0,sizeof(buffer2));
yaffs_StartUp();
yaffs_mount("/boot");
// Create a file of 2000 bytes.
make_a_file("/boot/a",'X',2000);
a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
// Write a short sequence to the file.
// This will go into the cache.
yaffs_lseek(a,0,SEEK_SET);
yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
// Read a short sequence from the file.
// This will come from the cache.
yaffs_lseek(a,0,SEEK_SET);
yaffs_read(a,buffer1,30);
// Read a page size sequence from the file.
yaffs_lseek(a,0,SEEK_SET);
yaffs_read(a,buffer2,512);
printf("buffer 1 %s\n",buffer1);
printf("buffer 2 %s\n",buffer2);
if(strncmp(buffer1,buffer2,20))
{
printf("Cache bypass bug detected!!!!!\n");
}
return 1;
}
void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2)
{
int h;
int iterations;
h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
iterations = (syze1 + strlen(fn) -1)/ strlen(fn);
while (iterations > 0)
{
yaffs_write(h,fn,strlen(fn));
iterations--;
}
yaffs_ftruncate(h,reSyze);
yaffs_lseek(h,0,SEEK_SET);
iterations = (syze2 + strlen(fn) -1)/ strlen(fn);
while (iterations > 0)
{
yaffs_write(h,fn,strlen(fn));
iterations--;
}
yaffs_close (h);
}
void verify_file_of_size(const char *fn,int syze)
{
int h;
int n;
char xx[200];
char yy[200];
int l;
int iterations = (syze + strlen(fn) -1)/ strlen(fn);
h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
while (iterations > 0)
{
sprintf(xx,"%s %8d",fn,iterations);
l = strlen(xx);
yaffs_read(h,yy,l);
yy[l] = 0;
if(strcmp(xx,yy)){
printf("=====>>>>> verification of file %s failed near position %d\n",fn,yaffs_lseek(h,0,SEEK_CUR));
}
iterations--;
}
yaffs_close (h);
}
/*
* Play DSP from WAV file:
*/
int PlayDSP(DSPFILE *dfile, WAVFILE *wfile)
{
UInt32 byte_count = (UInt32) wfile->wavinfo.Samples;
int bytes;
int n;
int byte_modulo;
int total_bytes;
//First determine how many bytes are required for each channel's sample:
switch ( wfile->wavinfo.DataBits )
{
case 8 :
byte_count = 1;
break;
case 16 :
byte_count = 2;
break;
default :
printf("Cannot process %u bit samples\n", (unsigned)wfile->wavinfo.DataBits);
return -1;
}
byte_modulo = byte_count; /* This many bytes per sample */
byte_count = wfile->wavinfo.Samples * byte_modulo; /* Total bytes to process */
total_bytes = byte_count;
/* Seek to requested start sample */
yaffs_lseek(wfile->fd,wfile->StartSample*byte_modulo,SEEK_CUR);
for (; byte_count > 0 && wfile->wavinfo.DataBytes > 0; byte_count -= (UInt32) n )
{
bytes = (int) ( byte_count > dfile->dspblksiz ? dfile->dspblksiz : byte_count );
if ( bytes > wfile->wavinfo.DataBytes ) /* Size bigger than data chunk? */
bytes = wfile->wavinfo.DataBytes; /* Data chunk only has this much left */
// printf("play databytes:%d bytes:%d n:%d\n",wfile->wavinfo.DataBytes,bytes,n);
if ( (n = yaffs_read(wfile->fd,dfile->dspbuf,bytes)) != bytes )
{
if ( n >= 0 )
printf("Unexpected EOF reading samples from WAV file\n");
else
printf("Reading samples from WAV file\n");
goto errxit;
}
// printf("pcm writeing data\n");//treckle
if (pcm_write(dfile->dspbuf,n) <= 0)
{
printf("Writing samples data failed\n");
goto errxit;
}
// printf("end pcm writeing data\n");//treckle
wfile->wavinfo.DataBytes -= (UInt32) bytes; /* We have fewer bytes left to read */
//printf("dspblksize=%d bytes=%d DataBytes=%d\n", dfile->dspblksiz, bytes, wfile->wavinfo.DataBytes);
}
return 0; /* All samples played successfully */
errxit: return -1; /* Indicate error return */
}
int LoadImageFile(char *str, char *buf, int size)
{
int h;
int len;
h = yaffs_open(str, O_RDONLY, S_IREAD | S_IWRITE);
if(h == -1)
return 0;
len = (int)yaffs_lseek(h, 0, SEEK_END);
if(len > size)
len = size;
yaffs_lseek(h, 0, SEEK_SET);
yaffs_read(h, buf, len);
yaffs_close(h);
return len;
}
void make_pattern_file(char *fn,int size)
{
int outh;
int marker;
int i;
outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
yaffs_lseek(outh,size-1,SEEK_SET);
yaffs_write(outh,"A",1);
for(i = 0; i < size; i+=256)
{
marker = ~i;
yaffs_lseek(outh,i,SEEK_SET);
yaffs_write(outh,&marker,sizeof(marker));
}
yaffs_close(outh);
}
char *V5M_LoadImageFile(char *str, UINT32 *size)
{
int h;
char *buf = NULL;
h = yaffs_open(str, O_RDONLY, S_IREAD | S_IWRITE);
if(h == -1)
return NULL;
*size = (int)yaffs_lseek(h, 0, SEEK_END);
yaffs_lseek(h, 0, SEEK_SET);
if (*size == 0)
return NULL;
buf = (char *) gHapiContext.pmalloc(*size);
yaffs_read(h, buf, (unsigned int)(*size));
yaffs_close(h);
return buf;
}
void small_overwrite_test(const char *mountpt,int nmounts)
{
char a[30];
int i;
int j;
int h0;
int h1;
sprintf(a,"%s/a",mountpt);
yaffs_StartUp();
for(i = 0; i < nmounts; i++){
static char xx[8000];
printf("############### Iteration %d Start\n",i);
if(1)
yaffs_mount(mountpt);
dump_directory_tree(mountpt);
yaffs_mkdir(a,0);
sprintf(xx,"%s/0",a);
h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
sprintf(xx,"%s/1",a);
h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
for(j = 0; j < 1000000; j+=1000){
yaffs_ftruncate(h0,j);
yaffs_lseek(h0,j,SEEK_SET);
yaffs_write(h0,xx,7000);
yaffs_write(h1,xx,7000);
if(early_exit)
exit(0);
}
yaffs_close(h0);
printf("########### %d\n",i);
dump_directory_tree(mountpt);
if(1)
yaffs_unmount(mountpt);
}
}
int truncate_test(void)
{
int a;
int r;
int i;
int l;
char y[10];
yaffs_StartUp();
yaffs_mount("/boot");
yaffs_unlink("/boot/trunctest");
a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
yaffs_ftruncate(a,3);
l= yaffs_lseek(a,0,SEEK_END);
printf("truncated length is %d\n",l);
yaffs_lseek(a,5,SEEK_SET);
yaffs_write(a,"1",1);
yaffs_lseek(a,0,SEEK_SET);
r = yaffs_read(a,y,10);
printf("read %d bytes:",r);
for(i = 0; i < r; i++) printf("[%02X]",y[i]);
printf("\n");
return 0;
}
static int yWriteFile(const char *fname, unsigned sz32)
{
int h;
int r;
int i;
unsigned checksum = 0;
printf("Writing file %s\n",fname);
h = yaffs_open(fname,O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
if(h < 0){
printf("could not open file %s\n",fname);
return h;
}
xx[0] = sz32;
checksum ^= xx[0];
if((r = yaffs_write(h,xx,sizeof(unsigned))) != sizeof(unsigned)){
goto WRITE_ERROR;
}
while(sz32> 0){
for(i = 0; i < XX_SIZE; i++){
xx[i] = sz32 + i;
checksum ^= xx[i];
}
if((r = yaffs_write(h,xx,sizeof(xx))) != sizeof(xx)){
goto WRITE_ERROR;
}
sz32--;
}
xx[0] = checksum;
if((r = yaffs_write(h,xx,sizeof(unsigned))) != sizeof(unsigned)){
goto WRITE_ERROR;
}
yaffs_close(h);
return 0;
WRITE_ERROR:
printf("ywrite error at position %d\n",(int)yaffs_lseek(h,0,SEEK_END));
yaffs_close(h);
return -1;
}
void simple_rw_test(const char *mountpt)
{
int i;
int h;
char a[100];
int x;
int result;
sprintf(a,"%s/aaa",mountpt);
yaffs_StartUp();
yaffs_mount(mountpt);
yaffs_unlink(a);
h = yaffs_open(a,O_CREAT| O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
for(i = 100000;i < 200000; i++){
result = yaffs_write(h,&i,sizeof(i));
if(result != 4)
{
printf("write error\n");
exit(1);
}
}
//yaffs_close(h);
// h = yaffs_open(a,O_RDWR, S_IREAD | S_IWRITE);
yaffs_lseek(h,0,SEEK_SET);
for(i = 100000; i < 200000; i++){
result = yaffs_read(h,&x,sizeof(x));
if(result != 4 || x != i){
printf("read error %d %x %x\n",i,result,x);
}
}
printf("Simple rw test passed\n");
}
void seek_overwrite_test(const char *mountpt,int nmounts)
{
static char xx[5000];
char a[30];
int i;
int j;
int h0;
sprintf(a,"%s/f",mountpt);
yaffs_StartUp();
yaffs_mount(mountpt);
for(i = 0; i < nmounts; i++){
h0 = yaffs_open(a, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
for(j = 0; j < 100000; j++){
yaffs_lseek(h0,0,SEEK_SET);
yaffs_write(h0,xx,5000);
yaffs_lseek(h0,0x100000,SEEK_SET);
yaffs_write(h0,xx,5000);
if(early_exit)
exit(0);
}
yaffs_close(h0);
}
}
int test_yaffs_lseek_EBADF(void)
{
int error_code=0;
int output=yaffs_lseek(-1, 0, SEEK_SET);
if (output<0){
error_code=yaffs_get_error();
if (abs(error_code)==EBADF){
return 1;
} else {
print_message("different error than expected\n", 2);
return -1;
}
} else {
print_message("lseeked to a negative position\n", 2);
return -1;
}
}
void dump_file(const char *fn)
{
int i;
int size;
int h;
h = yaffs_open(fn,O_RDONLY,0);
if(h < 0)
{
printf("*****\nDump file %s does not exist\n",fn);
}
else
{
size = yaffs_lseek(h,0,SEEK_SET);
printf("*****\nDump file %s size %d\n",fn,size);
for(i = 0; i < size; i++)
{
}
}
}
static int yVerifyFile(const char *fName)
{
unsigned checksum = 0;
unsigned totalSize;
unsigned sz32;
unsigned recordedSize = 0;
int r;
int h;
int i;
int retval = 0;
printf("Verifying file %s\n",fName);
h = yaffs_open(fName, O_RDONLY,S_IREAD | S_IWRITE);
if(h < 0){
printf("could not open file %s\n",fName);
return -1;
}
totalSize = yaffs_lseek(h,0,SEEK_END);
yaffs_lseek(h,0,SEEK_SET);
r = yaffs_read(h,&sz32,sizeof(sz32));
if(r != sizeof(sz32)){
printf("reading size failed ... returned %d\n",r);
yaffs_close(h);
return -1;
}
recordedSize = sz32 * sizeof(xx) + 8;
printf("verify %s: file size is %d, recorded size is %d\n", fName, totalSize, recordedSize);
if(totalSize != recordedSize){
printf("!!!!!!!!!!!!!!!!!!!!!!!!file size is wrong, should be %d, is %d\n", recordedSize,totalSize);
yaffs_close(h);
return -1;
}
checksum ^= sz32;
while(sz32 > 0){
r = yaffs_read(h,xx,sizeof(xx));
if(r != sizeof(xx)){
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!reading data failed ... returned %d\n",r);
yaffs_close(h);
return -1;
}
for(i = 0; i < XX_SIZE; i++)
checksum ^= xx[i];
sz32--;
}
r = yaffs_read(h,xx,sizeof(xx[0]));
if(r != sizeof(xx[0])){
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!reading data failed ... returned %d\n",r);
yaffs_close(h);
return -1;
}
checksum ^= xx[0];
if(checksum != 0){
printf("!!!!!!!!!!!!!!!!!!!!! checksum failed\n");
retval = -1;
} else
printf("verified ok\n");
yaffs_close(h);
return retval;
}
static off_t __yaffs_lseek(mount_point_t *point, file_t *file, off_t offset, int whence)
{
return yaffs_lseek((int)file->ctx, offset, whence);
//void main(void)
void yaffstest(void)
{
int i = 0,j;
int f = -1,f1=-1;
int fd[Nfile];
#if 1
char file[20];
char buf[2048];
char buffer[2048];
#endif
struct yaffs_stat s;
int ret;
unsigned int block;
unsigned int page;
int size;
#if 0
unsigned char buffer0[16];
unsigned char buffer1[2048];
unsigned char buffer2[64];
unsigned char buffer3[2048];
jz_nand_init ();
#if mkyaffs
/* we want to write the oob to spare here */
memset(buffer1,0xff,2048);
memset(buffer0,0xff,16);
#else
memset(buffer0,0x2,16);
buffer0[0]=0xff;
memset(buffer1,0xb,2048);
#endif
for(i=16;i<80;i++)
nand_flash_erase_block(i);
for(i=16;i<80;i++)
{
block=i;
printf("block=%d ok\n",block);
for(j=0;j<128;j++){
memset(buffer2,0,16);
memset(buffer3,0,2048);
page=block*128+j;
nand_flash_program_buf(page, buffer1,buffer0);//writeing data
// nand_flash_program_buf(page, NULL, buffer0);//writeing spare
if(nand_flash_read_buf(page, buffer3,buffer2)!=0)
printf("*********read nand failed\n");
if(nand_flash_read_buf(page, NULL,buffer2)!=0)
printf("*********read nand oob failed\n");
// ret=memcmp(buffer1+512+256+128,buffer3+512+256+128,64);
ret=memcmp(buffer1,buffer3,512);
if(ret!=0)
printf("ret=%d\n",ret);
ret=memcmp(buffer2,buffer0,16);
if(ret!=0)
printf("ret=%d\n \r\n",ret);
}
}
/*
for(i=0;i<16;i++)
printf("***data[%d]=%x,spare[%d]=%x\n",i,buffer3[i],i,buffer2[i]);
for(i=896+64;i>896;i--)
printf("*** buffer3[%d]=%x,buffer1[%d]=%x\n",i,buffer3[i],i,buffer1[i]);
*/
#else
#if 1
yaffs_StartUp();
yaffs_mount("/mnt");
// yaffs_mount("/d");
// return;
// ListDir("/mnt");
yaffs_mkdir("/mnt/mtdblock", 0);
yaffs_mkdir("/mnt/mtdblock/font", 0);
// yaffs_mkdir("/c/data1", 0);
// ListDir("/mnt/mtdblock");
// ListDir("/mnt/mtdblock/font");
#endif
#if 0
printf("testing serial\n\n");
Updatefile();
ReadOptions("/mnt/mtdblock/test1");
ReadOptions("/mnt/mtdblock/options.cfg");
// ReadOptions("/mnt/mtdblock/font/LANGUAGE.E");
ListDir("/mnt/mtdblock");
ListDir("/mnt/mtdblock/font");
return;
#else
/* testing memory */
return;
#endif
#if 1
// f = yaffs_open("/mnt/mtdblock/bigfile", O_CREAT | O_RDWR , S_IREAD | S_IWRITE);
f = yaffs_open("/mnt/mtdblock/options.cfg", O_CREAT | O_RDWR , S_IREAD | S_IWRITE);
if(f<0)
printf("Yaffs Open File Failed\n");
#if 1
// for(i=0;i<12000;i++)
for(i=0;i<1200;i++)
{
yaffs_lseek(f,0,SEEK_SET);
yaffs_read(f,buffer,50);
memset(buffer,i%255,2048);
size=yaffs_lseek(f,0,SEEK_END);
// ret=yaffs_write(f,buffer,2048);
ret=yaffs_write(f,buffer,100);
// printf("the result write = %d,No.%d\n",ret,i);
yaffs_lseek(f,0,SEEK_SET);
yaffs_read(f,buffer,50);
}
#endif
yaffs_lseek(f,0,SEEK_SET);
size=yaffs_lseek(f,0,SEEK_END);
yaffs_close(f);
printf("the length of file =%d,it should be %d\n",size,i*2048);
ListDir("/mnt/mtdblock");
// yaffs_unlink("/c/data1/bigfile");
// ListDir("/c/data1");
#else
for(i=0;i<Nfile;i++)
{
sprintf(file,"/c/data0/file%d",i);
printf("will open file %s\n",file);
// fd[i] = yaffs_open(file, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
fd[i] = yaffs_open(file, O_CREAT | O_RDWR , S_IREAD | S_IWRITE);
// printf("**************fd[%d]=%d\n",i,fd[i]);
memset(buffer,0x5b+i,2048);
#if 1
size=yaffs_lseek(fd[i],0,SEEK_END);
ret=yaffs_write(fd[i],buffer,2048);
printf("the result of yaffs write file %s = %d\n",file,ret);
/* for(j=0;j<2;j++)
{
printf("buffer[%i]=%x\n",j,buffer[j]);
}*/
yaffs_lseek(fd[i],0,SEEK_SET);
#endif
size=yaffs_lseek(fd[i],0,SEEK_END);
printf("the length of file %s=%d\n",file,size);
yaffs_lseek(fd[i],-2048,SEEK_END);
#if 1
memset(buf,0,2048);
ret=yaffs_read(fd[i],buf,2048);
printf("the result of yaffs read file %s ==%d\n",file,ret);
/*
for(j=0;j<2;j++)
{
printf("buf[%i]=%x\n",j,buf[j]);
} */
ret=memcmp(buffer,buf,2048);
printf("the result of compare read*write file %s = %d\n",file,ret);
#endif
// yaffs_close(fd[i]);
}
#endif
#endif
#if 0
yaffs_mkdir("/c/mydoc", 0);
yaffs_mkdir("/d/data0", 0);
yaffs_mkdir("/d/data1", 0);
f = yaffs_open("/d/data0/file1.gsk", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
yaffs_close(f);
f = yaffs_open("/d/data0/file2.gsk", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
yaffs_close(f);
#endif
// yaffs_unlink("/d/data0/file1");
// ListDir("/d/data0");
}
void yaffs_bash_around(const char *mountpt, int n_cycles)
{
char name[200];
char name1[200];
int h[BASH_HANDLES];
int i;
int op;
int pos;
int n;
int n1;
int start_op;
int op_max = 99;
int cycle = 0;
sprintf(name,"%s/bashdir",mountpt);
yaffs_mkdir(name,0666);
for(i = 0; i < BASH_HANDLES; i++)
h[i] = -1;
while(n_cycles){
if(cycle % 100 == 0){
printf("CYCLE %8d mo %2d inodes %d space %d ",cycle,op_max,
yaffs_inodecount(mountpt),(int)yaffs_freespace(mountpt));
for(i = 0; i < BASH_HANDLES; i++)
printf("%2d ",h[i]);
printf("\n");
}
cycle++;
if(n_cycles > 0)
n_cycles--;
i = rand() % BASH_HANDLES;
op = rand() % op_max;
pos = rand() & 20000000;
n = rand() % 100;
n1 = rand() % 100;
sprintf(name,"%s/bashdir/xx%d",mountpt,n);
sprintf(name1,"%s/bashdir/xx%d",mountpt,n1);
start_op = op;
op-=1;
if(op < 0){
if(h[i]>= 0){
yaffs_close(h[i]);
h[i] = -1;
}
continue;
}
op-=1;
if(op < 0){
if(h[i] < 0)
h[i] = yaffs_open(name,O_CREAT| O_RDWR, 0666);
continue;
}
op-=5;
if(op< 0){
yaffs_lseek(h[i],pos,SEEK_SET);
yaffs_write(h[i],name,n);
continue;
}
op-=1;
if(op < 0){
yaffs_unlink(name);
continue;
}
op-=1;
if(op < 0){
yaffs_rename(name,name1);
continue;
}
op-=1;
if(op < 0){
yaffs_mkdir(name,0666);
continue;
}
op-=1;
if(op < 0){
yaffs_rmdir(name);
continue;
}
op_max = start_op-op;
}
}
int resize_stress_test(const char *path)
{
int a,b,i,j;
int x;
int r;
char aname[100];
char bname[100];
char abuffer[1000];
char bbuffer[1000];
yaffs_StartUp();
yaffs_mount(path);
sprintf(aname,"%s%s",path,"/a");
sprintf(bname,"%s%s",path,"/b");
memset(abuffer,'a',1000);
memset(bbuffer,'b',1000);
a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
printf(" %s %d %s %d\n",aname,a,bname,b);
x = 0;
for(j = 0; j < 100; j++)
{
yaffs_lseek(a,0,SEEK_END);
for(i = 0; i <20000; i++)
{
//r = yaffs_lseek(b,i,SEEK_SET);
//r = yaffs_write(b,bbuffer,1000);
if(x & 0x16)
{
// shrink
int syz = yaffs_lseek(a,0,SEEK_END);
syz -= 500;
if(syz < 0) syz = 0;
yaffs_ftruncate(a,syz);
}
else
{
//expand
r = yaffs_lseek(a,i * 500,SEEK_SET);
r = yaffs_write(a,abuffer,1000);
}
x++;
}
}
return 0;
}
int resize_stress_test_no_grow(const char *path,int iters)
{
int a,b,i,j;
int x;
int r;
char aname[100];
char bname[100];
char abuffer[1000];
char bbuffer[1000];
yaffs_StartUp();
yaffs_mount(path);
sprintf(aname,"%s%s",path,"/a");
sprintf(bname,"%s%s",path,"/b");
memset(abuffer,'a',1000);
memset(bbuffer,'b',1000);
a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
printf(" %s %d %s %d\n",aname,a,bname,b);
x = 0;
for(j = 0; j < iters; j++)
{
yaffs_lseek(a,0,SEEK_END);
for(i = 0; i <20000; i++)
{
//r = yaffs_lseek(b,i,SEEK_SET);
//r = yaffs_write(b,bbuffer,1000);
if(!(x%20))
{
// shrink
int syz = yaffs_lseek(a,0,SEEK_END);
while(syz > 4000)
{
syz -= 2050;
if(syz < 0) syz = 0;
yaffs_ftruncate(a,syz);
syz = yaffs_lseek(a,0,SEEK_END);
printf("shrink to %d\n",syz);
}
}
else
{
//expand
r = yaffs_lseek(a,-500,SEEK_END);
r = yaffs_write(a,abuffer,1000);
}
x++;
}
printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
}
return 0;
}
int long_test(int argc, char *argv[])
{
int f;
int r;
char buffer[20];
char str[100];
int h;
mode_t temp_mode;
struct yaffs_stat ystat;
yaffs_StartUp();
yaffs_mount("/boot");
yaffs_mount("/data");
yaffs_mount("/flash");
yaffs_mount("/ram");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /data\n");
dumpDir("/data");
printf("\nDirectory look-up of /flash\n");
dumpDir("/flash");
//leave_unlinked_file("/flash",20000,0);
//leave_unlinked_file("/data",20000,0);
leave_unlinked_file("/ram",20,0);
f = yaffs_open("/boot/b1", O_RDONLY,0);
printf("open /boot/b1 readonly, f=%d\n",f);
f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
printf("open /boot/b1 O_CREAT, f=%d\n",f);
r = yaffs_write(f,"hello",1);
printf("write %d attempted to write to a read-only file\n",r);
r = yaffs_close(f);
printf("close %d\n",r);
f = yaffs_open("/boot/b1", O_RDWR,0);
printf("open /boot/b1 O_RDWR,f=%d\n",f);
r = yaffs_write(f,"hello",2);
printf("write %d attempted to write to a writeable file\n",r);
r = yaffs_write(f,"world",3);
printf("write %d attempted to write to a writeable file\n",r);
r= yaffs_lseek(f,0,SEEK_END);
printf("seek end %d\n",r);
memset(buffer,0,20);
r = yaffs_read(f,buffer,10);
printf("read %d \"%s\"\n",r,buffer);
r= yaffs_lseek(f,0,SEEK_SET);
printf("seek set %d\n",r);
memset(buffer,0,20);
r = yaffs_read(f,buffer,10);
printf("read %d \"%s\"\n",r,buffer);
memset(buffer,0,20);
r = yaffs_read(f,buffer,10);
printf("read %d \"%s\"\n",r,buffer);
// Check values reading at end.
// A read past end of file should return 0 for 0 bytes read.
r= yaffs_lseek(f,0,SEEK_END);
r = yaffs_read(f,buffer,10);
printf("read at end returned %d\n",r);
r= yaffs_lseek(f,500,SEEK_END);
r = yaffs_read(f,buffer,10);
printf("read past end returned %d\n",r);
r = yaffs_close(f);
printf("close %d\n",r);
copy_in_a_file("/boot/yyfile","xxx");
// Create a file with a long name
copy_in_a_file("/boot/file with a long name","xxx");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check stat
r = yaffs_stat("/boot/file with a long name",&ystat);
// Check rename
r = yaffs_rename("/boot/file with a long name","/boot/r1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check unlink
r = yaffs_unlink("/boot/r1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check mkdir
r = yaffs_mkdir("/boot/directory1",0);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
// add a file to the directory
copy_in_a_file("/boot/directory1/file with a long name","xxx");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
// Attempt to delete directory (should fail)
r = yaffs_rmdir("/boot/directory1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
// Delete file first, then rmdir should work
r = yaffs_unlink("/boot/directory1/file with a long name");
r = yaffs_rmdir("/boot/directory1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
#if 0
fill_disk_and_delete("/boot",20,20);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
#endif
yaffs_symlink("yyfile","/boot/slink");
yaffs_readlink("/boot/slink",str,100);
printf("symlink alias is %s\n",str);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
dumpDirFollow("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
h = yaffs_open("/boot/slink",O_RDWR,0);
printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
yaffs_close(h);
yaffs_unlink("/boot/slink");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check chmod
yaffs_stat("/boot/yyfile",&ystat);
temp_mode = ystat.st_mode;
yaffs_chmod("/boot/yyfile",0x55555);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
yaffs_chmod("/boot/yyfile",temp_mode);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Permission checks...
PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
yaffs_chmod("/boot/yyfile",temp_mode);
//create a zero-length file and unlink it (test for scan bug)
h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
yaffs_close(h);
yaffs_unlink("/boot/zlf");
yaffs_DumpDevStruct("/boot");
fill_disk_and_delete("/boot",20,20);
yaffs_DumpDevStruct("/boot");
fill_files("/boot",1,10000,0);
fill_files("/boot",1,10000,5000);
fill_files("/boot",2,10000,0);
fill_files("/boot",2,10000,5000);
leave_unlinked_file("/data",20000,0);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
yaffs_DumpDevStruct("/boot");
yaffs_DumpDevStruct("/data");
return 0;
}
void random_seek(int h)
{
int n;
n = random() & 0xFFFFF;
yaffs_lseek(h,n,SEEK_SET);
}
/*
* Open a WAV file for reading: returns (WAVFILE *)
*
* The opened file is positioned at the first byte of WAV file data, or
* NULL is returned if the open is unsuccessful.
*/
WAVFILE *WavOpenForRead(const char *Pathname)
{
WAVFILE *wfile;
UInt32 offset; /* File offset */
Byte ubuf[4]; /* 4 byte buffer */
UInt32 dbytes; /* Data byte count */
/* wavfile.c values : */
int channels; /* Channels recorded in this wav file */
u_long samplerate; /* Sampling rate */
int sample_bits; /* data bit size (8/12/16) */
u_long samples; /* The number of samples in this file */
u_long datastart; /* The offset to the wav data */
if(g_wfile) WavClose(g_wfile);
wfile = wavfile_alloc(Pathname);
if ( wfile == NULL )
return NULL; /* Insufficient memory (class B msg) */
/*
* Open the file for reading:
*/
printf("Opening WAV file %s\n", wfile->Pathname);
if ( (wfile->fd = yaffs_open(wfile->Pathname,O_RDONLY)) < 0 )
{
printf("Opening WAV file %s failed\n", wfile->Pathname);
goto errxit;
}
if ( yaffs_lseek(wfile->fd,0,SEEK_SET) != 0 )
{
printf("Rewinding WAV file %s\n",wfile->Pathname);
goto errxit; /* Wav file must be seekable device */
}
if ( WaveReadHeader(wfile->fd,&channels,&samplerate,&sample_bits,&samples,&datastart) != 0 )
{
printf("Reading WAV header from %s", wfile->Pathname);
goto errxit;
}
/*
* Copy WAV data over to WAVFILE struct:
*/
if ( channels == 2 )
wfile->wavinfo.Channels = Stereo;
else wfile->wavinfo.Channels = Mono;
wfile->wavinfo.SamplingRate = (UInt32) samplerate;
wfile->wavinfo.Samples = (UInt32) samples;
wfile->wavinfo.DataBits = (UInt16) sample_bits;
wfile->wavinfo.DataStart = (UInt32) datastart;
wfile->num_samples = wfile->wavinfo.Samples;
offset = wfile->wavinfo.DataStart - 4;
/*
* Seek to byte count and read dbytes:
*/
if ( yaffs_lseek(wfile->fd,offset,SEEK_SET) != offset )
{
printf("Seeking to WAV data in %s",wfile->Pathname);
goto errxit; /* Seek failure */
}
if ( yaffs_read(wfile->fd,ubuf,4) != 4 )
{
printf("Reading dbytes from %s",wfile->Pathname);
goto errxit;
}
/*
* Put little endian value into 32 bit value:
*/
dbytes = ubuf[3];
dbytes = (dbytes << 8) | ubuf[2];
dbytes = (dbytes << 8) | ubuf[1];
dbytes = (dbytes << 8) | ubuf[0];
wfile->wavinfo.DataBytes = dbytes;
/*
* Open succeeded:
*/
return wfile; /* Return open descriptor */
/*
* Return error after failed open:
WavClose*/
errxit:
mem_free(wfile); /* Dispose of WAVFILE struct */
return NULL; /* Return error indication */
}
void small_mount_test(const char *mountpt,int nmounts)
{
char a[30];
int i;
int j;
int h0;
int h1;
int len0;
int len1;
int nread;
sprintf(a,"%s/a",mountpt);
yaffs_StartUp();
for(i = 0; i < nmounts; i++){
static char xx[1000];
printf("############### Iteration %d Start\n",i);
if(1 || i == 0 || i == 5)
yaffs_mount(mountpt);
dump_directory_tree(mountpt);
yaffs_mkdir(a,0);
sprintf(xx,"%s/0",a);
if(i ==0){
h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
for(j = 0; j < 130; j++)
yaffs_write(h0,xx,1000);
yaffs_close(h0);
}
h0 = yaffs_open(xx,O_RDONLY,0);
sprintf(xx,"%s/1",a);
h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
while((nread = yaffs_read(h0,xx,1000)) > 0)
yaffs_write(h1,xx,nread);
len0 = yaffs_lseek(h0,0,SEEK_END);
len1 = yaffs_lseek(h1,0,SEEK_END);
yaffs_lseek(h0,0,SEEK_SET);
yaffs_lseek(h1,0,SEEK_SET);
for(j = 0; j < 200; j++){
yaffs_read(h0,xx,1000);
yaffs_read(h1,xx,1000);
}
yaffs_close(h0);
yaffs_close(h1);
printf("########### %d\n",i);
dump_directory_tree(mountpt);
if(1 || i == 4 || i == nmounts -1)
yaffs_unmount(mountpt);
}
}