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("Create directory and play with it\n");
 264
 265         d = yaffs_MknodDirectory(yaffs_Root(dev),"direct",0,0,0);
 266         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 267         yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
 268
 269         printf("Make file in directory\n");
 270
 271         df = yaffs_MknodFile(d,"file-in-directory",0,0,0);
 272         yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
 273
 274
 275         // Do some stuff with hardlinks
 276         //
 277         // NB Deleting hardlinked objects can mess up pointers to hardlinks.
 278         // The mechanism is as follows:
 279         // * If you unlink a file,softlink or directory that has one or more hardlinks,
 280         // then the object is renamed to one of the hardlinks and that hardlink is unlinked.
 281         // This means that a pointer to a hardlink so deleted will point to an invalid address.
 282         // Thus, make sure that pointers to hardlinks are immediately dereferenced.
 283
 284
 285         printf("Hard link tests\n");
 286
 287         f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 288         hl1 = yaffs_Link(yaffs_Root(dev),"HardLink 1",f);
 289         hl2 = yaffs_Link(yaffs_Root(dev),"HardLink 2",f);
 290         hl3 = yaffs_Link(yaffs_Root(dev),"HardLink 3",hl2);
 291
 292         printf("\n\nHard links created\n");
 293         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 294
 295         yaffs_Unlink(yaffs_Root(dev),"HardLink 1");
 296         printf("\n\nHard link deleted\n");
 297         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 298
 299         yaffs_Unlink(yaffs_Root(dev),"Name1");
 300         printf("\n\nHard linked file deleted\n");
 301         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 302
 303         yaffs_Unlink(yaffs_Root(dev),"HardLink 2");
 304         printf("\n\nHard link 2 deleted\n");
 305         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 306
 307         yaffs_Unlink(yaffs_Root(dev),"HardLink 3");
 308
 309         printf("\n\nHard link 3 deleted\n");
 310         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 311
 312         // NB We don't allow unlinking or rename of the root or lost+found
 313         // We allow setting attributes, but these must not be written to
 314         // NAND since they are not real objects.
 315
 316         printf("Attempt to rename lost+found - should have failed\n");
 317         x = yaffs_RenameObject(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME,NULL,"Renamed");
 318         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 319
 320         f = yaffs_MknodFile(yaffs_Root(dev),"pfile",0,0,0);
 321         yaffs_WriteDataToFile(f,testStr,0,strlen(testStr));
 322
 323         yaffs_Link(yaffs_Root(dev),"phl4",f);
 324 }
 325
 326 void TestTimeDeleteFocussed(yaffs_Device *dev)
 327 {
 328         yaffs_Object *f;
 329         yaffs_Object *lnf;
 330
 331
 332         int x;
 333         int i;
 334         int b;
 335         int written;
 336
 337
 338         printf("Exisiting objects\n");
 339         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 340         printf("Exisiting objects in lost+found\n");
 341         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 342         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 343
 344         printf("Start\n");
 345
 346
 347
 348
 349         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 350         if(f)
 351         {
 352                 printf("Found\n");
 353         }
 354         else
 355         {
 356                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 357                 printf("Created\n");
 358         }
 359
 360
 361         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 362
 363         for(i = 0; i < 100000; i+=20)
 364         {
 365
 366                 b++;
 367                 if(b & 1)
 368                         written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
 369                 else
 370                         written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
 371         }
 372
 373
 374
 375         yaffs_FlushFile(f);
 376
 377
 378         printf("Unlink file: %d\n",yaffs_Unlink(yaffs_Root(dev),"Rename"));
 379
 380         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 381
 382 }
 383
 384 void TestTimeTnodeFocussed(yaffs_Device *dev)
 385 {
 386         yaffs_Object *f;
 387         yaffs_Object *lnf;
 388
 389
 390         int x;
 391         int i;
 392         int b;
 393         int written;
 394
 395
 396         printf("Exisiting objects\n");
 397         yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
 398         printf("Exisiting objects in lost+found\n");
 399         lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
 400         yaffs_ApplyToDirectoryChildren(lnf,yaffs_DumpObject);
 401
 402         printf("Start\n");
 403
 404
 405
 406
 407         f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
 408         if(f)
 409         {
 410                 printf("Found\n");
 411         }
 412         else
 413         {
 414                 f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
 415                 printf("Created\n");
 416         }
 417
 418
 419         x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
 420
 421         for(i = 0; i < 10000; i+=20)
 422         {
 423
 424                 b++;
 425                 if(b & 1)
 426                         written = yaffs_WriteDataToFile(f,testStr,0,strlen(testStr));
 427                 else
 428                         written = yaffs_WriteDataToFile(f,testStr2,0,strlen(testStr2));
 429         }
 430
 431 }
 432
 433 int main(int argc,char *argv[])
 434 {
 435
 436 #if YAFFS_FILEEM
 437         device.nBlocks = (64 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
 438         device.writeChunkToNAND = yaffs_FEWriteChunkToNAND;
 439         device.readChunkFromNAND = yaffs_FEReadChunkFromNAND;
 440         device.eraseBlockInNAND = yaffs_FEEraseBlockInNAND;
 441         device.initialiseNAND = yaffs_FEInitialiseNAND;
 442
 443         printf("Testing on file emulation\n");
 444 #else
 445         device.nBlocks = (2 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
 446         device.writeChunkToNAND = nandemul_WriteChunkToNAND;
 447         device.readChunkFromNAND = nandemul_ReadChunkFromNAND;
 448         device.eraseBlockInNAND = nandemul_EraseBlockInNAND;
 449         device.initialiseNAND = nandemul_InitialiseNAND;
 450
 451         printf("Testing on RAM emulation\n");
 452 #endif
 453
 454         device.startBlock = 1;  // Don't use block 0
 455         device.endBlock = device.nBlocks - 1;
 456
 457         yaffs_GutsInitialise(&device);
 458
 459         // yaffs_GutsTest();
 460
 461         TestTime(&device);
 462
 463         exit(0);
 464 }