2 * YAFFS: Yet another FFS. A NAND-flash specific file system.
4 * Copyright (C) 2002-2010 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.
25 #include "yaffs_guts.h" /* Only for dumping device innards */
27 extern int yaffs_traceMask;
29 void dumpDir(const char *dname);
33 void copy_in_a_file(char *yaffsName,char *inName)
36 unsigned char buffer[100];
38 inh = open(inName,O_RDONLY);
39 outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
41 while((ni = read(inh,buffer,100)) > 0)
43 no = yaffs_write(outh,buffer,ni);
46 printf("problem writing yaffs file\n");
55 void make_a_file(char *yaffsName,char bval,int sizeOfFile)
59 unsigned char buffer[100];
61 outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
63 memset(buffer,bval,100);
70 yaffs_write(outh,buffer,i);
72 } while (sizeOfFile > 0);
79 void make_pattern_file(char *fn,int size)
84 outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
85 yaffs_lseek(outh,size-1,SEEK_SET);
86 yaffs_write(outh,"A",1);
88 for(i = 0; i < size; i+=256)
91 yaffs_lseek(outh,i,SEEK_SET);
92 yaffs_write(outh,&marker,sizeof(marker));
98 int check_pattern_file(char *fn)
106 h = yaffs_open(fn, O_RDWR,0);
107 size = yaffs_lseek(h,0,SEEK_END);
109 for(i = 0; i < size; i+=256)
111 yaffs_lseek(h,i,SEEK_SET);
112 yaffs_read(h,&marker,sizeof(marker));
116 printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x\n",
117 fn,size,i,marker,~i);
128 int dump_file_data(char *fn)
135 h = yaffs_open(fn, O_RDWR,0);
139 while(yaffs_read(h,&b,1)> 0)
156 void dump_file(const char *fn)
162 h = yaffs_open(fn,O_RDONLY,0);
165 printf("*****\nDump file %s does not exist\n",fn);
169 size = yaffs_lseek(h,0,SEEK_SET);
170 printf("*****\nDump file %s size %d\n",fn,size);
171 for(i = 0; i < size; i++)
178 void create_file_of_size(const char *fn,int syze)
186 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
190 sprintf(xx,"%s %8d",fn,iteration);
192 result = yaffs_write(h,xx,n);
194 printf("Wrote %d, should have been %d. syze is %d\n",result,n,syze);
203 void verify_file_of_size(const char *fn,int syze)
212 int iterations = (syze + strlen(fn) -1)/ strlen(fn);
214 h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
216 while (iterations > 0)
218 sprintf(xx,"%s %8d",fn,iterations);
221 result = yaffs_read(h,yy,l);
225 printf("=====>>>>> verification of file %s failed near position %lld\n",fn,(long long)yaffs_lseek(h,0,SEEK_CUR));
232 void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2)
238 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
240 iterations = (syze1 + strlen(fn) -1)/ strlen(fn);
241 while (iterations > 0)
243 yaffs_write(h,fn,strlen(fn));
247 yaffs_ftruncate(h,reSyze);
249 yaffs_lseek(h,0,SEEK_SET);
250 iterations = (syze2 + strlen(fn) -1)/ strlen(fn);
251 while (iterations > 0)
253 yaffs_write(h,fn,strlen(fn));
261 void do_some_file_stuff(const char *path)
266 sprintf(fn,"%s/%s",path,"f1");
267 create_file_of_size(fn,10000);
269 sprintf(fn,"%s/%s",path,"fdel");
270 create_file_of_size(fn,10000);
273 sprintf(fn,"%s/%s",path,"f2");
275 create_resized_file_of_size(fn,10000,3000,4000);
278 void yaffs_backward_scan_test(const char *path)
286 do_some_file_stuff(path);
288 sprintf(fn,"%s/ddd",path);
292 do_some_file_stuff(fn);
299 void null_name_test(const char *path)
307 sprintf(fn,"%s",path);
309 h = yaffs_open(fn,O_CREAT| O_TRUNC| O_RDWR, 0666);
318 void yaffs_device_flush_test(const char *path)
328 do_some_file_stuff(path);
330 // Open and add some data to a few files
331 for(i = 0; i < 10; i++) {
333 sprintf(fn,"%s/ff%d",path,i);
335 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD);
336 yaffs_write(h,xxzz,2000);
337 yaffs_write(h,xxzz,2000);
346 void short_scan_test(const char *path, int fsize, int niterations)
351 sprintf(fn,"%s/%s",path,"f1");
354 for(i = 0; i < niterations; i++)
356 printf("\n*****************\nIteration %d\n",i);
358 printf("\nmount: Directory look-up of %s\n",path);
360 make_a_file(fn,1,fsize);
367 void scan_pattern_test(const char *path, int fsize, int niterations)
374 sprintf(fn[0],"%s/%s",path,"f0");
375 sprintf(fn[1],"%s/%s",path,"f1");
376 sprintf(fn[2],"%s/%s",path,"f2");
380 for(i = 0; i < niterations; i++)
382 printf("\n*****************\nIteration %d\n",i);
384 printf("\nmount: Directory look-up of %s\n",path);
386 for(j = 0; j < 3; j++)
388 result = dump_file_data(fn[j]);
389 result = check_pattern_file(fn[j]);
390 make_pattern_file(fn[j],fsize);
391 result = dump_file_data(fn[j]);
392 result = check_pattern_file(fn[j]);
398 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(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 %d length %d mode %X ",de->d_name,(int)s.st_ino,(int)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 %d mode %X ",str,s.st_ino,de->d_dont_use,(int)s.st_size,s.st_mode);
584 switch(s.st_mode & S_IFMT)
586 case S_IFREG: printf("data file"); break;
587 case S_IFDIR: printf("directory"); break;
588 case S_IFLNK: printf("symlink -->");
589 if(yaffs_readlink(str,str,100) < 0)
592 printf("\"%s\"",str);
594 default: printf("unknown"); break;
599 if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
600 dump_directory_tree_worker(str,1);
609 static void dump_directory_tree(const char *dname)
611 dump_directory_tree_worker(dname,1);
613 printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
616 void dumpDir(const char *dname)
617 { dump_directory_tree_worker(dname,0);
619 printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
623 static void PermissionsCheck(const char *path, mode_t tmode, int tflags,int expectedResult)
627 if(yaffs_chmod(path,tmode)< 0) printf("chmod failed\n");
629 fd = yaffs_open(path,tflags,0);
631 if((fd >= 0) != (expectedResult > 0))
633 printf("Permissions check %x %x %d failed\n",tmode,tflags,expectedResult);
637 printf("Permissions check %x %x %d OK\n",tmode,tflags,expectedResult);
646 int long_test(int argc, char *argv[])
657 struct yaffs_stat ystat;
661 yaffs_mount("/boot");
662 yaffs_mount("/data");
663 yaffs_mount("/flash");
666 printf("\nDirectory look-up of /boot\n");
668 printf("\nDirectory look-up of /data\n");
670 printf("\nDirectory look-up of /flash\n");
673 //leave_unlinked_file("/flash",20000,0);
674 //leave_unlinked_file("/data",20000,0);
676 leave_unlinked_file("/ram",20,0);
679 f = yaffs_open("/boot/b1", O_RDONLY,0);
681 printf("open /boot/b1 readonly, f=%d\n",f);
683 f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
685 printf("open /boot/b1 O_CREAT, f=%d\n",f);
688 r = yaffs_write(f,"hello",1);
689 printf("write %d attempted to write to a read-only file\n",r);
693 printf("close %d\n",r);
695 f = yaffs_open("/boot/b1", O_RDWR,0);
697 printf("open /boot/b1 O_RDWR,f=%d\n",f);
700 r = yaffs_write(f,"hello",2);
701 printf("write %d attempted to write to a writeable file\n",r);
702 r = yaffs_write(f,"world",3);
703 printf("write %d attempted to write to a writeable file\n",r);
705 r= yaffs_lseek(f,0,SEEK_END);
706 printf("seek end %d\n",r);
708 r = yaffs_read(f,buffer,10);
709 printf("read %d \"%s\"\n",r,buffer);
710 r= yaffs_lseek(f,0,SEEK_SET);
711 printf("seek set %d\n",r);
713 r = yaffs_read(f,buffer,10);
714 printf("read %d \"%s\"\n",r,buffer);
716 r = yaffs_read(f,buffer,10);
717 printf("read %d \"%s\"\n",r,buffer);
719 // Check values reading at end.
720 // A read past end of file should return 0 for 0 bytes read.
722 r= yaffs_lseek(f,0,SEEK_END);
723 r = yaffs_read(f,buffer,10);
724 printf("read at end returned %d\n",r);
725 r= yaffs_lseek(f,500,SEEK_END);
726 r = yaffs_read(f,buffer,10);
727 printf("read past end returned %d\n",r);
731 printf("close %d\n",r);
733 copy_in_a_file("/boot/yyfile","xxx");
735 // Create a file with a long name
737 copy_in_a_file("/boot/file with a long name","xxx");
740 printf("\nDirectory look-up of /boot\n");
744 r = yaffs_stat("/boot/file with a long name",&ystat);
748 r = yaffs_rename("/boot/file with a long name","/boot/r1");
750 printf("\nDirectory look-up of /boot\n");
754 r = yaffs_unlink("/boot/r1");
756 printf("\nDirectory look-up of /boot\n");
761 r = yaffs_mkdir("/boot/directory1",0);
763 printf("\nDirectory look-up of /boot\n");
765 printf("\nDirectory look-up of /boot/directory1\n");
766 dumpDir("/boot/directory1");
768 // add a file to the directory
769 copy_in_a_file("/boot/directory1/file with a long name","xxx");
771 printf("\nDirectory look-up of /boot\n");
773 printf("\nDirectory look-up of /boot/directory1\n");
774 dumpDir("/boot/directory1");
776 // Attempt to delete directory (should fail)
778 r = yaffs_rmdir("/boot/directory1");
780 printf("\nDirectory look-up of /boot\n");
782 printf("\nDirectory look-up of /boot/directory1\n");
783 dumpDir("/boot/directory1");
785 // Delete file first, then rmdir should work
786 r = yaffs_unlink("/boot/directory1/file with a long name");
787 r = yaffs_rmdir("/boot/directory1");
790 printf("\nDirectory look-up of /boot\n");
792 printf("\nDirectory look-up of /boot/directory1\n");
793 dumpDir("/boot/directory1");
796 fill_disk_and_delete("/boot",20,20);
798 printf("\nDirectory look-up of /boot\n");
802 yaffs_symlink("yyfile","/boot/slink");
804 yaffs_readlink("/boot/slink",str,100);
805 printf("symlink alias is %s\n",str);
810 printf("\nDirectory look-up of /boot\n");
812 printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
813 dumpDirFollow("/boot");
814 printf("\nDirectory look-up of /boot/directory1\n");
815 dumpDir("/boot/directory1");
817 h = yaffs_open("/boot/slink",O_RDWR,0);
819 printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
823 yaffs_unlink("/boot/slink");
826 printf("\nDirectory look-up of /boot\n");
831 yaffs_stat("/boot/yyfile",&ystat);
832 temp_mode = ystat.st_mode;
834 yaffs_chmod("/boot/yyfile",0x55555);
835 printf("\nDirectory look-up of /boot\n");
838 yaffs_chmod("/boot/yyfile",temp_mode);
839 printf("\nDirectory look-up of /boot\n");
842 // Permission checks...
843 PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
844 PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
845 PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
847 PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
848 PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
849 PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
851 PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
852 PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
853 PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
855 PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
856 PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
857 PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
859 yaffs_chmod("/boot/yyfile",temp_mode);
861 //create a zero-length file and unlink it (test for scan bug)
863 h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
866 yaffs_unlink("/boot/zlf");
869 yaffs_DumpDevStruct("/boot");
871 fill_disk_and_delete("/boot",20,20);
873 yaffs_DumpDevStruct("/boot");
875 fill_files("/boot",1,10000,0);
876 fill_files("/boot",1,10000,5000);
877 fill_files("/boot",2,10000,0);
878 fill_files("/boot",2,10000,5000);
880 leave_unlinked_file("/data",20000,0);
881 leave_unlinked_file("/data",20000,5000);
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);
887 yaffs_DumpDevStruct("/boot");
888 yaffs_DumpDevStruct("/data");
896 int huge_directory_test_on_path(char *path)
916 // Create a large number of files
918 for(i = 0; i < 2000; i++)
920 sprintf(str,"%s/%d",path,i);
922 f = yaffs_open(str,O_CREAT,S_IREAD | S_IWRITE);
928 d = yaffs_opendir(path);
931 while((de = yaffs_readdir(d)) != NULL) {
932 if (total >lastTotal+100*9*1024||(i & 1023)==0){
933 printf("files = %d, total = %d\n",i, total);
937 sprintf(str,"%s/%s",path,de->d_name);
939 switch(s.st_mode & S_IFMT){
941 //printf("data file");
953 int yaffs_scan_test(const char *path)
959 void rename_over_test(const char *mountpt)
966 sprintf(a,"%s/a",mountpt);
967 sprintf(b,"%s/b",mountpt);
968 sprintf(c,"%s/c",mountpt);
972 yaffs_mount(mountpt);
974 printf("Existing files\n");
975 dumpDirFollow(mountpt);
979 i = yaffs_open(c,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
980 printf("File c handle is %d\n",i);
982 i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
984 i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
986 yaffs_rename(a,b); // rename over
987 yaffs_rename(b,a); // rename back again (not renaimng over)
988 yaffs_rename(a,b); // rename back again (not renaimng over)
991 yaffs_unmount(mountpt);
996 int resize_stress_test(const char *path)
1011 sprintf(aname,"%s%s",path,"/a");
1012 sprintf(bname,"%s%s",path,"/b");
1014 memset(abuffer,'a',1000);
1015 memset(bbuffer,'b',1000);
1017 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1018 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1020 printf(" %s %d %s %d\n",aname,a,bname,b);
1024 for(j = 0; j < 100; j++)
1026 yaffs_lseek(a,0,SEEK_END);
1029 for(i = 0; i <20000; i++)
1031 //r = yaffs_lseek(b,i,SEEK_SET);
1032 //r = yaffs_write(b,bbuffer,1000);
1037 int syz = yaffs_lseek(a,0,SEEK_END);
1040 if(syz < 0) syz = 0;
1041 yaffs_ftruncate(a,syz);
1047 r = yaffs_lseek(a,i * 500,SEEK_SET);
1048 r = yaffs_write(a,abuffer,1000);
1060 int overwrite_test(const char *path)
1072 sprintf(aname,"%s%s",path,"/a");
1073 sprintf(bname,"%s%s",path,"/b");
1075 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1076 for(j= 0; j < 500; j++){
1077 yaffs_write(b,bname,100);
1078 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1079 for(i = 0; i < rand() % 20000; i++)
1080 yaffs_write(a,&a,sizeof(a));
1089 int root_perm_remount(const char *path)
1091 struct yaffs_stat s;
1097 yaffs_stat(path,&s);
1098 printf("root perms after mount %x\n",s.st_mode);
1100 yaffs_chmod(path, 0777);
1102 yaffs_stat(path,&s);
1103 printf("root perms after setting to 0777 is %x\n",s.st_mode);
1105 yaffs_unmount(path);
1112 int resize_stress_test_no_grow_complex(const char *path,int iters)
1128 sprintf(aname,"%s%s",path,"/a");
1129 sprintf(bname,"%s%s",path,"/b");
1131 memset(abuffer,'a',1000);
1132 memset(bbuffer,'b',1000);
1134 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1135 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1137 printf(" %s %d %s %d\n",aname,a,bname,b);
1141 for(j = 0; j < iters; j++)
1143 yaffs_lseek(a,0,SEEK_END);
1146 for(i = 0; i <20000; i++)
1148 //r = yaffs_lseek(b,i,SEEK_SET);
1149 //r = yaffs_write(b,bbuffer,1000);
1154 int syz = yaffs_lseek(a,0,SEEK_END);
1160 if(syz < 0) syz = 0;
1161 yaffs_ftruncate(a,syz);
1162 syz = yaffs_lseek(a,0,SEEK_END);
1163 printf("shrink to %d\n",syz);
1171 r = yaffs_lseek(a,500,SEEK_END);
1172 r = yaffs_write(a,abuffer,1000);
1179 printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
1187 int resize_stress_test_no_grow(const char *path,int iters)
1202 sprintf(aname,"%s%s",path,"/a");
1203 sprintf(bname,"%s%s",path,"/b");
1205 memset(abuffer,'a',1000);
1206 memset(bbuffer,'b',1000);
1208 a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1209 b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1211 printf(" %s %d %s %d\n",aname,a,bname,b);
1215 for(j = 0; j < iters; j++)
1217 yaffs_lseek(a,0,SEEK_END);
1220 for(i = 0; i <20000; i++)
1222 //r = yaffs_lseek(b,i,SEEK_SET);
1223 //r = yaffs_write(b,bbuffer,1000);
1228 int syz = yaffs_lseek(a,0,SEEK_END);
1234 if(syz < 0) syz = 0;
1235 yaffs_ftruncate(a,syz);
1236 syz = yaffs_lseek(a,0,SEEK_END);
1237 printf("shrink to %d\n",syz);
1245 r = yaffs_lseek(a,-500,SEEK_END);
1246 r = yaffs_write(a,abuffer,1000);
1252 printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
1260 int directory_rename_test(void)
1265 yaffs_mount("/ram");
1266 yaffs_mkdir("/ram/a",0);
1267 yaffs_mkdir("/ram/a/b",0);
1268 yaffs_mkdir("/ram/c",0);
1270 printf("\nDirectory look-up of /ram\n");
1273 dumpDir("/ram/a/b");
1275 printf("Do rename (should fail)\n");
1277 r = yaffs_rename("/ram/a","/ram/a/b/d");
1278 printf("\nDirectory look-up of /ram\n");
1281 dumpDir("/ram/a/b");
1283 printf("Do rename (should not fail)\n");
1285 r = yaffs_rename("/ram/c","/ram/a/b/d");
1286 printf("\nDirectory look-up of /ram\n");
1289 dumpDir("/ram/a/b");
1296 int cache_read_test(void)
1300 int sizeOfFiles = 500000;
1305 yaffs_mount("/boot");
1307 make_a_file("/boot/a",'a',sizeOfFiles);
1308 make_a_file("/boot/b",'b',sizeOfFiles);
1310 a = yaffs_open("/boot/a",O_RDONLY,0);
1311 b = yaffs_open("/boot/b",O_RDONLY,0);
1312 c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
1316 if (i > 100) i = 100;
1318 yaffs_read(a,buffer,i);
1319 yaffs_read(b,buffer,i);
1320 yaffs_write(c,buffer,i);
1321 } while(sizeOfFiles > 0);
1329 int cache_bypass_bug_test(void)
1331 // This test reporoduces a bug whereby YAFFS caching *was* buypassed
1332 // resulting in erroneous reads after writes.
1333 // This bug has been fixed.
1339 memset(buffer1,0,sizeof(buffer1));
1340 memset(buffer2,0,sizeof(buffer2));
1344 yaffs_mount("/boot");
1346 // Create a file of 2000 bytes.
1347 make_a_file("/boot/a",'X',2000);
1349 a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
1351 // Write a short sequence to the file.
1352 // This will go into the cache.
1353 yaffs_lseek(a,0,SEEK_SET);
1354 yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
1356 // Read a short sequence from the file.
1357 // This will come from the cache.
1358 yaffs_lseek(a,0,SEEK_SET);
1359 yaffs_read(a,buffer1,30);
1361 // Read a page size sequence from the file.
1362 yaffs_lseek(a,0,SEEK_SET);
1363 yaffs_read(a,buffer2,512);
1365 printf("buffer 1 %s\n",buffer1);
1366 printf("buffer 2 %s\n",buffer2);
1368 if(strncmp(buffer1,buffer2,20))
1370 printf("Cache bypass bug detected!!!!!\n");
1378 int free_space_check(void)
1383 yaffs_mount("/boot");
1384 fill_disk("/boot/",2);
1385 f = yaffs_freespace("/boot");
1387 printf("%d free when disk full\n",f);
1391 int truncate_test(void)
1401 yaffs_mount("/boot");
1403 yaffs_unlink("/boot/trunctest");
1405 a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1407 yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
1409 yaffs_ftruncate(a,3);
1410 l= yaffs_lseek(a,0,SEEK_END);
1412 printf("truncated length is %d\n",l);
1414 yaffs_lseek(a,5,SEEK_SET);
1415 yaffs_write(a,"1",1);
1417 yaffs_lseek(a,0,SEEK_SET);
1419 r = yaffs_read(a,y,10);
1421 printf("read %d bytes:",r);
1423 for(i = 0; i < r; i++) printf("[%02X]",y[i]);
1435 void fill_disk_test(const char *mountpt)
1440 for(i = 0; i < 5; i++)
1442 yaffs_mount(mountpt);
1443 fill_disk_and_delete(mountpt,100,i+1);
1444 yaffs_unmount(mountpt);
1450 void fill_files_test(const char *mountpt)
1455 for(i = 0; i < 5; i++)
1457 yaffs_mount(mountpt);
1458 fill_files(mountpt,2,3,100);
1459 yaffs_unmount(mountpt);
1464 void fill_empty_files_test(const char *mountpt)
1473 for(i = 0; i < 5; i++)
1475 yaffs_mount(mountpt);
1476 for(d = 0; result >= 0 && d < 1000; d++){
1477 sprintf(name,"%s/%d",mountpt,d);
1478 result= yaffs_mkdir(name,0);
1479 printf("creating directory %s result %d\n",name,result);
1481 for(f = 0; result >= 0 && f < 100; f++){
1482 sprintf(name,"%s/%d/%d",mountpt,d,f);
1483 result= yaffs_open(name,O_CREAT, 0);
1484 yaffs_close(result);
1485 printf("creating file %s result %d\n",name,result);
1488 yaffs_unmount(mountpt);
1493 void long_name_test(const char *mountpt)
1497 char fullName[1000];
1503 // Make a 256 byte name
1504 memset(name,0,sizeof(name));
1505 for(i = 0; i < 256; i++)
1506 name[i] = '0' + i % 10;
1508 sprintf(fullName,"%s/%s",mountpt,name);
1510 for(i = 0; i < 1; i++)
1512 yaffs_mount(mountpt);
1514 printf("Files at start\n");
1517 printf("Creating file %s\n",fullName);
1519 f = yaffs_open(fullName,O_CREAT | O_RDWR,0);
1522 printf("Result %d\n",f);
1527 printf("Deleting %s\n",fullName);
1528 result = yaffs_unlink(fullName);
1529 printf("Result %d\n",result);
1535 yaffs_unmount(mountpt);
1541 void lookup_test(const char *mountpt)
1553 yaffs_mount(mountpt);
1555 d = yaffs_opendir(mountpt);
1559 printf("opendir failed\n");
1564 for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1566 printf("unlinking %s\n",de->d_name);
1567 yaffs_unlink(de->d_name);
1570 printf("%d files deleted\n",i);
1574 for(i = 0; i < 2000; i++){
1575 sprintf(a,"%s/%d",mountpt,i);
1576 h = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
1581 for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1583 printf("%d %s\n",i,de->d_name);
1586 printf("%d files listed\n\n\n",i);
1593 for(i = 0; i < 2000; i++){
1594 sprintf(a,"%s/%d",mountpt,i);
1599 yaffs_unmount(mountpt);
1603 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)
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_xattr_test(const char *mountpt)
2563 yaffs_mount(mountpt);
2565 strcpy(name,mountpt);
2567 strcat(name,"xfile");
2570 h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2576 printf("Add an attribute\n");
2578 result = yaffs_setxattr(name,"foo",&val1,sizeof(val1),0);
2579 printf("wrote attribute foo: result %d\n",result);
2581 printf("Add an attribute\n");
2583 result = yaffs_setxattr(name,"bar",&val1,sizeof(val1),0);
2584 printf("wrote attribute bar: result %d\n",result);
2587 printf("Get non-existanrt attribute\n");
2588 print_xattrib_val(name,"not here");
2590 printf("Delete non existing attribute\n");
2591 yaffs_removexattr(name,"not here");
2594 printf("Remove foo\n");
2595 yaffs_removexattr(name,"foo");
2598 printf("Remove bar\n");
2599 yaffs_removexattr(name,"bar");
2604 void big_xattr_test(const char *mountpt)
2614 yaffs_mount(mountpt);
2616 strcpy(name,mountpt);
2618 strcat(name,"xfile");
2621 h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2627 printf("Add a large attribute\n");
2628 memset(val,0x1,sizeof(val));
2629 result = yaffs_setxattr(name,"aaa",val,200,0);
2630 printf("wrote attribute aaa: result %d\n",result);
2633 printf("Add a large attribute\n");
2634 memset(val,0x2,sizeof(val));
2635 result = yaffs_setxattr(name,"bbb",val,1000,0);
2636 printf("wrote attribute bbb: result %d\n",result);
2639 printf("Replace attribute\n");
2640 memset(val,0x3,sizeof(val));
2641 result = yaffs_setxattr(name,"aaa",val,1000,0);
2642 printf("wrote attribute aaa: result %d\n",result);
2648 void dump_dev_stats(yaffs_Device *dev, const char * str)
2651 printf( "space free %d erased %d "
2652 "nand reads %d writes %d erases %d "
2653 "gc all %d passive %d oldestdirty %d blocks %d copies %d \n",
2654 dev->nFreeChunks, dev->nErasedBlocks * dev->param.nChunksPerBlock,
2655 dev->nPageReads, dev->nPageWrites, dev->nBlockErasures,
2656 dev->allGCs, dev->passiveGCs, dev->oldestDirtyGCs, dev->nGCBlocks, dev->nGCCopies);
2659 void test_flash_traffic(const char *mountpt)
2666 yaffs_traceMask = 0;
2670 yaffs_mount(mountpt);
2672 dev = yaffs_getdev(mountpt);
2674 strcpy(name0,mountpt);
2677 strcpy(name1,mountpt);
2680 dump_dev_stats(dev,"start");
2681 create_file_of_size(name0,32 * 1024 * 1024);
2682 dump_dev_stats(dev,"32MB written");
2683 for(i = 0; i < 20; i++)
2684 create_file_of_size(name1,1024 * 1024);
2685 dump_dev_stats(dev,"20x 1MB files written");
2690 int simulate_power_failure;
2692 int main(int argc, char *argv[])
2694 random_seed = time(NULL);
2695 //return long_test(argc,argv);
2697 //return cache_read_test();
2699 // resize_stress_test_no_grow("/flash/flash",20);
2700 //root_perm_remount("/flash/flash");
2702 //huge_directory_test_on_path("/ram2k");
2704 //yaffs_backward_scan_test("/flash/flash");
2705 // yaffs_device_flush_test("/flash/flash");
2707 //rename_over_test("//////////////////flash///////////////////yaffs1///////////");
2709 //fill_empty_files_test("/yaffs2/");
2710 //resize_stress_test("/yaffs2");
2711 //overwrite_test("/yaffs2");
2713 //long_name_test("/yaffs2");
2714 //link_test0("/yaffs2");
2715 //link_test1("yaffs2");
2716 //scan_pattern_test("/flash",10000,10);
2717 //short_scan_test("/flash/flash",40000,200);
2718 //small_mount_test("/flash/flash",1000);
2719 //small_overwrite_test("/flash/flash",1000);
2720 //seek_overwrite_test("/flash/flash",1000);
2721 //checkpoint_fill_test("/flash/flash",20);
2722 //checkpoint_upgrade_test("/flash/flash",20);
2723 //small_overwrite_test("/flash/flash",1000);
2724 //checkpoint_fill_test("/flash/flash",20);
2725 // random_small_file_test("/flash/flash",10000);
2726 // huge_array_test("/flash/flash",10);
2729 // handle_test("yaffs2/");
2731 //long_test_on_path("/ram2k");
2732 // long_test_on_path("/flash");
2733 //simple_rw_test("/flash/flash");
2734 //fill_disk_test("/flash/flash");
2735 // rename_over_test("/flash");
2736 //lookup_test("/flash");
2737 //freespace_test("/flash/flash");
2739 //link_test("/flash/flash");
2741 // cache_bypass_bug_test();
2743 //free_space_check();
2745 //check_resize_gc_bug("/flash");
2747 //basic_xattr_test("/yaffs2");
2748 //big_xattr_test("/yaffs2");
2750 //null_name_test("yaffs2");
2752 test_flash_traffic("yaffs2");