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 TestTime(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         // Test the problem of:
 164         // Create file
 165         // Delete file
 166         // Create file with same name
 167         // Delete file <== crash
 168
 169         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 170         if(f)
 171         {
 172                 printf("Found\n");
 173         }
 174         else
 175         {
 176                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 177                 printf("Created\n");
 178         }
 179         yaffs_Unlink(yaffs_Root(dev),"Name1");
 180
 181
 182         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 183         if(f)
 184         {
 185                 printf("Found\n");
 186         }
 187         else
 188         {
 189                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 190                 printf("Created\n");
 191         }
 192         yaffs_Unlink(yaffs_Root(dev),"Name1");
 193
 194
 195
 196         // Other tests
 197
 198         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 199         if(f)
 200         {
 201                 printf("Found\n");
 202         }
 203         else
 204         {
 205                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 206                 printf("Created\n");
 207         }
 208
 209
 210         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 211
 212         for(i = 0; i < 100000; i+=20)
 213         {
 214
 215                 b++;
 216                 if(b & 1)
 217                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 218                 else
 219                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 220         }
 221
 222         yaffs_ReadDataFromFile(f,data,1000,50);
 223         data[50] = 0;
 224
 225         printf("Read data is \"%s\"\n",data);
 226
 227         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 228         yaffs_ReadDataFromFile(f,data,1000,50);
 229         data[50] = 0;
 230
 231         printf("Read data is \"%s\"\n",data);
 232
 233         printf("Flush\n");
 234
 235         yaffs_FlushFile(f);
 236         yaffs_ReadDataFromFile(f,data,1000,50);
 237         data[50] = 0;
 238
 239         printf("Read data is \"%s\"\n",data);
 240
 241         printf("File length is %d\n",yaffs_GetObjectFileLength(f));
 242
 243         sl = yaffs_MknodSymLink(yaffs_Root(dev),"sym-link",0,0,0,"/tmp/alias");
 244         yaffs_ReadDataFromFile(f,data,1000,50);
 245         data[50] = 0;
 246
 247         printf("Read data is \"%s\"\n",data);
 248
 249
 250         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 251
 252         printf("\n\nsymlink alias is \"%s\"\n",alias = yaffs_GetSymlinkAlias(sl));
 253
 254         free(alias);
 255
 256         printf("Unlink symlink %d\n",yaffs_Unlink(yaffs_Root(dev),"sym-link"));
 257
 258
 259         yaffs_ReadDataFromFile(f,data,1000,50);
 260         data[50] = 0;
 261
 262         printf("Read data is \"%s\"\n",data);
 263
 264         yaffs_DumpObject(f);
 265
 266         printf("Resize 3000\n");
 267         yaffs_ResizeFile(f,3000);
 268
 269         printf("Resize 2050\n");
 270         yaffs_ResizeFile(f,2050);
 271         printf("Resize 2049\n");
 272         yaffs_ResizeFile(f,2049);
 273         printf("Resize 2048\n");
 274         yaffs_ResizeFile(f,2048);
 275
 276
 277         printf("Resize 2000\n");
 278         yaffs_ResizeFile(f,2000);
 279
 280         yaffs_DumpObject(f);
 281
 282         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 283
 284
 285
 286         yaffs_FlushFile(f);
 287
 288
 289         printf("Unlink file: %d\n",yaffs_Unlink(yaffs_Root(dev),"Rename"));
 290
 291         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 292
 293         // Create a directory and play with it
 294
 295
 296         printf("Find or Create directory and play with it\n");
 297         d =  yaffs_FindObjectByName(yaffs_Root(dev),"direct");
 298         if(!d)
 299         {
 300                 d = yaffs_MknodDirectory(yaffs_Root(dev),"direct",0,0,0);
 301         }
 302         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 303         yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
 304
 305         printf("Make file in directory\n");
 306
 307         df = yaffs_MknodFile(d,"file-in-directory",0,0,0);
 308         yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
 309
 310
 311         // Do some stuff with hardlinks
 312         //
 313         // NB Deleting hardlinked objects can mess up pointers to hardlinks.
 314         // The mechanism is as follows:
 315         // * If you unlink a file,softlink or directory that has one or more hardlinks,
 316         // then the object is renamed to one of the hardlinks and that hardlink is unlinked.
 317         // This means that a pointer to a hardlink so deleted will point to an invalid address.
 318         // Thus, make sure that pointers to hardlinks are immediately dereferenced.
 319
 320
 321         printf("Hard link tests\n");
 322
 323         f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 324         hl1 = yaffs_Link(yaffs_Root(dev),"HardLink 1",f);
 325         hl2 = yaffs_Link(yaffs_Root(dev),"HardLink 2",f);
 326         hl3 = yaffs_Link(yaffs_Root(dev),"HardLink 3",hl2);
 327
 328         printf("\n\nHard links created\n");
 329         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 330
 331         yaffs_Unlink(yaffs_Root(dev),"HardLink 1");
 332         printf("\n\nHard link deleted\n");
 333         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 334
 335         yaffs_Unlink(yaffs_Root(dev),"Name1");
 336         printf("\n\nHard linked file deleted\n");
 337         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 338
 339         yaffs_Unlink(yaffs_Root(dev),"HardLink 2");
 340         printf("\n\nHard link 2 deleted\n");
 341         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 342
 343         yaffs_Unlink(yaffs_Root(dev),"HardLink 3");
 344
 345         printf("\n\nHard link 3 deleted\n");
 346         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 347
 348         // NB We don't allow unlinking or rename of the root or lost+found
 349         // We allow setting attributes, but these must not be written to
 350         // NAND since they are not real objects.
 351
 352         printf("Attempt to rename lost+found - should have failed\n");
 353         x = yaffs_RenameObject(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME,NULL,"Renamed");
 354         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 355
 356         f = yaffs_MknodFile(yaffs_Root(dev),"pfile",0,0,0);
 357         yaffs_WriteDataToFile(f,testStr,0,strlen(testStr));
 358
 359         yaffs_Link(yaffs_Root(dev),"phl4",f);
 360 }
 361
 362 void TestTimeDeleteFocussed(yaffs_Device *dev)
 363 {
 364         yaffs_Object *f;
 365         yaffs_Object *lnf;
 366
 367
 368         int x;
 369         int i;
 370         int b;
 371         int written;
 372
 373
 374         printf("Exisiting objects\n");
 375         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 376         printf("Exisiting objects in lost+found\n");
 377         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 378         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 379
 380         printf("Start\n");
 381
 382
 383
 384
 385         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 386         if(f)
 387         {
 388                 printf("Found\n");
 389         }
 390         else
 391         {
 392                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 393                 printf("Created\n");
 394         }
 395
 396
 397         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 398
 399         for(i = 0; i < 100000; i+=20)
 400         {
 401
 402                 b++;
 403                 if(b & 1)
 404                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 405                 else
 406                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 407         }
 408
 409
 410
 411         yaffs_FlushFile(f);
 412
 413
 414         printf("Unlink file: %d\n",yaffs_Unlink(yaffs_Root(dev),"Rename"));
 415
 416         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 417
 418 }
 419
 420 void TestTimeTnodeFocussed(yaffs_Device *dev)
 421 {
 422         yaffs_Object *f;
 423         yaffs_Object *lnf;
 424
 425
 426         int x;
 427         int i;
 428         int b;
 429         int written;
 430
 431
 432         printf("Exisiting objects\n");
 433         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 434         printf("Exisiting objects in lost+found\n");
 435         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 436         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 437
 438         printf("Start\n");
 439
 440
 441
 442
 443         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 444         if(f)
 445         {
 446                 printf("Found\n");
 447         }
 448         else
 449         {
 450                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 451                 printf("Created\n");
 452         }
 453
 454
 455         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 456
 457         for(i = 0; i < 10000; i+=20)
 458         {
 459
 460                 b++;
 461                 if(b & 1)
 462                         written = yaffs_WriteDataToFile(f,testStr,0,strlen(testStr));
 463                 else
 464                         written = yaffs_WriteDataToFile(f,testStr2,0,strlen(testStr2));
 465         }
 466
 467 }
 468
 469 int main(int argc,char *argv[])
 470 {
 471
 472 #if YAFFS_FILEEM
 473         device.nBlocks = (64 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
 474         device.writeChunkToNAND = yaffs_FEWriteChunkToNAND;
 475         device.readChunkFromNAND = yaffs_FEReadChunkFromNAND;
 476         device.eraseBlockInNAND = yaffs_FEEraseBlockInNAND;
 477         device.initialiseNAND = yaffs_FEInitialiseNAND;
 478
 479         printf("Testing on file emulation\n");
 480 #else
 481         device.nBlocks = (2 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
 482         device.writeChunkToNAND = nandemul_WriteChunkToNAND;
 483         device.readChunkFromNAND = nandemul_ReadChunkFromNAND;
 484         device.eraseBlockInNAND = nandemul_EraseBlockInNAND;
 485         device.initialiseNAND = nandemul_InitialiseNAND;
 486
 487         printf("Testing on RAM emulation\n");
 488 #endif
 489
 490         device.startBlock = 1;  // Don't use block 0
 491         device.endBlock = device.nBlocks - 1;
 492
 493         yaffs_GutsInitialise(&device);
 494
 495         // yaffs_GutsTest();
 496
 497         TestTime(&device);
 498
 499         exit(0);
 500 }