direct/test-framework/tests/nor_stress.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2011 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 #include "nor_stress.h"
  16
  17
  18 #include "yaffsfs.h"
  19 #include "yaffs_fsx.h"
  20
  21 #include <stdio.h>
  22 #include <unistd.h>
  23
  24
  25 extern int fuzz_test;
  26
  27 #if 1
  28 #define FSX_INIT(mount_pt) do{ if(interleave_fsx) yaffs_fsx_init(mount_pt); } while(0)
  29 #define FSX_COMPLETE() do { if(interleave_fsx) yaffs_fsx_complete(); } while (0)
  30
  31 #define FSX() \
  32 do { \
  33   if((myrand() & 0x1) == 0){\
  34      if(interleave_fsx) \
  35         yaffs_fsx_do_op(); \
  36   } \
  37 } while(0)
  38
  39 #else
  40 #define FSX_INIT(mount_point) do { } while(0)
  41 #define FSX_COMPLETE() do { } while(0)
  42 #define FSX() do { } while(0)
  43 #endif
  44
  45
  46 void (*ext_fatal)(void) = NULL;
  47
  48 static unsigned powerUps;
  49 static unsigned cycleStarts;
  50 static unsigned cycleEnds;
  51
  52 static int interleave_fsx;
  53
  54 static int no_verification;
  55
  56 char fullPathName[100];
  57 char fullPowerUpName[100];
  58 char fullStartName[100];
  59 char fullEndName[100];
  60 char fullMainName[100];
  61 char fullTempMainName[100];
  62 char fullTempCounterName[100];
  63
  64
  65 extern int random_seed;
  66
  67 int myrand(void) {
  68   random_seed = random_seed * 1103515245 + 12345;
  69   return((unsigned)(random_seed/65536) % 32768);
  70 }
  71
  72 void MakeName(char *fullName,const char *prefix, const char *name)
  73 {
  74   strcpy(fullName,prefix);
  75   strcat(fullName,"/");
  76   strcat(fullName,name);
  77 }
  78
  79
  80 void MakeFullNames(const char *prefix)
  81 {
  82   MakeName(fullPathName,prefix,"");
  83   MakeName(fullPowerUpName,prefix,"powerUps");
  84   MakeName(fullStartName,prefix,"starts");
  85   MakeName(fullEndName,prefix,"ends");
  86   MakeName(fullMainName,prefix,"main");
  87   MakeName(fullTempCounterName,prefix,"tmp-counter");
  88   MakeName(fullTempMainName,prefix,"tmp-main");
  89 }
  90
  91 static void FatalError(int line_no)
  92 {
  93   printf("Integrity error %d\n",line_no);
  94
  95   if(fuzz_test)
  96         return;
  97
  98   if(ext_fatal)
  99         ext_fatal();
 100
 101   while(1){
 102    sleep(1);
 103   }
 104 }
 105 void print_stat(const char *str, struct yaffs_stat *st)
 106 {
 107         printf("%s inode %d\n",str,st->st_ino);
 108 }
 109
 110 static void UpdateCounter(const char *name, unsigned *val,  int initialise)
 111 {
 112   int inh=-1;
 113   int outh=-1;
 114   unsigned x[2];
 115   int nread = 0;
 116   int nwritten = 0;
 117
 118   x[0] = x[1] = 0;
 119
 120   if(initialise){
 121     x[0] = 0;
 122     x[1] = 1;
 123   } else {
 124     inh = yaffs_open(name,O_RDONLY, S_IREAD | S_IWRITE);
 125     if(inh >= 0){
 126       nread = yaffs_read(inh,x,sizeof(x));
 127       yaffs_close(inh);
 128     }
 129
 130     if(!no_verification &&
 131       (nread != sizeof(x) ||
 132        x[0] + 1 != x[1])){
 133       printf("Error reading counter %s handle %d, x[0] %u x[1] %u last error %d\n",
 134               name, inh, x[0], x[1],yaffsfs_GetLastError());
 135       FatalError(__LINE__);
 136
 137     }
 138     x[0]++;
 139     x[1]++;
 140   }
 141
 142   FSX();
 143   outh = yaffs_open(fullTempCounterName, O_RDWR | O_TRUNC | O_CREAT, S_IREAD | S_IWRITE);
 144
 145   if(outh >= 0){
 146    struct yaffs_stat tmpstat, oldstat, tmpfstat;
 147    FSX();
 148     yaffs_fstat(outh,&tmpfstat);
 149     printf("\n\n\n*** Writing file %s inode %d\n",fullTempCounterName,tmpfstat.st_ino);
 150     nwritten = yaffs_write(outh,x,sizeof(x));
 151     FSX();
 152     yaffs_close(outh);
 153     FSX();
 154
 155     printf("About to rename %s to %s\n",fullTempCounterName,name);
 156     yaffs_stat(fullTempCounterName,&tmpstat);
 157     yaffs_stat(name,&oldstat);
 158     print_stat("old stat",&oldstat);
 159     print_stat("new stat",&tmpstat);
 160     print_stat("new fstat",&tmpfstat);
 161     yaffs_rename(fullTempCounterName,name);
 162     FSX();
 163   }
 164
 165   if(nwritten != sizeof(x)){
 166       printf("Error writing counter %s handle %d, x[0] %u x[1] %u\n",
 167               name, inh, x[0], x[1]);
 168       FatalError(__LINE__);
 169   }
 170
 171   *val = x[0];
 172
 173   printf("##\n"
 174          "## Set counter %s to %u\n"
 175          "##\n", name,x[0]);
 176 }
 177
 178
 179 static void dump_directory_tree_worker(const char *dname,int recursive)
 180 {
 181         yaffs_DIR *d;
 182         struct yaffs_dirent *de;
 183         struct yaffs_stat s;
 184         char str[1000];
 185         int error_line = 0;
 186         int nentries;
 187
 188         d = yaffs_opendir(dname);
 189
 190         if(!d)
 191         {
 192                 printf("opendir failed\n");
 193         }
 194         else
 195         {
 196                 nentries = 0;
 197                 while((de = yaffs_readdir(d)) != NULL)
 198                 {
 199                         strcpy(str,dname);
 200                         strcat(str,"/");
 201                         strcat(str,de->d_name);
 202                         nentries++;
 203
 204                         yaffs_lstat(str,&s);
 205
 206                         printf("%s inode %ld obj %d %p length %d mode %X ",
 207                                 str, de->d_ino, s.st_ino,
 208                                 de->d_dont_use, (int)s.st_size, s.st_mode);
 209
 210                         if(de->d_ino != s.st_ino){
 211                                 printf(" \n\n!!!! HEY inode mismatch\n\n");
 212                                 error_line = __LINE__;
 213                         }
 214
 215                         switch(s.st_mode & S_IFMT)
 216                         {
 217                                 case S_IFREG: printf("data file"); break;
 218                                 case S_IFDIR: printf("directory"); break;
 219                                 case S_IFLNK: printf("symlink -->");
 220                                                           if(yaffs_readlink(str,str,100) < 0)
 221                                                                 printf("no alias");
 222                                                           else
 223                                                                 printf("\"%s\"",str);
 224                                                           break;
 225                                 default: printf("unknown"); break;
 226                         }
 227
 228                         printf("\n");
 229
 230                         if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
 231                                 dump_directory_tree_worker(str,1);
 232
 233                         if(s.st_ino > 10000)
 234                                 error_line = __LINE__;
 235
 236                 }
 237
 238                 if(strstr(dname,"lost+found") && nentries >0){
 239                         printf("\n\n!!! HEY lost+found not empty, had %d entries\n\n\n",nentries);
 240                         error_line = __LINE__;
 241                 }
 242
 243                 if(error_line && !no_verification)
 244                         FatalError(error_line);
 245
 246                 yaffs_closedir(d);
 247         }
 248
 249 }
 250
 251 static void dump_directory_tree(const char *dname)
 252 {
 253         dump_directory_tree_worker(dname,1);
 254         printf("\n");
 255         printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
 256 }
 257
 258
 259
 260
 261 #define XX_SIZE 500
 262
 263 static unsigned xx[XX_SIZE];
 264
 265 static int y_wr_file(const char *fname, unsigned sz32)
 266 {
 267         int h;
 268         int r;
 269         int i;
 270         struct yaffs_stat st;
 271         unsigned checksum = 0;
 272
 273
 274         FSX();
 275         h = yaffs_open(fname,O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
 276         yaffs_fstat(h,&st);
 277         printf("\n\n\n**** Open writing file %s inode %d\n",fname, st.st_ino);
 278
 279         FSX();
 280
 281         if(h < 0){
 282                 printf("could not open file %s\n",fname);
 283                 return h;
 284         }
 285
 286         xx[0] = sz32;
 287         checksum ^= xx[0];
 288
 289         if((r = yaffs_write(h,xx,sizeof(unsigned))) != sizeof(unsigned)){
 290                 goto WRITE_ERROR;
 291         }
 292         FSX();
 293         while(sz32> 0){
 294                 for(i = 0; i < XX_SIZE; i++){
 295                   xx[i] = sz32 + i;
 296                   checksum ^= xx[i];
 297                 }
 298
 299                 FSX();
 300                 if((r = yaffs_write(h,xx,sizeof(xx))) != sizeof(xx)){
 301                         goto WRITE_ERROR;
 302                 }
 303                 sz32--;
 304         }
 305
 306         xx[0] = checksum;
 307         FSX();
 308         if((r = yaffs_write(h,xx,sizeof(unsigned))) != sizeof(unsigned)){
 309                 goto WRITE_ERROR;
 310         }
 311
 312         FSX();
 313         yaffs_close(h);
 314         printf("File closed\n");
 315         return 0;
 316
 317 WRITE_ERROR:
 318         printf("ywrite error at position %d\n",(int)yaffs_lseek(h,0,SEEK_END));
 319         yaffs_close(h);
 320         return -1;
 321
 322 }
 323
 324 static int y_verify_file(const char *fName)
 325 {
 326         unsigned checksum = 0;
 327         unsigned totalSize;
 328         unsigned sz32;
 329         unsigned recordedSize = 0;
 330         int r;
 331         int h;
 332         int i;
 333         int retval = 0;
 334
 335         if(no_verification)
 336                 return 0;
 337
 338         printf("Verifying file %s\n",fName);
 339
 340         h = yaffs_open(fName, O_RDONLY,S_IREAD | S_IWRITE);
 341
 342         if(h < 0){
 343                 printf("could not open file %s\n",fName);
 344                 return -1;
 345         }
 346
 347         totalSize = yaffs_lseek(h,0,SEEK_END);
 348         yaffs_lseek(h,0,SEEK_SET);
 349
 350         r = yaffs_read(h,&sz32,sizeof(sz32));
 351
 352         if(r != sizeof(sz32)){
 353                 printf("reading size failed ... returned %d\n",r);
 354                 yaffs_close(h);
 355                 return -1;
 356         }
 357
 358         recordedSize = sz32 * sizeof(xx) + 8;
 359
 360         printf("verify %s: file size is %d, recorded size is %d\n", fName, totalSize, recordedSize);
 361         if(totalSize != recordedSize){
 362                 printf("!!!!!!!!!!!!!!!!!!!!!!!!file size is wrong, should be %d, is %d\n", recordedSize,totalSize);
 363                 yaffs_close(h);
 364                 return -1;
 365         }
 366
 367         checksum ^= sz32;
 368
 369
 370         while(sz32 > 0){
 371                 r = yaffs_read(h,xx,sizeof(xx));
 372                 if(r != sizeof(xx)){
 373                         printf("!!!!!!!!!!!!!!!!!!!!!!!!!!reading data failed ... returned %d\n",r);
 374                         yaffs_close(h);
 375                         return -1;
 376                 }
 377                 for(i = 0; i < XX_SIZE; i++)
 378                   checksum ^= xx[i];
 379                 sz32--;
 380         }
 381         r = yaffs_read(h,xx,sizeof(xx[0]));
 382         if(r != sizeof(xx[0])){
 383                 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!reading data failed ... returned %d\n",r);
 384                 yaffs_close(h);
 385                 return -1;
 386         }
 387
 388         checksum ^= xx[0];
 389
 390         if(checksum != 0){
 391                 printf("!!!!!!!!!!!!!!!!!!!!! checksum failed\n");
 392                 retval = -1;
 393         } else
 394                 printf("verified ok\n");
 395         yaffs_close(h);
 396
 397         return retval;
 398 }
 399
 400
 401 static void DoUpdateMainFile(void)
 402 {
 403         int result;
 404         int sz32;
 405         sz32 = (myrand() % 1000)   + 20;
 406
 407         result = y_wr_file(fullTempMainName,sz32);
 408         FSX();
 409         if(!no_verification && result)
 410             FatalError(__LINE__);
 411         printf("Rename file %s to %s\n",fullTempMainName,fullMainName);
 412         yaffs_rename(fullTempMainName,fullMainName);
 413         FSX();
 414 }
 415
 416 static void DoVerifyMainFile(void)
 417 {
 418         int result;
 419         if(no_verification)
 420                 return;
 421         result = y_verify_file(fullMainName);
 422         if(result)
 423             FatalError(__LINE__);
 424
 425 }
 426
 427
 428 void NorStressTestInitialise(const char *prefix)
 429 {
 430   MakeFullNames(prefix);
 431
 432   UpdateCounter(fullPowerUpName,&powerUps,1);
 433   UpdateCounter(fullStartName,&cycleStarts,1);
 434   UpdateCounter(fullEndName,&cycleEnds,1);
 435   UpdateCounter(fullPowerUpName,&powerUps,1);
 436   DoUpdateMainFile();
 437   DoVerifyMainFile();
 438 }
 439
 440
 441 void NorStressTestRun(const char *prefix, int n_cycles, int do_fsx, int skip_verification)
 442 {
 443
 444   interleave_fsx = do_fsx;
 445   no_verification = skip_verification;
 446
 447   MakeFullNames(prefix);
 448   dump_directory_tree(fullPathName);
 449   FSX_INIT(prefix);
 450
 451   dump_directory_tree(fullPathName);
 452
 453   UpdateCounter(fullPowerUpName,&powerUps,0);
 454   dump_directory_tree(fullPathName);
 455
 456   while(n_cycles < 0 || n_cycles > 0){
 457     if(n_cycles > 0)
 458       n_cycles--;
 459     UpdateCounter(fullStartName, &cycleStarts,0);
 460     dump_directory_tree(fullPathName);
 461     DoVerifyMainFile();
 462     DoUpdateMainFile();
 463     dump_directory_tree(fullPathName);
 464
 465     UpdateCounter(fullEndName,&cycleEnds,0);
 466     dump_directory_tree(fullPathName);
 467   }
 468   FSX_COMPLETE();
 469 }