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