yaffsdev.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  * yaffsdev.c
   4  *
   5  * Copyright (C) 2002 Aleph One Ltd.
   6  *   for Toby Churchill Ltd and Brightstar Engineering
   7  *
   8  * Created by Charles Manning <charles@aleph1.co.uk>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15
  16 #include "yaffsinterface.h"
  17 #include "yportenv.h"
  18
  19 #if YAFFS_FILEEM
  20 #include "yaffs_fileem.h"
  21 #else
  22 #include "yaffs_nandemul.h"
  23 #endif
  24
  25 #include "yaffs_guts.h"
  26 #include <stdlib.h>
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31
  32 yaffs_Device device;
  33
  34
  35 char *testStr = "this is a test string";
  36
  37 char *testStr2 = "abcdefghijklmnopqrstuvwxyz1234567890";
  38
  39 void TestTimexxx(yaffs_Device *dev)
  40 {
  41         yaffs_Object *f;
  42         int x;
  43
  44
  45         printf("Start\n");
  46
  47
  48         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
  49         if(f)
  50         {
  51                 printf("Found\n");
  52         }
  53         else
  54         {
  55                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
  56                 printf("Created\n");
  57         }
  58
  59
  60         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
  61
  62 }
  63
  64
  65 void TestTimeasasas(yaffs_Device *dev)
  66 {
  67         yaffs_Object *f;
  68         int x;
  69         int i;
  70         int b;
  71         char data[200];
  72         int written;
  73
  74
  75         printf("Start\n");
  76
  77
  78         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
  79         if(f)
  80         {
  81                 printf("Found\n");
  82         }
  83         else
  84         {
  85                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
  86                 printf("Created\n");
  87         }
  88
  89
  90         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
  91
  92
  93
  94         for(i = 0; i < 10000; i+=20)
  95         {
  96
  97                 b++;
  98                 if(b & 1)
  99                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 100                 else
 101                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 102         }
 103
 104
 105         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 106
 107         printf("Flush\n");
 108
 109         yaffs_FlushFile(f);
 110
 111         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 112
 113         yaffs_ReadDataFromFile(f,data,1000,50);
 114         data[50] = 0;
 115
 116         printf("Read data is \"%s\"\n",data);
 117
 118         yaffs_DumpObject(f);
 119
 120         printf("Resize to 3000\n");
 121         yaffs_ResizeFile(f,3000);
 122         printf("Resize to 2048\n");
 123         yaffs_ResizeFile(f,2048);
 124
 125         yaffs_DumpObject(f);
 126
 127         yaffs_FlushFile(f);
 128
 129
 130
 131
 132 }
 133
 134 void TestTimeBigDeletes(yaffs_Device *dev)
 135 {
 136         yaffs_Object *f;
 137         yaffs_Object *sl;
 138         yaffs_Object *lnf;
 139
 140         yaffs_Object *hl1;
 141         yaffs_Object *hl2;
 142         yaffs_Object *hl3;
 143         yaffs_Object *d, *df;
 144
 145         int x;
 146         int i;
 147         int b;
 148         char data[200];
 149
 150         char * alias;
 151         int written;
 152
 153
 154         printf("Exisiting objects\n");
 155         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 156         printf("Exisiting objects in lost+found\n");
 157         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 158         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 159
 160         printf("Start\n");
 161
 162
 163
 164         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 165         if(f)
 166         {
 167                 printf("Found\n");
 168         }
 169         else
 170         {
 171                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 172                 printf("Created\n");
 173         }
 174
 175         for(i = 0; i < 100000; i+=20)
 176         {
 177
 178                 b++;
 179                 if(b & 1)
 180                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 181                 else
 182                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 183         }
 184
 185         yaffs_FlushFile(f);
 186         yaffs_DeleteFile(f);
 187
 188         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 189         if(f)
 190         {
 191                 printf("Found\n");
 192         }
 193         else
 194         {
 195                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 196                 printf("Created\n");
 197         }
 198
 199         for(i = 0; i < 100000; i+=20)
 200         {
 201
 202                 b++;
 203                 if(b & 1)
 204                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 205                 else
 206                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 207         }
 208
 209         yaffs_FlushFile(f);
 210         yaffs_DeleteFile(f);
 211
 212         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 213         if(f)
 214         {
 215                 printf("Found\n");
 216         }
 217         else
 218         {
 219                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 220                 printf("Created\n");
 221         }
 222
 223         for(i = 0; i < 100000; i+=20)
 224         {
 225
 226                 b++;
 227                 if(b & 1)
 228                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 229                 else
 230                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 231         }
 232
 233         yaffs_FlushFile(f);
 234         yaffs_DeleteFile(f);
 235
 236 }
 237
 238 void TestTime(yaffs_Device *dev)
 239 {
 240         yaffs_Object *f;
 241         yaffs_Object *sl;
 242         yaffs_Object *lnf;
 243
 244         yaffs_Object *hl1;
 245         yaffs_Object *hl2;
 246         yaffs_Object *hl3;
 247         yaffs_Object *d, *df;
 248
 249         int x;
 250         int i;
 251         int b;
 252         char data[200];
 253
 254         char * alias;
 255         int written;
 256
 257
 258         printf("Exisiting objects\n");
 259         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 260         printf("Exisiting objects in lost+found\n");
 261         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 262         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 263
 264         printf("Start\n");
 265
 266
 267         // Test the problem of:
 268         // Create file
 269         // Delete file
 270         // Create file with same name
 271         // Delete file <== crash
 272
 273         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 274         if(f)
 275         {
 276                 printf("Found\n");
 277         }
 278         else
 279         {
 280                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 281                 printf("Created\n");
 282         }
 283         yaffs_Unlink(yaffs_Root(dev),"Name1");
 284
 285
 286         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 287         if(f)
 288         {
 289                 printf("Found\n");
 290         }
 291         else
 292         {
 293                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 294                 printf("Created\n");
 295         }
 296         yaffs_Unlink(yaffs_Root(dev),"Name1");
 297
 298
 299
 300         // Other tests
 301
 302         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 303         if(f)
 304         {
 305                 printf("Found\n");
 306         }
 307         else
 308         {
 309                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 310                 printf("Created\n");
 311         }
 312
 313
 314         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 315
 316         for(i = 0; i < 100000; i+=20)
 317         {
 318
 319                 b++;
 320                 if(b & 1)
 321                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 322                 else
 323                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 324         }
 325         // some short reads
 326         for(i = 1000; i < 50000; i+=2)
 327         {
 328                 yaffs_ReadDataFromFile(f,data,i,20);
 329         }
 330
 331
 332         yaffs_ReadDataFromFile(f,data,1000,50);
 333         data[50] = 0;
 334
 335         printf("Read data is \"%s\"\n",data);
 336
 337         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 338         yaffs_ReadDataFromFile(f,data,1000,50);
 339         data[50] = 0;
 340
 341         printf("Read data is \"%s\"\n",data);
 342
 343         printf("Flush\n");
 344
 345         yaffs_FlushFile(f);
 346         yaffs_ReadDataFromFile(f,data,1000,50);
 347         data[50] = 0;
 348
 349         printf("Read data is \"%s\"\n",data);
 350
 351         printf("File length is %d\n",yaffs_GetObjectFileLength(f));
 352
 353         sl = yaffs_MknodSymLink(yaffs_Root(dev),"sym-link",0,0,0,"/tmp/alias");
 354         yaffs_ReadDataFromFile(f,data,1000,50);
 355         data[50] = 0;
 356
 357         printf("Read data is \"%s\"\n",data);
 358
 359
 360         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 361
 362         printf("\n\nsymlink alias is \"%s\"\n",alias = yaffs_GetSymlinkAlias(sl));
 363
 364         free(alias);
 365
 366         printf("Unlink symlink %d\n",yaffs_Unlink(yaffs_Root(dev),"sym-link"));
 367
 368
 369         yaffs_ReadDataFromFile(f,data,1000,50);
 370         data[50] = 0;
 371
 372         printf("Read data is \"%s\"\n",data);
 373
 374         yaffs_DumpObject(f);
 375
 376         printf("Resize 3000\n");
 377         yaffs_ResizeFile(f,3000);
 378
 379         printf("Resize 2050\n");
 380         yaffs_ResizeFile(f,2050);
 381         printf("Resize 2049\n");
 382         yaffs_ResizeFile(f,2049);
 383         printf("Resize 2048\n");
 384         yaffs_ResizeFile(f,2048);
 385
 386
 387         printf("Resize 2000\n");
 388         yaffs_ResizeFile(f,2000);
 389
 390         yaffs_DumpObject(f);
 391
 392         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 393
 394
 395
 396         yaffs_FlushFile(f);
 397
 398
 399         printf("Unlink file: %d\n",yaffs_Unlink(yaffs_Root(dev),"Rename"));
 400
 401         yaffs_DeleteFile(f);
 402
 403         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 404
 405         // Create a directory and play with it
 406
 407
 408         printf("Find or Create directory and play with it\n");
 409         d =  yaffs_FindObjectByName(yaffs_Root(dev),"direct");
 410         if(!d)
 411         {
 412                 d = yaffs_MknodDirectory(yaffs_Root(dev),"direct",0,0,0);
 413         }
 414         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 415         yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
 416
 417         printf("Make file in directory\n");
 418
 419         df = yaffs_MknodFile(d,"file-in-directory",0,0,0);
 420         yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
 421
 422
 423         // Do some stuff with hardlinks
 424         //
 425         // NB Deleting hardlinked objects can mess up pointers to hardlinks.
 426         // The mechanism is as follows:
 427         // * If you unlink a file,softlink or directory that has one or more hardlinks,
 428         // then the object is renamed to one of the hardlinks and that hardlink is unlinked.
 429         // This means that a pointer to a hardlink so deleted will point to an invalid address.
 430         // Thus, make sure that pointers to hardlinks are immediately dereferenced.
 431
 432
 433         printf("Hard link tests\n");
 434
 435         f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 436         hl1 = yaffs_Link(yaffs_Root(dev),"HardLink 1",f);
 437         hl2 = yaffs_Link(yaffs_Root(dev),"HardLink 2",f);
 438         hl3 = yaffs_Link(yaffs_Root(dev),"HardLink 3",hl2);
 439
 440         printf("\n\nHard links created\n");
 441         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 442
 443         yaffs_Unlink(yaffs_Root(dev),"HardLink 1");
 444         printf("\n\nHard link deleted\n");
 445         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 446
 447         yaffs_Unlink(yaffs_Root(dev),"Name1");
 448         printf("\n\nHard linked file deleted\n");
 449         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 450
 451         yaffs_Unlink(yaffs_Root(dev),"HardLink 2");
 452         printf("\n\nHard link 2 deleted\n");
 453         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 454
 455         yaffs_Unlink(yaffs_Root(dev),"HardLink 3");
 456
 457         printf("\n\nHard link 3 deleted\n");
 458         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 459
 460         // NB We don't allow unlinking or rename of the root or lost+found
 461         // We allow setting attributes, but these must not be written to
 462         // NAND since they are not real objects.
 463
 464         printf("Attempt to rename lost+found - should have failed\n");
 465         x = yaffs_RenameObject(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME,NULL,"Renamed");
 466         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 467
 468         f = yaffs_MknodFile(yaffs_Root(dev),"pfile",0,0,0);
 469         if(f)
 470         {
 471                 yaffs_WriteDataToFile(f,testStr,0,strlen(testStr));
 472         }
 473
 474         yaffs_Link(yaffs_Root(dev),"phl4",f);
 475 }
 476
 477 void TestTimeDeleteFocussed(yaffs_Device *dev)
 478 {
 479         yaffs_Object *f;
 480         yaffs_Object *lnf;
 481
 482
 483         int x;
 484         int i;
 485         int b;
 486         int written;
 487
 488
 489         printf("Exisiting objects\n");
 490         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 491         printf("Exisiting objects in lost+found\n");
 492         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 493         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 494
 495         printf("Start\n");
 496
 497
 498
 499
 500         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 501         if(f)
 502         {
 503                 printf("Found\n");
 504         }
 505         else
 506         {
 507                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 508                 printf("Created\n");
 509         }
 510
 511
 512         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 513
 514         for(i = 0; i < 100000; i+=20)
 515         {
 516
 517                 b++;
 518                 if(b & 1)
 519                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 520                 else
 521                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 522         }
 523
 524
 525
 526         yaffs_FlushFile(f);
 527
 528
 529         printf("Unlink file: %d\n",yaffs_Unlink(yaffs_Root(dev),"Rename"));
 530
 531         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 532
 533 }
 534
 535 void TestTimeTnodeFocussed(yaffs_Device *dev)
 536 {
 537         yaffs_Object *f;
 538         yaffs_Object *lnf;
 539
 540
 541         int x;
 542         int i;
 543         int b;
 544         int written;
 545
 546
 547         printf("Exisiting objects\n");
 548         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 549         printf("Exisiting objects in lost+found\n");
 550         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 551         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 552
 553         printf("Start\n");
 554
 555
 556
 557
 558         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 559         if(f)
 560         {
 561                 printf("Found\n");
 562         }
 563         else
 564         {
 565                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 566                 printf("Created\n");
 567         }
 568
 569
 570         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 571
 572         for(i = 0; i < 10000; i+=20)
 573         {
 574
 575                 b++;
 576                 if(b & 1)
 577                         written = yaffs_WriteDataToFile(f,testStr,0,strlen(testStr));
 578                 else
 579                         written = yaffs_WriteDataToFile(f,testStr2,0,strlen(testStr2));
 580         }
 581
 582 }
 583
 584 int main(int argc,char *argv[])
 585 {
 586
 587         int nBlocks;
 588
 589 #if YAFFS_FILEEM
 590         nBlocks =(32 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK) ;
 591         device.writeChunkToNAND = yaffs_FEWriteChunkToNAND;
 592         device.readChunkFromNAND = yaffs_FEReadChunkFromNAND;
 593         device.eraseBlockInNAND = yaffs_FEEraseBlockInNAND;
 594         device.initialiseNAND = yaffs_FEInitialiseNAND;
 595
 596         printf("Testing on file emulation\n");
 597 #else
 598         nBlocks = (2 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
 599         device.writeChunkToNAND = nandemul_WriteChunkToNAND;
 600         device.readChunkFromNAND = nandemul_ReadChunkFromNAND;
 601         device.eraseBlockInNAND = nandemul_EraseBlockInNAND;
 602         device.initialiseNAND = nandemul_InitialiseNAND;
 603
 604         printf("Testing on RAM emulation\n");
 605 #endif
 606
 607 #ifdef YAFFS_START
 608         device.startBlock = YAFFS_START;  // Don't use block 0
 609         device.endBlock = YAFFS_END;
 610 #else
 611         device.startBlock = 1;  // Don't use block 0
 612         device.endBlock = nBlocks;
 613 #endif
 614
 615         yaffs_GutsInitialise(&device);
 616
 617         // yaffs_GutsTest();
 618
 619         TestTimeBigDeletes(&device);
 620
 621         printf("Cache hits %d\n",device.cacheHits);
 622         printf("Retired blocks %d\n",device.nRetiredBlocks);
 623
 624         exit(0);
 625 }