Added endianness support for YTIME_T
[yaffs2.git] / direct / test-framework / basic-tests / dtest.c
1 /*
2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
3  *
4  * Copyright (C) 2002-2018 Aleph One Ltd.
5  *
6  * Created by Charles Manning <charles@aleph1.co.uk>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13
14 #include <stdio.h>
15 #include <string.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <time.h>
19 #include <ctype.h>
20
21
22 #include "yaffsfs.h"
23
24 #include "yaffs_guts.h" /* Only for dumping device innards */
25 #include "yaffs_endian.h" /*For testing the swap_u64 macro */
26
27 extern int yaffs_trace_mask;
28
29 void dumpDir(const char *dname);
30
31 void copy_in_a_file(const char *yaffsName,const char *inName)
32 {
33         int inh,outh;
34         unsigned char buffer[100];
35         int ni,no;
36         inh = open(inName,O_RDONLY);
37         outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
38
39         while((ni = read(inh,buffer,100)) > 0)
40         {
41                 no = yaffs_write(outh,buffer,ni);
42                 if(ni != no)
43                 {
44                         printf("problem writing yaffs file\n");
45                 }
46
47         }
48
49         yaffs_close(outh);
50         close(inh);
51 }
52
53 void make_a_file(const char *yaffsName,char bval,int sizeOfFile)
54 {
55         int outh;
56         int i;
57         unsigned char buffer[100];
58
59         outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
60
61         memset(buffer,bval,100);
62
63         do{
64                 i = sizeOfFile;
65                 if(i > 100) i = 100;
66                 sizeOfFile -= i;
67
68                 yaffs_write(outh,buffer,i);
69
70         } while (sizeOfFile > 0);
71
72
73         yaffs_close(outh);
74
75 }
76
77 void make_pattern_file(char *fn,int size)
78 {
79         int outh;
80         int marker;
81         int i;
82         outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
83         yaffs_lseek(outh,size-1,SEEK_SET);
84         yaffs_write(outh,"A",1);
85
86         for(i = 0; i < size; i+=256)
87         {
88                 marker = ~i;
89                 yaffs_lseek(outh,i,SEEK_SET);
90                 yaffs_write(outh,&marker,sizeof(marker));
91         }
92         yaffs_close(outh);
93
94 }
95
96 int check_pattern_file(char *fn)
97 {
98         int h;
99         int marker;
100         int i;
101         int size;
102         int ok = 1;
103
104         h = yaffs_open(fn, O_RDWR,0);
105         size = yaffs_lseek(h,0,SEEK_END);
106
107         for(i = 0; i < size; i+=256)
108         {
109                 yaffs_lseek(h,i,SEEK_SET);
110                 yaffs_read(h,&marker,sizeof(marker));
111                 ok = (marker == ~i);
112                 if(!ok)
113                 {
114                    printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x\n",
115                                         fn,size,i,marker,~i);
116                 }
117         }
118         yaffs_close(h);
119         return ok;
120 }
121
122
123 int dump_file_data(char *fn)
124 {
125         int h;
126         int i = 0;
127         int ok = 1;
128         unsigned char b;
129
130         h = yaffs_open(fn, O_RDWR,0);
131
132
133         printf("%s\n",fn);
134         while(yaffs_read(h,&b,1)> 0)
135         {
136                 printf("%02x",b);
137                 i++;
138                 if(i > 32)
139                 {
140                    printf("\n");
141                    i = 0;;
142                  }
143         }
144         printf("\n");
145         yaffs_close(h);
146         return ok;
147 }
148
149
150
151 void dump_file(const char *fn)
152 {
153         int i;
154         int size;
155         int h;
156
157         h = yaffs_open(fn,O_RDONLY,0);
158         if(h < 0)
159         {
160                 printf("*****\nDump file %s does not exist\n",fn);
161         }
162         else
163         {
164                 size = yaffs_lseek(h,0,SEEK_SET);
165                 printf("*****\nDump file %s size %d\n",fn,size);
166                 for(i = 0; i < size; i++)
167                 {
168
169                 }
170         }
171 }
172
173 void create_file_of_size(const char *fn,int syze)
174 {
175         int h;
176         int n;
177         int result;
178         int iteration = 0;
179         char xx[200];
180
181         h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
182
183         while (syze > 0)
184         {
185                 sprintf(xx,"%s %8d",fn,iteration);
186                 n = strlen(xx);
187                 result = yaffs_write(h,xx,n);
188                 if(result != n){
189                         printf("Wrote %d, should have been %d. syze is %d\n",result,n,syze);
190                         syze = 0;
191                 } else
192                         syze-=n;
193                 iteration++;
194         }
195         yaffs_close (h);
196 }
197
198 void verify_file_of_size(const char *fn,int syze)
199 {
200         int h;
201         int result;
202
203         char xx[200];
204         char yy[200];
205         int l;
206
207         int iterations = (syze + strlen(fn) -1)/ strlen(fn);
208
209         h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
210
211         while (iterations > 0)
212         {
213                 sprintf(xx,"%s %8d",fn,iterations);
214                 l = strlen(xx);
215
216                 result = yaffs_read(h,yy,l);
217                 if (result)
218                         printf("result in line %d is %d", __LINE__, result);
219                 yy[l] = 0;
220
221                 if(strcmp(xx,yy)){
222                         printf("=====>>>>> verification of file %s failed near position %lld\n",fn,(long long)yaffs_lseek(h,0,SEEK_CUR));
223                 }
224                 iterations--;
225         }
226         yaffs_close (h);
227 }
228
229 void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2)
230 {
231         int h;
232
233         int iterations;
234
235         h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
236
237         iterations = (syze1 + strlen(fn) -1)/ strlen(fn);
238         while (iterations > 0)
239         {
240                 yaffs_write(h,fn,strlen(fn));
241                 iterations--;
242         }
243
244         yaffs_ftruncate(h,reSyze);
245
246         yaffs_lseek(h,0,SEEK_SET);
247         iterations = (syze2 + strlen(fn) -1)/ strlen(fn);
248         while (iterations > 0)
249         {
250                 yaffs_write(h,fn,strlen(fn));
251                 iterations--;
252         }
253
254         yaffs_close (h);
255 }
256
257
258 void do_some_file_stuff(const char *path)
259 {
260
261         char fn[100];
262
263         sprintf(fn,"%s/%s",path,"f1");
264         create_file_of_size(fn,10000);
265
266         sprintf(fn,"%s/%s",path,"fdel");
267         create_file_of_size(fn,10000);
268         yaffs_unlink(fn);
269
270         sprintf(fn,"%s/%s",path,"f2");
271
272         create_resized_file_of_size(fn,10000,3000,4000);
273 }
274
275 void yaffs_backward_scan_test(const char *path)
276 {
277         char fn[100];
278
279         yaffs_start_up();
280
281         yaffs_mount(path);
282
283         do_some_file_stuff(path);
284
285         sprintf(fn,"%s/ddd",path);
286
287         yaffs_mkdir(fn,0);
288
289         do_some_file_stuff(fn);
290
291         yaffs_unmount(path);
292
293         yaffs_mount(path);
294 }
295
296 void null_name_test(const char *path)
297 {
298         char fn[100];
299         int h;
300         yaffs_start_up();
301
302         yaffs_mount(path);
303
304         sprintf(fn,"%s",path);
305
306         h = yaffs_open(fn,O_CREAT| O_TRUNC| O_RDWR, 0666);
307
308         printf("%d\n",h);
309
310 }
311
312 char xxzz[2000];
313
314
315 void yaffs_device_flush_test(const char *path)
316 {
317         char fn[100];
318         int h;
319         int i;
320
321         yaffs_start_up();
322
323         yaffs_mount(path);
324
325         do_some_file_stuff(path);
326
327         // Open and add some data to a few files
328         for(i = 0; i < 10; i++) {
329
330                 sprintf(fn,"%s/ff%d",path,i);
331
332                 h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD);
333                 yaffs_write(h,xxzz,2000);
334                 yaffs_write(h,xxzz,2000);
335         }
336         yaffs_unmount(path);
337
338         yaffs_mount(path);
339 }
340
341
342
343 void short_scan_test(const char *path, int fsize, int niterations)
344 {
345         int i;
346         char fn[100];
347
348         sprintf(fn,"%s/%s",path,"f1");
349
350         yaffs_start_up();
351         for(i = 0; i < niterations; i++)
352         {
353                 printf("\n*****************\nIteration %d\n",i);
354                 yaffs_mount(path);
355                 printf("\nmount: Directory look-up of %s\n",path);
356                 dumpDir(path);
357                 make_a_file(fn,1,fsize);
358                 yaffs_unmount(path);
359         }
360 }
361
362
363
364 void scan_pattern_test(const char *path, int fsize, int niterations)
365 {
366         int i;
367         int j;
368         char fn[3][100];
369         int result;
370
371         sprintf(fn[0],"%s/%s",path,"f0");
372         sprintf(fn[1],"%s/%s",path,"f1");
373         sprintf(fn[2],"%s/%s",path,"f2");
374
375         yaffs_start_up();
376
377         for(i = 0; i < niterations; i++)
378         {
379                 printf("\n*****************\nIteration %d\n",i);
380                 yaffs_mount(path);
381                 printf("\nmount: Directory look-up of %s\n",path);
382                 dumpDir(path);
383                 for(j = 0; j < 3; j++)
384                 {
385                         result = dump_file_data(fn[j]);
386                         result = check_pattern_file(fn[j]);
387                         make_pattern_file(fn[j],fsize);
388                         result = dump_file_data(fn[j]);
389                         result = check_pattern_file(fn[j]);
390                         if (result)
391                                 printf("result in line %d is %d", __LINE__, result);
392                 }
393                 yaffs_unmount(path);
394         }
395 }
396
397 void fill_disk(const char *path,int nfiles)
398 {
399         int h;
400         int n;
401         int result;
402         int f =0;
403
404         static char xx[600];
405         char str[50];
406
407         for(n = 0; n < nfiles; n++)
408         {
409                 sprintf(str,"%s/%d",path,n);
410
411                 h = yaffs_open(str, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
412
413                 printf("writing file %s handle %d ",str, h);
414
415                 while ((result = yaffs_write(h,xx,600)) == 600)
416                 {
417                         f = yaffs_freespace(path);
418                 }
419                 printf("last freespace was %d\n", f);
420                 result = yaffs_close(h);
421                 printf(" close %d\n", result);
422         }
423 }
424
425 void fill_disk_and_delete(const char *path, int nfiles, int ncycles)
426 {
427         int i,j;
428         char str[50];
429         int result;
430
431         for(i = 0; i < ncycles; i++)
432         {
433                 printf("@@@@@@@@@@@@@@ cycle %d\n",i);
434                 fill_disk(path,nfiles);
435
436                 for(j = 0; j < nfiles; j++)
437                 {
438                         sprintf(str,"%s/%d",path,j);
439                         result = yaffs_unlink(str);
440                         printf("unlinking file %s, result %d\n", str, result);
441                 }
442         }
443 }
444
445
446 void fill_files(const char *path,int flags, int maxIterations,int siz)
447 {
448         int i;
449         int j;
450         char str[50];
451         int h;
452
453         i = 0;
454
455         do{
456                 sprintf(str,"%s/%d",path,i);
457                 h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
458
459                 if(h >= 0)
460                 {
461                         for(j = 0; j < siz; j++)
462                         {
463                                 yaffs_write(h,str,1);
464                         }
465                 }
466
467                 if( flags & 1)
468                 {
469                         yaffs_unlink(str);
470                 }
471                 i++;
472         } while(h >= 0 && i < maxIterations);
473
474         if(flags & 2)
475         {
476                 i = 0;
477                 do{
478                         sprintf(str,"%s/%d",path,i);
479                         printf("unlink %s\n",str);
480                         i++;
481                 } while(yaffs_unlink(str) >= 0);
482         }
483 }
484
485 void leave_unlinked_file(const char *path,int maxIterations,int siz)
486 {
487         int i;
488         char str[50];
489         int h;
490
491         i = 0;
492
493         do{
494                 sprintf(str,"%s/%d",path,i);
495                 printf("create %s\n",str);
496                 h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
497                 if(h >= 0)
498                 {
499                         yaffs_unlink(str);
500                 }
501                 i++;
502         } while(h < 0 && i < maxIterations);
503
504         if(h >= 0)
505         {
506                 for(i = 0; i < siz; i++)
507                 {
508                         yaffs_write(h,str,1);
509                 }
510         }
511
512         printf("Leaving file %s open\n",str);
513
514 }
515
516 void dumpDirFollow(const char *dname)
517 {
518         yaffs_DIR *d;
519         struct yaffs_dirent *de;
520         struct yaffs_stat s;
521         char str[300];
522
523         d = yaffs_opendir(dname);
524
525         if(!d)
526         {
527                 printf("opendir failed\n");
528         }
529         else
530         {
531                 while((de = yaffs_readdir(d)) != NULL)
532                 {
533                         sprintf(str,"%s/%s",dname,de->d_name);
534
535                         yaffs_lstat(str,&s);
536
537                         printf("%s ino %d length %d mode %X ",
538                                 de->d_name, (int)s.st_ino, (int)s.st_size, s.st_mode);
539                         switch(s.st_mode & S_IFMT)
540                         {
541                                 case S_IFREG: printf("data file"); break;
542                                 case S_IFDIR: printf("directory"); break;
543                                 case S_IFLNK: printf("symlink -->");
544                                                           if(yaffs_readlink(str,str,100) < 0)
545                                                                 printf("no alias");
546                                                           else
547                                                                 printf("\"%s\"",str);
548                                                           break;
549                                 default: printf("unknown"); break;
550                         }
551
552                         printf("\n");
553                 }
554
555                 yaffs_closedir(d);
556         }
557         printf("\n");
558
559         printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
560
561 }
562
563
564 void dump_directory_tree_worker(const char *dname,int recursive)
565 {
566         yaffs_DIR *d;
567         struct yaffs_dirent *de;
568         struct yaffs_stat s;
569         char str[1000];
570
571         d = yaffs_opendir(dname);
572
573         if(!d)
574         {
575                 printf("opendir failed\n");
576         }
577         else
578         {
579                 while((de = yaffs_readdir(d)) != NULL)
580                 {
581                         sprintf(str,"%s/%s",dname,de->d_name);
582
583                         yaffs_lstat(str,&s);
584
585                         printf("%s inode %d length %d mode %X ",
586                                 str, s.st_ino, (int)s.st_size, s.st_mode);
587                         switch(s.st_mode & S_IFMT)
588                         {
589                                 case S_IFREG: printf("data file"); break;
590                                 case S_IFDIR: printf("directory"); break;
591                                 case S_IFLNK: printf("symlink -->");
592                                                           if(yaffs_readlink(str,str,100) < 0)
593                                                                 printf("no alias");
594                                                           else
595                                                                 printf("\"%s\"",str);
596                                                           break;
597                                 default: printf("unknown"); break;
598                         }
599
600                         printf("\n");
601
602                         if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
603                                 dump_directory_tree_worker(str,1);
604
605                 }
606
607                 yaffs_closedir(d);
608         }
609
610 }
611
612 static void dump_directory_tree(const char *dname)
613 {
614         dump_directory_tree_worker(dname,1);
615         printf("\n");
616         printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
617 }
618
619 void dump_directory_tree_worker_fd(const char *dname,int recursive)
620 {
621         int h;
622         struct yaffs_dirent *de;
623         struct yaffs_stat s;
624         char str[1000];
625
626         h = yaffs_open(dname, O_RDONLY, 0);
627
628         if(h < 0)
629         {
630                 printf("open of dir failed\n");
631         }
632         else
633         {
634                 printf("using fd %d\n", h);
635
636                 while((de = yaffs_readdir_fd(h)) != NULL)
637                 {
638                         sprintf(str,"%s/%s",dname,de->d_name);
639
640                         yaffs_lstat(str,&s);
641
642                         printf("%s inode %d length %d mode %X ",
643                                 str,s.st_ino, (int)s.st_size, s.st_mode);
644                         switch(s.st_mode & S_IFMT)
645                         {
646                                 case S_IFREG: printf("data file"); break;
647                                 case S_IFDIR: printf("directory"); break;
648                                 case S_IFLNK: printf("symlink -->");
649                                                           if(yaffs_readlink(str,str,100) < 0)
650                                                                 printf("no alias");
651                                                           else
652                                                                 printf("\"%s\"",str);
653                                                           break;
654                                 default: printf("unknown"); break;
655                         }
656
657                         printf("\n");
658
659                         if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
660                                 dump_directory_tree_worker_fd(str,1);
661
662                 }
663
664                 yaffs_close(h);
665         }
666
667 }
668
669 static void dump_directory_tree_fd(const char *dname)
670 {
671         dump_directory_tree_worker_fd(dname,1);
672         printf("\n");
673         printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
674 }
675
676 void dumpDir(const char *dname)
677 {       dump_directory_tree_worker(dname,0);
678         printf("\n");
679         printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
680 }
681
682
683 static void PermissionsCheck(const char *path, mode_t tmode, int tflags,int expectedResult)
684 {
685         int fd;
686
687         if(yaffs_chmod(path,tmode)< 0) printf("chmod failed\n");
688
689         fd = yaffs_open(path,tflags,0);
690
691         if((fd >= 0) != (expectedResult > 0))
692         {
693                 printf("Permissions check %x %x %d failed\n",tmode,tflags,expectedResult);
694         }
695         else
696         {
697                 printf("Permissions check %x %x %d OK\n",tmode,tflags,expectedResult);
698         }
699
700
701         yaffs_close(fd);
702
703
704 }
705
706 int long_test(int argc, char *argv[])
707 {
708
709         int f;
710         int r;
711         char buffer[20];
712
713         char str[100];
714
715         int h;
716         mode_t temp_mode;
717         struct yaffs_stat ystat;
718
719         (void) argc;
720         (void) argv;
721
722         yaffs_start_up();
723
724         yaffs_mount("/boot");
725         yaffs_mount("/data");
726         yaffs_mount("/flash");
727         yaffs_mount("/ram");
728
729         printf("\nDirectory look-up of /boot\n");
730         dumpDir("/boot");
731         printf("\nDirectory look-up of /data\n");
732         dumpDir("/data");
733         printf("\nDirectory look-up of /flash\n");
734         dumpDir("/flash");
735
736         //leave_unlinked_file("/flash",20000,0);
737         //leave_unlinked_file("/data",20000,0);
738
739         leave_unlinked_file("/ram",20,0);
740
741
742         f = yaffs_open("/boot/b1", O_RDONLY,0);
743
744         printf("open /boot/b1 readonly, f=%d\n",f);
745
746         f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
747
748         printf("open /boot/b1 O_CREAT, f=%d\n",f);
749
750
751         r = yaffs_write(f,"hello",1);
752         printf("write %d attempted to write to a read-only file\n",r);
753
754         r = yaffs_close(f);
755
756         printf("close %d\n",r);
757
758         f = yaffs_open("/boot/b1", O_RDWR,0);
759
760         printf("open /boot/b1 O_RDWR,f=%d\n",f);
761
762
763         r = yaffs_write(f,"hello",2);
764         printf("write %d attempted to write to a writeable file\n",r);
765         r = yaffs_write(f,"world",3);
766         printf("write %d attempted to write to a writeable file\n",r);
767
768         r= yaffs_lseek(f,0,SEEK_END);
769         printf("seek end %d\n",r);
770         memset(buffer,0,20);
771         r = yaffs_read(f,buffer,10);
772         printf("read %d \"%s\"\n",r,buffer);
773         r= yaffs_lseek(f,0,SEEK_SET);
774         printf("seek set %d\n",r);
775         memset(buffer,0,20);
776         r = yaffs_read(f,buffer,10);
777         printf("read %d \"%s\"\n",r,buffer);
778         memset(buffer,0,20);
779         r = yaffs_read(f,buffer,10);
780         printf("read %d \"%s\"\n",r,buffer);
781
782         // Check values reading at end.
783         // A read past end of file should return 0 for 0 bytes read.
784
785         r= yaffs_lseek(f,0,SEEK_END);
786         r = yaffs_read(f,buffer,10);
787         printf("read at end returned  %d\n",r);
788         r= yaffs_lseek(f,500,SEEK_END);
789         r = yaffs_read(f,buffer,10);
790         printf("read past end returned  %d\n",r);
791
792         r = yaffs_close(f);
793
794         printf("close %d\n",r);
795
796         copy_in_a_file("/boot/yyfile","xxx");
797
798         // Create a file with a long name
799
800         copy_in_a_file("/boot/file with a long name","xxx");
801
802
803         printf("\nDirectory look-up of /boot\n");
804         dumpDir("/boot");
805
806         // Check stat
807         r = yaffs_lstat("/boot/file with a long name",&ystat);
808
809         // Check rename
810
811         r = yaffs_rename("/boot/file with a long name","/boot/r1");
812
813         printf("\nDirectory look-up of /boot\n");
814         dumpDir("/boot");
815
816         // Check unlink
817         r = yaffs_unlink("/boot/r1");
818
819         printf("\nDirectory look-up of /boot\n");
820         dumpDir("/boot");
821
822         // Check mkdir
823
824         r = yaffs_mkdir("/boot/directory1",0);
825
826         printf("\nDirectory look-up of /boot\n");
827         dumpDir("/boot");
828         printf("\nDirectory look-up of /boot/directory1\n");
829         dumpDir("/boot/directory1");
830
831         // add a file to the directory
832         copy_in_a_file("/boot/directory1/file with a long name","xxx");
833
834         printf("\nDirectory look-up of /boot\n");
835         dumpDir("/boot");
836         printf("\nDirectory look-up of /boot/directory1\n");
837         dumpDir("/boot/directory1");
838
839         //  Attempt to delete directory (should fail)
840
841         r = yaffs_rmdir("/boot/directory1");
842
843         printf("\nDirectory look-up of /boot\n");
844         dumpDir("/boot");
845         printf("\nDirectory look-up of /boot/directory1\n");
846         dumpDir("/boot/directory1");
847
848         // Delete file first, then rmdir should work
849         r = yaffs_unlink("/boot/directory1/file with a long name");
850         r = yaffs_rmdir("/boot/directory1");
851
852
853         printf("\nDirectory look-up of /boot\n");
854         dumpDir("/boot");
855         printf("\nDirectory look-up of /boot/directory1\n");
856         dumpDir("/boot/directory1");
857
858 #if 0
859         fill_disk_and_delete("/boot",20,20);
860
861         printf("\nDirectory look-up of /boot\n");
862         dumpDir("/boot");
863 #endif
864
865         yaffs_symlink("yyfile","/boot/slink");
866
867         yaffs_readlink("/boot/slink",str,100);
868         printf("symlink alias is %s\n",str);
869
870
871
872
873         printf("\nDirectory look-up of /boot\n");
874         dumpDir("/boot");
875         printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
876         dumpDirFollow("/boot");
877         printf("\nDirectory look-up of /boot/directory1\n");
878         dumpDir("/boot/directory1");
879
880         h = yaffs_open("/boot/slink",O_RDWR,0);
881
882         printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
883
884         yaffs_close(h);
885
886         yaffs_unlink("/boot/slink");
887
888
889         printf("\nDirectory look-up of /boot\n");
890         dumpDir("/boot");
891
892         // Check chmod
893
894         yaffs_lstat("/boot/yyfile",&ystat);
895         temp_mode = ystat.st_mode;
896
897         yaffs_chmod("/boot/yyfile",0x55555);
898         printf("\nDirectory look-up of /boot\n");
899         dumpDir("/boot");
900
901         yaffs_chmod("/boot/yyfile",temp_mode);
902         printf("\nDirectory look-up of /boot\n");
903         dumpDir("/boot");
904
905         // Permission checks...
906         PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
907         PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
908         PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
909
910         PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
911         PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
912         PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
913
914         PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
915         PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
916         PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
917
918         PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
919         PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
920         PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
921
922         yaffs_chmod("/boot/yyfile",temp_mode);
923
924         //create a zero-length file and unlink it (test for scan bug)
925
926         h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
927         yaffs_close(h);
928
929         yaffs_unlink("/boot/zlf");
930
931
932         yaffs_dump_dev("/boot");
933
934         fill_disk_and_delete("/boot",20,20);
935
936         yaffs_dump_dev("/boot");
937
938         fill_files("/boot",1,10000,0);
939         fill_files("/boot",1,10000,5000);
940         fill_files("/boot",2,10000,0);
941         fill_files("/boot",2,10000,5000);
942
943         leave_unlinked_file("/data",20000,0);
944         leave_unlinked_file("/data",20000,5000);
945         leave_unlinked_file("/data",20000,5000);
946         leave_unlinked_file("/data",20000,5000);
947         leave_unlinked_file("/data",20000,5000);
948         leave_unlinked_file("/data",20000,5000);
949
950         yaffs_dump_dev("/boot");
951         yaffs_dump_dev("/data");
952
953
954
955         return 0;
956
957 }
958
959 int huge_directory_test_on_path(char *path)
960 {
961
962         yaffs_DIR *d;
963         struct yaffs_dirent *de;
964         struct yaffs_stat s;
965
966         int f;
967         int i;
968
969         int total = 0;
970         int lastTotal = 0;
971
972         char str[300];
973
974
975         yaffs_start_up();
976
977         yaffs_mount(path);
978
979         // Create a large number of files
980
981         for(i = 0; i < 2000; i++)
982         {
983           sprintf(str,"%s/%d",path,i);
984
985            f = yaffs_open(str,O_CREAT,S_IREAD | S_IWRITE);
986            yaffs_close(f);
987         }
988
989
990
991         d = yaffs_opendir(path);
992         i = 0;
993         if (d) {
994         while((de = yaffs_readdir(d)) != NULL) {
995         if (total >lastTotal+100*9*1024||(i & 1023)==0){
996         printf("files = %d, total = %d\n",i, total);
997         lastTotal = total;
998         }
999                 i++;
1000                 sprintf(str,"%s/%s",path,de->d_name);
1001                 yaffs_lstat(str,&s);
1002                 switch(s.st_mode & S_IFMT){
1003                 case S_IFREG:
1004         //printf("data file");
1005         total += s.st_size;
1006         break;
1007         }
1008         }
1009
1010         yaffs_closedir(d);
1011         }
1012
1013         return 0;
1014 }
1015
1016 int yaffs_scan_test(const char *path)
1017 {
1018         (void) path;
1019
1020         return 0;
1021 }
1022
1023
1024 void rename_over_test(const char *mountpt)
1025 {
1026         int i;
1027         char a[100];
1028         char b[100];
1029         char c[100];
1030
1031         sprintf(a,"%s/a",mountpt);
1032         sprintf(b,"%s/b",mountpt);
1033         sprintf(c,"%s/c",mountpt);
1034
1035         yaffs_start_up();
1036
1037         yaffs_mount(mountpt);
1038
1039         printf("Existing files\n");
1040         dumpDirFollow(mountpt);
1041
1042
1043
1044         i = yaffs_open(c,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1045         printf("File c handle is %d\n",i);
1046         yaffs_close(i);
1047         i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);
1048         yaffs_close(i);
1049         i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);
1050         yaffs_close(i);
1051         yaffs_rename(a,b); // rename over
1052         yaffs_rename(b,a); // rename back again (not renaimng over)
1053         yaffs_rename(a,b); // rename back again (not renaimng over)
1054
1055
1056         yaffs_unmount(mountpt);
1057
1058 }
1059
1060
1061 int resize_stress_test(const char *path)
1062 {
1063    int a,b,i,j;
1064    int x;
1065    int r;
1066    char aname[100];
1067    char bname[100];
1068
1069    char abuffer[1000];
1070    char bbuffer[1000];
1071
1072    yaffs_start_up();
1073
1074    yaffs_mount(path);
1075
1076    sprintf(aname,"%s%s",path,"/a");
1077    sprintf(bname,"%s%s",path,"/b");
1078
1079    memset(abuffer,'a',1000);
1080    memset(bbuffer,'b',1000);
1081
1082    a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1083    b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1084
1085    printf(" %s %d %s %d\n",aname,a,bname,b);
1086
1087    x = 0;
1088
1089    for(j = 0; j < 100; j++)
1090    {
1091                 yaffs_lseek(a,0,SEEK_END);
1092
1093
1094                 for(i = 0; i <20000; i++)
1095                 {
1096                    //r =        yaffs_lseek(b,i,SEEK_SET);
1097                         //r = yaffs_write(b,bbuffer,1000);
1098
1099                         if(x & 0x16)
1100                         {
1101                                 // shrink
1102                                 int syz = yaffs_lseek(a,0,SEEK_END);
1103
1104                                 syz -= 500;
1105                                 if(syz < 0) syz = 0;
1106                                 yaffs_ftruncate(a,syz);
1107
1108                         }
1109                         else
1110                         {
1111                                 //expand
1112                                 r = yaffs_lseek(a,i * 500,SEEK_SET);
1113                                 if (r < 0)
1114                                         printf("At line %d, r is %d\n", __LINE__, r);
1115                                 r = yaffs_write(a,abuffer,1000);
1116                                 if (r < 0)
1117                                         printf("At line %d, r is %d\n", __LINE__, r);
1118                         }
1119                         x++;
1120
1121                 }
1122    }
1123
1124    return 0;
1125
1126 }
1127
1128
1129 int overwrite_test(const char *path)
1130 {
1131    char aname[100];
1132    char bname[100];
1133    int i;
1134    int j;
1135    int a;
1136    int b;
1137    yaffs_start_up();
1138
1139    yaffs_mount(path);
1140
1141    sprintf(aname,"%s%s",path,"/a");
1142    sprintf(bname,"%s%s",path,"/b");
1143
1144    b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1145    for(j= 0; j < 500; j++){
1146         yaffs_write(b,bname,100);
1147         a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1148         for(i = 0; i < rand() % 20000; i++)
1149                 yaffs_write(a,&a,sizeof(a));
1150         yaffs_close(a);
1151    }
1152
1153    return 0;
1154
1155 }
1156
1157
1158 int root_perm_remount(const char *path)
1159 {
1160    struct yaffs_stat s;
1161
1162    yaffs_start_up();
1163
1164    yaffs_mount(path);
1165
1166    yaffs_lstat(path,&s);
1167    printf("root perms after mount %x\n",s.st_mode);
1168
1169    yaffs_chmod(path, 0777);
1170
1171    yaffs_lstat(path,&s);
1172    printf("root perms after setting to 0777 is  %x\n",s.st_mode);
1173
1174    yaffs_unmount(path);
1175
1176    return 0;
1177
1178 }
1179
1180
1181 int resize_stress_test_no_grow_complex(const char *path,int iters)
1182 {
1183    int a,b,i,j;
1184    int x;
1185    int r;
1186    char aname[100];
1187    char bname[100];
1188
1189    char abuffer[1000];
1190    char bbuffer[1000];
1191
1192
1193    yaffs_start_up();
1194
1195    yaffs_mount(path);
1196
1197    sprintf(aname,"%s%s",path,"/a");
1198    sprintf(bname,"%s%s",path,"/b");
1199
1200    memset(abuffer,'a',1000);
1201    memset(bbuffer,'b',1000);
1202
1203    a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1204    b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1205
1206    printf(" %s %d %s %d\n",aname,a,bname,b);
1207
1208    x = 0;
1209
1210    for(j = 0; j < iters; j++)
1211    {
1212                 yaffs_lseek(a,0,SEEK_END);
1213
1214
1215                 for(i = 0; i <20000; i++)
1216                 {
1217                    //r =        yaffs_lseek(b,i,SEEK_SET);
1218                         //r = yaffs_write(b,bbuffer,1000);
1219
1220                         if(!(x%20))
1221                         {
1222                                 // shrink
1223                                 int syz = yaffs_lseek(a,0,SEEK_END);
1224
1225                                 while(syz > 4000)
1226                                 {
1227
1228                                         syz -= 2050;
1229                                         if(syz < 0) syz = 0;
1230                                         yaffs_ftruncate(a,syz);
1231                                         syz = yaffs_lseek(a,0,SEEK_END);
1232                                         printf("shrink to %d\n",syz);
1233                                 }
1234
1235
1236                         }
1237                         else
1238                         {
1239                                 //expand
1240                                 r = yaffs_lseek(a,500,SEEK_END);
1241                                 r = yaffs_write(a,abuffer,1000);
1242                                 if (r < 0)
1243                                         printf("At line %d, r is %d\n", __LINE__, r);
1244                         }
1245                         x++;
1246
1247
1248                 }
1249
1250                 printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
1251
1252    }
1253
1254    return 0;
1255
1256 }
1257
1258 int resize_stress_test_no_grow(const char *path,int iters)
1259 {
1260    int a,b,i,j;
1261    int x;
1262    int r;
1263    char aname[100];
1264    char bname[100];
1265
1266    char abuffer[1000];
1267    char bbuffer[1000];
1268
1269    yaffs_start_up();
1270
1271    yaffs_mount(path);
1272
1273    sprintf(aname,"%s%s",path,"/a");
1274    sprintf(bname,"%s%s",path,"/b");
1275
1276    memset(abuffer,'a',1000);
1277    memset(bbuffer,'b',1000);
1278
1279    a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1280    b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1281
1282    printf(" %s %d %s %d\n",aname,a,bname,b);
1283
1284    x = 0;
1285
1286    for(j = 0; j < iters; j++)
1287    {
1288                 yaffs_lseek(a,0,SEEK_END);
1289
1290
1291                 for(i = 0; i <20000; i++)
1292                 {
1293                    //r =        yaffs_lseek(b,i,SEEK_SET);
1294                         //r = yaffs_write(b,bbuffer,1000);
1295
1296                         if(!(x%20))
1297                         {
1298                                 // shrink
1299                                 int syz = yaffs_lseek(a,0,SEEK_END);
1300
1301                                 while(syz > 4000)
1302                                 {
1303
1304                                         syz -= 2050;
1305                                         if(syz < 0) syz = 0;
1306                                         yaffs_ftruncate(a,syz);
1307                                         syz = yaffs_lseek(a,0,SEEK_END);
1308                                         printf("shrink to %d\n",syz);
1309                                 }
1310
1311
1312                         }
1313                         else
1314                         {
1315                                 //expand
1316                                 r = yaffs_lseek(a,-500,SEEK_END);
1317                                 r = yaffs_write(a,abuffer,1000);
1318                                 if (r < 0)
1319                                         printf("At line %d, r is %d\n", __LINE__, r);
1320                         }
1321                         x++;
1322
1323
1324                 }
1325                 printf("file size is %lld\n",(long long)yaffs_lseek(a,0,SEEK_END));
1326
1327    }
1328
1329    return 0;
1330
1331 }
1332
1333 int directory_rename_test(void)
1334 {
1335         int r;
1336         yaffs_start_up();
1337
1338         yaffs_mount("/ram");
1339         yaffs_mkdir("/ram/a",0);
1340         yaffs_mkdir("/ram/a/b",0);
1341         yaffs_mkdir("/ram/c",0);
1342
1343         printf("\nDirectory look-up of /ram\n");
1344         dumpDir("/ram");
1345         dumpDir("/ram/a");
1346         dumpDir("/ram/a/b");
1347
1348         printf("Do rename (should fail)\n");
1349
1350         r = yaffs_rename("/ram/a","/ram/a/b/d");
1351         if (r < 0)
1352                 printf("At line %d, r is %d\n", __LINE__, r);
1353
1354         printf("\nDirectory look-up of /ram\n");
1355         dumpDir("/ram");
1356         dumpDir("/ram/a");
1357         dumpDir("/ram/a/b");
1358
1359         printf("Do rename (should not fail)\n");
1360
1361         r = yaffs_rename("/ram/c","/ram/a/b/d");
1362         printf("\nDirectory look-up of /ram\n");
1363         dumpDir("/ram");
1364         dumpDir("/ram/a");
1365         dumpDir("/ram/a/b");
1366
1367
1368         return 1;
1369
1370 }
1371
1372 int cache_read_test(void)
1373 {
1374         int a,b,c;
1375         int i;
1376         int sizeOfFiles = 500000;
1377         char buffer[100];
1378
1379         yaffs_start_up();
1380
1381         yaffs_mount("/boot");
1382
1383         make_a_file("/boot/a",'a',sizeOfFiles);
1384         make_a_file("/boot/b",'b',sizeOfFiles);
1385
1386         a = yaffs_open("/boot/a",O_RDONLY,0);
1387         b = yaffs_open("/boot/b",O_RDONLY,0);
1388         c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
1389
1390         do{
1391                 i = sizeOfFiles;
1392                 if (i > 100) i = 100;
1393                 sizeOfFiles  -= i;
1394                 yaffs_read(a,buffer,i);
1395                 yaffs_read(b,buffer,i);
1396                 yaffs_write(c,buffer,i);
1397         } while(sizeOfFiles > 0);
1398
1399
1400
1401         return 1;
1402
1403 }
1404
1405 int cache_bypass_bug_test(void)
1406 {
1407         // This test reporoduces a bug whereby YAFFS caching *was* buypassed
1408         // resulting in erroneous reads after writes.
1409         // This bug has been fixed.
1410
1411         int a;
1412         char buffer1[1000];
1413         char buffer2[1000];
1414
1415         memset(buffer1,0,sizeof(buffer1));
1416         memset(buffer2,0,sizeof(buffer2));
1417
1418         yaffs_start_up();
1419
1420         yaffs_mount("/boot");
1421
1422         // Create a file of 2000 bytes.
1423         make_a_file("/boot/a",'X',2000);
1424
1425         a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
1426
1427         // Write a short sequence to the file.
1428         // This will go into the cache.
1429         yaffs_lseek(a,0,SEEK_SET);
1430         yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
1431
1432         // Read a short sequence from the file.
1433         // This will come from the cache.
1434         yaffs_lseek(a,0,SEEK_SET);
1435         yaffs_read(a,buffer1,30);
1436
1437         // Read a page size sequence from the file.
1438         yaffs_lseek(a,0,SEEK_SET);
1439         yaffs_read(a,buffer2,512);
1440
1441         printf("buffer 1 %s\n",buffer1);
1442         printf("buffer 2 %s\n",buffer2);
1443
1444         if(strncmp(buffer1,buffer2,20))
1445         {
1446                 printf("Cache bypass bug detected!!!!!\n");
1447         }
1448
1449
1450         return 1;
1451 }
1452
1453
1454 int free_space_check(void)
1455 {
1456         int f;
1457
1458         yaffs_start_up();
1459         yaffs_mount("/boot");
1460         fill_disk("/boot/",2);
1461         f = yaffs_freespace("/boot");
1462
1463         printf("%d free when disk full\n",f);
1464         return 1;
1465 }
1466
1467 int truncate_test(void)
1468 {
1469         int a;
1470         int r;
1471         int i;
1472         int l;
1473
1474         char y[10];
1475
1476         yaffs_start_up();
1477         yaffs_mount("/boot");
1478
1479         yaffs_unlink("/boot/trunctest");
1480
1481         a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);
1482
1483         yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
1484
1485         yaffs_ftruncate(a,3);
1486         l= yaffs_lseek(a,0,SEEK_END);
1487
1488         printf("truncated length is %d\n",l);
1489
1490         yaffs_lseek(a,5,SEEK_SET);
1491         yaffs_write(a,"1",1);
1492
1493         yaffs_lseek(a,0,SEEK_SET);
1494
1495         r = yaffs_read(a,y,10);
1496
1497         printf("read %d bytes:", r);
1498
1499         for(i = 0; i < r; i++) printf("[%02X]",y[i]);
1500
1501         printf("\n");
1502
1503         return 0;
1504
1505 }
1506
1507
1508
1509
1510
1511 void fill_disk_test(const char *mountpt)
1512 {
1513         int i;
1514         yaffs_start_up();
1515
1516         for(i = 0; i < 5; i++)
1517         {
1518                 yaffs_mount(mountpt);
1519                 fill_disk_and_delete(mountpt,100,i+1);
1520                 yaffs_unmount(mountpt);
1521         }
1522
1523 }
1524
1525
1526 void fill_n_file_test(const char *mountpt, int n, int syz)
1527 {
1528         int i;
1529         int l;
1530
1531         yaffs_start_up();
1532
1533         yaffs_format(mountpt, 0, 0, 0);
1534         yaffs_mount(mountpt);
1535
1536
1537         for(i = 0; i < n; i++)
1538         {
1539                 int h;
1540                 char fname[200];
1541
1542                 sprintf(fname, "%s/%d", mountpt, i);
1543
1544                 h = yaffs_open(fname, O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);
1545
1546                 l = syz;
1547
1548                 while(l > 0) {
1549                         yaffs_write(h, fname, sizeof(fname));
1550                         l -= sizeof(fname);
1551                 }
1552
1553                 yaffs_close(h);
1554
1555         }
1556
1557 }
1558
1559
1560 void fill_files_test(const char *mountpt)
1561 {
1562         int i;
1563         yaffs_start_up();
1564
1565         for(i = 0; i < 5; i++)
1566         {
1567                 yaffs_mount(mountpt);
1568                 fill_files(mountpt,2,3,100);
1569                 yaffs_unmount(mountpt);
1570         }
1571
1572 }
1573
1574 void fill_empty_files_test(const char *mountpt)
1575 {
1576         int i;
1577         yaffs_start_up();
1578         char name[100];
1579         int result = 0;
1580
1581         int d,f;
1582
1583         for(i = 0; i < 5; i++)
1584         {
1585                 yaffs_mount(mountpt);
1586                 for(d = 0; result >= 0 && d < 1000; d++){
1587                         sprintf(name,"%s/%d",mountpt,d);
1588                         result= yaffs_mkdir(name,0);
1589                         printf("creating directory %s result %d\n",name,result);
1590
1591                         for(f = 0; result >= 0 && f < 100; f++){
1592                                 sprintf(name,"%s/%d/%d",mountpt,d,f);
1593                                 result= yaffs_open(name,O_CREAT, 0);
1594                                 yaffs_close(result);
1595                                 printf("creating file %s result %d\n",name,result);
1596                         }
1597                 }
1598                 yaffs_unmount(mountpt);
1599         }
1600
1601 }
1602
1603 void long_name_test(const char *mountpt)
1604 {
1605         int i;
1606         yaffs_start_up();
1607         char fullName[1000];
1608         char name[300];
1609         int result = 0;
1610
1611         int f;
1612
1613         // Make a 256 byte name
1614         memset(name,0,sizeof(name));
1615         for(i = 0; i < 256; i++)
1616                 name[i] = '0' + i % 10;
1617
1618         sprintf(fullName,"%s/%s",mountpt,name);
1619
1620         for(i = 0; i < 1; i++)
1621         {
1622                 yaffs_mount(mountpt);
1623
1624                 printf("Files at start\n");
1625                 dumpDir(mountpt);
1626
1627                 printf("Creating file %s\n",fullName);
1628
1629                 f = yaffs_open(fullName,O_CREAT | O_RDWR,0);
1630                 yaffs_close(f);
1631
1632                 printf("Result %d\n",f);
1633
1634                 printf("Files\n");
1635                 dumpDir(mountpt);
1636
1637                 printf("Deleting %s\n",fullName);
1638                 result = yaffs_unlink(fullName);
1639                 printf("Result %d\n",result);
1640
1641                 printf("Files\n");
1642
1643                 dumpDir(mountpt);
1644
1645                 yaffs_unmount(mountpt);
1646         }
1647
1648 }
1649
1650
1651 void lookup_test(const char *mountpt)
1652 {
1653         int i;
1654         int h;
1655         char a[100];
1656
1657
1658         yaffs_DIR *d;
1659         struct yaffs_dirent *de;
1660
1661         yaffs_start_up();
1662
1663         yaffs_mount(mountpt);
1664
1665         d = yaffs_opendir(mountpt);
1666
1667         if(!d)
1668         {
1669                 printf("opendir failed\n");
1670         }
1671         else
1672         {
1673
1674                 for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1675                 {
1676                         printf("unlinking %s\n",de->d_name);
1677                         yaffs_unlink(de->d_name);
1678                 }
1679
1680                 printf("%d files deleted\n",i);
1681         }
1682
1683
1684         for(i = 0; i < 2000; i++){
1685         sprintf(a,"%s/%d",mountpt,i);
1686                 h =  yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
1687                 yaffs_close(h);
1688         }
1689
1690         yaffs_rewinddir(d);
1691         for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1692         {
1693                 printf("%d  %s\n",i,de->d_name);
1694         }
1695
1696         printf("%d files listed\n\n\n",i);
1697
1698         yaffs_rewinddir(d);
1699         yaffs_readdir(d);
1700         yaffs_readdir(d);
1701         yaffs_readdir(d);
1702
1703         for(i = 0; i < 2000; i++){
1704                 sprintf(a,"%s/%d",mountpt,i);
1705                 yaffs_unlink(a);
1706         }
1707
1708
1709         yaffs_unmount(mountpt);
1710
1711 }
1712
1713 void link_test0(const char *mountpt)
1714 {
1715         char namea[300];
1716         char nameb[300];
1717         int result = 0;
1718
1719
1720         yaffs_start_up();
1721         yaffs_mount(mountpt);
1722
1723
1724         sprintf(namea,"%s/a",mountpt);
1725         sprintf(nameb,"%s/b",mountpt);
1726
1727         printf("mounted\n");
1728         dumpDir(mountpt);
1729
1730         yaffs_unlink(namea);
1731         printf("a unlinked\n");
1732         dumpDir(mountpt);
1733
1734         yaffs_unlink(nameb);
1735         printf("b unlinked\n");
1736         dumpDir(mountpt);
1737
1738         result = yaffs_open(namea,O_CREAT| O_RDWR,0666);
1739         yaffs_close(result);
1740         printf("a created\n");
1741         dumpDir(mountpt);
1742
1743         yaffs_link(namea,nameb);
1744         printf("linked\n");
1745         dumpDir(mountpt);
1746         yaffs_unlink(namea);
1747         printf("a ulinked\n");
1748         dumpDir(mountpt);
1749         yaffs_unlink(nameb);
1750         printf("b unlinked\n");
1751         dumpDir(mountpt);
1752
1753         yaffs_unmount(mountpt);
1754 }
1755
1756
1757 void link_test1(const char *mountpt)
1758 {
1759         int i;
1760         int h;
1761         char a[100];
1762         char b[100];
1763         char c[100];
1764
1765         sprintf(a,"%s/aaa",mountpt);
1766         sprintf(b,"%s/bbb",mountpt);
1767         sprintf(c,"%s/ccc",mountpt);
1768
1769         yaffs_start_up();
1770
1771         yaffs_mount(mountpt);
1772
1773
1774         h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1775         for(i = 0; i < 100; i++)
1776                 yaffs_write(h,a,100);
1777
1778         yaffs_close(h);
1779
1780         yaffs_unlink(b);
1781         yaffs_unlink(c);
1782         yaffs_link(a,b);
1783         yaffs_link(a,c);
1784         yaffs_unlink(b);
1785         yaffs_unlink(c);
1786         yaffs_unlink(a);
1787
1788
1789         yaffs_unmount(mountpt);
1790         yaffs_mount(mountpt);
1791
1792         printf("link test done\n");
1793 }
1794
1795 void handle_test(const char *mountpt)
1796 {
1797         int i;
1798         int h;
1799         int cycle;
1800         char a[100];
1801
1802         sprintf(a,"%s/aaa",mountpt);
1803
1804         yaffs_start_up();
1805
1806         yaffs_mount(mountpt);
1807
1808         for(cycle = 0; cycle < 5; cycle++){
1809         printf("Start cycle %d\n",cycle);
1810         i = 0;
1811         do {
1812         h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1813         printf("%d  handle %d\n",i,h);
1814         i++;
1815         } while(h >= 0);
1816
1817         while(i >= -1) {
1818          yaffs_close(i);
1819          i--;
1820         }
1821         }
1822
1823         yaffs_unmount(mountpt);
1824 }
1825
1826 void freespace_test(const char *mountpt)
1827 {
1828         int i;
1829         int h;
1830         char a[100];
1831
1832         int  f0;
1833         int f1;
1834         int f2;
1835         int f3;
1836         sprintf(a,"%s/aaa",mountpt);
1837
1838         yaffs_start_up();
1839
1840         yaffs_mount(mountpt);
1841
1842         f0 = yaffs_freespace(mountpt);
1843
1844         h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1845
1846         for(i = 0; i < 100; i++)
1847                 yaffs_write(h,a,100);
1848
1849         yaffs_close(h);
1850
1851         f1 = yaffs_freespace(mountpt);
1852
1853         yaffs_unlink(a);
1854
1855         f2 = yaffs_freespace(mountpt);
1856
1857
1858         yaffs_unmount(mountpt);
1859         yaffs_mount(mountpt);
1860
1861         f3 = yaffs_freespace(mountpt);
1862
1863         printf("%d\n%d\n%d\n%d\n",f0, f1,f2,f3);
1864
1865
1866 }
1867
1868 void simple_rw_test(const char *mountpt)
1869 {
1870         int i;
1871         int h;
1872         char a[100];
1873
1874         int x;
1875         int result;
1876
1877         sprintf(a,"%s/aaa",mountpt);
1878
1879         yaffs_start_up();
1880
1881         yaffs_mount(mountpt);
1882
1883         yaffs_unlink(a);
1884
1885         h = yaffs_open(a,O_CREAT| O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1886
1887         for(i = 100000;i < 200000; i++){
1888                 result = yaffs_write(h,&i,sizeof(i));
1889
1890                 if(result != 4)
1891                 {
1892                         printf("write error\n");
1893                         exit(1);
1894                 }
1895         }
1896
1897         //yaffs_close(h);
1898
1899         // h = yaffs_open(a,O_RDWR, S_IREAD | S_IWRITE);
1900
1901
1902         yaffs_lseek(h,0,SEEK_SET);
1903
1904         for(i = 100000; i < 200000; i++){
1905                 result = yaffs_read(h,&x,sizeof(x));
1906
1907                 if(result != 4 || x != i){
1908                         printf("read error %d %x %x\n",i,result,x);
1909                 }
1910         }
1911
1912         printf("Simple rw test passed\n");
1913
1914
1915
1916 }
1917
1918
1919 void scan_deleted_files_test(const char *mountpt)
1920 {
1921         char fn[100];
1922         char sub[100];
1923
1924         const char *p;
1925
1926         int i;
1927         int j;
1928         int k;
1929         int h;
1930
1931         sprintf(sub,"%s/sdir",mountpt);
1932         yaffs_start_up();
1933
1934         for(j = 0; j < 10; j++)
1935         {
1936                 printf("\n\n>>>>>>> Run %d <<<<<<<<<<<<<\n\n",j);
1937                 yaffs_mount(mountpt);
1938                 yaffs_mkdir(sub,0);
1939
1940
1941                 p = (j & 0) ? mountpt: sub;
1942
1943                 for(i = 0; i < 100; i++)
1944                 {
1945                   sprintf(fn,"%s/%d",p,i);
1946
1947                   if(i & 1)
1948                   {
1949                           h = yaffs_open(fn,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1950                           for(k = 0; k < 1000; k++)
1951                                   yaffs_write(h,fn,100);
1952                           yaffs_close(h);
1953                   }
1954                   else
1955                         yaffs_mkdir(fn,0);
1956                 }
1957
1958                 for(i = 0; i < 10; i++)
1959                 {
1960                   sprintf(fn,"%s/%d",p,i);
1961                   if(i & 1)
1962                         yaffs_unlink(fn);
1963                   else
1964                         yaffs_rmdir(fn);
1965
1966                 }
1967
1968                 yaffs_unmount(mountpt);
1969         }
1970
1971
1972
1973
1974 }
1975
1976
1977 void write_10k(int h)
1978 {
1979    int i;
1980    const char *s="0123456789";
1981    for(i = 0; i < 1000; i++)
1982      yaffs_write(h,s,10);
1983
1984 }
1985 void write_200k_file(const char *fn, const char *fdel, const char *fdel1)
1986 {
1987    int h1;
1988    int i;
1989    int offs;
1990
1991    h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1992
1993    for(i = 0; i < 100000; i+= 10000)
1994    {
1995         write_10k(h1);
1996    }
1997
1998    offs = yaffs_lseek(h1,0,SEEK_CUR);
1999    if( offs != 100000)
2000    {
2001         printf("Could not write file\n");
2002    }
2003
2004    yaffs_unlink(fdel);
2005    for(i = 0; i < 100000; i+= 10000)
2006    {
2007         write_10k(h1);
2008    }
2009
2010    offs = yaffs_lseek(h1,0,SEEK_CUR);
2011    if( offs != 200000)
2012    {
2013         printf("Could not write file\n");
2014    }
2015
2016    yaffs_close(h1);
2017    yaffs_unlink(fdel1);
2018
2019 }
2020
2021
2022 void verify_200k_file(const char *fn)
2023 {
2024    int h1;
2025    int i;
2026    char x[11];
2027    const char *s="0123456789";
2028    int errCount = 0;
2029
2030    h1 = yaffs_open(fn, O_RDONLY, 0);
2031
2032    for(i = 0; i < 200000 && errCount < 10; i+= 10)
2033    {
2034         yaffs_read(h1,x,10);
2035         if(strncmp(x,s,10) != 0)
2036         {
2037                 printf("File %s verification failed at %d\n",fn,i);
2038                 errCount++;
2039         }
2040    }
2041    if(errCount >= 10)
2042         printf("Too many errors... aborted\n");
2043
2044    yaffs_close(h1);
2045
2046 }
2047
2048
2049 void check_resize_gc_bug(const char *mountpt)
2050 {
2051
2052         char a[30];
2053         char b[30];
2054         char c[30];
2055
2056         int i;
2057
2058         sprintf(a,"%s/a",mountpt);
2059         sprintf(b,"%s/b",mountpt);
2060         sprintf(c,"%s/c",mountpt);
2061
2062
2063
2064
2065         yaffs_start_up();
2066         yaffs_mount(mountpt);
2067         yaffs_unlink(a);
2068         yaffs_unlink(b);
2069
2070         for(i = 0; i < 50; i++)
2071         {
2072            printf("A\n");write_200k_file(a,"",c);
2073            printf("B\n");verify_200k_file(a);
2074            printf("C\n");write_200k_file(b,a,c);
2075            printf("D\n");verify_200k_file(b);
2076            yaffs_unmount(mountpt);
2077            yaffs_mount(mountpt);
2078            printf("E\n");verify_200k_file(a);
2079            printf("F\n");verify_200k_file(b);
2080         }
2081
2082 }
2083
2084
2085 void multi_mount_test(const char *mountpt,int nmounts)
2086 {
2087
2088         char a[30];
2089
2090         int i;
2091         int j;
2092
2093         sprintf(a,"%s/a",mountpt);
2094
2095         yaffs_start_up();
2096
2097         for(i = 0; i < nmounts; i++){
2098                 int h0;
2099                 int h1;
2100                 char xx[1000];
2101
2102                 printf("############### Iteration %d   Start\n",i);
2103                 if(1 || i == 0 || i == 5)
2104                         yaffs_mount(mountpt);
2105
2106                 dump_directory_tree(mountpt);
2107
2108
2109                 yaffs_mkdir(a,0);
2110
2111                 sprintf(xx,"%s/0",a);
2112                 h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2113
2114                 sprintf(xx,"%s/1",a);
2115                 h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2116
2117 #if 0
2118                 for(j = 0; j < 200; j++){
2119                    yaffs_write(h0,xx,1000);
2120                    yaffs_write(h1,xx,1000);
2121                 }
2122 #else
2123                 while(yaffs_write(h0,xx,1000) > 0){
2124
2125                    yaffs_write(h1,xx,1000);
2126                 }
2127 #endif
2128                 yaffs_lseek(h0,0,SEEK_END);
2129                 yaffs_lseek(h1,0,SEEK_END);
2130
2131                 yaffs_lseek(h0,0,SEEK_SET);
2132                 yaffs_lseek(h1,0,SEEK_SET);
2133
2134                 for(j = 0; j < 200; j++){
2135                    yaffs_read(h0,xx,1000);
2136                    yaffs_read(h1,xx,1000);
2137                 }
2138
2139
2140         //      yaffs_truncate(h0,0);
2141                 yaffs_close(h0);
2142                 yaffs_close(h1);
2143
2144                 printf("########### %d\n",i);
2145                 dump_directory_tree(mountpt);
2146
2147                 if(1 || i == 4 || i == nmounts -1)
2148                         yaffs_unmount(mountpt);
2149         }
2150 }
2151
2152
2153 void small_mount_test(const char *mountpt,int nmounts)
2154 {
2155
2156         char a[30];
2157
2158         int i;
2159         int j;
2160
2161         int h0;
2162         int h1;
2163         int nread;
2164
2165         sprintf(a,"%s/a",mountpt);
2166
2167         yaffs_start_up();
2168
2169
2170
2171         for(i = 0; i < nmounts; i++){
2172
2173                 char xx[1000];
2174
2175                 printf("############### Iteration %d   Start\n",i);
2176                 if(1 || i == 0 || i == 5)
2177                         yaffs_mount(mountpt);
2178
2179                 dump_directory_tree(mountpt);
2180
2181                 yaffs_mkdir(a,0);
2182
2183                 sprintf(xx,"%s/0",a);
2184                 if(i ==0){
2185
2186                         h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2187                         for(j = 0; j < 130; j++)
2188                                 yaffs_write(h0,xx,1000);
2189                         yaffs_close(h0);
2190                 }
2191
2192                 h0 = yaffs_open(xx,O_RDONLY,0);
2193
2194                 sprintf(xx,"%s/1",a);
2195                 h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2196
2197                 while((nread = yaffs_read(h0,xx,1000)) > 0)
2198                         yaffs_write(h1,xx,nread);
2199
2200
2201                 yaffs_lseek(h0,0,SEEK_END);
2202                 yaffs_lseek(h1,0,SEEK_END);
2203
2204                 yaffs_lseek(h0,0,SEEK_SET);
2205                 yaffs_lseek(h1,0,SEEK_SET);
2206
2207                 for(j = 0; j < 200; j++){
2208                    yaffs_read(h0,xx,1000);
2209                    yaffs_read(h1,xx,1000);
2210                 }
2211
2212                 yaffs_close(h0);
2213                 yaffs_close(h1);
2214
2215                 printf("########### %d\n",i);
2216                 dump_directory_tree(mountpt);
2217
2218                 if(1 || i == 4 || i == nmounts -1)
2219                         yaffs_unmount(mountpt);
2220         }
2221 }
2222
2223
2224 int early_exit;
2225
2226 void small_overwrite_test(const char *mountpt,int nmounts)
2227 {
2228
2229         char a[30];
2230         int i;
2231         int j;
2232
2233         int h0;
2234         int h1;
2235
2236
2237         sprintf(a,"%s/a",mountpt);
2238
2239         yaffs_start_up();
2240
2241
2242
2243         for(i = 0; i < nmounts; i++){
2244
2245                 static char xx[8000];
2246
2247                 printf("############### Iteration %d   Start\n",i);
2248                 if(1)
2249                         yaffs_mount(mountpt);
2250
2251                 dump_directory_tree(mountpt);
2252
2253                 yaffs_mkdir(a,0);
2254
2255                 sprintf(xx,"%s/0",a);
2256                 h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2257                 sprintf(xx,"%s/1",a);
2258                 h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2259
2260                 for(j = 0; j < 1000000; j+=1000){
2261                         yaffs_ftruncate(h0,j);
2262                         yaffs_lseek(h0,j,SEEK_SET);
2263                         yaffs_write(h0,xx,7000);
2264                         yaffs_write(h1,xx,7000);
2265
2266                         if(early_exit)
2267                                 exit(0);
2268                 }
2269
2270                 yaffs_close(h0);
2271
2272                 printf("########### %d\n",i);
2273                 dump_directory_tree(mountpt);
2274
2275                 if(1)
2276                         yaffs_unmount(mountpt);
2277         }
2278 }
2279
2280
2281 void seek_overwrite_test(const char *mountpt,int nmounts)
2282 {
2283         static char xx[5000];
2284         char a[30];
2285
2286         int i;
2287         int j;
2288
2289         int h0;
2290
2291
2292         sprintf(a,"%s/f",mountpt);
2293
2294         yaffs_start_up();
2295
2296         yaffs_mount(mountpt);
2297
2298
2299         for(i = 0; i < nmounts; i++){
2300
2301                 h0 = yaffs_open(a, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2302
2303                 for(j = 0; j < 100000; j++){
2304                         yaffs_lseek(h0,0,SEEK_SET);
2305                         yaffs_write(h0,xx,5000);
2306                         yaffs_lseek(h0,0x100000,SEEK_SET);
2307                         yaffs_write(h0,xx,5000);
2308
2309                         if(early_exit)
2310                                 exit(0);
2311                 }
2312
2313                 yaffs_close(h0);
2314
2315         }
2316 }
2317
2318
2319 void yaffs_touch(const char *fn)
2320 {
2321         yaffs_chmod(fn, S_IREAD | S_IWRITE);
2322 }
2323
2324 void checkpoint_fill_test(const char *mountpt,int nmounts)
2325 {
2326
2327         char a[50];
2328         char b[50];
2329         char c[50];
2330
2331         int i;
2332         int j;
2333         int h;
2334
2335         sprintf(a,"%s/a",mountpt);
2336
2337
2338
2339
2340         yaffs_start_up();
2341
2342         for(i = 0; i < nmounts; i++){
2343                 printf("############### Iteration %d   Start\n",i);
2344                 yaffs_mount(mountpt);
2345                 dump_directory_tree(mountpt);
2346                 yaffs_mkdir(a,0);
2347
2348                 sprintf(b,"%s/zz",a);
2349
2350                 h = yaffs_open(b,O_CREAT | O_RDWR,S_IREAD |S_IWRITE);
2351
2352
2353                 while(yaffs_write(h,c,50) == 50){}
2354
2355                 yaffs_close(h);
2356
2357                 for(j = 0; j < 2; j++){
2358                         printf("touch %d\n",j);
2359                         yaffs_touch(b);
2360                         yaffs_unmount(mountpt);
2361                         yaffs_mount(mountpt);
2362                 }
2363
2364                 dump_directory_tree(mountpt);
2365                 yaffs_unmount(mountpt);
2366         }
2367 }
2368
2369
2370 int make_file2(const char *name1, const char *name2,int syz)
2371 {
2372
2373         char xx[2500];
2374         int i;
2375         int h1=-1,h2=-1;
2376         int n = 1;
2377
2378
2379         if(name1)
2380                 h1 = yaffs_open(name1,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2381         if(name2)
2382                 h2 = yaffs_open(name2,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2383
2384         while(syz > 0 && n > 0){
2385                 i = (syz > 2500) ? 2500 : syz;
2386                 n = yaffs_write(h1,xx,i);
2387                 n = yaffs_write(h2,xx,i);
2388                 syz -= 500;
2389         }
2390         yaffs_close(h1);
2391         yaffs_close(h2);
2392         return 0;
2393 }
2394
2395
2396 extern void SetCheckpointReservedBlocks(int n);
2397
2398 void checkpoint_upgrade_test(const char *mountpt, int nmounts)
2399 {
2400
2401         char a[50];
2402         char b[50];
2403         char c[50];
2404         char d[50];
2405
2406         int j;
2407
2408         (void) nmounts;
2409
2410         sprintf(a,"%s/a",mountpt);
2411
2412         printf("Create start condition\n");
2413         yaffs_start_up();
2414         yaffs_mount(mountpt);
2415         yaffs_mkdir(a,0);
2416         sprintf(b,"%s/zz",a);
2417         sprintf(c,"%s/xx",a);
2418         make_file2(b,c,2000000);
2419         sprintf(d,"%s/aa",a);
2420         make_file2(d,NULL,500000000);
2421         dump_directory_tree(mountpt);
2422
2423         printf("Umount/mount attempt full\n");
2424         yaffs_unmount(mountpt);
2425
2426         yaffs_mount(mountpt);
2427
2428         printf("unlink small file\n");
2429         yaffs_unlink(c);
2430         dump_directory_tree(mountpt);
2431
2432         printf("Umount/mount attempt\n");
2433         yaffs_unmount(mountpt);
2434         yaffs_mount(mountpt);
2435
2436         for(j = 0; j < 500; j++){
2437                 printf("***** touch %d\n",j);
2438                 dump_directory_tree(mountpt);
2439                 yaffs_touch(b);
2440                 yaffs_unmount(mountpt);
2441                 yaffs_mount(mountpt);
2442         }
2443
2444         for(j = 0; j < 500; j++){
2445                 printf("***** touch %d\n",j);
2446                 dump_directory_tree(mountpt);
2447                 yaffs_touch(b);
2448                 yaffs_unmount(mountpt);
2449                 yaffs_mount(mountpt);
2450         }
2451 }
2452
2453 void huge_array_test(const char *mountpt,int n)
2454 {
2455
2456         char a[50];
2457
2458
2459         int i;
2460         int space;
2461
2462         int fnum;
2463
2464         sprintf(a,"mount point %s",mountpt);
2465
2466
2467
2468         yaffs_start_up();
2469
2470         yaffs_mount(mountpt);
2471
2472         while(n>0){
2473                 n--;
2474                 fnum = 0;
2475                 printf("\n\n START run\n\n");
2476                 while((space = yaffs_freespace(mountpt)) > 25000000){
2477                         sprintf(a,"%s/file%d",mountpt,fnum);
2478                         fnum++;
2479                         printf("create file %s, free space %d\n",a,space);
2480                         create_file_of_size(a,10000000);
2481                         printf("verifying file %s\n",a);
2482                         verify_file_of_size(a,10000000);
2483                 }
2484
2485                 printf("\n\n verification/deletion\n\n");
2486
2487                 for(i = 0; i < fnum; i++){
2488                         sprintf(a,"%s/file%d",mountpt,i);
2489                         printf("verifying file %s\n",a);
2490                         verify_file_of_size(a,10000000);
2491                         printf("deleting file %s\n",a);
2492                         yaffs_unlink(a);
2493                 }
2494                 printf("\n\n done \n\n");
2495
2496
2497         }
2498 }
2499
2500
2501 void random_write(int h)
2502 {
2503         static char buffer[12000];
2504         int n;
2505
2506         n = random() & 0x1FFF;
2507         yaffs_write(h,buffer,n);
2508 }
2509
2510 void random_seek(int h)
2511 {
2512         int n;
2513         n = random() & 0xFFFFF;
2514         yaffs_lseek(h,n,SEEK_SET);
2515 }
2516
2517 void random_truncate(int h, char *name)
2518 {
2519         int n;
2520         int flen;
2521
2522         (void) name;
2523
2524         n = random() & 0xFFFFF;
2525         flen = yaffs_lseek(h,0,SEEK_END);
2526         if(n > flen)
2527                 n = flen / 2;
2528         yaffs_ftruncate(h,n);
2529         yaffs_lseek(h,n,SEEK_SET);
2530 }
2531
2532
2533 #define NSMALLFILES 10
2534 void random_small_file_test(const char *mountpt,int iterations)
2535 {
2536
2537         char a[NSMALLFILES][50];
2538
2539
2540         int i;
2541         int n;
2542         int h[NSMALLFILES];
2543         int r;
2544
2545
2546         yaffs_start_up();
2547
2548         yaffs_mount(mountpt);
2549
2550         for(i = 0; i < NSMALLFILES; i++){
2551                 h[i]=-1;
2552                 strcpy(a[i],"");
2553         }
2554
2555         for(n = 0; n < iterations; n++){
2556
2557                 for(i = 0; i < NSMALLFILES; i++) {
2558                         r = random();
2559
2560                         if(strlen(a[i]) == 0){
2561                                 sprintf(a[i],"%s/%dx%d",mountpt,n,i);
2562                                 h[i] = yaffs_open(a[i],O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
2563                         }
2564
2565                         if(h[i] < -1)
2566                                 printf("Could not open yaffs file %d %d error %d\n",n,i,h[i]);
2567                         else {
2568                                 r = r & 7;
2569                                 switch(r){
2570                                         case 0:
2571                                         case 1:
2572                                         case 2:
2573                                                 random_write(h[i]);
2574                                                 break;
2575                                         case 3:
2576                                                 random_truncate(h[i],a[i]);
2577                                                 break;
2578                                         case 4:
2579                                         case 5: random_seek(h[i]);
2580                                                 break;
2581                                         case 6:
2582                                                 yaffs_close(h[i]);
2583                                                 h[i] = -1;
2584                                                 break;
2585                                         case 7:
2586                                                 yaffs_close(h[i]);
2587                                                 yaffs_unlink(a[i]);
2588                                                 strcpy(a[i],"");
2589                                                 h[i] = -1;
2590                                 }
2591                         }
2592                 }
2593
2594         }
2595
2596         for(i = 0; i < NSMALLFILES; i++)
2597                 yaffs_close(h[i]);
2598
2599         yaffs_unmount(mountpt);
2600 }
2601
2602 void rmdir_test(const char *mountpt)
2603 {
2604         char name[100];
2605         yaffs_start_up();
2606
2607         yaffs_mount(mountpt);
2608
2609         strcpy(name,mountpt);
2610         strcat(name,"/");
2611         strcat(name,"hello");
2612         yaffs_mkdir(name,0666);
2613         yaffs_rmdir(name);
2614         yaffs_unmount(mountpt);
2615 }
2616
2617
2618
2619 static void print_xattrib_val(const char *path, const char *name)
2620 {
2621         char buffer[1000];
2622         int n;
2623
2624         n = yaffs_getxattr(path,name,buffer,sizeof(buffer));
2625         if(n >= 0){
2626                 u8 *b = (u8 *)buffer;
2627
2628                 printf("%d bytes:",n);
2629                 if(n > 10)
2630                         n = 10;
2631                 while(n > 0){
2632                         printf("[%02X]",*b);
2633                         b++;
2634                         n--;
2635                 }
2636                 printf("\n");
2637         } else
2638                 printf(" Novalue result %d\n",n);
2639 }
2640
2641 static void list_xattr(const char *path)
2642 {
2643         char list[1000];
2644         int n=0;
2645         int list_len;
2646         int len;
2647
2648         list_len = yaffs_listxattr(path,list,sizeof(list));
2649         printf("xattribs for %s, result is %d\n",path,list_len);
2650         while(n < list_len){
2651                 len = strlen(list + n);
2652                 printf("\"%s\" value ",list+n);
2653                 print_xattrib_val(path,list + n);
2654                 n += (len + 1);
2655         }
2656         printf("end\n");
2657 }
2658
2659 void basic_utime_test(const char *mountpt)
2660 {
2661         char name[100];
2662         int h;
2663         int result;
2664         struct yaffs_utimbuf utb;
2665         struct yaffs_stat st;
2666
2667         //setup
2668         yaffs_start_up();
2669
2670         yaffs_mount(mountpt);
2671
2672         strcpy(name,mountpt);
2673         strcat(name,"/");
2674         strcat(name,"xfile");
2675
2676         yaffs_unlink(name);
2677
2678         printf("created\n");
2679         h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2680
2681         yaffs_fstat(h,&st);
2682         printf(" times before %llu %llu %llu\n",
2683                         ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2684
2685         //here are the last access and modification times.
2686         utb.actime = 1000;
2687         utb.modtime = 2000;
2688
2689         //futime sets the last modification and access time of the file
2690         result = yaffs_futime(h,&utb);
2691         printf("setting times using the futime function to a 1000 m 2000 result  %d\n",result);
2692
2693         //read the times from the file header
2694         yaffs_fstat(h,&st);
2695         printf(" times %llu %llu %llu\n",
2696                         ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2697
2698
2699         utb.actime = 5000;
2700         utb.modtime = 8000;
2701         result = yaffs_utime(name, &utb);
2702         printf("utime to a 5000 m 8000 result %d\n",result);
2703         yaffs_fstat(h,&st);
2704         printf(" times %llu %llu %llu\n",
2705                         ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2706
2707         result = yaffs_utime(name, NULL);
2708         printf("utime to NULL result %d\n",result);
2709         yaffs_fstat(h,&st);
2710         printf(" times %llu %llu %llu\n",
2711                         ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2712
2713
2714 }
2715
2716 void print_binary(u64 val){
2717         int count = 0;
2718         for (int i= 63; i>=0; i --) {
2719                 if (count == 0){
2720                         printf(" ");
2721                 }
2722                 if ((((u64)1) << i) & val) {
2723                         printf("1");
2724                 } else {
2725                         printf("0");
2726                 }
2727                 count = (count +1) % 8;
2728         }
2729 }
2730
2731 void testing_swap_u64() {
2732         int numberOfFailedTests = 0;
2733         for (int i =0; i < 8; i ++) {
2734                 u64 startingNumber = (0xffLLu << (i*8));
2735                 u64 expected = (0xffLLu << (64 - (i*8) -8));
2736                 u64 converted = swap_u64(startingNumber);
2737                 if (converted != expected) {
2738                         numberOfFailedTests ++;
2739                         printf("numbers do not match.\n");
2740                         printf("0xff\t\t\t");
2741                         print_binary(0xff);
2742                         printf("\nStarting Number \t");
2743             print_binary(startingNumber);
2744                         printf("\nExpecting \t\t");
2745                         print_binary(expected);
2746                         printf("\nConverted \t\t");
2747                         print_binary(converted);
2748
2749                         printf("\n");
2750                 }
2751         }
2752         if (numberOfFailedTests){
2753                 printf("testing_swap failed %d tests\n", numberOfFailedTests);
2754         } else {
2755                 printf("testing_swap_u64 passed all tests\n");
2756         }
2757 }
2758
2759
2760 void size_utime_test(const char *mountpt)
2761 {
2762         char name[100];
2763         int h;
2764         int result;
2765         struct yaffs_utimbuf utb;
2766         struct yaffs_stat st;
2767
2768         //setup
2769         yaffs_start_up();
2770
2771         yaffs_mount(mountpt);
2772
2773         strcpy(name,mountpt);
2774         strcat(name,"/");
2775         strcat(name,"xfile");
2776
2777         yaffs_unlink(name);
2778
2779         printf("created\n");
2780         h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2781
2782         yaffs_fstat(h,&st);
2783         printf(" times before %llu %llu %llu\n",
2784                           ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2785
2786         //first lets get the yaffs_object.
2787
2788         //then check that yaffs_stat also works.
2789         //yaffs_stat already uses 64 bits for both wince and unix times.
2790         //To see if we are using 32 or 64 bit time, save a large number into the time and
2791         //see if it overflows.
2792         long bitsInTime = 8*sizeof(st.yst_ctime);
2793         printf("the times are %ld bits long\n", bitsInTime);
2794
2795         //two testcases
2796         if (bitsInTime == 64) {
2797                 //no need to test the overflow. Just check that it can be retrieved intact.
2798
2799                         //use u64 variables in case utb truncates the values to 32 bit time by accident.
2800                         u64 start = 0xfffff;
2801                         u64 end =       0xffffff;
2802
2803                 utb.actime =  start;
2804                 utb.modtime = end;
2805
2806                 result = yaffs_futime(h,&utb);
2807                 yaffs_fstat(h,&st);
2808                 if (st.yst_atime == start && st.yst_mtime == end) {
2809                         printf("successfully stored and retrevied a 64 bit number for atime and modtime\n");
2810                 } else {
2811                         printf("failed to store and retrieve a 64 bit number for atime and modtime\n");
2812
2813                 }
2814         } else {
2815                 //it is a 32 bit number. Check to see that it overflowed.
2816
2817         }
2818
2819
2820         //here are the last access and modification times.
2821         utb.actime = 1000;
2822         utb.modtime = 2000;
2823
2824         //futime sets the last modification and access time of the file
2825         result = yaffs_futime(h,&utb);
2826         printf("setting times using the futime function to a 1000 m 2000 result  %d\n",result);
2827
2828         //read the times from the file header
2829         yaffs_fstat(h,&st);
2830         printf(" times %llu %llu %llu\n",
2831                    ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2832
2833
2834         utb.actime = 5000;
2835         utb.modtime = 8000;
2836         result = yaffs_utime(name, &utb);
2837         printf("utime to a 5000 m 8000 result %d\n",result);
2838         yaffs_fstat(h,&st);
2839         printf(" times %llu %llu %llu\n",
2840                    ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2841
2842         result = yaffs_utime(name, NULL);
2843         printf("utime to NULL result %d\n",result);
2844         yaffs_fstat(h,&st);
2845         printf(" times %llu %llu %llu\n",
2846                    ( u64) st.yst_atime, ( u64) st.yst_ctime, ( u64) st.yst_mtime);
2847
2848
2849 }
2850
2851
2852 void basic_xattr_test(const char *mountpt)
2853 {
2854         char name[100];
2855         int h;
2856         int result;
2857         int val1;
2858
2859         yaffs_start_up();
2860
2861         yaffs_mount(mountpt);
2862
2863         strcpy(name,mountpt);
2864         strcat(name,"/");
2865         strcat(name,"xfile");
2866
2867         yaffs_unlink(name);
2868         h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2869         yaffs_close(h);
2870
2871         printf("Start\n");
2872         list_xattr(name);
2873
2874         printf("Add an attribute\n");
2875         val1 = 0x123456;
2876         result = yaffs_setxattr(name,"foo",&val1,sizeof(val1),0);
2877         printf("wrote attribute foo: result %d\n",result);
2878         list_xattr(name);
2879         printf("Add an attribute\n");
2880         val1 = 0x7890;
2881         result = yaffs_setxattr(name,"bar",&val1,sizeof(val1),0);
2882         printf("wrote attribute bar: result %d\n",result);
2883         list_xattr(name);
2884
2885         printf("Get non-existanrt attribute\n");
2886         print_xattrib_val(name,"not here");
2887
2888         printf("Delete non existing attribute\n");
2889         yaffs_removexattr(name,"not here");
2890         list_xattr(name);
2891
2892         printf("Remove foo\n");
2893         yaffs_removexattr(name,"foo");
2894         list_xattr(name);
2895
2896         printf("Remove bar\n");
2897         yaffs_removexattr(name,"bar");
2898         list_xattr(name);
2899
2900 }
2901
2902 void big_xattr_test(const char *mountpt)
2903 {
2904         char name[100];
2905         int h;
2906         int result;
2907         char val[1000];
2908
2909         yaffs_start_up();
2910
2911         yaffs_mount(mountpt);
2912
2913         strcpy(name,mountpt);
2914         strcat(name,"/");
2915         strcat(name,"xfile");
2916
2917         yaffs_unlink(name);
2918         h = yaffs_open(name,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
2919         yaffs_close(h);
2920
2921         printf("Start\n");
2922         list_xattr(name);
2923
2924         printf("Add a large  attribute\n");
2925         memset(val,0x1,sizeof(val));
2926         result = yaffs_setxattr(name,"aaa",val,200,0);
2927         printf("wrote attribute aaa: result %d\n",result);
2928         list_xattr(name);
2929
2930         printf("Add a large  attribute\n");
2931         memset(val,0x2,sizeof(val));
2932         result = yaffs_setxattr(name,"bbb",val,1000,0);
2933         printf("wrote attribute bbb: result %d\n",result);
2934         list_xattr(name);
2935
2936         printf("Replace attribute\n");
2937         memset(val,0x3,sizeof(val));
2938         result = yaffs_setxattr(name,"aaa",val,1000,0);
2939         printf("wrote attribute aaa: result %d\n",result);
2940         list_xattr(name);
2941
2942 }
2943
2944
2945 void dump_dev_stats(struct yaffs_dev *dev, const char * str)
2946 {
2947         printf("%s\n",str);
2948         printf( "space free %d erased %d "
2949                 "nand reads %d writes %d erases %d "
2950                 "gc all %d passive %d oldestdirty %d blocks %d copies %d \n",
2951                 dev->n_free_chunks, dev->n_erased_blocks * dev->param.chunks_per_block,
2952                 dev->n_page_reads, dev->n_page_writes, dev->n_erasures,
2953                 dev->all_gcs, dev->passive_gc_count, dev->oldest_dirty_gc_count, dev->n_gc_blocks, dev->n_gc_copies);
2954 }
2955
2956 void test_flash_traffic(const char *mountpt)
2957 {
2958         char name0[100];
2959         char name1[100];
2960         int i;
2961         struct yaffs_dev *dev;
2962
2963         yaffs_trace_mask = 0;
2964
2965         yaffs_start_up();
2966
2967         yaffs_mount(mountpt);
2968
2969         dev = yaffs_getdev(mountpt);
2970
2971         strcpy(name0,mountpt);
2972         strcat(name0,"/x");
2973
2974         strcpy(name1,mountpt);
2975         strcat(name1,"/y");
2976
2977         dump_dev_stats(dev,"start");
2978         create_file_of_size(name0,32 * 1024 * 1024);
2979         dump_dev_stats(dev,"32MB written");
2980         for(i = 0; i < 20; i++)
2981                 create_file_of_size(name1,1024 * 1024);
2982         dump_dev_stats(dev,"20x 1MB files written");
2983
2984 }
2985
2986 void link_follow_test(const char *mountpt)
2987 {
2988         char fn[100];
2989         char sn[100];
2990         char hn[100];
2991         int result;
2992         int h;
2993
2994         yaffs_trace_mask = 0;
2995
2996         yaffs_start_up();
2997
2998         yaffs_mount(mountpt);
2999
3000         sprintf(fn,"%s/file",mountpt);
3001         sprintf(sn,"%s/sym",mountpt);
3002         sprintf(hn,"%s/hl-sym",mountpt);
3003
3004         h = yaffs_open(fn,O_CREAT| O_RDWR, S_IREAD | S_IWRITE);
3005         result = yaffs_close(h);
3006
3007         result = yaffs_symlink(fn,sn);
3008         result = yaffs_link(sn,hn);
3009
3010         if (result < 0)
3011                 printf("At line %d result is %d\n", __LINE__, result);
3012
3013         h =yaffs_open(hn,O_RDWR,0);
3014
3015 }
3016
3017 void max_files_test(const char *mountpt)
3018 {
3019         char fn[100];
3020
3021         int result;
3022         int h;
3023         int i;
3024
3025         yaffs_trace_mask = 0;
3026
3027         yaffs_start_up();
3028
3029         yaffs_mount(mountpt);
3030
3031         for(i = 0; i < 5000; i++) {
3032                 sprintf(fn,"%s/file%d", mountpt, i);
3033                 yaffs_unlink(fn);
3034                 h = yaffs_open(fn,O_CREAT| O_RDWR, S_IREAD | S_IWRITE);
3035                 if(h < 0)
3036                         printf("File %s not created\n", fn);
3037                 yaffs_write(h,fn,100);
3038                 result = yaffs_close(h);
3039         }
3040         for(i = 0; i < 5; i++){
3041                 sprintf(fn,"%s/file%d",mountpt, i);
3042                 yaffs_unlink(fn);
3043         }
3044
3045         for(i = 1000; i < 1010; i++){
3046                 sprintf(fn,"%s/file%d",mountpt, i);
3047                 h = yaffs_open(fn,O_CREAT| O_RDWR, S_IREAD | S_IWRITE);
3048                 yaffs_write(h,fn,100);
3049                 if(h < 0)
3050                         printf("File %s not created\n", fn);
3051                 result = yaffs_close(h);
3052         }
3053
3054         if (result < 0)
3055                 printf("At line %d result is %d\n", __LINE__, result);
3056
3057         yaffs_unmount(mountpt);
3058 }
3059
3060 void case_insensitive_test(const char *mountpt)
3061 {
3062         char fn[100];
3063         char fn2[100];
3064         char buffer[100];
3065         int ret;
3066         struct yaffs_stat s;
3067         int h;
3068         char *x;
3069
3070         yaffs_trace_mask = 0;
3071
3072         yaffs_start_up();
3073
3074         yaffs_mount(mountpt);
3075         dump_directory_tree(mountpt);
3076
3077         sprintf(fn,"%s/Abc.Txt",mountpt);
3078         yaffs_unlink(fn);
3079         h = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
3080
3081         ret = yaffs_write(h,fn, strlen(fn) + 1);
3082
3083         ret = yaffs_close(h);
3084
3085         dump_directory_tree(mountpt);
3086
3087
3088         strcpy(fn2, fn);
3089         x = fn2;
3090         while(*x) {
3091                 *x = toupper(*x);
3092                 x++;
3093         }
3094
3095         h = yaffs_open(fn2, O_RDONLY, 0);
3096         ret = yaffs_read(h, buffer, 100);
3097
3098         if (ret != (int)(strlen(fn) + 1) || memcmp(buffer, fn, ret)){
3099                 printf("wrong file read\n");
3100         } else {
3101                 printf("File %s is the same as file %s\n", fn, fn2);
3102         }
3103
3104         ret = yaffs_stat(fn2, &s);
3105
3106         printf("renaming\n");
3107
3108         ret = yaffs_rename(fn, fn2);
3109         dump_directory_tree(mountpt);
3110
3111 }
3112
3113 void start_twice(const char *mountpt)
3114 {
3115          printf("About to do first yaffs_start\n");
3116          yaffs_start_up();
3117          printf("started\n");
3118          printf("First mount returns %d\n", yaffs_mount(mountpt));
3119          printf("About to do second yaffs_start\n");
3120          yaffs_start_up();
3121          printf("started\n");
3122          printf("Second mount returns %d\n", yaffs_mount(mountpt));
3123 }
3124
3125 #define N_WRITES 2000
3126 #define STRIDE   2000
3127
3128 #define BUFFER_N 1100
3129 unsigned  xxbuffer[BUFFER_N];
3130
3131 void set_buffer(int n)
3132 {
3133         int i;
3134         for(i = 0; i < BUFFER_N; i++)
3135                 xxbuffer[i] = i + n;
3136 }
3137
3138 void write_big_sparse_file(int h)
3139 {
3140         int i;
3141         loff_t offset = 0;
3142         loff_t pos;
3143         int n = sizeof(xxbuffer);
3144         int wrote;
3145
3146         for(i = 0; i < N_WRITES; i++) {
3147                 printf("writing at %d\n", (int)offset);
3148                 set_buffer(i);
3149                 pos = yaffs_lseek(h, offset, SEEK_SET);
3150                 if(pos != offset) {
3151                         printf("mismatched seek pos %d offset %d\n",
3152                                 (int)pos, (int)offset);
3153                         perror("lseek64");
3154                         exit(1);
3155                 }
3156                 wrote = yaffs_write(h, xxbuffer, n);
3157
3158                 if(wrote != n) {
3159                         printf("mismatched write wrote %d n %d\n", wrote, n);
3160                         exit(1);
3161                 }
3162
3163                 offset += (STRIDE * sizeof(xxbuffer));
3164         }
3165
3166         yaffs_ftruncate(h, offset);
3167
3168 }
3169
3170 void verify_big_sparse_file(int h)
3171 {
3172         unsigned check_buffer[BUFFER_N];
3173         int i;
3174         loff_t offset = 0;
3175         loff_t pos;
3176         int n = sizeof(check_buffer);
3177         int result;
3178         int checks_failed = 0;
3179         int checks_passed = 0;
3180
3181         for(i = 0; i < N_WRITES * STRIDE; i++) {
3182                 if(i % STRIDE) {
3183                         memset(xxbuffer,0, n);
3184                 } else {
3185                         set_buffer(i/STRIDE);
3186                 }
3187                 pos = yaffs_lseek(h, offset, SEEK_SET);
3188                 if(pos != offset) {
3189                         printf("mismatched seek pos %d offset %d\n",
3190                                 (int)pos, (int)offset);
3191                         perror("lseek64");
3192                         exit(1);
3193                 }
3194                 result = yaffs_read(h, check_buffer, n);
3195
3196                 if(result != n) {
3197                         printf("mismatched read result %d n %d\n", result, n);
3198                         exit(1);
3199                 }
3200
3201                 if(memcmp(xxbuffer, check_buffer, n)) {
3202                         int j;
3203
3204                         printf("buffer at %d mismatches\n", (int)pos);
3205                         printf("xxbuffer ");
3206                         for(j = 0; j < 20; j++)
3207                                 printf(" %d",xxbuffer[j]);
3208                         printf("\n");
3209                         printf("check_buffer ");
3210                         for(j = 0; j < 20; j++)
3211                                 printf(" %d",check_buffer[j]);
3212                         printf("\n");
3213
3214                         checks_failed++;
3215                 } else {
3216                         checks_passed++;
3217                 }
3218
3219                 offset += sizeof(xxbuffer);
3220         }
3221
3222         printf("%d checks passed, %d checks failed\n", checks_passed, checks_failed);
3223
3224 }
3225
3226
3227 void large_file_test(const char *mountpt)
3228 {
3229         char xx_buffer[1000];
3230         int i;
3231         int handle;
3232         char fullname[100];
3233         loff_t file_end;
3234
3235         yaffs_trace_mask = 0;
3236
3237         yaffs_start_up();
3238
3239         yaffs_mount(mountpt);
3240         printf("mounted\n");
3241         dumpDir(mountpt);
3242
3243         sprintf(fullname, "%s/%s", mountpt, "big-test-file");
3244
3245         handle = yaffs_open(fullname, O_RDONLY, 0);
3246
3247         handle = yaffs_open(fullname, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
3248
3249         if(handle < 0) {
3250                 perror("opening file");
3251                 exit(1);
3252         }
3253
3254         write_big_sparse_file(handle);
3255         verify_big_sparse_file(handle);
3256
3257         yaffs_close(handle);
3258
3259         printf("Job done\n");
3260         yaffs_unmount(mountpt);
3261
3262         yaffs_mount(mountpt);
3263         printf("mounted again\n");
3264         dumpDir(mountpt);
3265         handle = yaffs_open(fullname, O_RDONLY, 0);
3266         verify_big_sparse_file(handle);
3267         yaffs_unmount(mountpt);
3268
3269
3270         yaffs_mount3(mountpt, 0, 1);
3271         printf("mounted with no checkpt\n");
3272         dumpDir(mountpt);
3273         handle = yaffs_open(fullname, O_RDONLY, 0);
3274         verify_big_sparse_file(handle);
3275         yaffs_unmount(mountpt);
3276
3277         /* Check resize by adding to the end, resizing back and verifying. */
3278         yaffs_mount3(mountpt, 0, 1);
3279         printf("checking resize\n");
3280         dumpDir(mountpt);
3281         handle = yaffs_open(fullname, O_RDWR, 0);
3282
3283         file_end = yaffs_lseek(handle, 0, SEEK_END);
3284         printf("file_end %d\n", (int)file_end);
3285         for(i = 0; i < 10000; i++)
3286                 yaffs_write(handle, xx_buffer, sizeof(xx_buffer));
3287         yaffs_ftruncate(handle, file_end);
3288
3289         verify_big_sparse_file(handle);
3290         yaffs_unmount(mountpt);
3291
3292 }
3293
3294
3295 int  mk_dir(const char *mp, const char *name)
3296 {
3297         char full_name[100];
3298
3299         sprintf(full_name, "%s/%s", mp, name);
3300
3301         return yaffs_mkdir(full_name, S_IREAD| S_IWRITE);
3302 }
3303
3304 int  mk_file(const char *mp, const char *name)
3305 {
3306         char full_name[100];
3307         int h;
3308
3309         sprintf(full_name, "%s/%s", mp, name);
3310
3311         h = yaffs_open(full_name, O_RDWR | O_CREAT | O_TRUNC, S_IREAD| S_IWRITE);
3312
3313         yaffs_write(h, name, strlen(name));
3314
3315         yaffs_close(h);
3316         return 0;
3317 }
3318
3319 void xx_test(const char *mountpt)
3320 {
3321         yaffs_start_up();
3322
3323         yaffs_format(mountpt,0,0,0);
3324
3325         yaffs_mount(mountpt);
3326         printf("mounted\n");
3327         dumpDir(mountpt);
3328
3329         printf("create files\n");
3330
3331         mk_dir(mountpt, "foo");
3332         mk_file(mountpt, "foo/f1");
3333         mk_file(mountpt, "foo/f2");
3334         mk_file(mountpt, "foo/f3");
3335         mk_file(mountpt, "foo/f4");
3336         dump_directory_tree(mountpt);
3337
3338         printf("unmount and remount\n");
3339
3340         /* Unmount/remount */
3341         yaffs_unmount(mountpt);
3342         yaffs_mount(mountpt);
3343         dump_directory_tree(mountpt);
3344 }
3345
3346 void yy_test(const char *mountpt)
3347 {
3348         yaffs_start_up();
3349
3350         yaffs_mount(mountpt);
3351         dump_directory_tree(mountpt);
3352 }
3353
3354
3355 void readdir_test(const char *mountpt)
3356 {
3357         int i;
3358         yaffs_DIR *dirs[100];
3359
3360         yaffs_trace_mask = 0;
3361
3362         yaffs_start_up();
3363
3364         yaffs_mount(mountpt);
3365
3366         for(i = 0; i < 100; i++) {
3367                  dirs[i] = yaffs_opendir(mountpt);
3368                  printf("%2d %p,", i, dirs[i]);
3369         }
3370
3371         printf("\n");
3372
3373         for(i = 0; i < 100; i++) {
3374                  if(dirs[i])
3375                           yaffs_closedir(dirs[i]);
3376         }
3377
3378
3379         for(i = 0; i < 100; i++) {
3380                  dirs[i] = yaffs_opendir(mountpt);
3381                  printf("%2d %p,", i, dirs[i]);
3382         }
3383
3384         yaffs_unmount(mountpt);
3385
3386 }
3387
3388 void format_test(const char *mountpt)
3389 {
3390         int ret;
3391
3392         yaffs_start_up();
3393
3394         ret = yaffs_format(mountpt, 0, 0, 0);
3395         printf("yaffs_format(...,0, 0, 0) of unmounted returned %d."
3396                 " Should return 0\n\n\n", ret);
3397
3398         yaffs_mount(mountpt);
3399
3400         ret = yaffs_format(mountpt, 0, 0, 0);
3401         printf("yaffs_format(...,0, 0, 0) of mounted returned %d."
3402                 " Should return -1 (busy)\n\n\n", ret);
3403
3404         ret = yaffs_format(mountpt, 1, 0, 0);
3405         printf("yaffs_format(...,1, 0, 0) of mounted returned %d."
3406                 " Should return 0.\n\n\n", ret);
3407
3408         ret = yaffs_mount(mountpt);
3409         printf("mount should return 0 returned %d\n\n\n", ret);
3410
3411         ret = yaffs_format(mountpt, 1, 0, 1);
3412         printf("yaffs_format(...,1, 0, 1) of mounted returned %d."
3413                 " Should return 0.\n\n\n", ret);
3414
3415         ret = yaffs_mount(mountpt);
3416         printf("mount should return -1 returned %d\n", ret);