direct/dtest.c

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