1/*
2* Test code for the "direct" interface.
3*/
4
5
6#include <stdio.h>
7#include <string.h>
8#include <unistd.h>
9#include <fcntl.h>
10
11#include "yaffsfs.h"
12
13void dumpDir(const char *dname);
14
15char xx[600];
16
17void copy_in_a_file(char *yaffsName,char *inName)
18{
19	int inh,outh;
20	unsigned char buffer[100];
21	int ni,no;
22	inh = open(inName,O_RDONLY);
23	outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
24
25	while((ni = read(inh,buffer,100)) > 0)
26	{
27		no = yaffs_write(outh,buffer,ni);
28		if(ni != no)
29		{
30			printf("problem writing yaffs file\n");
31		}
32
33	}
34
35	yaffs_close(outh);
36	close(inh);
37}
38
39void make_a_file(char *yaffsName,char bval,int sizeOfFile)
40{
41	int outh;
42	int i;
43	unsigned char buffer[100];
44
45	outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
46
47	memset(buffer,bval,100);
48
49	do{
50		i = sizeOfFile;
51		if(i > 100) i = 100;
52		sizeOfFile -= i;
53
54		yaffs_write(outh,buffer,i);
55
56	} while (sizeOfFile > 0);
57
58
59	yaffs_close(outh);
60
61}
62
63void make_pattern_file(char *fn,int size)
64{
65	int outh;
66	int marker;
67	int i;
68	outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
69	yaffs_lseek(outh,size-1,SEEK_SET);
70	yaffs_write(outh,"A",1);
71
72	for(i = 0; i < size; i+=256)
73	{
74		marker = ~i;
75		yaffs_lseek(outh,i,SEEK_SET);
76		yaffs_write(outh,&marker,sizeof(marker));
77	}
78	yaffs_close(outh);
79
80}
81
82int check_pattern_file(char *fn)
83{
84	int h;
85	int marker;
86	int i;
87	int size;
88	int ok = 1;
89
90	h = yaffs_open(fn, O_RDWR,0);
91	size = yaffs_lseek(h,0,SEEK_END);
92
93	for(i = 0; i < size; i+=256)
94	{
95		yaffs_lseek(h,i,SEEK_SET);
96		yaffs_read(h,&marker,sizeof(marker));
97		ok = (marker == ~i);
98		if(!ok)
99		{
100		   printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x\n",
101					fn,size,i,marker,~i);
102		}
103	}
104	yaffs_close(h);
105	return ok;
106}
107
108
109
110
111
112int dump_file_data(char *fn)
113{
114	int h;
115	int marker;
116	int i = 0;
117	int size;
118	int ok = 1;
119	unsigned char b;
120
121	h = yaffs_open(fn, O_RDWR,0);
122
123
124	printf("%s\n",fn);
125	while(yaffs_read(h,&b,1)> 0)
126	{
127		printf("%02x",b);
128		i++;
129		if(i > 32)
130		{
131		   printf("\n");
132		   i = 0;;
133		 }
134	}
135	printf("\n");
136	yaffs_close(h);
137	return ok;
138}
139
140
141
142void dump_file(const char *fn)
143{
144	int i;
145	int size;
146	int h;
147
148	h = yaffs_open(fn,O_RDONLY,0);
149	if(h < 0)
150	{
151		printf("*****\nDump file %s does not exist\n",fn);
152	}
153	else
154	{
155		size = yaffs_lseek(h,0,SEEK_SET);
156		printf("*****\nDump file %s size %d\n",fn,size);
157		for(i = 0; i < size; i++)
158		{
159
160		}
161	}
162}
163
164void create_file_of_size(const char *fn,int syze)
165{
166	int h;
167	int n;
168
169	char xx[200];
170
171	int iterations = (syze + strlen(fn) -1)/ strlen(fn);
172
173	h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
174
175	while (iterations > 0)
176	{
177		sprintf(xx,"%s %8d",fn,iterations);
178		yaffs_write(h,xx,strlen(xx));
179		iterations--;
180	}
181	yaffs_close (h);
182}
183
184void verify_file_of_size(const char *fn,int syze)
185{
186	int h;
187	int n;
188
189	char xx[200];
190	char yy[200];
191	int l;
192
193	int iterations = (syze + strlen(fn) -1)/ strlen(fn);
194
195	h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
196
197	while (iterations > 0)
198	{
199		sprintf(xx,"%s %8d",fn,iterations);
200		l = strlen(xx);
201
202		yaffs_read(h,yy,l);
203		yy[l] = 0;
204
205		if(strcmp(xx,yy)){
206			printf("=====>>>>> verification of file %s failed near position %d\n",fn,yaffs_lseek(h,0,SEEK_CUR));
207		}
208		iterations--;
209	}
210	yaffs_close (h);
211}
212
213void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2)
214{
215	int h;
216	int n;
217
218
219	int iterations;
220
221	h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
222
223	iterations = (syze1 + strlen(fn) -1)/ strlen(fn);
224	while (iterations > 0)
225	{
226		yaffs_write(h,fn,strlen(fn));
227		iterations--;
228	}
229
230	yaffs_truncate(h,reSyze);
231
232	yaffs_lseek(h,0,SEEK_SET);
233	iterations = (syze2 + strlen(fn) -1)/ strlen(fn);
234	while (iterations > 0)
235	{
236		yaffs_write(h,fn,strlen(fn));
237		iterations--;
238	}
239
240	yaffs_close (h);
241}
242
243
244void do_some_file_stuff(const char *path)
245{
246
247	char fn[100];
248
249	sprintf(fn,"%s/%s",path,"f1");
250	create_file_of_size(fn,10000);
251
252	sprintf(fn,"%s/%s",path,"fdel");
253	create_file_of_size(fn,10000);
254	yaffs_unlink(fn);
255
256	sprintf(fn,"%s/%s",path,"f2");
257
258	create_resized_file_of_size(fn,10000,3000,4000);
259}
260
261void yaffs_backward_scan_test(const char *path)
262{
263	char fn[100];
264
265	yaffs_StartUp();
266
267	yaffs_mount(path);
268
269	do_some_file_stuff(path);
270
271	sprintf(fn,"%s/ddd",path);
272
273	yaffs_mkdir(fn,0);
274
275	do_some_file_stuff(fn);
276
277	yaffs_unmount(path);
278
279	yaffs_mount(path);
280}
281
282char xxzz[2000];
283
284
285void yaffs_device_flush_test(const char *path)
286{
287	char fn[100];
288	int h;
289	int i;
290
291	yaffs_StartUp();
292
293	yaffs_mount(path);
294
295	do_some_file_stuff(path);
296
297	// Open and add some data to a few files
298	for(i = 0; i < 10; i++) {
299
300		sprintf(fn,"%s/ff%d",path,i);
301
302		h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD);
303		yaffs_write(h,xxzz,2000);
304		yaffs_write(h,xxzz,2000);
305	}
306	yaffs_unmount(path);
307
308	yaffs_mount(path);
309}
310
311
312
313void short_scan_test(const char *path, int fsize, int niterations)
314{
315	int i;
316	char fn[100];
317
318	sprintf(fn,"%s/%s",path,"f1");
319
320	yaffs_StartUp();
321	for(i = 0; i < niterations; i++)
322	{
323		printf("\n*****************\nIteration %d\n",i);
324		yaffs_mount(path);
325		printf("\nmount: Directory look-up of %s\n",path);
326		dumpDir(path);
327		make_a_file(fn,1,fsize);
328		yaffs_unmount(path);
329	}
330}
331
332
333
334void scan_pattern_test(const char *path, int fsize, int niterations)
335{
336	int i;
337	int j;
338	char fn[3][100];
339	int result;
340
341	sprintf(fn[0],"%s/%s",path,"f0");
342	sprintf(fn[1],"%s/%s",path,"f1");
343	sprintf(fn[2],"%s/%s",path,"f2");
344
345	yaffs_StartUp();
346
347	for(i = 0; i < niterations; i++)
348	{
349		printf("\n*****************\nIteration %d\n",i);
350		yaffs_mount(path);
351		printf("\nmount: Directory look-up of %s\n",path);
352		dumpDir(path);
353		for(j = 0; j < 3; j++)
354		{
355			result = dump_file_data(fn[j]);
356			result = check_pattern_file(fn[j]);
357			make_pattern_file(fn[j],fsize);
358			result = dump_file_data(fn[j]);
359			result = check_pattern_file(fn[j]);
360		}
361		yaffs_unmount(path);
362	}
363}
364
365void fill_disk(char *path,int nfiles)
366{
367	int h;
368	int n;
369	int result;
370	int f;
371
372	char str[50];
373
374	for(n = 0; n < nfiles; n++)
375	{
376		sprintf(str,"%s/%d",path,n);
377
378		h = yaffs_open(str, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
379
380		printf("writing file %s handle %d ",str, h);
381
382		while ((result = yaffs_write(h,xx,600)) == 600)
383		{
384			f = yaffs_freespace(path);
385		}
386		result = yaffs_close(h);
387		printf(" close %d\n",result);
388	}
389}
390
391void fill_disk_and_delete(char *path, int nfiles, int ncycles)
392{
393	int i,j;
394	char str[50];
395	int result;
396
397	for(i = 0; i < ncycles; i++)
398	{
399		printf("@@@@@@@@@@@@@@ cycle %d\n",i);
400		fill_disk(path,nfiles);
401
402		for(j = 0; j < nfiles; j++)
403		{
404			sprintf(str,"%s/%d",path,j);
405			result = yaffs_unlink(str);
406			printf("unlinking file %s, result %d\n",str,result);
407		}
408	}
409}
410
411
412void fill_files(char *path,int flags, int maxIterations,int siz)
413{
414	int i;
415	int j;
416	char str[50];
417	int h;
418
419	i = 0;
420
421	do{
422		sprintf(str,"%s/%d",path,i);
423		h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
424		yaffs_close(h);
425
426		if(h >= 0)
427		{
428			for(j = 0; j < siz; j++)
429			{
430				yaffs_write(h,str,1);
431			}
432		}
433
434		if( flags & 1)
435		{
436			yaffs_unlink(str);
437		}
438		i++;
439	} while(h >= 0 && i < maxIterations);
440
441	if(flags & 2)
442	{
443		i = 0;
444		do{
445			sprintf(str,"%s/%d",path,i);
446			printf("unlink %s\n",str);
447			i++;
448		} while(yaffs_unlink(str) >= 0);
449	}
450}
451
452void leave_unlinked_file(char *path,int maxIterations,int siz)
453{
454	int i;
455	char str[50];
456	int h;
457
458	i = 0;
459
460	do{
461		sprintf(str,"%s/%d",path,i);
462		printf("create %s\n",str);
463		h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
464		if(h >= 0)
465		{
466			yaffs_unlink(str);
467		}
468		i++;
469	} while(h < 0 && i < maxIterations);
470
471	if(h >= 0)
472	{
473		for(i = 0; i < siz; i++)
474		{
475			yaffs_write(h,str,1);
476		}
477	}
478
479	printf("Leaving file %s open\n",str);
480
481}
482
483void dumpDirFollow(const char *dname)
484{
485	yaffs_DIR *d;
486	yaffs_dirent *de;
487	struct yaffs_stat s;
488	char str[100];
489
490	d = yaffs_opendir(dname);
491
492	if(!d)
493	{
494		printf("opendir failed\n");
495	}
496	else
497	{
498		while((de = yaffs_readdir(d)) != NULL)
499		{
500			sprintf(str,"%s/%s",dname,de->d_name);
501
502			yaffs_stat(str,&s);
503
504			printf("%s length %d mode %X ",de->d_name,(int)s.st_size,s.st_mode);
505			switch(s.st_mode & S_IFMT)
506			{
507				case S_IFREG: printf("data file"); break;
508				case S_IFDIR: printf("directory"); break;
509				case S_IFLNK: printf("symlink -->");
510							  if(yaffs_readlink(str,str,100) < 0)
511								printf("no alias");
512							  else
513								printf("\"%s\"",str);
514							  break;
515				default: printf("unknown"); break;
516			}
517
518			printf("\n");
519		}
520
521		yaffs_closedir(d);
522	}
523	printf("\n");
524
525	printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
526
527}
528
529
530void dump_directory_tree_worker(const char *dname,int recursive)
531{
532	yaffs_DIR *d;
533	yaffs_dirent *de;
534	struct yaffs_stat s;
535	char str[100];
536
537	d = yaffs_opendir(dname);
538
539	if(!d)
540	{
541		printf("opendir failed\n");
542	}
543	else
544	{
545		while((de = yaffs_readdir(d)) != NULL)
546		{
547			sprintf(str,"%s/%s",dname,de->d_name);
548
549			yaffs_lstat(str,&s);
550
551			printf("%s length %d mode %X ",str,(int)s.st_size,s.st_mode);
552			switch(s.st_mode & S_IFMT)
553			{
554				case S_IFREG: printf("data file"); break;
555				case S_IFDIR: printf("directory"); break;
556				case S_IFLNK: printf("symlink -->");
557							  if(yaffs_readlink(str,str,100) < 0)
558								printf("no alias");
559							  else
560								printf("\"%s\"",str);
561							  break;
562				default: printf("unknown"); break;
563			}
564
565			printf("\n");
566
567			if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
568				dump_directory_tree_worker(str,1);
569
570		}
571
572		yaffs_closedir(d);
573	}
574
575}
576
577static void dump_directory_tree(const char *dname)
578{
579	dump_directory_tree_worker(dname,1);
580	printf("\n");
581	printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
582}
583
584void dumpDir(const char *dname)
585{	dump_directory_tree_worker(dname,0);
586	printf("\n");
587	printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
588}
589
590
591static void PermissionsCheck(const char *path, mode_t tmode, int tflags,int expectedResult)
592{
593	int fd;
594
595	if(yaffs_chmod(path,tmode)< 0) printf("chmod failed\n");
596
597	fd = yaffs_open(path,tflags,0);
598
599	if((fd >= 0) != (expectedResult > 0))
600	{
601		printf("Permissions check %x %x %d failed\n",tmode,tflags,expectedResult);
602	}
603	else
604	{
605		printf("Permissions check %x %x %d OK\n",tmode,tflags,expectedResult);
606	}
607
608
609	yaffs_close(fd);
610
611
612}
613
614int long_test(int argc, char *argv[])
615{
616
617	int f;
618	int r;
619	char buffer[20];
620
621	char str[100];
622
623	int h;
624	mode_t temp_mode;
625	struct yaffs_stat ystat;
626
627	yaffs_StartUp();
628
629	yaffs_mount("/boot");
630	yaffs_mount("/data");
631	yaffs_mount("/flash");
632	yaffs_mount("/ram");
633
634	printf("\nDirectory look-up of /boot\n");
635	dumpDir("/boot");
636	printf("\nDirectory look-up of /data\n");
637	dumpDir("/data");
638	printf("\nDirectory look-up of /flash\n");
639	dumpDir("/flash");
640
641	//leave_unlinked_file("/flash",20000,0);
642	//leave_unlinked_file("/data",20000,0);
643
644	leave_unlinked_file("/ram",20,0);
645
646
647	f = yaffs_open("/boot/b1", O_RDONLY,0);
648
649	printf("open /boot/b1 readonly, f=%d\n",f);
650
651	f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
652
653	printf("open /boot/b1 O_CREAT, f=%d\n",f);
654
655
656	r = yaffs_write(f,"hello",1);
657	printf("write %d attempted to write to a read-only file\n",r);
658
659	r = yaffs_close(f);
660
661	printf("close %d\n",r);
662
663	f = yaffs_open("/boot/b1", O_RDWR,0);
664
665	printf("open /boot/b1 O_RDWR,f=%d\n",f);
666
667
668	r = yaffs_write(f,"hello",2);
669	printf("write %d attempted to write to a writeable file\n",r);
670	r = yaffs_write(f,"world",3);
671	printf("write %d attempted to write to a writeable file\n",r);
672
673	r= yaffs_lseek(f,0,SEEK_END);
674	printf("seek end %d\n",r);
675	memset(buffer,0,20);
676	r = yaffs_read(f,buffer,10);
677	printf("read %d \"%s\"\n",r,buffer);
678	r= yaffs_lseek(f,0,SEEK_SET);
679	printf("seek set %d\n",r);
680	memset(buffer,0,20);
681	r = yaffs_read(f,buffer,10);
682	printf("read %d \"%s\"\n",r,buffer);
683	memset(buffer,0,20);
684	r = yaffs_read(f,buffer,10);
685	printf("read %d \"%s\"\n",r,buffer);
686
687	// Check values reading at end.
688	// A read past end of file should return 0 for 0 bytes read.
689
690	r= yaffs_lseek(f,0,SEEK_END);
691	r = yaffs_read(f,buffer,10);
692	printf("read at end returned  %d\n",r);
693	r= yaffs_lseek(f,500,SEEK_END);
694	r = yaffs_read(f,buffer,10);
695	printf("read past end returned  %d\n",r);
696
697	r = yaffs_close(f);
698
699	printf("close %d\n",r);
700
701	copy_in_a_file("/boot/yyfile","xxx");
702
703	// Create a file with a long name
704
705	copy_in_a_file("/boot/file with a long name","xxx");
706
707
708	printf("\nDirectory look-up of /boot\n");
709	dumpDir("/boot");
710
711	// Check stat
712	r = yaffs_stat("/boot/file with a long name",&ystat);
713
714	// Check rename
715
716	r = yaffs_rename("/boot/file with a long name","/boot/r1");
717
718	printf("\nDirectory look-up of /boot\n");
719	dumpDir("/boot");
720
721	// Check unlink
722	r = yaffs_unlink("/boot/r1");
723
724	printf("\nDirectory look-up of /boot\n");
725	dumpDir("/boot");
726
727	// Check mkdir
728
729	r = yaffs_mkdir("/boot/directory1",0);
730
731	printf("\nDirectory look-up of /boot\n");
732	dumpDir("/boot");
733	printf("\nDirectory look-up of /boot/directory1\n");
734	dumpDir("/boot/directory1");
735
736	// add a file to the directory
737	copy_in_a_file("/boot/directory1/file with a long name","xxx");
738
739	printf("\nDirectory look-up of /boot\n");
740	dumpDir("/boot");
741	printf("\nDirectory look-up of /boot/directory1\n");
742	dumpDir("/boot/directory1");
743
744	//  Attempt to delete directory (should fail)
745
746	r = yaffs_rmdir("/boot/directory1");
747
748	printf("\nDirectory look-up of /boot\n");
749	dumpDir("/boot");
750	printf("\nDirectory look-up of /boot/directory1\n");
751	dumpDir("/boot/directory1");
752
753	// Delete file first, then rmdir should work
754	r = yaffs_unlink("/boot/directory1/file with a long name");
755	r = yaffs_rmdir("/boot/directory1");
756
757
758	printf("\nDirectory look-up of /boot\n");
759	dumpDir("/boot");
760	printf("\nDirectory look-up of /boot/directory1\n");
761	dumpDir("/boot/directory1");
762
763#if 0
764	fill_disk_and_delete("/boot",20,20);
765
766	printf("\nDirectory look-up of /boot\n");
767	dumpDir("/boot");
768#endif
769
770	yaffs_symlink("yyfile","/boot/slink");
771
772	yaffs_readlink("/boot/slink",str,100);
773	printf("symlink alias is %s\n",str);
774
775
776
777
778	printf("\nDirectory look-up of /boot\n");
779	dumpDir("/boot");
780	printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
781	dumpDirFollow("/boot");
782	printf("\nDirectory look-up of /boot/directory1\n");
783	dumpDir("/boot/directory1");
784
785	h = yaffs_open("/boot/slink",O_RDWR,0);
786
787	printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
788
789	yaffs_close(h);
790
791	yaffs_unlink("/boot/slink");
792
793
794	printf("\nDirectory look-up of /boot\n");
795	dumpDir("/boot");
796
797	// Check chmod
798
799	yaffs_stat("/boot/yyfile",&ystat);
800	temp_mode = ystat.st_mode;
801
802	yaffs_chmod("/boot/yyfile",0x55555);
803	printf("\nDirectory look-up of /boot\n");
804	dumpDir("/boot");
805
806	yaffs_chmod("/boot/yyfile",temp_mode);
807	printf("\nDirectory look-up of /boot\n");
808	dumpDir("/boot");
809
810	// Permission checks...
811	PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
812	PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
813	PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
814
815	PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
816	PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
817	PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
818
819	PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
820	PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
821	PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
822
823	PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
824	PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
825	PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
826
827	yaffs_chmod("/boot/yyfile",temp_mode);
828
829	//create a zero-length file and unlink it (test for scan bug)
830
831	h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
832	yaffs_close(h);
833
834	yaffs_unlink("/boot/zlf");
835
836
837	yaffs_DumpDevStruct("/boot");
838
839	fill_disk_and_delete("/boot",20,20);
840
841	yaffs_DumpDevStruct("/boot");
842
843	fill_files("/boot",1,10000,0);
844	fill_files("/boot",1,10000,5000);
845	fill_files("/boot",2,10000,0);
846	fill_files("/boot",2,10000,5000);
847
848	leave_unlinked_file("/data",20000,0);
849	leave_unlinked_file("/data",20000,5000);
850	leave_unlinked_file("/data",20000,5000);
851	leave_unlinked_file("/data",20000,5000);
852	leave_unlinked_file("/data",20000,5000);
853	leave_unlinked_file("/data",20000,5000);
854
855	yaffs_DumpDevStruct("/boot");
856	yaffs_DumpDevStruct("/data");
857
858
859
860	return 0;
861
862}
863
864int huge_directory_test_on_path(char *path)
865{
866
867	yaffs_DIR *d;
868	yaffs_dirent *de;
869	struct yaffs_stat s;
870
871	int f;
872	int i;
873	int r;
874	int total = 0;
875	int lastTotal = 0;
876	char buffer[20];
877
878	char str[100];
879	char name[100];
880	char name2[100];
881
882	int h;
883	mode_t temp_mode;
884	struct yaffs_stat ystat;
885
886	yaffs_StartUp();
887
888	yaffs_mount(path);
889
890	// Create a large number of files
891
892	for(i = 0; i < 2000; i++)
893	{
894	  sprintf(str,"%s/%d",path,i);
895
896	   f = yaffs_open(str,O_CREAT,S_IREAD | S_IWRITE);
897	   yaffs_close(f);
898	}
899
900
901
902	d = yaffs_opendir(path);
903	i = 0;
904	if (d) {
905	while((de = yaffs_readdir(d)) != NULL) {
906	if (total >lastTotal+100*9*1024||(i & 1023)==0){
907	printf("files = %d, total = %d\n",i, total);
908	lastTotal = total;
909	}
910		i++;
911		sprintf(str,"%s/%s",path,de->d_name);
912		yaffs_lstat(str,&s);
913		switch(s.st_mode & S_IFMT){
914		case S_IFREG:
915	//printf("data file");
916	total += s.st_size;
917	break;
918	}
919	}
920
921	yaffs_closedir(d);
922	}
923
924	return 0;
925}
926
927int yaffs_scan_test(const char *path)
928{
929}
930
931
932void rename_over_test(const char *mountpt)
933{
934	int i;
935	char a[100];
936	char b[100];
937
938	sprintf(a,"%s/a",mountpt);
939	sprintf(b,"%s/b",mountpt);
940
941	yaffs_StartUp();
942
943	yaffs_mount(mountpt);
944	i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
945	yaffs_close(i);
946	i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR, 0);
947	yaffs_close(i);
948	yaffs_rename(a,b); // rename over
949	yaffs_rename(b,a); // rename back again (not renaimng over)
950	yaffs_rename(a,b); // rename back again (not renaimng over)
951
952
953	yaffs_unmount(mountpt);
954
955}
956
957int resize_stress_test(const char *path)
958{
959   int a,b,i,j;
960   int x;
961   int r;
962   char aname[100];
963   char bname[100];
964
965   char abuffer[1000];
966   char bbuffer[1000];
967
968   yaffs_StartUp();
969
970   yaffs_mount(path);
971
972   sprintf(aname,"%s%s",path,"/a");
973   sprintf(bname,"%s%s",path,"/b");
974
975   memset(abuffer,'a',1000);
976   memset(bbuffer,'b',1000);
977
978   a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
979   b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
980
981   printf(" %s %d %s %d\n",aname,a,bname,b);
982
983   x = 0;
984
985   for(j = 0; j < 100; j++)
986   {
987		yaffs_lseek(a,0,SEEK_END);
988
989
990		for(i = 0; i <20000; i++)
991		{
992		   //r =        yaffs_lseek(b,i,SEEK_SET);
993			//r = yaffs_write(b,bbuffer,1000);
994
995			if(x & 0x16)
996			{
997				// shrink
998				int syz = yaffs_lseek(a,0,SEEK_END);
999
1000				syz -= 500;
1001				if(syz < 0) syz = 0;
1002				yaffs_truncate(a,syz);
1003
1004			}
1005			else
1006			{
1007				//expand
1008				r = yaffs_lseek(a,i * 500,SEEK_SET);
1009				r = yaffs_write(a,abuffer,1000);
1010			}
1011			x++;
1012
1013		}
1014   }
1015
1016   return 0;
1017
1018}
1019
1020
1021int resize_stress_test_no_grow_complex(const char *path,int iters)
1022{
1023   int a,b,i,j;
1024   int x;
1025   int r;
1026   char aname[100];
1027   char bname[100];
1028
1029   char abuffer[1000];
1030   char bbuffer[1000];
1031
1032   yaffs_StartUp();
1033
1034   yaffs_mount(path);
1035
1036   sprintf(aname,"%s%s",path,"/a");
1037   sprintf(bname,"%s%s",path,"/b");
1038
1039   memset(abuffer,'a',1000);
1040   memset(bbuffer,'b',1000);
1041
1042   a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1043   b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1044
1045   printf(" %s %d %s %d\n",aname,a,bname,b);
1046
1047   x = 0;
1048
1049   for(j = 0; j < iters; j++)
1050   {
1051		yaffs_lseek(a,0,SEEK_END);
1052
1053
1054		for(i = 0; i <20000; i++)
1055		{
1056		   //r =        yaffs_lseek(b,i,SEEK_SET);
1057			//r = yaffs_write(b,bbuffer,1000);
1058
1059			if(!(x%20))
1060			{
1061				// shrink
1062				int syz = yaffs_lseek(a,0,SEEK_END);
1063
1064				while(syz > 4000)
1065				{
1066
1067					syz -= 2050;
1068					if(syz < 0) syz = 0;
1069					yaffs_truncate(a,syz);
1070					syz = yaffs_lseek(a,0,SEEK_END);
1071					printf("shrink to %d\n",syz);
1072				}
1073
1074
1075			}
1076			else
1077			{
1078				//expand
1079				r = yaffs_lseek(a,500,SEEK_END);
1080				r = yaffs_write(a,abuffer,1000);
1081			}
1082			x++;
1083
1084
1085		}
1086		printf("file size is %d\n",yaffs_lseek(a,0,SEEK_END));
1087
1088   }
1089
1090   return 0;
1091
1092}
1093
1094int resize_stress_test_no_grow(const char *path,int iters)
1095{
1096   int a,b,i,j;
1097   int x;
1098   int r;
1099   char aname[100];
1100   char bname[100];
1101
1102   char abuffer[1000];
1103   char bbuffer[1000];
1104
1105   yaffs_StartUp();
1106
1107   yaffs_mount(path);
1108
1109   sprintf(aname,"%s%s",path,"/a");
1110   sprintf(bname,"%s%s",path,"/b");
1111
1112   memset(abuffer,'a',1000);
1113   memset(bbuffer,'b',1000);
1114
1115   a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1116   b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1117
1118   printf(" %s %d %s %d\n",aname,a,bname,b);
1119
1120   x = 0;
1121
1122   for(j = 0; j < iters; j++)
1123   {
1124		yaffs_lseek(a,0,SEEK_END);
1125
1126
1127		for(i = 0; i <20000; i++)
1128		{
1129		   //r =        yaffs_lseek(b,i,SEEK_SET);
1130			//r = yaffs_write(b,bbuffer,1000);
1131
1132			if(!(x%20))
1133			{
1134				// shrink
1135				int syz = yaffs_lseek(a,0,SEEK_END);
1136
1137				while(syz > 4000)
1138				{
1139
1140					syz -= 2050;
1141					if(syz < 0) syz = 0;
1142					yaffs_truncate(a,syz);
1143					syz = yaffs_lseek(a,0,SEEK_END);
1144					printf("shrink to %d\n",syz);
1145				}
1146
1147
1148			}
1149			else
1150			{
1151				//expand
1152				r = yaffs_lseek(a,-500,SEEK_END);
1153				r = yaffs_write(a,abuffer,1000);
1154			}
1155			x++;
1156
1157
1158		}
1159		printf("file size is %d\n",yaffs_lseek(a,0,SEEK_END));
1160
1161   }
1162
1163   return 0;
1164
1165}
1166
1167int directory_rename_test(void)
1168{
1169	int r;
1170	yaffs_StartUp();
1171
1172	yaffs_mount("/ram");
1173	yaffs_mkdir("/ram/a",0);
1174	yaffs_mkdir("/ram/a/b",0);
1175	yaffs_mkdir("/ram/c",0);
1176
1177	printf("\nDirectory look-up of /ram\n");
1178	dumpDir("/ram");
1179	dumpDir("/ram/a");
1180	dumpDir("/ram/a/b");
1181
1182	printf("Do rename (should fail)\n");
1183
1184	r = yaffs_rename("/ram/a","/ram/a/b/d");
1185	printf("\nDirectory look-up of /ram\n");
1186	dumpDir("/ram");
1187	dumpDir("/ram/a");
1188	dumpDir("/ram/a/b");
1189
1190	printf("Do rename (should not fail)\n");
1191
1192	r = yaffs_rename("/ram/c","/ram/a/b/d");
1193	printf("\nDirectory look-up of /ram\n");
1194	dumpDir("/ram");
1195	dumpDir("/ram/a");
1196	dumpDir("/ram/a/b");
1197
1198
1199	return 1;
1200
1201}
1202
1203int cache_read_test(void)
1204{
1205	int a,b,c;
1206	int i;
1207	int sizeOfFiles = 500000;
1208	char buffer[100];
1209
1210	yaffs_StartUp();
1211
1212	yaffs_mount("/boot");
1213
1214	make_a_file("/boot/a",'a',sizeOfFiles);
1215	make_a_file("/boot/b",'b',sizeOfFiles);
1216
1217	a = yaffs_open("/boot/a",O_RDONLY,0);
1218	b = yaffs_open("/boot/b",O_RDONLY,0);
1219	c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
1220
1221	do{
1222		i = sizeOfFiles;
1223		if (i > 100) i = 100;
1224		sizeOfFiles  -= i;
1225		yaffs_read(a,buffer,i);
1226		yaffs_read(b,buffer,i);
1227		yaffs_write(c,buffer,i);
1228	} while(sizeOfFiles > 0);
1229
1230
1231
1232	return 1;
1233
1234}
1235
1236int cache_bypass_bug_test(void)
1237{
1238	// This test reporoduces a bug whereby YAFFS caching *was* buypassed
1239	// resulting in erroneous reads after writes.
1240	// This bug has been fixed.
1241
1242	int a;
1243	int i;
1244	char buffer1[1000];
1245	char buffer2[1000];
1246
1247	memset(buffer1,0,sizeof(buffer1));
1248	memset(buffer2,0,sizeof(buffer2));
1249
1250	yaffs_StartUp();
1251
1252	yaffs_mount("/boot");
1253
1254	// Create a file of 2000 bytes.
1255	make_a_file("/boot/a",'X',2000);
1256
1257	a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
1258
1259	// Write a short sequence to the file.
1260	// This will go into the cache.
1261	yaffs_lseek(a,0,SEEK_SET);
1262	yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
1263
1264	// Read a short sequence from the file.
1265	// This will come from the cache.
1266	yaffs_lseek(a,0,SEEK_SET);
1267	yaffs_read(a,buffer1,30);
1268
1269	// Read a page size sequence from the file.
1270	yaffs_lseek(a,0,SEEK_SET);
1271	yaffs_read(a,buffer2,512);
1272
1273	printf("buffer 1 %s\n",buffer1);
1274	printf("buffer 2 %s\n",buffer2);
1275
1276	if(strncmp(buffer1,buffer2,20))
1277	{
1278		printf("Cache bypass bug detected!!!!!\n");
1279	}
1280
1281
1282	return 1;
1283}
1284
1285
1286int free_space_check(void)
1287{
1288	int f;
1289
1290		yaffs_StartUp();
1291		yaffs_mount("/boot");
1292	    fill_disk("/boot/",2);
1293	    f = yaffs_freespace("/boot");
1294
1295	    printf("%d free when disk full\n",f);
1296	    return 1;
1297}
1298
1299int truncate_test(void)
1300{
1301	int a;
1302	int r;
1303	int i;
1304	int l;
1305
1306	char y[10];
1307
1308	yaffs_StartUp();
1309	yaffs_mount("/boot");
1310
1311	yaffs_unlink("/boot/trunctest");
1312
1313	a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);
1314
1315	yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
1316
1317	yaffs_truncate(a,3);
1318	l= yaffs_lseek(a,0,SEEK_END);
1319
1320	printf("truncated length is %d\n",l);
1321
1322	yaffs_lseek(a,5,SEEK_SET);
1323	yaffs_write(a,"1",1);
1324
1325	yaffs_lseek(a,0,SEEK_SET);
1326
1327	r = yaffs_read(a,y,10);
1328
1329	printf("read %d bytes:",r);
1330
1331	for(i = 0; i < r; i++) printf("[%02X]",y[i]);
1332
1333	printf("\n");
1334
1335	return 0;
1336
1337}
1338
1339
1340
1341
1342
1343void fill_disk_test(const char *mountpt)
1344{
1345	int i;
1346	yaffs_StartUp();
1347
1348	for(i = 0; i < 5; i++)
1349	{
1350		yaffs_mount(mountpt);
1351		fill_disk_and_delete(mountpt,100,i+1);
1352		yaffs_unmount(mountpt);
1353	}
1354
1355}
1356
1357
1358
1359void lookup_test(const char *mountpt)
1360{
1361	int i;
1362	int h;
1363	char a[100];
1364	char b[100];
1365
1366
1367	yaffs_DIR *d;
1368	yaffs_dirent *de;
1369	struct yaffs_stat s;
1370	char str[100];
1371
1372	yaffs_StartUp();
1373
1374	yaffs_mount(mountpt);
1375
1376	d = yaffs_opendir(mountpt);
1377
1378	if(!d)
1379	{
1380		printf("opendir failed\n");
1381	}
1382	else
1383	{
1384
1385		for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1386		{
1387			printf("unlinking %s\n",de->d_name);
1388			yaffs_unlink(de->d_name);
1389		}
1390
1391		printf("%d files deleted\n",i);
1392	}
1393
1394
1395	for(i = 0; i < 2000; i++){
1396	sprintf(a,"%s/%d",mountpt,i);
1397		h =  yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
1398		yaffs_close(h);
1399	}
1400
1401	yaffs_rewinddir(d);
1402	for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
1403	{
1404		printf("%d  %s\n",i,de->d_name);
1405	}
1406
1407	printf("%d files listed\n\n\n",i);
1408
1409	yaffs_rewinddir(d);
1410	yaffs_readdir(d);
1411	yaffs_readdir(d);
1412	yaffs_readdir(d);
1413
1414	for(i = 0; i < 2000; i++){
1415		sprintf(a,"%s/%d",mountpt,i);
1416		yaffs_unlink(a);
1417	}
1418
1419
1420	yaffs_unmount(mountpt);
1421
1422}
1423
1424void link_test(const char *mountpt)
1425{
1426	int i;
1427	int h;
1428	char a[100];
1429	char b[100];
1430	char c[100];
1431
1432	int  f0;
1433	int f1;
1434	int f2;
1435	int f3;
1436	sprintf(a,"%s/aaa",mountpt);
1437	sprintf(b,"%s/bbb",mountpt);
1438	sprintf(c,"%s/ccc",mountpt);
1439
1440	yaffs_StartUp();
1441
1442	yaffs_mount(mountpt);
1443
1444
1445	h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1446	for(i = 0; i < 100; i++)
1447		yaffs_write(h,a,100);
1448
1449	yaffs_close(h);
1450
1451	yaffs_unlink(b);
1452	yaffs_unlink(c);
1453	yaffs_link(a,b);
1454	yaffs_link(a,c);
1455	yaffs_unlink(b);
1456	yaffs_unlink(c);
1457	yaffs_unlink(a);
1458
1459
1460	yaffs_unmount(mountpt);
1461	yaffs_mount(mountpt);
1462
1463	printf("link test done\n");
1464
1465}
1466
1467void freespace_test(const char *mountpt)
1468{
1469	int i;
1470	int h;
1471	char a[100];
1472	char b[100];
1473
1474	int  f0;
1475	int f1;
1476	int f2;
1477	int f3;
1478	sprintf(a,"%s/aaa",mountpt);
1479
1480	yaffs_StartUp();
1481
1482	yaffs_mount(mountpt);
1483
1484	f0 = yaffs_freespace(mountpt);
1485
1486	h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1487
1488	for(i = 0; i < 100; i++)
1489		yaffs_write(h,a,100);
1490
1491	yaffs_close(h);
1492
1493	f1 = yaffs_freespace(mountpt);
1494
1495	yaffs_unlink(a);
1496
1497	f2 = yaffs_freespace(mountpt);
1498
1499
1500	yaffs_unmount(mountpt);
1501	yaffs_mount(mountpt);
1502
1503	f3 = yaffs_freespace(mountpt);
1504
1505	printf("%d\n%d\n%d\n%d\n",f0, f1,f2,f3);
1506
1507
1508}
1509
1510void simple_rw_test(const char *mountpt)
1511{
1512	int i;
1513	int h;
1514	char a[100];
1515
1516	int x;
1517	int result;
1518
1519	sprintf(a,"%s/aaa",mountpt);
1520
1521	yaffs_StartUp();
1522
1523	yaffs_mount(mountpt);
1524
1525	yaffs_unlink(a);
1526
1527	h = yaffs_open(a,O_CREAT| O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1528
1529	for(i = 100000;i < 200000; i++){
1530		result = yaffs_write(h,&i,sizeof(i));
1531
1532		if(result != 4)
1533		{
1534			printf("write error\n");
1535			exit(1);
1536		}
1537	}
1538
1539	//yaffs_close(h);
1540
1541	// h = yaffs_open(a,O_RDWR, S_IREAD | S_IWRITE);
1542
1543
1544	yaffs_lseek(h,0,SEEK_SET);
1545
1546	for(i = 100000; i < 200000; i++){
1547		result = yaffs_read(h,&x,sizeof(x));
1548
1549		if(result != 4 || x != i){
1550			printf("read error %d %x %x\n",i,result,x);
1551		}
1552	}
1553
1554	printf("Simple rw test passed\n");
1555
1556
1557
1558}
1559
1560
1561void scan_deleted_files_test(const char *mountpt)
1562{
1563	char fn[100];
1564	char sub[100];
1565
1566	const char *p;
1567
1568	int i;
1569	int j;
1570	int k;
1571	int h;
1572
1573	sprintf(sub,"%s/sdir",mountpt);
1574	yaffs_StartUp();
1575
1576	for(j = 0; j < 10; j++)
1577	{
1578		printf("\n\n>>>>>>> Run %d <<<<<<<<<<<<<\n\n",j);
1579		yaffs_mount(mountpt);
1580		yaffs_mkdir(sub,0);
1581
1582
1583		p = (j & 0) ? mountpt: sub;
1584
1585		for(i = 0; i < 100; i++)
1586		{
1587		  sprintf(fn,"%s/%d",p,i);
1588
1589		  if(i & 1)
1590		  {
1591			  h = yaffs_open(fn,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1592			  for(k = 0; k < 1000; k++)
1593				  yaffs_write(h,fn,100);
1594			  yaffs_close(h);
1595		  }
1596		  else
1597		    	yaffs_mkdir(fn,0);
1598		}
1599
1600		for(i = 0; i < 10; i++)
1601		{
1602		  sprintf(fn,"%s/%d",p,i);
1603		  if(i & 1)
1604		  	yaffs_unlink(fn);
1605		  else
1606		  	yaffs_rmdir(fn);
1607
1608		}
1609
1610		yaffs_unmount(mountpt);
1611	}
1612
1613
1614
1615
1616}
1617
1618
1619void write_10k(int h)
1620{
1621   int i;
1622   const char *s="0123456789";
1623   for(i = 0; i < 1000; i++)
1624     yaffs_write(h,s,10);
1625
1626}
1627void write_200k_file(const char *fn, const char *fdel, const char *fdel1)
1628{
1629   int h1;
1630   int i;
1631   int offs;
1632
1633   h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1634
1635   for(i = 0; i < 100000; i+= 10000)
1636   {
1637   	write_10k(h1);
1638   }
1639
1640   offs = yaffs_lseek(h1,0,SEEK_CUR);
1641   if( offs != 100000)
1642   {
1643   	printf("Could not write file\n");
1644   }
1645
1646   yaffs_unlink(fdel);
1647   for(i = 0; i < 100000; i+= 10000)
1648   {
1649   	write_10k(h1);
1650   }
1651
1652   offs = yaffs_lseek(h1,0,SEEK_CUR);
1653   if( offs != 200000)
1654   {
1655   	printf("Could not write file\n");
1656   }
1657
1658   yaffs_close(h1);
1659   yaffs_unlink(fdel1);
1660
1661}
1662
1663
1664void verify_200k_file(const char *fn)
1665{
1666   int h1;
1667   int i;
1668   char x[11];
1669   const char *s="0123456789";
1670   int errCount = 0;
1671
1672   h1 = yaffs_open(fn, O_RDONLY, 0);
1673
1674   for(i = 0; i < 200000 && errCount < 10; i+= 10)
1675   {
1676   	yaffs_read(h1,x,10);
1677	if(strncmp(x,s,10) != 0)
1678	{
1679		printf("File %s verification failed at %d\n",fn,i);
1680		errCount++;
1681	}
1682   }
1683   if(errCount >= 10)
1684   	printf("Too many errors... aborted\n");
1685
1686   yaffs_close(h1);
1687
1688}
1689
1690
1691void check_resize_gc_bug(const char *mountpt)
1692{
1693
1694	char a[30];
1695	char b[30];
1696	char c[30];
1697
1698	int i;
1699
1700	sprintf(a,"%s/a",mountpt);
1701	sprintf(b,"%s/b",mountpt);
1702	sprintf(c,"%s/c",mountpt);
1703
1704
1705
1706
1707	yaffs_StartUp();
1708	yaffs_mount(mountpt);
1709	yaffs_unlink(a);
1710	yaffs_unlink(b);
1711
1712	for(i = 0; i < 50; i++)
1713	{
1714	   printf("A\n");write_200k_file(a,"",c);
1715	   printf("B\n");verify_200k_file(a);
1716	   printf("C\n");write_200k_file(b,a,c);
1717	   printf("D\n");verify_200k_file(b);
1718	   yaffs_unmount(mountpt);
1719	   yaffs_mount(mountpt);
1720	   printf("E\n");verify_200k_file(a);
1721	   printf("F\n");verify_200k_file(b);
1722	}
1723
1724}
1725
1726
1727void multi_mount_test(const char *mountpt,int nmounts)
1728{
1729
1730	char a[30];
1731	char b[30];
1732	char c[30];
1733
1734	int i;
1735	int j;
1736
1737	sprintf(a,"%s/a",mountpt);
1738
1739
1740
1741
1742	yaffs_StartUp();
1743
1744	for(i = 0; i < nmounts; i++){
1745		printf("############### Iteration %d   Start\n",i);
1746		yaffs_mount(mountpt);
1747		dump_directory_tree(mountpt);
1748		yaffs_mkdir(a,0);
1749		for(j = 0; j < i; j++){
1750			sprintf(b,"%s/%d",a,j);
1751			verify_200k_file(b);
1752		}
1753		sprintf(b,"%s/%d",a,i);
1754
1755		write_200k_file(b,"","");
1756
1757		printf("######## Iteration %d   End\n",i);
1758		dump_directory_tree(mountpt);
1759
1760		yaffs_unmount(mountpt);
1761	}
1762}
1763
1764
1765void yaffs_touch(const char *fn)
1766{
1767	yaffs_chmod(fn, S_IREAD | S_IWRITE);
1768}
1769
1770void checkpoint_fill_test(const char *mountpt,int nmounts)
1771{
1772
1773	char a[50];
1774	char b[50];
1775	char c[50];
1776
1777	int i;
1778	int j;
1779	int h;
1780
1781	sprintf(a,"%s/a",mountpt);
1782
1783
1784
1785
1786	yaffs_StartUp();
1787
1788	for(i = 0; i < nmounts; i++){
1789		printf("############### Iteration %d   Start\n",i);
1790		yaffs_mount(mountpt);
1791		dump_directory_tree(mountpt);
1792		yaffs_mkdir(a,0);
1793
1794		sprintf(b,"%s/zz",a);
1795
1796		h = yaffs_open(b,O_CREAT | O_RDWR,S_IREAD |S_IWRITE);
1797
1798
1799		while(yaffs_write(h,c,50) == 50){}
1800
1801		yaffs_close(h);
1802
1803		for(j = 0; j < 2; j++){
1804			printf("touch %d\n",j);
1805			yaffs_touch(b);
1806			yaffs_unmount(mountpt);
1807			yaffs_mount(mountpt);
1808		}
1809
1810		dump_directory_tree(mountpt);
1811		yaffs_unmount(mountpt);
1812	}
1813}
1814
1815
1816int make_file2(const char *name1, const char *name2,int syz)
1817{
1818
1819	char xx[2500];
1820	int i;
1821	int h1=-1,h2=-1;
1822	int n = 1;
1823
1824
1825	if(name1)
1826		h1 = yaffs_open(name1,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1827	if(name2)
1828		h2 = yaffs_open(name2,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
1829
1830	while(syz > 0 && n > 0){
1831		i = (syz > 2500) ? 2500 : syz;
1832		n = yaffs_write(h1,xx,i);
1833		n = yaffs_write(h2,xx,i);
1834		syz -= 500;
1835	}
1836	yaffs_close(h1);
1837	yaffs_close(h2);
1838
1839}
1840
1841
1842extern void SetCheckpointReservedBlocks(int n);
1843
1844void checkpoint_upgrade_test(const char *mountpt,int nmounts)
1845{
1846
1847	char a[50];
1848	char b[50];
1849	char c[50];
1850	char d[50];
1851
1852	int i;
1853	int j;
1854	int h;
1855
1856	sprintf(a,"%s/a",mountpt);
1857
1858
1859
1860
1861	printf("Create start condition\n");
1862	yaffs_StartUp();
1863	SetCheckpointReservedBlocks(0);
1864	yaffs_mount(mountpt);
1865	yaffs_mkdir(a,0);
1866	sprintf(b,"%s/zz",a);
1867	sprintf(c,"%s/xx",a);
1868	make_file2(b,c,2000000);
1869	sprintf(d,"%s/aa",a);
1870	make_file2(d,NULL,500000000);
1871	dump_directory_tree(mountpt);
1872
1873	printf("Umount/mount attempt full\n");
1874	yaffs_unmount(mountpt);
1875
1876	SetCheckpointReservedBlocks(10);
1877	yaffs_mount(mountpt);
1878
1879	printf("unlink small file\n");
1880	yaffs_unlink(c);
1881	dump_directory_tree(mountpt);
1882
1883	printf("Umount/mount attempt\n");
1884	yaffs_unmount(mountpt);
1885	yaffs_mount(mountpt);
1886
1887	for(j = 0; j < 500; j++){
1888		printf("***** touch %d\n",j);
1889		dump_directory_tree(mountpt);
1890		yaffs_touch(b);
1891		yaffs_unmount(mountpt);
1892		yaffs_mount(mountpt);
1893	}
1894
1895	for(j = 0; j < 500; j++){
1896		printf("***** touch %d\n",j);
1897		dump_directory_tree(mountpt);
1898		yaffs_touch(b);
1899		yaffs_unmount(mountpt);
1900		yaffs_mount(mountpt);
1901	}
1902}
1903
1904void huge_array_test(const char *mountpt,int n)
1905{
1906
1907	char a[50];
1908
1909
1910	int i;
1911	int j;
1912	int h;
1913
1914	int fnum;
1915
1916	sprintf(a,"mount point %s",mountpt);
1917
1918
1919
1920	yaffs_StartUp();
1921
1922	yaffs_mount(mountpt);
1923
1924	while(n>0){
1925		n--;
1926		fnum = 0;
1927		printf("\n\n START run\n\n");
1928		while(yaffs_freespace(mountpt) > 25000000){
1929			sprintf(a,"%s/file%d",mountpt,fnum);
1930			fnum++;
1931			printf("create file %s\n",a);
1932			create_file_of_size(a,10000000);
1933			printf("verifying file %s\n",a);
1934			verify_file_of_size(a,10000000);
1935		}
1936
1937		printf("\n\n\ verification/deletion\n\n");
1938
1939		for(i = 0; i < fnum; i++){
1940			sprintf(a,"%s/file%d",mountpt,i);
1941			printf("verifying file %s\n",a);
1942			verify_file_of_size(a,10000000);
1943			printf("deleting file %s\n",a);
1944			yaffs_unlink(a);
1945		}
1946		printf("\n\n\ done \n\n");
1947
1948
1949	}
1950}
1951
1952
1953
1954int main(int argc, char *argv[])
1955{
1956	//return long_test(argc,argv);
1957
1958	//return cache_read_test();
1959
1960	//resize_stress_test_no_grow("/flash",20);
1961
1962	//huge_directory_test_on_path("/ram2k");
1963
1964	 //yaffs_backward_scan_test("/flash/flash");
1965	// yaffs_device_flush_test("/flash/flash");
1966
1967
1968	 //scan_pattern_test("/flash",10000,10);
1969	//short_scan_test("/flash/flash",40000,200);
1970	 //multi_mount_test("/flash/flash",20);
1971	 //checkpoint_fill_test("/flash/flash",20);
1972	 //checkpoint_upgrade_test("/flash/flash",20);
1973	  huge_array_test("/flash/flash",10);
1974
1975
1976
1977
1978	//long_test_on_path("/ram2k");
1979	// long_test_on_path("/flash");
1980	//simple_rw_test("/flash/flash");
1981	//fill_disk_test("/flash/flash");
1982	// rename_over_test("/flash");
1983	//lookup_test("/flash");
1984	//freespace_test("/flash/flash");
1985
1986	//link_test("/flash/flash");
1987
1988
1989
1990
1991	// cache_bypass_bug_test();
1992
1993	 //free_space_check();
1994
1995	 //check_resize_gc_bug("/flash");
1996
1997	 return 0;
1998
1999}
2000