2 * YAFFS: Yet another FFS. A NAND-flash specific file system.
4 * Copyright (C) 2002-2011 Aleph One Ltd.
5 * for Toby Churchill Ltd and Brightstar Engineering
7 * Created by Charles Manning <charles@aleph1.co.uk>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
26 #include "yaffs_guts.h" /* Only for dumping device innards */
28 extern int yaffs_trace_mask;
30 void dumpDir(const char *dname);
32 void copy_in_a_file(const char *yaffsName,const char *inName)
35 unsigned char buffer[100];
37 inh = open(inName,O_RDONLY);
38 outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
40 while((ni = read(inh,buffer,100)) > 0)
42 no = yaffs_write(outh,buffer,ni);
45 printf("problem writing yaffs file\n");
54 void make_a_file(const char *yaffsName,char bval,int sizeOfFile)
58 unsigned char buffer[100];
60 outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
62 memset(buffer,bval,100);
69 yaffs_write(outh,buffer,i);
71 } while (sizeOfFile > 0);
78 void make_pattern_file(char *fn,int size)
83 outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
84 yaffs_lseek(outh,size-1,SEEK_SET);
85 yaffs_write(outh,"A",1);
87 for(i = 0; i < size; i+=256)
90 yaffs_lseek(outh,i,SEEK_SET);
91 yaffs_write(outh,&marker,sizeof(marker));
97 int check_pattern_file(char *fn)
105 h = yaffs_open(fn, O_RDWR,0);
106 size = yaffs_lseek(h,0,SEEK_END);
108 for(i = 0; i < size; i+=256)
110 yaffs_lseek(h,i,SEEK_SET);
111 yaffs_read(h,&marker,sizeof(marker));
115 printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x\n",
116 fn,size,i,marker,~i);
127 int dump_file_data(char *fn)
134 h = yaffs_open(fn, O_RDWR,0);
138 while(yaffs_read(h,&b,1)> 0)
155 void dump_file(const char *fn)
161 h = yaffs_open(fn,O_RDONLY,0);
164 printf("*****\nDump file %s does not exist\n",fn);
168 size = yaffs_lseek(h,0,SEEK_SET);
169 printf("*****\nDump file %s size %d\n",fn,size);
170 for(i = 0; i < size; i++)
177 void create_file_of_size(const char *fn,int syze)
185 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
189 sprintf(xx,"%s %8d",fn,iteration);
191 result = yaffs_write(h,xx,n);
193 printf("Wrote %d, should have been %d. syze is %d\n",result,n,syze);
202 void verify_file_of_size(const char *fn,int syze)
211 int iterations = (syze + strlen(fn) -1)/ strlen(fn);
213 h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
215 while (iterations > 0)
217 sprintf(xx,"%s %8d",fn,iterations);
220 result = yaffs_read(h,yy,l);
224 printf("=====>>>>> verification of file %s failed near position %lld\n",fn,(long long)yaffs_lseek(h,0,SEEK_CUR));
231 void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2)
237 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
239 iterations = (syze1 + strlen(fn) -1)/ strlen(fn);
240 while (iterations > 0)
242 yaffs_write(h,fn,strlen(fn));
246 yaffs_ftruncate(h,reSyze);
248 yaffs_lseek(h,0,SEEK_SET);
249 iterations = (syze2 + strlen(fn) -1)/ strlen(fn);
250 while (iterations > 0)
252 yaffs_write(h,fn,strlen(fn));
260 void do_some_file_stuff(const char *path)
265 sprintf(fn,"%s/%s",path,"f1");
266 create_file_of_size(fn,10000);
268 sprintf(fn,"%s/%s",path,"fdel");
269 create_file_of_size(fn,10000);
272 sprintf(fn,"%s/%s",path,"f2");
274 create_resized_file_of_size(fn,10000,3000,4000);
277 void yaffs_backward_scan_test(const char *path)
285 do_some_file_stuff(path);
287 sprintf(fn,"%s/ddd",path);
291 do_some_file_stuff(fn);
298 void null_name_test(const char *path)
306 sprintf(fn,"%s",path);
308 h = yaffs_open(fn,O_CREAT| O_TRUNC| O_RDWR, 0666);
317 void yaffs_device_flush_test(const char *path)
327 do_some_file_stuff(path);
329 // Open and add some data to a few files
330 for(i = 0; i < 10; i++) {
332 sprintf(fn,"%s/ff%d",path,i);
334 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD);
335 yaffs_write(h,xxzz,2000);
336 yaffs_write(h,xxzz,2000);
345 void short_scan_test(const char *path, int fsize, int niterations)
350 sprintf(fn,"%s/%s",path,"f1");
353 for(i = 0; i < niterations; i++)
355 printf("\n*****************\nIteration %d\n",i);
357 printf("\nmount: Directory look-up of %s\n",path);
359 make_a_file(fn,1,fsize);
366 void scan_pattern_test(const char *path, int fsize, int niterations)
373 sprintf(fn[0],"%s/%s",path,"f0");
374 sprintf(fn[1],"%s/%s",path,"f1");
375 sprintf(fn[2],"%s/%s",path,"f2");
379 for(i = 0; i < niterations; i++)
381 printf("\n*****************\nIteration %d\n",i);
383 printf("\nmount: Directory look-up of %s\n",path);
385 for(j = 0; j < 3; j++)
387 result = dump_file_data(fn[j]);
388 result = check_pattern_file(fn[j]);
389 make_pattern_file(fn[j],fsize);
390 result = dump_file_data(fn[j]);
391 result = check_pattern_file(fn[j]);
397 void fill_disk(const char *path,int nfiles)
407 for(n = 0; n < nfiles; n++)
409 sprintf(str,"%s/%d",path,n);
411 h = yaffs_open(str, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
413 printf("writing file %s handle %d ",str, h);
415 while ((result = yaffs_write(h,xx,600)) == 600)
417 f = yaffs_freespace(path);
419 result = yaffs_close(h);
420 printf(" close %d\n",result);
424 void fill_disk_and_delete(const char *path, int nfiles, int ncycles)
430 for(i = 0; i < ncycles; i++)
432 printf("@@@@@@@@@@@@@@ cycle %d\n",i);
433 fill_disk(path,nfiles);
435 for(j = 0; j < nfiles; j++)
437 sprintf(str,"%s/%d",path,j);
438 result = yaffs_unlink(str);
439 printf("unlinking file %s, result %d\n",str,result);
445 void fill_files(const char *path,int flags, int maxIterations,int siz)
455 sprintf(str,"%s/%d",path,i);
456 h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
460 for(j = 0; j < siz; j++)
462 yaffs_write(h,str,1);
471 } while(h >= 0 && i < maxIterations);
477 sprintf(str,"%s/%d",path,i);
478 printf("unlink %s\n",str);
480 } while(yaffs_unlink(str) >= 0);
484 void leave_unlinked_file(const char *path,int maxIterations,int siz)
493 sprintf(str,"%s/%d",path,i);
494 printf("create %s\n",str);
495 h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
501 } while(h < 0 && i < maxIterations);
505 for(i = 0; i < siz; i++)
507 yaffs_write(h,str,1);
511 printf("Leaving file %s open\n",str);
515 void dumpDirFollow(const char *dname)
522 d = yaffs_opendir(dname);
526 printf("opendir failed\n");
530 while((de = yaffs_readdir(d)) != NULL)
532 sprintf(str,"%s/%s",dname,de->d_name);
536 printf("%s ino %lld length %d mode %X ",de->d_name,(int)s.st_ino,s.st_size,s.st_mode);
537 switch(s.st_mode & S_IFMT)
539 case S_IFREG: printf("data file"); break;
540 case S_IFDIR: printf("directory"); break;
541 case S_IFLNK: printf("symlink -->");
542 if(yaffs_readlink(str,str,100) < 0)
545 printf("\"%s\"",str);
547 default: printf("unknown"); break;
557 printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
562 void dump_directory_tree_worker(const char *dname,int recursive)
569 d = yaffs_opendir(dname);
573 printf("opendir failed\n");
577 while((de = yaffs_readdir(d)) != NULL)
579 sprintf(str,"%s/%s",dname,de->d_name);
583 printf("%s inode %d obj %x length %lld mode %X ",
584 str,s.st_ino,de->d_dont_use, s.st_size,s.st_mode);
585 switch(s.st_mode & S_IFMT)
587 case S_IFREG: printf("data file"); break;
588 case S_IFDIR: printf("directory"); break;
589 case S_IFLNK: printf("symlink -->");
590 if(yaffs_readlink(str,str,100) < 0)
593 printf("\"%s\"",str);
595 default: printf("unknown"); break;
600 if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
601 dump_directory_tree_worker(str,1);
610 static void dump_directory_tree(const char *dname)
612 dump_directory_tree_worker(dname,1);
614 printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
617 void dumpDir(const char *dname)
618 { dump_directory_tree_worker(dname,0);
620 printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
624 static void PermissionsCheck(const char *path, mode_t tmode, int tflags,int expectedResult)
628 if(yaffs_chmod(path,tmode)< 0) printf("chmod failed\n");
630 fd = yaffs_open(path,tflags,0);
632 if((fd >= 0) != (expectedResult > 0))
634 printf("Permissions check %x %x %d failed\n",tmode,tflags,expectedResult);
638 printf("Permissions check %x %x %d OK\n",tmode,tflags,expectedResult);
647 int long_test(int argc, char *argv[])
658 struct yaffs_stat ystat;
662 yaffs_mount("/boot");
663 yaffs_mount("/data");
664 yaffs_mount("/flash");
667 printf("\nDirectory look-up of /boot\n");
669 printf("\nDirectory look-up of /data\n");
671 printf("\nDirectory look-up of /flash\n");
674 //leave_unlinked_file("/flash",20000,0);
675 //leave_unlinked_file("/data",20000,0);
677 leave_unlinked_file("/ram",20,0);
680 f = yaffs_open("/boot/b1", O_RDONLY,0);
682 printf("open /boot/b1 readonly, f=%d\n",f);
684 f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
686 printf("open /boot/b1 O_CREAT, f=%d\n",f);
689 r = yaffs_write(f,"hello",1);
690 printf("write %d attempted to write to a read-only file\n",r);
694 printf("close %d\n",r);
696 f = yaffs_open("/boot/b1", O_RDWR,0);
698 printf("open /boot/b1 O_RDWR,f=%d\n",f);
701 r = yaffs_write(f,"hello",2);
702 printf("write %d attempted to write to a writeable file\n",r);
703 r = yaffs_write(f,"world",3);
704 printf("write %d attempted to write to a writeable file\n",r);
706 r= yaffs_lseek(f,0,SEEK_END);
707 printf("seek end %d\n",r);
709 r = yaffs_read(f,buffer,10);
710 printf("read %d \"%s\"\n",r,buffer);
711 r= yaffs_lseek(f,0,SEEK_SET);
712 printf("seek set %d\n",r);
714 r = yaffs_read(f,buffer,10);
715 printf("read %d \"%s\"\n",r,buffer);
717 r = yaffs_read(f,buffer,10);
718 printf("read %d \"%s\"\n",r,buffer);
720 // Check values reading at end.
721 // A read past end of file should return 0 for 0 bytes read.
723 r= yaffs_lseek(f,0,SEEK_END);
724 r = yaffs_read(f,buffer,10);
725 printf("read at end returned %d\n",r);
726 r= yaffs_lseek(f,500,SEEK_END);
727 r = yaffs_read(f,buffer,10);
728 printf("read past end returned %d\n",r);
732 printf("close %d\n",r);
734 copy_in_a_file("/boot/yyfile","xxx");
736 // Create a file with a long name
738 copy_in_a_file("/boot/file with a long name","xxx");
741 printf("\nDirectory look-up of /boot\n");
745 r = yaffs_lstat("/boot/file with a long name",&ystat);
749 r = yaffs_rename("/boot/file with a long name","/boot/r1");
751 printf("\nDirectory look-up of /boot\n");
755 r = yaffs_unlink("/boot/r1");
757 printf("\nDirectory look-up of /boot\n");
762 r = yaffs_mkdir("/boot/directory1",0);
764 printf("\nDirectory look-up of /boot\n");
766 printf("\nDirectory look-up of /boot/directory1\n");
767 dumpDir("/boot/directory1");
769 // add a file to the directory
770 copy_in_a_file("/boot/directory1/file with a long name","xxx");
772 printf("\nDirectory look-up of /boot\n");
774 printf("\nDirectory look-up of /boot/directory1\n");
775 dumpDir("/boot/directory1");
777 // Attempt to delete directory (should fail)
779 r = yaffs_rmdir("/boot/directory1");
781 printf("\nDirectory look-up of /boot\n");
783 printf("\nDirectory look-up of /boot/directory1\n");
784 dumpDir("/boot/directory1");
786 // Delete file first, then rmdir should work
787 r = yaffs_unlink("/boot/directory1/file with a long name");
788 r = yaffs_rmdir("/boot/directory1");
791 printf("\nDirectory look-up of /boot\n");
793 printf("\nDirectory look-up of /boot/directory1\n");
794 dumpDir("/boot/directory1");
797 fill_disk_and_delete("/boot",20,20);
799 printf("\nDirectory look-up of /boot\n");
803 yaffs_symlink("yyfile","/boot/slink");
805 yaffs_readlink("/boot/slink",str,100);
806 printf("symlink alias is %s\n",str);
811 printf("\nDirectory look-up of /boot\n");
813 printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
814 dumpDirFollow("/boot");
815 printf("\nDirectory look-up of /boot/directory1\n");
816 dumpDir("/boot/directory1");
818 h = yaffs_open("/boot/slink",O_RDWR,0);
820 printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
824 yaffs_unlink("/boot/slink");
827 printf("\nDirectory look-up of /boot\n");
832 yaffs_lstat("/boot/yyfile",&ystat);
833 temp_mode = ystat.st_mode;
835 yaffs_chmod("/boot/yyfile",0x55555);
836 printf("\nDirectory look-up of /boot\n");
839 yaffs_chmod("/boot/yyfile",temp_mode);
840 printf("\nDirectory look-up of /boot\n");
843 // Permission checks...
844 PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
845 PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
846 PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
848 PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
849 PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
850 PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
852 PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
853 PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
854 PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
856 PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
857 PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
858 PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
860 yaffs_chmod("/boot/yyfile",temp_mode);
862 //create a zero-length file and unlink it (test for scan bug)
864 h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
867 yaffs_unlink("/boot/zlf");
870 yaffs_dump_dev("/boot");
872 fill_disk_and_delete("/boot",20,20);
874 yaffs_dump_dev("/boot");
876 fill_files("/boot",1,10000,0);
877 fill_files("/boot",1,10000,5000);
878 fill_files("/boot",2,10000,0);
879 fill_files("/boot",2,10000,5000);
881 leave_unlinked_file("/data",20000,0);
882 leave_unlinked_file("/data",20000,5000);
883 leave_unlinked_file("/data",20000,5000);
884 leave_unlinked_file("/data",20000,5000);
885 leave_unlinked_file("/data",20000,5000);
886 leave_unlinked_file("/data",20000,5000);
888 yaffs_dump_dev("/boot");
889 yaffs_dump_dev("/data");
897 int huge_directory_test_on_path(char *path)
917 // Create a large number of files
919 for(i = 0; i < 2000; i++)
921 sprintf(str,"%s/%d",path,i);
923 f = yaffs_open(str,O_CREAT,S_IREAD | S_IWRITE);
929 d = yaffs_opendir(path);
932 while((de = yaffs_readdir(d)) != NULL) {
933 if (total >lastTotal+100*9*1024||(i & 1023)==0){
934 printf("files = %d, total = %d\n",i, total);
938 sprintf(str,"%s/%s",path,de->d_name);
940 switch(s.st_mode & S_IFMT){
942 //printf("data file");
954 int yaffs_scan_test(const char *path)
960 void rename_over_test(const char *mountpt)
967 sprintf(a,"%s/a",mountpt);
968 sprintf(b,"%s/b",mountpt);
969 sprintf(c,"%s/c",mountpt);
973 yaffs_mount(mountpt);
975 printf("Existing files\n");
976 dumpDirFollow(mountpt);
980 i = yaffs_open(c,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
981 printf("File c handle is %d\n",i);
983 i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
985 i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
987 yaffs_rename(a,b); // rename over
988 yaffs_rename(b,a); // rename back again (not renaimng over)
989 yaffs_rename(a,b); // rename back again (not renaimng over)
992 yaffs_unmount(mountpt);
997 int resize_stress_test(const char *path)
1012 sprintf(aname,"%s%s",path,"/a");
1013 sprintf(bname,"%s%s",path,"/b");
1015 memset(abuffer,'a',1000);
1016 memset(bbuffer,'b',1000);
1018 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1019 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1021 printf(" %s %d %s %d\n",aname,a,bname,b);
1025 for(j = 0; j < 100; j++)
1027 yaffs_lseek(a,0,SEEK_END);
1030 for(i = 0; i <20000; i++)
1032 //r = yaffs_lseek(b,i,SEEK_SET);
1033 //r = yaffs_write(b,bbuffer,1000);
1038 int syz = yaffs_lseek(a,0,SEEK_END);
1041 if(syz < 0) syz = 0;
1042 yaffs_ftruncate(a,syz);
1048 r = yaffs_lseek(a,i * 500,SEEK_SET);
1049 r = yaffs_write(a,abuffer,1000);
1061 int overwrite_test(const char *path)
1073 sprintf(aname,"%s%s",path,"/a");
1074 sprintf(bname,"%s%s",path,"/b");
1076 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1077 for(j= 0; j < 500; j++){
1078 yaffs_write(b,bname,100);
1079 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1080 for(i = 0; i < rand() % 20000; i++)
1081 yaffs_write(a,&a,sizeof(a));
1090 int root_perm_remount(const char *path)
1092 struct yaffs_stat s;
1098 yaffs_lstat(path,&s);
1099 printf("root perms after mount %x\n",s.st_mode);
1101 yaffs_chmod(path, 0777);
1103 yaffs_lstat(path,&s);
1104 printf("root perms after setting to 0777 is %x\n",s.st_mode);
1106 yaffs_unmount(path);
1113 int resize_stress_test_no_grow_complex(const char *path,int iters)
1129 sprintf(aname,"%s%s",path,"/a");
1130 sprintf(bname,"%s%s",path,"/b");
1132 memset(abuffer,'a',1000);
1133 memset(bbuffer,'b',1000);
1135 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1136 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1138 printf(" %s %d %s %d\n",aname,a,bname,b);
1142 for(j = 0; j < iters; j++)
1144 yaffs_lseek(a,0,SEEK_END);
1147 for(i = 0; i <20000; i++)
1149 //r = yaffs_lseek(b,i,SEEK_SET);
1150 //r = yaffs_write(b,bbuffer,1000);
1155 int syz = yaffs_lseek(a,0,SEEK_END);
1161 if(syz < 0) syz = 0;
1162 yaffs_ftruncate(a,syz);
1163 syz = yaffs_lseek(a,0,SEEK_END);
1164 printf("shrink to %d\n",syz);
1172 r = yaffs_lseek(a,500,SEEK_END);
1173 r = yaffs_write(a,abuffer,1000);
1180 printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
1188 int resize_stress_test_no_grow(const char *path,int iters)
1203 sprintf(aname,"%s%s",path,"/a");
1204 sprintf(bname,"%s%s",path,"/b");
1206 memset(abuffer,'a',1000);
1207 memset(bbuffer,'b',1000);
1209 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1210 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1212 printf(" %s %d %s %d\n",aname,a,bname,b);
1216 for(j = 0; j < iters; j++)
1218 yaffs_lseek(a,0,SEEK_END);
1221 for(i = 0; i <20000; i++)
1223 //r = yaffs_lseek(b,i,SEEK_SET);
1224 //r = yaffs_write(b,bbuffer,1000);
1229 int syz = yaffs_lseek(a,0,SEEK_END);
1235 if(syz < 0) syz = 0;
1236 yaffs_ftruncate(a,syz);
1237 syz = yaffs_lseek(a,0,SEEK_END);
1238 printf("shrink to %d\n",syz);
1246 r = yaffs_lseek(a,-500,SEEK_END);
1247 r = yaffs_write(a,abuffer,1000);
1253 printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
1261 int directory_rename_test(void)
1266 yaffs_mount("/ram");
1267 yaffs_mkdir("/ram/a",0);
1268 yaffs_mkdir("/ram/a/b",0);
1269 yaffs_mkdir("/ram/c",0);
1271 printf("\nDirectory look-up of /ram\n");
1274 dumpDir("/ram/a/b");
1276 printf("Do rename (should fail)\n");
1278 r = yaffs_rename("/ram/a","/ram/a/b/d");
1279 printf("\nDirectory look-up of /ram\n");
1282 dumpDir("/ram/a/b");
1284 printf("Do rename (should not fail)\n");
1286 r = yaffs_rename("/ram/c","/ram/a/b/d");
1287 printf("\nDirectory look-up of /ram\n");
1290 dumpDir("/ram/a/b");
1297 int cache_read_test(void)
1301 int sizeOfFiles = 500000;
1306 yaffs_mount("/boot");
1308 make_a_file("/boot/a",'a',sizeOfFiles);
1309 make_a_file("/boot/b",'b',sizeOfFiles);
1311 a = yaffs_open("/boot/a",O_RDONLY,0);
1312 b = yaffs_open("/boot/b",O_RDONLY,0);
1313 c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
1317 if (i > 100) i = 100;
1319 yaffs_read(a,buffer,i);
1320 yaffs_read(b,buffer,i);
1321 yaffs_write(c,buffer,i);
1322 } while(sizeOfFiles > 0);
1330 int cache_bypass_bug_test(void)
1332 // This test reporoduces a bug whereby YAFFS caching *was* buypassed
1333 // resulting in erroneous reads after writes.
1334 // This bug has been fixed.
1340 memset(buffer1,0,sizeof(buffer1));
1341 memset(buffer2,0,sizeof(buffer2));
1345 yaffs_mount("/boot");
1347 // Create a file of 2000 bytes.
1348 make_a_file("/boot/a",'X',2000);
1350 a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
1352 // Write a short sequence to the file.
1353 // This will go into the cache.
1354 yaffs_lseek(a,0,SEEK_SET);
1355 yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
1357 // Read a short sequence from the file.
1358 // This will come from the cache.
1359 yaffs_lseek(a,0,SEEK_SET);
1360 yaffs_read(a,buffer1,30);
1362 // Read a page size sequence from the file.
1363 yaffs_lseek(a,0,SEEK_SET);
1364 yaffs_read(a,buffer2,512);
1366 printf("buffer 1 %s\n",buffer1);
1367 printf("buffer 2 %s\n",buffer2);
1369 if(strncmp(buffer1,buffer2,20))
1371 printf("Cache bypass bug detected!!!!!\n");
1379 int free_space_check(void)
1384 yaffs_mount("/boot");
1385 fill_disk("/boot/",2);
1386 f = yaffs_freespace("/boot");
1388 printf("%d free when disk full\n",f);
1392 int truncate_test(void)
1402 yaffs_mount("/boot");
1404 yaffs_unlink("/boot/trunctest");
1406 a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1408 yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
1410 yaffs_ftruncate(a,3);
1411 l= yaffs_lseek(a,0,SEEK_END);
1413 printf("truncated length is %d\n",l);
1415 yaffs_lseek(a,5,SEEK_SET);
1416 yaffs_write(a,"1",1);
1418 yaffs_lseek(a,0,SEEK_SET);
1420 r = yaffs_read(a,y,10);
1422 printf("read %d bytes:",r);
1424 for(i = 0; i < r; i++) printf("[%02X]",y[i]);
1436 void fill_disk_test(const char *mountpt)
1441 for(i = 0; i < 5; i++)
1443 yaffs_mount(mountpt);
1444 fill_disk_and_delete(mountpt,100,i+1);
1445 yaffs_unmount(mountpt);
1451 void fill_files_test(const char *mountpt)
1456 for(i = 0; i < 5; i++)
1458 yaffs_mount(mountpt);
1459 fill_files(mountpt,2,3,100);
1460 yaffs_unmount(mountpt);
1465 void fill_empty_files_test(const char *mountpt)
1474 for(i = 0; i < 5; i++)
1476 yaffs_mount(mountpt);
1477 for(d = 0; result >= 0 && d < 1000; d++){
1478 sprintf(name,"%s/%d",mountpt,d);
1479 result= yaffs_mkdir(name,0);
1480 printf("creating directory %s result %d\n",name,result);
1482 for(f = 0; result >= 0 && f < 100; f++){
1483 sprintf(name,"%s/%d/%d",mountpt,d,f);
1484 result= yaffs_open(name,O_CREAT, 0);
1485 yaffs_close(result);
1486 printf("creating file %s result %d\n",name,result);
1489 yaffs_unmount(mountpt);
1494 void long_name_test(const char *mountpt)
1498 char fullName[1000];
1504 // Make a 256 byte name
1505 memset(name,0,sizeof(name));
1506 for(i = 0; i < 256; i++)
1507 name[i] = '0' + i % 10;
1509 sprintf(fullName,"%s/%s",mountpt,name);
1511 for(i = 0; i < 1; i++)
1513 yaffs_mount(mountpt);
1515 printf("Files at start\n");
1518 printf("Creating file %s\n",fullName);
1520 f = yaffs_open(fullName,O_CREAT | O_RDWR,0);
1523 printf("Result %d\n",f);
1528 printf("Deleting %s\n",fullName);
1529 result = yaffs_unlink(fullName);
1530 printf("Result %d\n",result);
1536 yaffs_unmount(mountpt);
1542 void lookup_test(const char *mountpt)
1554 yaffs_mount(mountpt);
1556 d = yaffs_opendir(mountpt);
1560 printf("opendir failed\n");
1565 for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1567 printf("unlinking %s\n",de->d_name);
1568 yaffs_unlink(de->d_name);
1571 printf("%d files deleted\n",i);
1575 for(i = 0; i < 2000; i++){
1576 sprintf(a,"%s/%d",mountpt,i);
1577 h = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
1582 for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1584 printf("%d %s\n",i,de->d_name);
1587 printf("%d files listed\n\n\n",i);
1594 for(i = 0; i < 2000; i++){
1595 sprintf(a,"%s/%d",mountpt,i);
1600 yaffs_unmount(mountpt);
1604 void link_test0(const char *mountpt)
1612 yaffs_mount(mountpt);
1615 sprintf(namea,"%s/a",mountpt);
1616 sprintf(nameb,"%s/b",mountpt);
1618 printf("mounted\n");
1621 yaffs_unlink(namea);
1622 printf("a unlinked\n");
1625 yaffs_unlink(nameb);
1626 printf("b unlinked\n");
1629 result = yaffs_open(namea,O_CREAT| O_RDWR,0666);
1630 yaffs_close(result);
1631 printf("a created\n");
1634 yaffs_link(namea,nameb);
1637 yaffs_unlink(namea);
1638 printf("a ulinked\n");
1640 yaffs_unlink(nameb);
1641 printf("b unlinked\n");
1644 yaffs_unmount(mountpt);
1648 void link_test1(const char *mountpt)
1656 sprintf(a,"%s/aaa",mountpt);
1657 sprintf(b,"%s/bbb",mountpt);
1658 sprintf(c,"%s/ccc",mountpt);
1662 yaffs_mount(mountpt);
1665 h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1666 for(i = 0; i < 100; i++)
1667 yaffs_write(h,a,100);
1680 yaffs_unmount(mountpt);
1681 yaffs_mount(mountpt);
1683 printf("link test done\n");
1686 void handle_test(const char *mountpt)
1693 sprintf(a,"%s/aaa",mountpt);
1697 yaffs_mount(mountpt);
1699 for(cycle = 0; cycle < 5; cycle++){
1700 printf("Start cycle %d\n",cycle);
1703 h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1704 printf("%d handle %d\n",i,h);
1714 yaffs_unmount(mountpt);
1717 void freespace_test(const char *mountpt)
1727 sprintf(a,"%s/aaa",mountpt);
1731 yaffs_mount(mountpt);
1733 f0 = yaffs_freespace(mountpt);
1735 h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1737 for(i = 0; i < 100; i++)
1738 yaffs_write(h,a,100);
1742 f1 = yaffs_freespace(mountpt);
1746 f2 = yaffs_freespace(mountpt);
1749 yaffs_unmount(mountpt);
1750 yaffs_mount(mountpt);
1752 f3 = yaffs_freespace(mountpt);
1754 printf("%d\n%d\n%d\n%d\n",f0, f1,f2,f3);
1759 void simple_rw_test(const char *mountpt)
1768 sprintf(a,"%s/aaa",mountpt);
1772 yaffs_mount(mountpt);
1776 h = yaffs_open(a,O_CREAT| O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1778 for(i = 100000;i < 200000; i++){
1779 result = yaffs_write(h,&i,sizeof(i));
1783 printf("write error\n");
1790 // h = yaffs_open(a,O_RDWR, S_IREAD | S_IWRITE);
1793 yaffs_lseek(h,0,SEEK_SET);
1795 for(i = 100000; i < 200000; i++){
1796 result = yaffs_read(h,&x,sizeof(x));
1798 if(result != 4 || x != i){
1799 printf("read error %d %x %x\n",i,result,x);
1803 printf("Simple rw test passed\n");
1810 void scan_deleted_files_test(const char *mountpt)
1822 sprintf(sub,"%s/sdir",mountpt);
1825 for(j = 0; j < 10; j++)
1827 printf("\n\n>>>>>>> Run %d <<<<<<<<<<<<<\n\n",j);
1828 yaffs_mount(mountpt);
1832 p = (j & 0) ? mountpt: sub;
1834 for(i = 0; i < 100; i++)
1836 sprintf(fn,"%s/%d",p,i);
1840 h = yaffs_open(fn,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1841 for(k = 0; k < 1000; k++)
1842 yaffs_write(h,fn,100);
1849 for(i = 0; i < 10; i++)
1851 sprintf(fn,"%s/%d",p,i);
1859 yaffs_unmount(mountpt);
1868 void write_10k(int h)
1871 const char *s="0123456789";
1872 for(i = 0; i < 1000; i++)
1873 yaffs_write(h,s,10);
1876 void write_200k_file(const char *fn, const char *fdel, const char *fdel1)
1882 h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1884 for(i = 0; i < 100000; i+= 10000)
1889 offs = yaffs_lseek(h1,0,SEEK_CUR);
1892 printf("Could not write file\n");
1896 for(i = 0; i < 100000; i+= 10000)
1901 offs = yaffs_lseek(h1,0,SEEK_CUR);
1904 printf("Could not write file\n");
1908 yaffs_unlink(fdel1);
1913 void verify_200k_file(const char *fn)
1918 const char *s="0123456789";
1921 h1 = yaffs_open(fn, O_RDONLY, 0);
1923 for(i = 0; i < 200000 && errCount < 10; i+= 10)
1925 yaffs_read(h1,x,10);
1926 if(strncmp(x,s,10) != 0)
1928 printf("File %s verification failed at %d\n",fn,i);
1933 printf("Too many errors... aborted\n");
1940 void check_resize_gc_bug(const char *mountpt)
1949 sprintf(a,"%s/a",mountpt);
1950 sprintf(b,"%s/b",mountpt);
1951 sprintf(c,"%s/c",mountpt);
1957 yaffs_mount(mountpt);
1961 for(i = 0; i < 50; i++)
1963 printf("A\n");write_200k_file(a,"",c);
1964 printf("B\n");verify_200k_file(a);
1965 printf("C\n");write_200k_file(b,a,c);
1966 printf("D\n");verify_200k_file(b);
1967 yaffs_unmount(mountpt);
1968 yaffs_mount(mountpt);
1969 printf("E\n");verify_200k_file(a);
1970 printf("F\n");verify_200k_file(b);
1976 void multi_mount_test(const char *mountpt,int nmounts)
1984 sprintf(a,"%s/a",mountpt);
1988 for(i = 0; i < nmounts; i++){
1994 static char xx[1000];
1996 printf("############### Iteration %d Start\n",i);
1997 if(1 || i == 0 || i == 5)
1998 yaffs_mount(mountpt);
2000 dump_directory_tree(mountpt);
2005 sprintf(xx,"%s/0",a);
2006 h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2008 sprintf(xx,"%s/1",a);
2009 h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2012 for(j = 0; j < 200; j++){
2013 yaffs_write(h0,xx,1000);
2014 yaffs_write(h1,xx,1000);
2017 while(yaffs_write(h0,xx,1000) > 0){
2019 yaffs_write(h1,xx,1000);
2022 len0 = yaffs_lseek(h0,0,SEEK_END);
2023 len1 = yaffs_lseek(h1,0,SEEK_END);
2025 yaffs_lseek(h0,0,SEEK_SET);
2026 yaffs_lseek(h1,0,SEEK_SET);
2028 for(j = 0; j < 200; j++){
2029 yaffs_read(h0,xx,1000);
2030 yaffs_read(h1,xx,1000);
2034 // yaffs_truncate(h0,0);
2038 printf("########### %d\n",i);
2039 dump_directory_tree(mountpt);
2041 if(1 || i == 4 || i == nmounts -1)
2042 yaffs_unmount(mountpt);
2047 void small_mount_test(const char *mountpt,int nmounts)
2061 sprintf(a,"%s/a",mountpt);
2067 for(i = 0; i < nmounts; i++){
2069 static char xx[1000];
2071 printf("############### Iteration %d Start\n",i);
2072 if(1 || i == 0 || i == 5)
2073 yaffs_mount(mountpt);
2075 dump_directory_tree(mountpt);
2079 sprintf(xx,"%s/0",a);
2082 h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2083 for(j = 0; j < 130; j++)
2084 yaffs_write(h0,xx,1000);
2088 h0 = yaffs_open(xx,O_RDONLY,0);
2090 sprintf(xx,"%s/1",a);
2091 h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2093 while((nread = yaffs_read(h0,xx,1000)) > 0)
2094 yaffs_write(h1,xx,nread);
2097 len0 = yaffs_lseek(h0,0,SEEK_END);
2098 len1 = yaffs_lseek(h1,0,SEEK_END);
2100 yaffs_lseek(h0,0,SEEK_SET);
2101 yaffs_lseek(h1,0,SEEK_SET);
2103 for(j = 0; j < 200; j++){
2104 yaffs_read(h0,xx,1000);
2105 yaffs_read(h1,xx,1000);
2111 printf("########### %d\n",i);
2112 dump_directory_tree(mountpt);
2114 if(1 || i == 4 || i == nmounts -1)
2115 yaffs_unmount(mountpt);
2122 void small_overwrite_test(const char *mountpt,int nmounts)
2133 sprintf(a,"%s/a",mountpt);
2139 for(i = 0; i < nmounts; i++){
2141 static char xx[8000];
2143 printf("############### Iteration %d Start\n",i);
2145 yaffs_mount(mountpt);
2147 dump_directory_tree(mountpt);
2151 sprintf(xx,"%s/0",a);
2152 h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2153 sprintf(xx,"%s/1",a);
2154 h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2156 for(j = 0; j < 1000000; j+=1000){
2157 yaffs_ftruncate(h0,j);
2158 yaffs_lseek(h0,j,SEEK_SET);
2159 yaffs_write(h0,xx,7000);
2160 yaffs_write(h1,xx,7000);
2168 printf("########### %d\n",i);
2169 dump_directory_tree(mountpt);
2172 yaffs_unmount(mountpt);
2177 void seek_overwrite_test(const char *mountpt,int nmounts)
2179 static char xx[5000];
2188 sprintf(a,"%s/f",mountpt);
2192 yaffs_mount(mountpt);
2195 for(i = 0; i < nmounts; i++){
2197 h0 = yaffs_open(a, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2199 for(j = 0; j < 100000; j++){
2200 yaffs_lseek(h0,0,SEEK_SET);
2201 yaffs_write(h0,xx,5000);
2202 yaffs_lseek(h0,0x100000,SEEK_SET);
2203 yaffs_write(h0,xx,5000);
2215 void yaffs_touch(const char *fn)
2217 yaffs_chmod(fn, S_IREAD | S_IWRITE);
2220 void checkpoint_fill_test(const char *mountpt,int nmounts)
2231 sprintf(a,"%s/a",mountpt);
2238 for(i = 0; i < nmounts; i++){
2239 printf("############### Iteration %d Start\n",i);
2240 yaffs_mount(mountpt);
2241 dump_directory_tree(mountpt);
2244 sprintf(b,"%s/zz",a);
2246 h = yaffs_open(b,O_CREAT | O_RDWR,S_IREAD |S_IWRITE);
2249 while(yaffs_write(h,c,50) == 50){}
2253 for(j = 0; j < 2; j++){
2254 printf("touch %d\n",j);
2256 yaffs_unmount(mountpt);
2257 yaffs_mount(mountpt);
2260 dump_directory_tree(mountpt);
2261 yaffs_unmount(mountpt);
2266 int make_file2(const char *name1, const char *name2,int syz)
2276 h1 = yaffs_open(name1,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2278 h2 = yaffs_open(name2,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2280 while(syz > 0 && n > 0){
2281 i = (syz > 2500) ? 2500 : syz;
2282 n = yaffs_write(h1,xx,i);
2283 n = yaffs_write(h2,xx,i);
2292 extern void SetCheckpointReservedBlocks(int n);
2294 void checkpoint_upgrade_test(const char *mountpt,int nmounts)
2304 sprintf(a,"%s/a",mountpt);
2309 printf("Create start condition\n");
2311 yaffs_mount(mountpt);
2313 sprintf(b,"%s/zz",a);
2314 sprintf(c,"%s/xx",a);
2315 make_file2(b,c,2000000);
2316 sprintf(d,"%s/aa",a);
2317 make_file2(d,NULL,500000000);
2318 dump_directory_tree(mountpt);
2320 printf("Umount/mount attempt full\n");
2321 yaffs_unmount(mountpt);
2323 yaffs_mount(mountpt);
2325 printf("unlink small file\n");
2327 dump_directory_tree(mountpt);
2329 printf("Umount/mount attempt\n");
2330 yaffs_unmount(mountpt);
2331 yaffs_mount(mountpt);
2333 for(j = 0; j < 500; j++){
2334 printf("***** touch %d\n",j);
2335 dump_directory_tree(mountpt);
2337 yaffs_unmount(mountpt);
2338 yaffs_mount(mountpt);
2341 for(j = 0; j < 500; j++){
2342 printf("***** touch %d\n",j);
2343 dump_directory_tree(mountpt);
2345 yaffs_unmount(mountpt);
2346 yaffs_mount(mountpt);
2350 void huge_array_test(const char *mountpt,int n)
2361 sprintf(a,"mount point %s",mountpt);
2367 yaffs_mount(mountpt);
2372 printf("\n\n START run\n\n");
2373 while((space = yaffs_freespace(mountpt)) > 25000000){
2374 sprintf(a,"%s/file%d",mountpt,fnum);
2376 printf("create file %s, free space %d\n",a,space);
2377 create_file_of_size(a,10000000);
2378 printf("verifying file %s\n",a);
2379 verify_file_of_size(a,10000000);
2382 printf("\n\n verification/deletion\n\n");
2384 for(i = 0; i < fnum; i++){
2385 sprintf(a,"%s/file%d",mountpt,i);
2386 printf("verifying file %s\n",a);
2387 verify_file_of_size(a,10000000);
2388 printf("deleting file %s\n",a);
2391 printf("\n\n done \n\n");
2398 void random_write(int h)
2400 static char buffer[12000];
2403 n = random() & 0x1FFF;
2404 yaffs_write(h,buffer,n);
2407 void random_seek(int h)
2410 n = random() & 0xFFFFF;
2411 yaffs_lseek(h,n,SEEK_SET);
2414 void random_truncate(int h, char * name)
2418 n = random() & 0xFFFFF;
2419 flen = yaffs_lseek(h,0,SEEK_END);
2422 yaffs_ftruncate(h,n);
2423 yaffs_lseek(h,n,SEEK_SET);
2427 #define NSMALLFILES 10
2428 void random_small_file_test(const char *mountpt,int iterations)
2431 char a[NSMALLFILES][50];
2442 yaffs_mount(mountpt);
2444 for(i = 0; i < NSMALLFILES; i++){
2449 for(n = 0; n < iterations; n++){
2451 for(i = 0; i < NSMALLFILES; i++) {
2454 if(strlen(a[i]) == 0){
2455 sprintf(a[i],"%s/%dx%d",mountpt,n,i);
2456 h[i] = yaffs_open(a[i],O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2460 printf("Could not open yaffs file %d %d error %d\n",n,i,h[i]);
2470 random_truncate(h[i],a[i]);
2473 case 5: random_seek(h[i]);
2490 for(i = 0; i < NSMALLFILES; i++)
2493 yaffs_unmount(mountpt);
2496 void rmdir_test(const char *mountpt)
2501 yaffs_mount(mountpt);
2503 strcpy(name,mountpt);
2505 strcat(name,"hello");
2506 yaffs_mkdir(name,0666);
2508 yaffs_unmount(mountpt);
2513 static void print_xattrib_val(const char *path, const char *name)
2518 n = yaffs_getxattr(path,name,buffer,sizeof(buffer));
2520 u8 *b = (u8 *)buffer;
2522 printf("%d bytes:",n);
2526 printf("[%02X]",*b);
2532 printf(" Novalue result %d\n",n);
2535 static void list_xattr(const char *path)
2542 list_len = yaffs_listxattr(path,list,sizeof(list));
2543 printf("xattribs for %s, result is %d\n",path,list_len);
2544 while(n < list_len){
2545 len = strlen(list + n);
2546 printf("\"%s\" value ",list+n);
2547 print_xattrib_val(path,list + n);
2553 void basic_utime_test(const char *mountpt)
2559 struct yaffs_utimbuf utb;
2560 struct yaffs_stat st;
2564 yaffs_mount(mountpt);
2566 strcpy(name,mountpt);
2568 strcat(name,"xfile");
2572 printf("created\n");
2573 h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2575 yaffs_fstat(h,&st); printf(" times %u %u %u\n",st.yst_atime, st.yst_ctime, st.yst_mtime);
2579 result = yaffs_futime(h,&utb);
2580 printf("futime to a 1000 m 2000 result %d\n",result);
2581 yaffs_fstat(h,&st); printf(" times %u %u %u\n",st.yst_atime, st.yst_ctime, st.yst_mtime);
2586 result = yaffs_utime(name, &utb);
2587 printf("utime to a 5000 m 8000 result %d\n",result);
2588 yaffs_fstat(h,&st); printf(" times %u %u %u\n",st.yst_atime, st.yst_ctime, st.yst_mtime);
2590 result = yaffs_utime(name, NULL);
2591 printf("utime to NULL result %d\n",result);
2592 yaffs_fstat(h,&st); printf(" times %u %u %u\n",st.yst_atime, st.yst_ctime, st.yst_mtime);
2597 void basic_xattr_test(const char *mountpt)
2606 yaffs_mount(mountpt);
2608 strcpy(name,mountpt);
2610 strcat(name,"xfile");
2613 h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2619 printf("Add an attribute\n");
2621 result = yaffs_setxattr(name,"foo",&val1,sizeof(val1),0);
2622 printf("wrote attribute foo: result %d\n",result);
2624 printf("Add an attribute\n");
2626 result = yaffs_setxattr(name,"bar",&val1,sizeof(val1),0);
2627 printf("wrote attribute bar: result %d\n",result);
2630 printf("Get non-existanrt attribute\n");
2631 print_xattrib_val(name,"not here");
2633 printf("Delete non existing attribute\n");
2634 yaffs_removexattr(name,"not here");
2637 printf("Remove foo\n");
2638 yaffs_removexattr(name,"foo");
2641 printf("Remove bar\n");
2642 yaffs_removexattr(name,"bar");
2647 void big_xattr_test(const char *mountpt)
2656 yaffs_mount(mountpt);
2658 strcpy(name,mountpt);
2660 strcat(name,"xfile");
2663 h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2669 printf("Add a large attribute\n");
2670 memset(val,0x1,sizeof(val));
2671 result = yaffs_setxattr(name,"aaa",val,200,0);
2672 printf("wrote attribute aaa: result %d\n",result);
2675 printf("Add a large attribute\n");
2676 memset(val,0x2,sizeof(val));
2677 result = yaffs_setxattr(name,"bbb",val,1000,0);
2678 printf("wrote attribute bbb: result %d\n",result);
2681 printf("Replace attribute\n");
2682 memset(val,0x3,sizeof(val));
2683 result = yaffs_setxattr(name,"aaa",val,1000,0);
2684 printf("wrote attribute aaa: result %d\n",result);
2690 void dump_dev_stats(struct yaffs_dev *dev, const char * str)
2693 printf( "space free %d erased %d "
2694 "nand reads %d writes %d erases %d "
2695 "gc all %d passive %d oldestdirty %d blocks %d copies %d \n",
2696 dev->n_free_chunks, dev->n_erased_blocks * dev->param.chunks_per_block,
2697 dev->n_page_reads, dev->n_page_writes, dev->n_erasures,
2698 dev->all_gcs, dev->passive_gc_count, dev->oldest_dirty_gc_count, dev->n_gc_blocks, dev->n_gc_copies);
2701 void test_flash_traffic(const char *mountpt)
2706 struct yaffs_dev *dev;
2708 yaffs_trace_mask = 0;
2712 yaffs_mount(mountpt);
2714 dev = yaffs_getdev(mountpt);
2716 strcpy(name0,mountpt);
2719 strcpy(name1,mountpt);
2722 dump_dev_stats(dev,"start");
2723 create_file_of_size(name0,32 * 1024 * 1024);
2724 dump_dev_stats(dev,"32MB written");
2725 for(i = 0; i < 20; i++)
2726 create_file_of_size(name1,1024 * 1024);
2727 dump_dev_stats(dev,"20x 1MB files written");
2731 void link_follow_test(const char *mountpt)
2739 yaffs_trace_mask = 0;
2743 yaffs_mount(mountpt);
2745 sprintf(fn,"%s/file",mountpt);
2746 sprintf(sn,"%s/sym",mountpt);
2747 sprintf(hn,"%s/hl-sym",mountpt);
2749 h = yaffs_open(fn,O_CREAT| O_RDWR, S_IREAD | S_IWRITE);
2750 result = yaffs_close(h);
2752 result = yaffs_symlink(fn,sn);
2753 result = yaffs_link(sn,hn);
2755 h =yaffs_open(hn,O_RDWR,0);
2760 #define N_WRITES 2000
2763 #define BUFFER_N 1100
2764 unsigned xxbuffer[BUFFER_N];
2767 void set_buffer(int n)
2770 for(i = 0; i < BUFFER_N; i++)
2771 xxbuffer[i] = i + n;
2774 void write_big_sparse_file(int h)
2779 int n = sizeof(xxbuffer);
2782 for(i = 0; i < N_WRITES; i++) {
2783 printf("writing at %lld\n", offset);
2785 pos = yaffs_lseek(h, offset, SEEK_SET);
2787 printf("mismatched seek pos %lld offset %lld\n",
2792 wrote = yaffs_write(h, xxbuffer, n);
2795 printf("mismatched write wrote %d n %d\n", wrote, n);
2799 offset += (STRIDE * sizeof(xxbuffer));
2802 yaffs_ftruncate(h, offset);
2809 void verify_big_sparse_file(int h)
2811 unsigned check_buffer[BUFFER_N];
2815 int n = sizeof(check_buffer);
2817 const char * check_type;
2818 int checks_failed = 0;
2819 int checks_passed = 0;
2821 for(i = 0; i < N_WRITES * STRIDE; i++) {
2823 check_type = "zero";
2824 memset(xxbuffer,0, n);
2826 check_type = "buffer";
2827 set_buffer(i/STRIDE);
2829 printf("%s checking %lld\n", check_type, offset);
2830 pos = yaffs_lseek(h, offset, SEEK_SET);
2832 printf("mismatched seek pos %lld offset %lld\n",
2837 result = yaffs_read(h, check_buffer, n);
2840 printf("mismatched read result %d n %d\n", result, n);
2847 if(memcmp(xxbuffer, check_buffer, n)) {
2850 printf("buffer at %lld mismatches\n", pos);
2851 printf("xxbuffer ");
2852 for(j = 0; j < 20; j++)
2853 printf(" %d",xxbuffer[j]);
2855 printf("check_buffer ");
2856 for(j = 0; j < 20; j++)
2857 printf(" %d",check_buffer[j]);
2865 offset += sizeof(xxbuffer);
2868 printf("%d checks passed, %d checks failed\n", checks_passed, checks_failed);
2873 void large_file_test(const char *mountpt)
2878 yaffs_trace_mask = 0;
2882 yaffs_mount(mountpt);
2883 printf("mounted\n");
2886 sprintf(fullname, "%s/%s", mountpt, "big-test-file");
2888 handle = yaffs_open(fullname, O_RDONLY, 0);
2890 handle = yaffs_open(fullname, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
2893 perror("opening file");
2897 write_big_sparse_file(handle);
2898 verify_big_sparse_file(handle);
2900 yaffs_close(handle);
2902 printf("Job done\n");
2903 yaffs_unmount(mountpt);
2905 yaffs_mount(mountpt);
2906 printf("mounted again\n");
2908 handle = yaffs_open(fullname, O_RDONLY, 0);
2909 verify_big_sparse_file(handle);
2910 yaffs_unmount(mountpt);
2913 yaffs_mount_common(mountpt, 0, 1);
2914 printf("mounted with no checkpt\n");
2916 handle = yaffs_open(fullname, O_RDONLY, 0);
2917 verify_big_sparse_file(handle);
2918 yaffs_unmount(mountpt);
2924 int simulate_power_failure;
2926 int main(int argc, char *argv[])
2928 random_seed = time(NULL);
2929 //return long_test(argc,argv);
2931 //return cache_read_test();
2933 // resize_stress_test_no_grow("/flash/flash",20);
2934 //root_perm_remount("/flash/flash");
2936 //huge_directory_test_on_path("/ram2k");
2938 //yaffs_backward_scan_test("/flash/flash");
2939 // yaffs_device_flush_test("/flash/flash");
2941 //rename_over_test("//////////////////flash///////////////////yaffs1///////////");
2943 //fill_empty_files_test("/yaffs2/");
2944 //resize_stress_test("/yaffs2");
2945 //overwrite_test("/yaffs2");
2947 //long_name_test("/yaffs2");
2948 //link_test0("/yaffs2");
2949 //link_test1("yaffs2");
2950 //scan_pattern_test("/flash",10000,10);
2951 //short_scan_test("/flash/flash",40000,200);
2952 //small_mount_test("/flash/flash",1000);
2953 //small_overwrite_test("/flash/flash",1000);
2954 //seek_overwrite_test("/flash/flash",1000);
2955 //checkpoint_fill_test("/flash/flash",20);
2956 //checkpoint_upgrade_test("/flash/flash",20);
2957 //small_overwrite_test("/flash/flash",1000);
2958 //checkpoint_fill_test("/flash/flash",20);
2959 // random_small_file_test("/flash/flash",10000);
2960 // huge_array_test("/flash/flash",10);
2963 // handle_test("yaffs2/");
2965 //long_test_on_path("/ram2k");
2966 // long_test_on_path("/flash");
2967 //simple_rw_test("/flash/flash");
2968 //fill_disk_test("/flash/flash");
2969 // rename_over_test("/flash");
2970 //lookup_test("/flash");
2971 //freespace_test("/flash/flash");
2973 //link_test("/flash/flash");
2975 // cache_bypass_bug_test();
2977 //free_space_check();
2979 //check_resize_gc_bug("/flash");
2981 //basic_xattr_test("/yaffs2");
2982 //big_xattr_test("/yaffs2");
2984 //null_name_test("yaffs2");
2986 //test_flash_traffic("yaffs2");
2987 // link_follow_test("/yaffs2");
2989 large_file_test("/yaffs2");
2991 //basic_utime_test("/yaffs2");