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