summaryrefslogtreecommitdiff
path: root/fs/yaffs2/direct
diff options
context:
space:
mode:
Diffstat (limited to 'fs/yaffs2/direct')
-rw-r--r--fs/yaffs2/direct/Makefile66
-rw-r--r--fs/yaffs2/direct/dtest.c2280
-rw-r--r--fs/yaffs2/direct/fsx_test/Makefile75
-rw-r--r--fs/yaffs2/direct/fsx_test/README7
-rw-r--r--fs/yaffs2/direct/fsx_test/yaffs_fsx.c1007
-rw-r--r--fs/yaffs2/direct/yaffs_fileem.c218
-rw-r--r--fs/yaffs2/direct/yaffs_fileem2k.c441
-rw-r--r--fs/yaffs2/direct/yaffs_fileem2k.h50
-rw-r--r--fs/yaffs2/direct/yaffs_flashif.c229
-rw-r--r--fs/yaffs2/direct/yaffs_flashif.h31
-rw-r--r--fs/yaffs2/direct/yaffs_malloc.h23
-rw-r--r--fs/yaffs2/direct/yaffs_ramdisk.c234
-rw-r--r--fs/yaffs2/direct/yaffs_ramdisk.h32
-rw-r--r--fs/yaffs2/direct/yaffs_ramem2k.c363
-rw-r--r--fs/yaffs2/direct/yaffscfg.c144
-rw-r--r--fs/yaffs2/direct/yaffscfg.h45
-rw-r--r--fs/yaffs2/direct/yaffscfg2k.c229
-rw-r--r--fs/yaffs2/direct/yaffsfs.c1505
-rw-r--r--fs/yaffs2/direct/yaffsfs.h233
-rw-r--r--fs/yaffs2/direct/ydirectenv.h88
20 files changed, 7300 insertions, 0 deletions
diff --git a/fs/yaffs2/direct/Makefile b/fs/yaffs2/direct/Makefile
new file mode 100644
index 0000000000..6315117cdf
--- /dev/null
+++ b/fs/yaffs2/direct/Makefile
@@ -0,0 +1,66 @@
+# Makefile for YAFFS direct test
+#
+#
+# YAFFS: Yet another Flash File System. A NAND-flash specific file system.
+#
+# Copyright (C) 2003 Aleph One Ltd.
+#
+#
+# Created by Charles Manning <charles@aleph1.co.uk>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# NB Warning this Makefile does not include header dependencies.
+#
+# $Id: Makefile,v 1.15 2007/07/18 19:40:38 charles Exp $
+
+#EXTRA_COMPILE_FLAGS = -DYAFFS_IGNORE_TAGS_ECC
+
+CFLAGS = -Wall -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -g $(EXTRA_COMPILE_FLAGS) -DNO_Y_INLINE
+CFLAGS+= -fstack-check -O0
+
+#CFLAGS+= -Wshadow -Wpointer-arith -Wwrite-strings -Wstrict-prototypes -Wmissing-declarations
+#CFLAGS+= -Wmissing-prototypes -Wredundant-decls -Wnested-externs -Winline
+
+
+DIRECTTESTOBJS = dtest.o yaffscfg2k.o yaffs_ecc.o yaffs_fileem2k.o yaffsfs.o yaffs_guts.o \
+ yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \
+ yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o yaffs_nand.o \
+ yaffs_checkptrw.o yaffs_qsort.o \
+# yaffs_checkptrwtest.o\
+
+
+BOOTTESTOBJS = bootldtst.o yboot.o yaffs_fileem.o nand_ecc.o
+
+#ALLOBJS = dtest.o nand_ecc.o yaffscfg.o yaffs_fileem.o yaffsfs.o yaffs_ramdisk.o bootldtst.o yboot.o yaffs_ramem2k.o
+
+ALLOBJS = $(DIRECTTESTOBJS) $(BOOTTESTOBJS)
+
+SYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yaffsinterface.h yportenv.h yaffs_tagscompat.c yaffs_tagscompat.h \
+ yaffs_packedtags1.c yaffs_packedtags1.h yaffs_packedtags2.c yaffs_packedtags2.h yaffs_nandemul2k.h \
+ yaffs_nand.c yaffs_nand.h \
+ yaffs_tagsvalidity.c yaffs_tagsvalidity.h yaffs_checkptrw.h yaffs_checkptrw.c \
+ yaffs_qsort.c yaffs_qsort.h
+
+#all: directtest2k boottest
+
+all: directtest2k
+
+$(ALLOBJS): %.o: %.c
+ gcc -c $(CFLAGS) $< -o $@
+
+$(SYMLINKS):
+ ln -s ../$@ $@
+
+directtest2k: $(SYMLINKS) $(DIRECTTESTOBJS)
+ gcc -o $@ $(DIRECTTESTOBJS)
+
+
+boottest: $(SYMLINKS) $(BOOTTESTOBJS)
+ gcc -o $@ $(BOOTTESTOBJS)
+
+
+clean:
+ rm -f $(ALLOBJS) core
diff --git a/fs/yaffs2/direct/dtest.c b/fs/yaffs2/direct/dtest.c
new file mode 100644
index 0000000000..be492b47c9
--- /dev/null
+++ b/fs/yaffs2/direct/dtest.c
@@ -0,0 +1,2280 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+* Test code for the "direct" interface.
+*/
+
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "yaffsfs.h"
+
+void dumpDir(const char *dname);
+
+char xx[600];
+
+void copy_in_a_file(char *yaffsName,char *inName)
+{
+ int inh,outh;
+ unsigned char buffer[100];
+ int ni,no;
+ inh = open(inName,O_RDONLY);
+ outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+
+ while((ni = read(inh,buffer,100)) > 0)
+ {
+ no = yaffs_write(outh,buffer,ni);
+ if(ni != no)
+ {
+ printf("problem writing yaffs file\n");
+ }
+
+ }
+
+ yaffs_close(outh);
+ close(inh);
+}
+
+void make_a_file(char *yaffsName,char bval,int sizeOfFile)
+{
+ int outh;
+ int i;
+ unsigned char buffer[100];
+
+ outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+
+ memset(buffer,bval,100);
+
+ do{
+ i = sizeOfFile;
+ if(i > 100) i = 100;
+ sizeOfFile -= i;
+
+ yaffs_write(outh,buffer,i);
+
+ } while (sizeOfFile > 0);
+
+
+ yaffs_close(outh);
+
+}
+
+void make_pattern_file(char *fn,int size)
+{
+ int outh;
+ int marker;
+ int i;
+ outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+ yaffs_lseek(outh,size-1,SEEK_SET);
+ yaffs_write(outh,"A",1);
+
+ for(i = 0; i < size; i+=256)
+ {
+ marker = ~i;
+ yaffs_lseek(outh,i,SEEK_SET);
+ yaffs_write(outh,&marker,sizeof(marker));
+ }
+ yaffs_close(outh);
+
+}
+
+int check_pattern_file(char *fn)
+{
+ int h;
+ int marker;
+ int i;
+ int size;
+ int ok = 1;
+
+ h = yaffs_open(fn, O_RDWR,0);
+ size = yaffs_lseek(h,0,SEEK_END);
+
+ for(i = 0; i < size; i+=256)
+ {
+ yaffs_lseek(h,i,SEEK_SET);
+ yaffs_read(h,&marker,sizeof(marker));
+ ok = (marker == ~i);
+ if(!ok)
+ {
+ printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x\n",
+ fn,size,i,marker,~i);
+ }
+ }
+ yaffs_close(h);
+ return ok;
+}
+
+
+
+
+
+int dump_file_data(char *fn)
+{
+ int h;
+ int marker;
+ int i = 0;
+ int size;
+ int ok = 1;
+ unsigned char b;
+
+ h = yaffs_open(fn, O_RDWR,0);
+
+
+ printf("%s\n",fn);
+ while(yaffs_read(h,&b,1)> 0)
+ {
+ printf("%02x",b);
+ i++;
+ if(i > 32)
+ {
+ printf("\n");
+ i = 0;;
+ }
+ }
+ printf("\n");
+ yaffs_close(h);
+ return ok;
+}
+
+
+
+void dump_file(const char *fn)
+{
+ int i;
+ int size;
+ int h;
+
+ h = yaffs_open(fn,O_RDONLY,0);
+ if(h < 0)
+ {
+ printf("*****\nDump file %s does not exist\n",fn);
+ }
+ else
+ {
+ size = yaffs_lseek(h,0,SEEK_SET);
+ printf("*****\nDump file %s size %d\n",fn,size);
+ for(i = 0; i < size; i++)
+ {
+
+ }
+ }
+}
+
+void create_file_of_size(const char *fn,int syze)
+{
+ int h;
+ int n;
+
+ char xx[200];
+
+ int iterations = (syze + strlen(fn) -1)/ strlen(fn);
+
+ h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+
+ while (iterations > 0)
+ {
+ sprintf(xx,"%s %8d",fn,iterations);
+ yaffs_write(h,xx,strlen(xx));
+ iterations--;
+ }
+ yaffs_close (h);
+}
+
+void verify_file_of_size(const char *fn,int syze)
+{
+ int h;
+ int n;
+
+ char xx[200];
+ char yy[200];
+ int l;
+
+ int iterations = (syze + strlen(fn) -1)/ strlen(fn);
+
+ h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
+
+ while (iterations > 0)
+ {
+ sprintf(xx,"%s %8d",fn,iterations);
+ l = strlen(xx);
+
+ yaffs_read(h,yy,l);
+ yy[l] = 0;
+
+ if(strcmp(xx,yy)){
+ printf("=====>>>>> verification of file %s failed near position %d\n",fn,yaffs_lseek(h,0,SEEK_CUR));
+ }
+ iterations--;
+ }
+ yaffs_close (h);
+}
+
+void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2)
+{
+ int h;
+ int n;
+
+
+ int iterations;
+
+ h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+
+ iterations = (syze1 + strlen(fn) -1)/ strlen(fn);
+ while (iterations > 0)
+ {
+ yaffs_write(h,fn,strlen(fn));
+ iterations--;
+ }
+
+ yaffs_truncate(h,reSyze);
+
+ yaffs_lseek(h,0,SEEK_SET);
+ iterations = (syze2 + strlen(fn) -1)/ strlen(fn);
+ while (iterations > 0)
+ {
+ yaffs_write(h,fn,strlen(fn));
+ iterations--;
+ }
+
+ yaffs_close (h);
+}
+
+
+void do_some_file_stuff(const char *path)
+{
+
+ char fn[100];
+
+ sprintf(fn,"%s/%s",path,"f1");
+ create_file_of_size(fn,10000);
+
+ sprintf(fn,"%s/%s",path,"fdel");
+ create_file_of_size(fn,10000);
+ yaffs_unlink(fn);
+
+ sprintf(fn,"%s/%s",path,"f2");
+
+ create_resized_file_of_size(fn,10000,3000,4000);
+}
+
+void yaffs_backward_scan_test(const char *path)
+{
+ char fn[100];
+
+ yaffs_StartUp();
+
+ yaffs_mount(path);
+
+ do_some_file_stuff(path);
+
+ sprintf(fn,"%s/ddd",path);
+
+ yaffs_mkdir(fn,0);
+
+ do_some_file_stuff(fn);
+
+ yaffs_unmount(path);
+
+ yaffs_mount(path);
+}
+
+char xxzz[2000];
+
+
+void yaffs_device_flush_test(const char *path)
+{
+ char fn[100];
+ int h;
+ int i;
+
+ yaffs_StartUp();
+
+ yaffs_mount(path);
+
+ do_some_file_stuff(path);
+
+ // Open and add some data to a few files
+ for(i = 0; i < 10; i++) {
+
+ sprintf(fn,"%s/ff%d",path,i);
+
+ h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD);
+ yaffs_write(h,xxzz,2000);
+ yaffs_write(h,xxzz,2000);
+ }
+ yaffs_unmount(path);
+
+ yaffs_mount(path);
+}
+
+
+
+void short_scan_test(const char *path, int fsize, int niterations)
+{
+ int i;
+ char fn[100];
+
+ sprintf(fn,"%s/%s",path,"f1");
+
+ yaffs_StartUp();
+ for(i = 0; i < niterations; i++)
+ {
+ printf("\n*****************\nIteration %d\n",i);
+ yaffs_mount(path);
+ printf("\nmount: Directory look-up of %s\n",path);
+ dumpDir(path);
+ make_a_file(fn,1,fsize);
+ yaffs_unmount(path);
+ }
+}
+
+
+
+void scan_pattern_test(const char *path, int fsize, int niterations)
+{
+ int i;
+ int j;
+ char fn[3][100];
+ int result;
+
+ sprintf(fn[0],"%s/%s",path,"f0");
+ sprintf(fn[1],"%s/%s",path,"f1");
+ sprintf(fn[2],"%s/%s",path,"f2");
+
+ yaffs_StartUp();
+
+ for(i = 0; i < niterations; i++)
+ {
+ printf("\n*****************\nIteration %d\n",i);
+ yaffs_mount(path);
+ printf("\nmount: Directory look-up of %s\n",path);
+ dumpDir(path);
+ for(j = 0; j < 3; j++)
+ {
+ result = dump_file_data(fn[j]);
+ result = check_pattern_file(fn[j]);
+ make_pattern_file(fn[j],fsize);
+ result = dump_file_data(fn[j]);
+ result = check_pattern_file(fn[j]);
+ }
+ yaffs_unmount(path);
+ }
+}
+
+void fill_disk(char *path,int nfiles)
+{
+ int h;
+ int n;
+ int result;
+ int f;
+
+ char str[50];
+
+ for(n = 0; n < nfiles; n++)
+ {
+ sprintf(str,"%s/%d",path,n);
+
+ h = yaffs_open(str, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+
+ printf("writing file %s handle %d ",str, h);
+
+ while ((result = yaffs_write(h,xx,600)) == 600)
+ {
+ f = yaffs_freespace(path);
+ }
+ result = yaffs_close(h);
+ printf(" close %d\n",result);
+ }
+}
+
+void fill_disk_and_delete(char *path, int nfiles, int ncycles)
+{
+ int i,j;
+ char str[50];
+ int result;
+
+ for(i = 0; i < ncycles; i++)
+ {
+ printf("@@@@@@@@@@@@@@ cycle %d\n",i);
+ fill_disk(path,nfiles);
+
+ for(j = 0; j < nfiles; j++)
+ {
+ sprintf(str,"%s/%d",path,j);
+ result = yaffs_unlink(str);
+ printf("unlinking file %s, result %d\n",str,result);
+ }
+ }
+}
+
+
+void fill_files(char *path,int flags, int maxIterations,int siz)
+{
+ int i;
+ int j;
+ char str[50];
+ int h;
+
+ i = 0;
+
+ do{
+ sprintf(str,"%s/%d",path,i);
+ h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
+ yaffs_close(h);
+
+ if(h >= 0)
+ {
+ for(j = 0; j < siz; j++)
+ {
+ yaffs_write(h,str,1);
+ }
+ }
+
+ if( flags & 1)
+ {
+ yaffs_unlink(str);
+ }
+ i++;
+ } while(h >= 0 && i < maxIterations);
+
+ if(flags & 2)
+ {
+ i = 0;
+ do{
+ sprintf(str,"%s/%d",path,i);
+ printf("unlink %s\n",str);
+ i++;
+ } while(yaffs_unlink(str) >= 0);
+ }
+}
+
+void leave_unlinked_file(char *path,int maxIterations,int siz)
+{
+ int i;
+ char str[50];
+ int h;
+
+ i = 0;
+
+ do{
+ sprintf(str,"%s/%d",path,i);
+ printf("create %s\n",str);
+ h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);
+ if(h >= 0)
+ {
+ yaffs_unlink(str);
+ }
+ i++;
+ } while(h < 0 && i < maxIterations);
+
+ if(h >= 0)
+ {
+ for(i = 0; i < siz; i++)
+ {
+ yaffs_write(h,str,1);
+ }
+ }
+
+ printf("Leaving file %s open\n",str);
+
+}
+
+void dumpDirFollow(const char *dname)
+{
+ yaffs_DIR *d;
+ yaffs_dirent *de;
+ struct yaffs_stat s;
+ char str[100];
+
+ d = yaffs_opendir(dname);
+
+ if(!d)
+ {
+ printf("opendir failed\n");
+ }
+ else
+ {
+ while((de = yaffs_readdir(d)) != NULL)
+ {
+ sprintf(str,"%s/%s",dname,de->d_name);
+
+ yaffs_stat(str,&s);
+
+ printf("%s length %d mode %X ",de->d_name,(int)s.st_size,s.st_mode);
+ switch(s.st_mode & S_IFMT)
+ {
+ case S_IFREG: printf("data file"); break;
+ case S_IFDIR: printf("directory"); break;
+ case S_IFLNK: printf("symlink -->");
+ if(yaffs_readlink(str,str,100) < 0)
+ printf("no alias");
+ else
+ printf("\"%s\"",str);
+ break;
+ default: printf("unknown"); break;
+ }
+
+ printf("\n");
+ }
+
+ yaffs_closedir(d);
+ }
+ printf("\n");
+
+ printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
+
+}
+
+
+void dump_directory_tree_worker(const char *dname,int recursive)
+{
+ yaffs_DIR *d;
+ yaffs_dirent *de;
+ struct yaffs_stat s;
+ char str[1000];
+
+ d = yaffs_opendir(dname);
+
+ if(!d)
+ {
+ printf("opendir failed\n");
+ }
+ else
+ {
+ while((de = yaffs_readdir(d)) != NULL)
+ {
+ sprintf(str,"%s/%s",dname,de->d_name);
+
+ yaffs_lstat(str,&s);
+
+ printf("%s inode %d obj %x length %d mode %X ",str,s.st_ino,de->d_dont_use,(int)s.st_size,s.st_mode);
+ switch(s.st_mode & S_IFMT)
+ {
+ case S_IFREG: printf("data file"); break;
+ case S_IFDIR: printf("directory"); break;
+ case S_IFLNK: printf("symlink -->");
+ if(yaffs_readlink(str,str,100) < 0)
+ printf("no alias");
+ else
+ printf("\"%s\"",str);
+ break;
+ default: printf("unknown"); break;
+ }
+
+ printf("\n");
+
+ if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
+ dump_directory_tree_worker(str,1);
+
+ }
+
+ yaffs_closedir(d);
+ }
+
+}
+
+static void dump_directory_tree(const char *dname)
+{
+ dump_directory_tree_worker(dname,1);
+ printf("\n");
+ printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
+}
+
+void dumpDir(const char *dname)
+{ dump_directory_tree_worker(dname,0);
+ printf("\n");
+ printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));
+}
+
+
+static void PermissionsCheck(const char *path, mode_t tmode, int tflags,int expectedResult)
+{
+ int fd;
+
+ if(yaffs_chmod(path,tmode)< 0) printf("chmod failed\n");
+
+ fd = yaffs_open(path,tflags,0);
+
+ if((fd >= 0) != (expectedResult > 0))
+ {
+ printf("Permissions check %x %x %d failed\n",tmode,tflags,expectedResult);
+ }
+ else
+ {
+ printf("Permissions check %x %x %d OK\n",tmode,tflags,expectedResult);
+ }
+
+
+ yaffs_close(fd);
+
+
+}
+
+int long_test(int argc, char *argv[])
+{
+
+ int f;
+ int r;
+ char buffer[20];
+
+ char str[100];
+
+ int h;
+ mode_t temp_mode;
+ struct yaffs_stat ystat;
+
+ yaffs_StartUp();
+
+ yaffs_mount("/boot");
+ yaffs_mount("/data");
+ yaffs_mount("/flash");
+ yaffs_mount("/ram");
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+ printf("\nDirectory look-up of /data\n");
+ dumpDir("/data");
+ printf("\nDirectory look-up of /flash\n");
+ dumpDir("/flash");
+
+ //leave_unlinked_file("/flash",20000,0);
+ //leave_unlinked_file("/data",20000,0);
+
+ leave_unlinked_file("/ram",20,0);
+
+
+ f = yaffs_open("/boot/b1", O_RDONLY,0);
+
+ printf("open /boot/b1 readonly, f=%d\n",f);
+
+ f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
+
+ printf("open /boot/b1 O_CREAT, f=%d\n",f);
+
+
+ r = yaffs_write(f,"hello",1);
+ printf("write %d attempted to write to a read-only file\n",r);
+
+ r = yaffs_close(f);
+
+ printf("close %d\n",r);
+
+ f = yaffs_open("/boot/b1", O_RDWR,0);
+
+ printf("open /boot/b1 O_RDWR,f=%d\n",f);
+
+
+ r = yaffs_write(f,"hello",2);
+ printf("write %d attempted to write to a writeable file\n",r);
+ r = yaffs_write(f,"world",3);
+ printf("write %d attempted to write to a writeable file\n",r);
+
+ r= yaffs_lseek(f,0,SEEK_END);
+ printf("seek end %d\n",r);
+ memset(buffer,0,20);
+ r = yaffs_read(f,buffer,10);
+ printf("read %d \"%s\"\n",r,buffer);
+ r= yaffs_lseek(f,0,SEEK_SET);
+ printf("seek set %d\n",r);
+ memset(buffer,0,20);
+ r = yaffs_read(f,buffer,10);
+ printf("read %d \"%s\"\n",r,buffer);
+ memset(buffer,0,20);
+ r = yaffs_read(f,buffer,10);
+ printf("read %d \"%s\"\n",r,buffer);
+
+ // Check values reading at end.
+ // A read past end of file should return 0 for 0 bytes read.
+
+ r= yaffs_lseek(f,0,SEEK_END);
+ r = yaffs_read(f,buffer,10);
+ printf("read at end returned %d\n",r);
+ r= yaffs_lseek(f,500,SEEK_END);
+ r = yaffs_read(f,buffer,10);
+ printf("read past end returned %d\n",r);
+
+ r = yaffs_close(f);
+
+ printf("close %d\n",r);
+
+ copy_in_a_file("/boot/yyfile","xxx");
+
+ // Create a file with a long name
+
+ copy_in_a_file("/boot/file with a long name","xxx");
+
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+
+ // Check stat
+ r = yaffs_stat("/boot/file with a long name",&ystat);
+
+ // Check rename
+
+ r = yaffs_rename("/boot/file with a long name","/boot/r1");
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+
+ // Check unlink
+ r = yaffs_unlink("/boot/r1");
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+
+ // Check mkdir
+
+ r = yaffs_mkdir("/boot/directory1",0);
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+ printf("\nDirectory look-up of /boot/directory1\n");
+ dumpDir("/boot/directory1");
+
+ // add a file to the directory
+ copy_in_a_file("/boot/directory1/file with a long name","xxx");
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+ printf("\nDirectory look-up of /boot/directory1\n");
+ dumpDir("/boot/directory1");
+
+ // Attempt to delete directory (should fail)
+
+ r = yaffs_rmdir("/boot/directory1");
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+ printf("\nDirectory look-up of /boot/directory1\n");
+ dumpDir("/boot/directory1");
+
+ // Delete file first, then rmdir should work
+ r = yaffs_unlink("/boot/directory1/file with a long name");
+ r = yaffs_rmdir("/boot/directory1");
+
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+ printf("\nDirectory look-up of /boot/directory1\n");
+ dumpDir("/boot/directory1");
+
+#if 0
+ fill_disk_and_delete("/boot",20,20);
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+#endif
+
+ yaffs_symlink("yyfile","/boot/slink");
+
+ yaffs_readlink("/boot/slink",str,100);
+ printf("symlink alias is %s\n",str);
+
+
+
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+ printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
+ dumpDirFollow("/boot");
+ printf("\nDirectory look-up of /boot/directory1\n");
+ dumpDir("/boot/directory1");
+
+ h = yaffs_open("/boot/slink",O_RDWR,0);
+
+ printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
+
+ yaffs_close(h);
+
+ yaffs_unlink("/boot/slink");
+
+
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+
+ // Check chmod
+
+ yaffs_stat("/boot/yyfile",&ystat);
+ temp_mode = ystat.st_mode;
+
+ yaffs_chmod("/boot/yyfile",0x55555);
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+
+ yaffs_chmod("/boot/yyfile",temp_mode);
+ printf("\nDirectory look-up of /boot\n");
+ dumpDir("/boot");
+
+ // Permission checks...
+ PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
+ PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
+ PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
+
+ PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
+ PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
+ PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
+
+ PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
+ PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
+ PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
+
+ PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
+ PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
+ PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
+
+ yaffs_chmod("/boot/yyfile",temp_mode);
+
+ //create a zero-length file and unlink it (test for scan bug)
+
+ h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
+ yaffs_close(h);
+
+ yaffs_unlink("/boot/zlf");
+
+
+ yaffs_DumpDevStruct("/boot");
+
+ fill_disk_and_delete("/boot",20,20);
+
+ yaffs_DumpDevStruct("/boot");
+
+ fill_files("/boot",1,10000,0);
+ fill_files("/boot",1,10000,5000);
+ fill_files("/boot",2,10000,0);
+ fill_files("/boot",2,10000,5000);
+
+ leave_unlinked_file("/data",20000,0);
+ leave_unlinked_file("/data",20000,5000);
+ leave_unlinked_file("/data",20000,5000);
+ leave_unlinked_file("/data",20000,5000);
+ leave_unlinked_file("/data",20000,5000);
+ leave_unlinked_file("/data",20000,5000);
+
+ yaffs_DumpDevStruct("/boot");
+ yaffs_DumpDevStruct("/data");
+
+
+
+ return 0;
+
+}
+
+int huge_directory_test_on_path(char *path)
+{
+
+ yaffs_DIR *d;
+ yaffs_dirent *de;
+ struct yaffs_stat s;
+
+ int f;
+ int i;
+ int r;
+ int total = 0;
+ int lastTotal = 0;
+ char buffer[20];
+
+ char str[100];
+ char name[100];
+ char name2[100];
+
+ int h;
+ mode_t temp_mode;
+ struct yaffs_stat ystat;
+
+ yaffs_StartUp();
+
+ yaffs_mount(path);
+
+ // Create a large number of files
+
+ for(i = 0; i < 2000; i++)
+ {
+ sprintf(str,"%s/%d",path,i);
+
+ f = yaffs_open(str,O_CREAT,S_IREAD | S_IWRITE);
+ yaffs_close(f);
+ }
+
+
+
+ d = yaffs_opendir(path);
+ i = 0;
+ if (d) {
+ while((de = yaffs_readdir(d)) != NULL) {
+ if (total >lastTotal+100*9*1024||(i & 1023)==0){
+ printf("files = %d, total = %d\n",i, total);
+ lastTotal = total;
+ }
+ i++;
+ sprintf(str,"%s/%s",path,de->d_name);
+ yaffs_lstat(str,&s);
+ switch(s.st_mode & S_IFMT){
+ case S_IFREG:
+ //printf("data file");
+ total += s.st_size;
+ break;
+ }
+ }
+
+ yaffs_closedir(d);
+ }
+
+ return 0;
+}
+
+int yaffs_scan_test(const char *path)
+{
+}
+
+
+void rename_over_test(const char *mountpt)
+{
+ int i;
+ char a[100];
+ char b[100];
+
+ sprintf(a,"%s/a",mountpt);
+ sprintf(b,"%s/b",mountpt);
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+ i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
+ yaffs_close(i);
+ i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR, 0);
+ yaffs_close(i);
+ yaffs_rename(a,b); // rename over
+ yaffs_rename(b,a); // rename back again (not renaimng over)
+ yaffs_rename(a,b); // rename back again (not renaimng over)
+
+
+ yaffs_unmount(mountpt);
+
+}
+
+int resize_stress_test(const char *path)
+{
+ int a,b,i,j;
+ int x;
+ int r;
+ char aname[100];
+ char bname[100];
+
+ char abuffer[1000];
+ char bbuffer[1000];
+
+ yaffs_StartUp();
+
+ yaffs_mount(path);
+
+ sprintf(aname,"%s%s",path,"/a");
+ sprintf(bname,"%s%s",path,"/b");
+
+ memset(abuffer,'a',1000);
+ memset(bbuffer,'b',1000);
+
+ a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+ b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ printf(" %s %d %s %d\n",aname,a,bname,b);
+
+ x = 0;
+
+ for(j = 0; j < 100; j++)
+ {
+ yaffs_lseek(a,0,SEEK_END);
+
+
+ for(i = 0; i <20000; i++)
+ {
+ //r = yaffs_lseek(b,i,SEEK_SET);
+ //r = yaffs_write(b,bbuffer,1000);
+
+ if(x & 0x16)
+ {
+ // shrink
+ int syz = yaffs_lseek(a,0,SEEK_END);
+
+ syz -= 500;
+ if(syz < 0) syz = 0;
+ yaffs_truncate(a,syz);
+
+ }
+ else
+ {
+ //expand
+ r = yaffs_lseek(a,i * 500,SEEK_SET);
+ r = yaffs_write(a,abuffer,1000);
+ }
+ x++;
+
+ }
+ }
+
+ return 0;
+
+}
+
+
+int resize_stress_test_no_grow_complex(const char *path,int iters)
+{
+ int a,b,i,j;
+ int x;
+ int r;
+ char aname[100];
+ char bname[100];
+
+ char abuffer[1000];
+ char bbuffer[1000];
+
+ yaffs_StartUp();
+
+ yaffs_mount(path);
+
+ sprintf(aname,"%s%s",path,"/a");
+ sprintf(bname,"%s%s",path,"/b");
+
+ memset(abuffer,'a',1000);
+ memset(bbuffer,'b',1000);
+
+ a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+ b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ printf(" %s %d %s %d\n",aname,a,bname,b);
+
+ x = 0;
+
+ for(j = 0; j < iters; j++)
+ {
+ yaffs_lseek(a,0,SEEK_END);
+
+
+ for(i = 0; i <20000; i++)
+ {
+ //r = yaffs_lseek(b,i,SEEK_SET);
+ //r = yaffs_write(b,bbuffer,1000);
+
+ if(!(x%20))
+ {
+ // shrink
+ int syz = yaffs_lseek(a,0,SEEK_END);
+
+ while(syz > 4000)
+ {
+
+ syz -= 2050;
+ if(syz < 0) syz = 0;
+ yaffs_truncate(a,syz);
+ syz = yaffs_lseek(a,0,SEEK_END);
+ printf("shrink to %d\n",syz);
+ }
+
+
+ }
+ else
+ {
+ //expand
+ r = yaffs_lseek(a,500,SEEK_END);
+ r = yaffs_write(a,abuffer,1000);
+ }
+ x++;
+
+
+ }
+ printf("file size is %d\n",yaffs_lseek(a,0,SEEK_END));
+
+ }
+
+ return 0;
+
+}
+
+int resize_stress_test_no_grow(const char *path,int iters)
+{
+ int a,b,i,j;
+ int x;
+ int r;
+ char aname[100];
+ char bname[100];
+
+ char abuffer[1000];
+ char bbuffer[1000];
+
+ yaffs_StartUp();
+
+ yaffs_mount(path);
+
+ sprintf(aname,"%s%s",path,"/a");
+ sprintf(bname,"%s%s",path,"/b");
+
+ memset(abuffer,'a',1000);
+ memset(bbuffer,'b',1000);
+
+ a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+ b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ printf(" %s %d %s %d\n",aname,a,bname,b);
+
+ x = 0;
+
+ for(j = 0; j < iters; j++)
+ {
+ yaffs_lseek(a,0,SEEK_END);
+
+
+ for(i = 0; i <20000; i++)
+ {
+ //r = yaffs_lseek(b,i,SEEK_SET);
+ //r = yaffs_write(b,bbuffer,1000);
+
+ if(!(x%20))
+ {
+ // shrink
+ int syz = yaffs_lseek(a,0,SEEK_END);
+
+ while(syz > 4000)
+ {
+
+ syz -= 2050;
+ if(syz < 0) syz = 0;
+ yaffs_truncate(a,syz);
+ syz = yaffs_lseek(a,0,SEEK_END);
+ printf("shrink to %d\n",syz);
+ }
+
+
+ }
+ else
+ {
+ //expand
+ r = yaffs_lseek(a,-500,SEEK_END);
+ r = yaffs_write(a,abuffer,1000);
+ }
+ x++;
+
+
+ }
+ printf("file size is %d\n",yaffs_lseek(a,0,SEEK_END));
+
+ }
+
+ return 0;
+
+}
+
+int directory_rename_test(void)
+{
+ int r;
+ yaffs_StartUp();
+
+ yaffs_mount("/ram");
+ yaffs_mkdir("/ram/a",0);
+ yaffs_mkdir("/ram/a/b",0);
+ yaffs_mkdir("/ram/c",0);
+
+ printf("\nDirectory look-up of /ram\n");
+ dumpDir("/ram");
+ dumpDir("/ram/a");
+ dumpDir("/ram/a/b");
+
+ printf("Do rename (should fail)\n");
+
+ r = yaffs_rename("/ram/a","/ram/a/b/d");
+ printf("\nDirectory look-up of /ram\n");
+ dumpDir("/ram");
+ dumpDir("/ram/a");
+ dumpDir("/ram/a/b");
+
+ printf("Do rename (should not fail)\n");
+
+ r = yaffs_rename("/ram/c","/ram/a/b/d");
+ printf("\nDirectory look-up of /ram\n");
+ dumpDir("/ram");
+ dumpDir("/ram/a");
+ dumpDir("/ram/a/b");
+
+
+ return 1;
+
+}
+
+int cache_read_test(void)
+{
+ int a,b,c;
+ int i;
+ int sizeOfFiles = 500000;
+ char buffer[100];
+
+ yaffs_StartUp();
+
+ yaffs_mount("/boot");
+
+ make_a_file("/boot/a",'a',sizeOfFiles);
+ make_a_file("/boot/b",'b',sizeOfFiles);
+
+ a = yaffs_open("/boot/a",O_RDONLY,0);
+ b = yaffs_open("/boot/b",O_RDONLY,0);
+ c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
+
+ do{
+ i = sizeOfFiles;
+ if (i > 100) i = 100;
+ sizeOfFiles -= i;
+ yaffs_read(a,buffer,i);
+ yaffs_read(b,buffer,i);
+ yaffs_write(c,buffer,i);
+ } while(sizeOfFiles > 0);
+
+
+
+ return 1;
+
+}
+
+int cache_bypass_bug_test(void)
+{
+ // This test reporoduces a bug whereby YAFFS caching *was* buypassed
+ // resulting in erroneous reads after writes.
+ // This bug has been fixed.
+
+ int a;
+ int i;
+ char buffer1[1000];
+ char buffer2[1000];
+
+ memset(buffer1,0,sizeof(buffer1));
+ memset(buffer2,0,sizeof(buffer2));
+
+ yaffs_StartUp();
+
+ yaffs_mount("/boot");
+
+ // Create a file of 2000 bytes.
+ make_a_file("/boot/a",'X',2000);
+
+ a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
+
+ // Write a short sequence to the file.
+ // This will go into the cache.
+ yaffs_lseek(a,0,SEEK_SET);
+ yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
+
+ // Read a short sequence from the file.
+ // This will come from the cache.
+ yaffs_lseek(a,0,SEEK_SET);
+ yaffs_read(a,buffer1,30);
+
+ // Read a page size sequence from the file.
+ yaffs_lseek(a,0,SEEK_SET);
+ yaffs_read(a,buffer2,512);
+
+ printf("buffer 1 %s\n",buffer1);
+ printf("buffer 2 %s\n",buffer2);
+
+ if(strncmp(buffer1,buffer2,20))
+ {
+ printf("Cache bypass bug detected!!!!!\n");
+ }
+
+
+ return 1;
+}
+
+
+int free_space_check(void)
+{
+ int f;
+
+ yaffs_StartUp();
+ yaffs_mount("/boot");
+ fill_disk("/boot/",2);
+ f = yaffs_freespace("/boot");
+
+ printf("%d free when disk full\n",f);
+ return 1;
+}
+
+int truncate_test(void)
+{
+ int a;
+ int r;
+ int i;
+ int l;
+
+ char y[10];
+
+ yaffs_StartUp();
+ yaffs_mount("/boot");
+
+ yaffs_unlink("/boot/trunctest");
+
+ a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
+
+ yaffs_truncate(a,3);
+ l= yaffs_lseek(a,0,SEEK_END);
+
+ printf("truncated length is %d\n",l);
+
+ yaffs_lseek(a,5,SEEK_SET);
+ yaffs_write(a,"1",1);
+
+ yaffs_lseek(a,0,SEEK_SET);
+
+ r = yaffs_read(a,y,10);
+
+ printf("read %d bytes:",r);
+
+ for(i = 0; i < r; i++) printf("[%02X]",y[i]);
+
+ printf("\n");
+
+ return 0;
+
+}
+
+
+
+
+
+void fill_disk_test(const char *mountpt)
+{
+ int i;
+ yaffs_StartUp();
+
+ for(i = 0; i < 5; i++)
+ {
+ yaffs_mount(mountpt);
+ fill_disk_and_delete(mountpt,100,i+1);
+ yaffs_unmount(mountpt);
+ }
+
+}
+
+
+
+void lookup_test(const char *mountpt)
+{
+ int i;
+ int h;
+ char a[100];
+ char b[100];
+
+
+ yaffs_DIR *d;
+ yaffs_dirent *de;
+ struct yaffs_stat s;
+ char str[100];
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+
+ d = yaffs_opendir(mountpt);
+
+ if(!d)
+ {
+ printf("opendir failed\n");
+ }
+ else
+ {
+
+ for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
+ {
+ printf("unlinking %s\n",de->d_name);
+ yaffs_unlink(de->d_name);
+ }
+
+ printf("%d files deleted\n",i);
+ }
+
+
+ for(i = 0; i < 2000; i++){
+ sprintf(a,"%s/%d",mountpt,i);
+ h = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
+ yaffs_close(h);
+ }
+
+ yaffs_rewinddir(d);
+ for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
+ {
+ printf("%d %s\n",i,de->d_name);
+ }
+
+ printf("%d files listed\n\n\n",i);
+
+ yaffs_rewinddir(d);
+ yaffs_readdir(d);
+ yaffs_readdir(d);
+ yaffs_readdir(d);
+
+ for(i = 0; i < 2000; i++){
+ sprintf(a,"%s/%d",mountpt,i);
+ yaffs_unlink(a);
+ }
+
+
+ yaffs_unmount(mountpt);
+
+}
+
+void link_test(const char *mountpt)
+{
+ int i;
+ int h;
+ char a[100];
+ char b[100];
+ char c[100];
+
+ int f0;
+ int f1;
+ int f2;
+ int f3;
+ sprintf(a,"%s/aaa",mountpt);
+ sprintf(b,"%s/bbb",mountpt);
+ sprintf(c,"%s/ccc",mountpt);
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+
+
+ h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+ for(i = 0; i < 100; i++)
+ yaffs_write(h,a,100);
+
+ yaffs_close(h);
+
+ yaffs_unlink(b);
+ yaffs_unlink(c);
+ yaffs_link(a,b);
+ yaffs_link(a,c);
+ yaffs_unlink(b);
+ yaffs_unlink(c);
+ yaffs_unlink(a);
+
+
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+
+ printf("link test done\n");
+
+}
+
+void freespace_test(const char *mountpt)
+{
+ int i;
+ int h;
+ char a[100];
+ char b[100];
+
+ int f0;
+ int f1;
+ int f2;
+ int f3;
+ sprintf(a,"%s/aaa",mountpt);
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+
+ f0 = yaffs_freespace(mountpt);
+
+ h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ for(i = 0; i < 100; i++)
+ yaffs_write(h,a,100);
+
+ yaffs_close(h);
+
+ f1 = yaffs_freespace(mountpt);
+
+ yaffs_unlink(a);
+
+ f2 = yaffs_freespace(mountpt);
+
+
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+
+ f3 = yaffs_freespace(mountpt);
+
+ printf("%d\n%d\n%d\n%d\n",f0, f1,f2,f3);
+
+
+}
+
+void simple_rw_test(const char *mountpt)
+{
+ int i;
+ int h;
+ char a[100];
+
+ int x;
+ int result;
+
+ sprintf(a,"%s/aaa",mountpt);
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+
+ yaffs_unlink(a);
+
+ h = yaffs_open(a,O_CREAT| O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ for(i = 100000;i < 200000; i++){
+ result = yaffs_write(h,&i,sizeof(i));
+
+ if(result != 4)
+ {
+ printf("write error\n");
+ exit(1);
+ }
+ }
+
+ //yaffs_close(h);
+
+ // h = yaffs_open(a,O_RDWR, S_IREAD | S_IWRITE);
+
+
+ yaffs_lseek(h,0,SEEK_SET);
+
+ for(i = 100000; i < 200000; i++){
+ result = yaffs_read(h,&x,sizeof(x));
+
+ if(result != 4 || x != i){
+ printf("read error %d %x %x\n",i,result,x);
+ }
+ }
+
+ printf("Simple rw test passed\n");
+
+
+
+}
+
+
+void scan_deleted_files_test(const char *mountpt)
+{
+ char fn[100];
+ char sub[100];
+
+ const char *p;
+
+ int i;
+ int j;
+ int k;
+ int h;
+
+ sprintf(sub,"%s/sdir",mountpt);
+ yaffs_StartUp();
+
+ for(j = 0; j < 10; j++)
+ {
+ printf("\n\n>>>>>>> Run %d <<<<<<<<<<<<<\n\n",j);
+ yaffs_mount(mountpt);
+ yaffs_mkdir(sub,0);
+
+
+ p = (j & 0) ? mountpt: sub;
+
+ for(i = 0; i < 100; i++)
+ {
+ sprintf(fn,"%s/%d",p,i);
+
+ if(i & 1)
+ {
+ h = yaffs_open(fn,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+ for(k = 0; k < 1000; k++)
+ yaffs_write(h,fn,100);
+ yaffs_close(h);
+ }
+ else
+ yaffs_mkdir(fn,0);
+ }
+
+ for(i = 0; i < 10; i++)
+ {
+ sprintf(fn,"%s/%d",p,i);
+ if(i & 1)
+ yaffs_unlink(fn);
+ else
+ yaffs_rmdir(fn);
+
+ }
+
+ yaffs_unmount(mountpt);
+ }
+
+
+
+
+}
+
+
+void write_10k(int h)
+{
+ int i;
+ const char *s="0123456789";
+ for(i = 0; i < 1000; i++)
+ yaffs_write(h,s,10);
+
+}
+void write_200k_file(const char *fn, const char *fdel, const char *fdel1)
+{
+ int h1;
+ int i;
+ int offs;
+
+ h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ for(i = 0; i < 100000; i+= 10000)
+ {
+ write_10k(h1);
+ }
+
+ offs = yaffs_lseek(h1,0,SEEK_CUR);
+ if( offs != 100000)
+ {
+ printf("Could not write file\n");
+ }
+
+ yaffs_unlink(fdel);
+ for(i = 0; i < 100000; i+= 10000)
+ {
+ write_10k(h1);
+ }
+
+ offs = yaffs_lseek(h1,0,SEEK_CUR);
+ if( offs != 200000)
+ {
+ printf("Could not write file\n");
+ }
+
+ yaffs_close(h1);
+ yaffs_unlink(fdel1);
+
+}
+
+
+void verify_200k_file(const char *fn)
+{
+ int h1;
+ int i;
+ char x[11];
+ const char *s="0123456789";
+ int errCount = 0;
+
+ h1 = yaffs_open(fn, O_RDONLY, 0);
+
+ for(i = 0; i < 200000 && errCount < 10; i+= 10)
+ {
+ yaffs_read(h1,x,10);
+ if(strncmp(x,s,10) != 0)
+ {
+ printf("File %s verification failed at %d\n",fn,i);
+ errCount++;
+ }
+ }
+ if(errCount >= 10)
+ printf("Too many errors... aborted\n");
+
+ yaffs_close(h1);
+
+}
+
+
+void check_resize_gc_bug(const char *mountpt)
+{
+
+ char a[30];
+ char b[30];
+ char c[30];
+
+ int i;
+
+ sprintf(a,"%s/a",mountpt);
+ sprintf(b,"%s/b",mountpt);
+ sprintf(c,"%s/c",mountpt);
+
+
+
+
+ yaffs_StartUp();
+ yaffs_mount(mountpt);
+ yaffs_unlink(a);
+ yaffs_unlink(b);
+
+ for(i = 0; i < 50; i++)
+ {
+ printf("A\n");write_200k_file(a,"",c);
+ printf("B\n");verify_200k_file(a);
+ printf("C\n");write_200k_file(b,a,c);
+ printf("D\n");verify_200k_file(b);
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+ printf("E\n");verify_200k_file(a);
+ printf("F\n");verify_200k_file(b);
+ }
+
+}
+
+
+void multi_mount_test(const char *mountpt,int nmounts)
+{
+
+ char a[30];
+ char b[30];
+ char c[30];
+
+ int i;
+ int j;
+
+ sprintf(a,"%s/a",mountpt);
+
+ yaffs_StartUp();
+
+ for(i = 0; i < nmounts; i++){
+ int h0;
+ int h1;
+ int len0;
+ int len1;
+
+ static char xx[1000];
+
+ printf("############### Iteration %d Start\n",i);
+ if(1 || i == 0 || i == 5)
+ yaffs_mount(mountpt);
+
+ dump_directory_tree(mountpt);
+
+
+ yaffs_mkdir(a,0);
+
+ sprintf(xx,"%s/0",a);
+ h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+
+ sprintf(xx,"%s/1",a);
+ h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+
+ for(j = 0; j < 200; j++){
+ yaffs_write(h0,xx,1000);
+ yaffs_write(h1,xx,1000);
+ }
+
+ len0 = yaffs_lseek(h0,0,SEEK_END);
+ len1 = yaffs_lseek(h1,0,SEEK_END);
+
+ yaffs_lseek(h0,0,SEEK_SET);
+ yaffs_lseek(h1,0,SEEK_SET);
+
+ for(j = 0; j < 200; j++){
+ yaffs_read(h0,xx,1000);
+ yaffs_read(h1,xx,1000);
+ }
+
+
+ yaffs_truncate(h0,0);
+ yaffs_close(h0);
+ yaffs_close(h1);
+
+ printf("########### %d\n",i);
+ dump_directory_tree(mountpt);
+
+ if(1 || i == 4 || i == nmounts -1)
+ yaffs_unmount(mountpt);
+ }
+}
+
+
+void small_mount_test(const char *mountpt,int nmounts)
+{
+
+ char a[30];
+ char b[30];
+ char c[30];
+
+ int i;
+ int j;
+
+ int h0;
+ int h1;
+ int len0;
+ int len1;
+ int nread;
+
+ sprintf(a,"%s/a",mountpt);
+
+ yaffs_StartUp();
+
+
+
+ for(i = 0; i < nmounts; i++){
+
+ static char xx[1000];
+
+ printf("############### Iteration %d Start\n",i);
+ if(1 || i == 0 || i == 5)
+ yaffs_mount(mountpt);
+
+ dump_directory_tree(mountpt);
+
+ yaffs_mkdir(a,0);
+
+ sprintf(xx,"%s/0",a);
+ if(i ==0){
+
+ h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+ for(j = 0; j < 130; j++)
+ yaffs_write(h0,xx,1000);
+ yaffs_close(h0);
+ }
+
+ h0 = yaffs_open(xx,O_RDONLY,0);
+
+ sprintf(xx,"%s/1",a);
+ h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+
+ while((nread = yaffs_read(h0,xx,1000)) > 0)
+ yaffs_write(h1,xx,nread);
+
+
+ len0 = yaffs_lseek(h0,0,SEEK_END);
+ len1 = yaffs_lseek(h1,0,SEEK_END);
+
+ yaffs_lseek(h0,0,SEEK_SET);
+ yaffs_lseek(h1,0,SEEK_SET);
+
+ for(j = 0; j < 200; j++){
+ yaffs_read(h0,xx,1000);
+ yaffs_read(h1,xx,1000);
+ }
+
+ yaffs_close(h0);
+ yaffs_close(h1);
+
+ printf("########### %d\n",i);
+ dump_directory_tree(mountpt);
+
+ if(1 || i == 4 || i == nmounts -1)
+ yaffs_unmount(mountpt);
+ }
+}
+
+
+int early_exit;
+
+void small_overwrite_test(const char *mountpt,int nmounts)
+{
+
+ char a[30];
+ char b[30];
+ char c[30];
+
+ int i;
+ int j;
+
+ int h0;
+ int h1;
+ int len0;
+ int len1;
+ int nread;
+
+ sprintf(a,"%s/a",mountpt);
+
+ yaffs_StartUp();
+
+
+
+ for(i = 0; i < nmounts; i++){
+
+ static char xx[8000];
+
+ printf("############### Iteration %d Start\n",i);
+ if(1)
+ yaffs_mount(mountpt);
+
+ dump_directory_tree(mountpt);
+
+ yaffs_mkdir(a,0);
+
+ sprintf(xx,"%s/0",a);
+ h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+ sprintf(xx,"%s/1",a);
+ h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+
+ for(j = 0; j < 1000000; j+=1000){
+ yaffs_truncate(h0,j);
+ yaffs_lseek(h0,j,SEEK_SET);
+ yaffs_write(h0,xx,7000);
+ yaffs_write(h1,xx,7000);
+
+ if(early_exit)
+ exit(0);
+ }
+
+ yaffs_close(h0);
+
+ printf("########### %d\n",i);
+ dump_directory_tree(mountpt);
+
+ if(1)
+ yaffs_unmount(mountpt);
+ }
+}
+
+
+void yaffs_touch(const char *fn)
+{
+ yaffs_chmod(fn, S_IREAD | S_IWRITE);
+}
+
+void checkpoint_fill_test(const char *mountpt,int nmounts)
+{
+
+ char a[50];
+ char b[50];
+ char c[50];
+
+ int i;
+ int j;
+ int h;
+
+ sprintf(a,"%s/a",mountpt);
+
+
+
+
+ yaffs_StartUp();
+
+ for(i = 0; i < nmounts; i++){
+ printf("############### Iteration %d Start\n",i);
+ yaffs_mount(mountpt);
+ dump_directory_tree(mountpt);
+ yaffs_mkdir(a,0);
+
+ sprintf(b,"%s/zz",a);
+
+ h = yaffs_open(b,O_CREAT | O_RDWR,S_IREAD |S_IWRITE);
+
+
+ while(yaffs_write(h,c,50) == 50){}
+
+ yaffs_close(h);
+
+ for(j = 0; j < 2; j++){
+ printf("touch %d\n",j);
+ yaffs_touch(b);
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+ }
+
+ dump_directory_tree(mountpt);
+ yaffs_unmount(mountpt);
+ }
+}
+
+
+int make_file2(const char *name1, const char *name2,int syz)
+{
+
+ char xx[2500];
+ int i;
+ int h1=-1,h2=-1;
+ int n = 1;
+
+
+ if(name1)
+ h1 = yaffs_open(name1,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+ if(name2)
+ h2 = yaffs_open(name2,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ while(syz > 0 && n > 0){
+ i = (syz > 2500) ? 2500 : syz;
+ n = yaffs_write(h1,xx,i);
+ n = yaffs_write(h2,xx,i);
+ syz -= 500;
+ }
+ yaffs_close(h1);
+ yaffs_close(h2);
+
+}
+
+
+extern void SetCheckpointReservedBlocks(int n);
+
+void checkpoint_upgrade_test(const char *mountpt,int nmounts)
+{
+
+ char a[50];
+ char b[50];
+ char c[50];
+ char d[50];
+
+ int i;
+ int j;
+ int h;
+
+ sprintf(a,"%s/a",mountpt);
+
+
+
+
+ printf("Create start condition\n");
+ yaffs_StartUp();
+ SetCheckpointReservedBlocks(0);
+ yaffs_mount(mountpt);
+ yaffs_mkdir(a,0);
+ sprintf(b,"%s/zz",a);
+ sprintf(c,"%s/xx",a);
+ make_file2(b,c,2000000);
+ sprintf(d,"%s/aa",a);
+ make_file2(d,NULL,500000000);
+ dump_directory_tree(mountpt);
+
+ printf("Umount/mount attempt full\n");
+ yaffs_unmount(mountpt);
+
+ SetCheckpointReservedBlocks(10);
+ yaffs_mount(mountpt);
+
+ printf("unlink small file\n");
+ yaffs_unlink(c);
+ dump_directory_tree(mountpt);
+
+ printf("Umount/mount attempt\n");
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+
+ for(j = 0; j < 500; j++){
+ printf("***** touch %d\n",j);
+ dump_directory_tree(mountpt);
+ yaffs_touch(b);
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+ }
+
+ for(j = 0; j < 500; j++){
+ printf("***** touch %d\n",j);
+ dump_directory_tree(mountpt);
+ yaffs_touch(b);
+ yaffs_unmount(mountpt);
+ yaffs_mount(mountpt);
+ }
+}
+
+void huge_array_test(const char *mountpt,int n)
+{
+
+ char a[50];
+
+
+ int i;
+ int j;
+ int h;
+
+ int fnum;
+
+ sprintf(a,"mount point %s",mountpt);
+
+
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+
+ while(n>0){
+ n--;
+ fnum = 0;
+ printf("\n\n START run\n\n");
+ while(yaffs_freespace(mountpt) > 25000000){
+ sprintf(a,"%s/file%d",mountpt,fnum);
+ fnum++;
+ printf("create file %s\n",a);
+ create_file_of_size(a,10000000);
+ printf("verifying file %s\n",a);
+ verify_file_of_size(a,10000000);
+ }
+
+ printf("\n\n verification/deletion\n\n");
+
+ for(i = 0; i < fnum; i++){
+ sprintf(a,"%s/file%d",mountpt,i);
+ printf("verifying file %s\n",a);
+ verify_file_of_size(a,10000000);
+ printf("deleting file %s\n",a);
+ yaffs_unlink(a);
+ }
+ printf("\n\n done \n\n");
+
+
+ }
+}
+
+
+void random_write(int h)
+{
+ static char buffer[12000];
+ int n;
+
+ n = random() & 0x1FFF;
+ yaffs_write(h,buffer,n);
+}
+
+void random_seek(int h)
+{
+ int n;
+ n = random() & 0xFFFFF;
+ yaffs_lseek(h,n,SEEK_SET);
+}
+
+void random_truncate(int h, char * name)
+{
+ int n;
+ int flen;
+ n = random() & 0xFFFFF;
+ flen = yaffs_lseek(h,0,SEEK_END);
+ if(n > flen)
+ n = flen / 2;
+ yaffs_truncate(name,n);
+ yaffs_lseek(h,n,SEEK_SET);
+}
+
+
+#define NSMALLFILES 10
+void random_small_file_test(const char *mountpt,int iterations)
+{
+
+ char a[NSMALLFILES][50];
+
+
+ int i;
+ int n;
+ int j;
+ int h[NSMALLFILES];
+ int r;
+ int fnum;
+
+
+ yaffs_StartUp();
+
+ yaffs_mount(mountpt);
+
+ for(i = 0; i < NSMALLFILES; i++){
+ h[i]=-1;
+ strcpy(a[i],"");
+ }
+
+ for(n = 0; n < iterations; n++){
+
+ for(i = 0; i < NSMALLFILES; i++) {
+ r = random();
+
+ if(strlen(a[i]) == 0){
+ sprintf(a[i],"%s/%dx%d",mountpt,n,i);
+ h[i] = yaffs_open(a,O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+ }
+
+ if(h[i] < -1)
+ printf("Could not open yaffs file %d %d error %d\n",n,i,h[i]);
+ else {
+ r = r & 7;
+ switch(r){
+ case 0:
+ case 1:
+ case 2:
+ random_write(h[i]);
+ break;
+ case 3:
+ random_truncate(h[i],a[i]);
+ break;
+ case 4:
+ case 5: random_seek(h[i]);
+ break;
+ case 6:
+ yaffs_close(h[i]);
+ h[i] = -1;
+ break;
+ case 7:
+ yaffs_close(h[i]);
+ yaffs_unlink(a[i]);
+ strcpy(a[i],"");
+ h[i] = -1;
+ }
+ }
+ }
+
+ }
+
+ for(i = 0; i < NSMALLFILES; i++)
+ yaffs_close(h[i]);
+
+ yaffs_unmount(mountpt);
+}
+
+
+
+int main(int argc, char *argv[])
+{
+ //return long_test(argc,argv);
+
+ //return cache_read_test();
+
+ resize_stress_test_no_grow("/flash/flash",20);
+
+ //huge_directory_test_on_path("/ram2k");
+
+ //yaffs_backward_scan_test("/flash/flash");
+ // yaffs_device_flush_test("/flash/flash");
+
+
+ //scan_pattern_test("/flash",10000,10);
+ //short_scan_test("/flash/flash",40000,200);
+ //small_mount_test("/flash/flash",1000);
+ //small_overwrite_test("/flash/flash",1000);
+ //checkpoint_fill_test("/flash/flash",20);
+ // random_small_file_test("/flash/flash",10000);
+ // huge_array_test("/flash/flash",10);
+
+
+
+
+ //long_test_on_path("/ram2k");
+ // long_test_on_path("/flash");
+ //simple_rw_test("/flash/flash");
+ //fill_disk_test("/flash/flash");
+ // rename_over_test("/flash");
+ //lookup_test("/flash");
+ //freespace_test("/flash/flash");
+
+ //link_test("/flash/flash");
+
+
+
+
+ // cache_bypass_bug_test();
+
+ //free_space_check();
+
+ //check_resize_gc_bug("/flash");
+
+ return 0;
+
+}
diff --git a/fs/yaffs2/direct/fsx_test/Makefile b/fs/yaffs2/direct/fsx_test/Makefile
new file mode 100644
index 0000000000..1927865422
--- /dev/null
+++ b/fs/yaffs2/direct/fsx_test/Makefile
@@ -0,0 +1,75 @@
+# Makefile for YAFFS direct test
+#
+#
+# YAFFS: Yet another Flash File System. A NAND-flash specific file system.
+#
+# Copyright (C) 2003 Aleph One Ltd.
+#
+#
+# Created by Charles Manning <charles@aleph1.co.uk>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# NB Warning this Makefile does not include header dependencies.
+#
+# $Id: Makefile,v 1.1 2007/10/16 00:46:33 charles Exp $
+
+#EXTRA_COMPILE_FLAGS = -DYAFFS_IGNORE_TAGS_ECC
+
+CFLAGS = -Wall -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -g $(EXTRA_COMPILE_FLAGS) -DNO_Y_INLINE
+CFLAGS+= -fstack-check -O0
+
+#CFLAGS+= -Wshadow -Wpointer-arith -Wwrite-strings -Wstrict-prototypes -Wmissing-declarations
+#CFLAGS+= -Wmissing-prototypes -Wredundant-decls -Wnested-externs -Winline
+
+
+FSXTESTOBJS = yaffs_fsx.o yaffscfg2k.o yaffs_ecc.o yaffs_fileem2k.o yaffsfs.o yaffs_guts.o \
+ yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \
+ yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o yaffs_nand.o \
+ yaffs_checkptrw.o yaffs_qsort.o \
+# yaffs_checkptrwtest.o\
+
+
+BOOTTESTOBJS = bootldtst.o yboot.o yaffs_fileem.o nand_ecc.o
+
+#ALLOBJS = dtest.o nand_ecc.o yaffscfg.o yaffs_fileem.o yaffsfs.o yaffs_ramdisk.o bootldtst.o yboot.o yaffs_ramem2k.o
+
+ALLOBJS = $(FSXTESTOBJS) $(BOOTTESTOBJS)
+
+YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yaffsinterface.h yportenv.h yaffs_tagscompat.c yaffs_tagscompat.h \
+ yaffs_packedtags1.c yaffs_packedtags1.h yaffs_packedtags2.c yaffs_packedtags2.h yaffs_nandemul2k.h \
+ yaffs_nand.c yaffs_nand.h \
+ yaffs_tagsvalidity.c yaffs_tagsvalidity.h yaffs_checkptrw.h yaffs_checkptrw.c \
+ yaffs_qsort.c yaffs_qsort.h
+
+YAFFSDIRECTSYMLINKS = yaffscfg2k.c yaffs_fileem2k.c yaffsfs.c yaffs_flashif.h \
+ yaffs_fileem2k.h yaffsfs.h yaffs_malloc.h yaffs_ramdisk.h ydirectenv.h \
+ yaffscfg.h yaffs_fileem.c yaffs_flashif.c yaffs_ramdisk.c yaffs_ramem2k.c
+
+
+
+#all: fsxtest boottest
+
+all: fsxtest
+
+$(ALLOBJS): %.o: %.c
+ gcc -c $(CFLAGS) $< -o $@
+
+$(YAFFSSYMLINKS):
+ ln -s ../../$@ $@
+
+$(YAFFSDIRECTSYMLINKS):
+ ln -s ../$@ $@
+
+fsxtest: $(YAFFSSYMLINKS) $(YAFFSDIRECTSYMLINKS) $(FSXTESTOBJS)
+ gcc -o $@ $(FSXTESTOBJS)
+
+
+boottest: $(SYMLINKS) $(BOOTTESTOBJS)
+ gcc -o $@ $(BOOTTESTOBJS)
+
+
+clean:
+ rm -f $(ALLOBJS) core
diff --git a/fs/yaffs2/direct/fsx_test/README b/fs/yaffs2/direct/fsx_test/README
new file mode 100644
index 0000000000..725ab07558
--- /dev/null
+++ b/fs/yaffs2/direct/fsx_test/README
@@ -0,0 +1,7 @@
+NB THis directory uses a hacked version of fsx.c which is released under
+Apple Public Source License.
+
+From what I have been able to determine, it is legally OK to release a hacked
+version for the purposes of testing.
+
+If anyone knows otherwise, please contact me: manningc2@actrix.gen.nz
diff --git a/fs/yaffs2/direct/fsx_test/yaffs_fsx.c b/fs/yaffs2/direct/fsx_test/yaffs_fsx.c
new file mode 100644
index 0000000000..1e110b9b72
--- /dev/null
+++ b/fs/yaffs2/direct/fsx_test/yaffs_fsx.c
@@ -0,0 +1,1007 @@
+/*
+ * Copyright (c) 1998-2001 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * The contents of this file constitute Original Code as defined in and
+ * are subject to the Apple Public Source License Version 1.2 (the
+ * "License"). You may not use this file except in compliance with the
+ * License. Please obtain a copy of the License at
+ * http://www.apple.com/publicsource and read it before using this file.
+ *
+ * This Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ *
+ * WARNING--WARNING--WARNING
+ * This is not the original fsx.c. It has been modified to run with
+ * yaffs direct. Seek out the original fsx.c if you want to do anything
+ * else.
+ *
+ *
+ *
+ * File: fsx.c
+ * Author: Avadis Tevanian, Jr.
+ *
+ * File system exerciser.
+ *
+ * Rewrite and enhancements 1998-2001 Conrad Minshall -- conrad@mac.com
+ *
+ * Various features from Joe Sokol, Pat Dirks, and Clark Warner.
+ *
+ * Small changes to work under Linux -- davej@suse.de
+ *
+ * Sundry porting patches from Guy Harris 12/2001
+ *
+ * Checks for mmap last-page zero fill.
+ *
+ * Modified heavily by Charles Manning to exercise via the
+ * yaffs direct interface.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef _UWIN
+# include <sys/param.h>
+# include <limits.h>
+# include <time.h>
+# include <strings.h>
+#endif
+#include <fcntl.h>
+#include <sys/mman.h>
+#ifndef MAP_FILE
+# define MAP_FILE 0
+#endif
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#include "yaffsfs.h"
+
+#define NUMPRINTCOLUMNS 32 /* # columns of data to print on each line */
+
+/*
+ * A log entry is an operation and a bunch of arguments.
+ */
+
+struct log_entry {
+ int operation;
+ int args[3];
+};
+
+#define LOGSIZE 1000
+
+struct log_entry oplog[LOGSIZE]; /* the log */
+int logptr = 0; /* current position in log */
+int logcount = 0; /* total ops */
+
+/*
+ * Define operations
+ */
+
+#define OP_READ 1
+#define OP_WRITE 2
+#define OP_TRUNCATE 3
+#define OP_CLOSEOPEN 4
+#define OP_MAPREAD 5
+#define OP_MAPWRITE 6
+#define OP_SKIPPED 7
+
+int page_size;
+int page_mask;
+
+char *original_buf; /* a pointer to the original data */
+char *good_buf; /* a pointer to the correct data */
+char *temp_buf; /* a pointer to the current data */
+char *fname; /* name of our test file */
+int fd; /* fd for our test file */
+
+off_t file_size = 0;
+off_t biggest = 0;
+char state[256];
+unsigned long testcalls = 0; /* calls to function "test" */
+
+unsigned long simulatedopcount = 0; /* -b flag */
+int closeprob = 0; /* -c flag */
+int debug = 0; /* -d flag */
+unsigned long debugstart = 0; /* -D flag */
+unsigned long maxfilelen = 256 * 1024; /* -l flag */
+int sizechecks = 1; /* -n flag disables them */
+int maxoplen = 64 * 1024; /* -o flag */
+int quiet = 0; /* -q flag */
+unsigned long progressinterval = 0; /* -p flag */
+int readbdy = 1; /* -r flag */
+int style = 0; /* -s flag */
+int truncbdy = 1; /* -t flag */
+int writebdy = 1; /* -w flag */
+long monitorstart = -1; /* -m flag */
+long monitorend = -1; /* -m flag */
+int lite = 0; /* -L flag */
+long numops = -1; /* -N flag */
+int randomoplen = 1; /* -O flag disables it */
+int seed = 1; /* -S flag */
+
+int mapped_writes = 0; /* yaffs direct does not support mmapped files */
+int mapped_reads = 0;
+
+int fsxgoodfd = 0;
+FILE * fsxlogf = NULL;
+int badoff = -1;
+int closeopen = 0;
+
+
+void
+vwarnc(code, fmt, ap)
+ int code;
+ const char *fmt;
+ va_list ap;
+{
+ fprintf(stderr, "fsx: ");
+ if (fmt != NULL) {
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, ": ");
+ }
+ fprintf(stderr, "%s\n", strerror(code));
+}
+
+
+void
+warn(const char * fmt, ...)
+{
+ va_list ap;
+ va_start(ap, fmt);
+ vwarnc(errno, fmt, ap);
+ va_end(ap);
+}
+
+
+void
+prt(char *fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ vfprintf(stdout, fmt, args);
+ if (fsxlogf)
+ vfprintf(fsxlogf, fmt, args);
+ va_end(args);
+}
+
+void
+prterr(char *prefix)
+{
+ prt("%s%s%s\n", prefix, prefix ? ": " : "", strerror(errno));
+}
+
+
+void
+log4(int operation, int arg0, int arg1, int arg2)
+{
+ struct log_entry *le;
+
+ le = &oplog[logptr];
+ le->operation = operation;
+ if (closeopen)
+ le->operation = ~ le->operation;
+ le->args[0] = arg0;
+ le->args[1] = arg1;
+ le->args[2] = arg2;
+ logptr++;
+ logcount++;
+ if (logptr >= LOGSIZE)
+ logptr = 0;
+}
+
+
+void
+logdump(void)
+{
+ int i, count, down;
+ struct log_entry *lp;
+
+ prt("LOG DUMP (%d total operations):\n", logcount);
+ if (logcount < LOGSIZE) {
+ i = 0;
+ count = logcount;
+ } else {
+ i = logptr;
+ count = LOGSIZE;
+ }
+ for ( ; count > 0; count--) {
+ int opnum;
+
+ opnum = i+1 + (logcount/LOGSIZE)*LOGSIZE;
+ prt("%d(%d mod 256): ", opnum, opnum%256);
+ lp = &oplog[i];
+ if ((closeopen = lp->operation < 0))
+ lp->operation = ~ lp->operation;
+
+ switch (lp->operation) {
+ case OP_MAPREAD:
+ prt("MAPREAD\t0x%x thru 0x%x\t(0x%x bytes)",
+ lp->args[0], lp->args[0] + lp->args[1] - 1,
+ lp->args[1]);
+ if (badoff >= lp->args[0] && badoff <
+ lp->args[0] + lp->args[1])
+ prt("\t***RRRR***");
+ break;
+ case OP_MAPWRITE:
+ prt("MAPWRITE 0x%x thru 0x%x\t(0x%x bytes)",
+ lp->args[0], lp->args[0] + lp->args[1] - 1,
+ lp->args[1]);
+ if (badoff >= lp->args[0] && badoff <
+ lp->args[0] + lp->args[1])
+ prt("\t******WWWW");
+ break;
+ case OP_READ:
+ prt("READ\t0x%x thru 0x%x\t(0x%x bytes)",
+ lp->args[0], lp->args[0] + lp->args[1] - 1,
+ lp->args[1]);
+ if (badoff >= lp->args[0] &&
+ badoff < lp->args[0] + lp->args[1])
+ prt("\t***RRRR***");
+ break;
+ case OP_WRITE:
+ prt("WRITE\t0x%x thru 0x%x\t(0x%x bytes)",
+ lp->args[0], lp->args[0] + lp->args[1] - 1,
+ lp->args[1]);
+ if (lp->args[0] > lp->args[2])
+ prt(" HOLE");
+ else if (lp->args[0] + lp->args[1] > lp->args[2])
+ prt(" EXTEND");
+ if ((badoff >= lp->args[0] || badoff >=lp->args[2]) &&
+ badoff < lp->args[0] + lp->args[1])
+ prt("\t***WWWW");
+ break;
+ case OP_TRUNCATE:
+ down = lp->args[0] < lp->args[1];
+ prt("TRUNCATE %s\tfrom 0x%x to 0x%x",
+ down ? "DOWN" : "UP", lp->args[1], lp->args[0]);
+ if (badoff >= lp->args[!down] &&
+ badoff < lp->args[!!down])
+ prt("\t******WWWW");
+ break;
+ case OP_SKIPPED:
+ prt("SKIPPED (no operation)");
+ break;
+ default:
+ prt("BOGUS LOG ENTRY (operation code = %d)!",
+ lp->operation);
+ }
+ if (closeopen)
+ prt("\n\t\tCLOSE/OPEN");
+ prt("\n");
+ i++;
+ if (i == LOGSIZE)
+ i = 0;
+ }
+}
+
+
+void
+save_buffer(char *buffer, off_t bufferlength, int fd)
+{
+ off_t ret;
+ ssize_t byteswritten;
+
+ if (fd <= 0 || bufferlength == 0)
+ return;
+
+ if (bufferlength > SSIZE_MAX) {
+ prt("fsx flaw: overflow in save_buffer\n");
+ exit(67);
+ }
+ if (lite) {
+ off_t size_by_seek = yaffs_lseek(fd, (off_t)0, SEEK_END);
+ if (size_by_seek == (off_t)-1)
+ prterr("save_buffer: lseek eof");
+ else if (bufferlength > size_by_seek) {
+ warn("save_buffer: .fsxgood file too short... will save 0x%llx bytes instead of 0x%llx\n", (unsigned long long)size_by_seek,
+ (unsigned long long)bufferlength);
+ bufferlength = size_by_seek;
+ }
+ }
+
+ ret = yaffs_lseek(fd, (off_t)0, SEEK_SET);
+ if (ret == (off_t)-1)
+ prterr("save_buffer: lseek 0");
+
+ byteswritten = yaffs_write(fd, buffer, (size_t)bufferlength);
+ if (byteswritten != bufferlength) {
+ if (byteswritten == -1)
+ prterr("save_buffer write");
+ else
+ warn("save_buffer: short write, 0x%x bytes instead of 0x%llx\n",
+ (unsigned)byteswritten,
+ (unsigned long long)bufferlength);
+ }
+}
+
+
+void
+report_failure(int status)
+{
+ logdump();
+
+ if (fsxgoodfd) {
+ if (good_buf) {
+ save_buffer(good_buf, file_size, fsxgoodfd);
+ prt("Correct content saved for comparison\n");
+ prt("(maybe hexdump \"%s\" vs \"%s.fsxgood\")\n",
+ fname, fname);
+ }
+ close(fsxgoodfd);
+ }
+ prt("Exiting with %d\n",status);
+ exit(status);
+}
+
+
+#define short_at(cp) ((unsigned short)((*((unsigned char *)(cp)) << 8) | \
+ *(((unsigned char *)(cp)) + 1)))
+
+void
+check_buffers(unsigned offset, unsigned size)
+{
+ unsigned char c, t;
+ unsigned i = 0;
+ unsigned n = 0;
+ unsigned op = 0;
+ unsigned bad = 0;
+
+ if (memcmp(good_buf + offset, temp_buf, size) != 0) {
+ prt("READ BAD DATA: offset = 0x%x, size = 0x%x\n",
+ offset, size);
+ prt("OFFSET\tGOOD\tBAD\tRANGE\n");
+ while (size > 0) {
+ c = good_buf[offset];
+ t = temp_buf[i];
+ if (c != t) {
+ if (n == 0) {
+ bad = short_at(&temp_buf[i]);
+ prt("0x%5x\t0x%04x\t0x%04x", offset,
+ short_at(&good_buf[offset]), bad);
+ op = temp_buf[offset & 1 ? i+1 : i];
+ }
+ n++;
+ badoff = offset;
+ }
+ offset++;
+ i++;
+ size--;
+ }
+ if (n) {
+ prt("\t0x%5x\n", n);
+ if (bad)
+ prt("operation# (mod 256) for the bad data may be %u\n", ((unsigned)op & 0xff));
+ else
+ prt("operation# (mod 256) for the bad data unknown, check HOLE and EXTEND ops\n");
+ } else
+ prt("????????????????\n");
+ report_failure(110);
+ }
+}
+
+
+void
+check_size(void)
+{
+ struct yaffs_stat statbuf;
+ off_t size_by_seek;
+
+ if (yaffs_fstat(fd, &statbuf)) {
+ prterr("check_size: fstat");
+ statbuf.st_size = -1;
+ }
+ size_by_seek = yaffs_lseek(fd, (off_t)0, SEEK_END);
+ if (file_size != statbuf.st_size || file_size != size_by_seek) {
+ prt("Size error: expected 0x%llx stat 0x%llx seek 0x%llx\n",
+ (unsigned long long)file_size,
+ (unsigned long long)statbuf.st_size,
+ (unsigned long long)size_by_seek);
+ report_failure(120);
+ }
+}
+
+
+void
+check_trunc_hack(void)
+{
+ struct yaffs_stat statbuf;
+
+ yaffs_truncate(fd, (off_t)0);
+ yaffs_truncate(fd, (off_t)100000);
+ yaffs_fstat(fd, &statbuf);
+ if (statbuf.st_size != (off_t)100000) {
+ prt("no extend on truncate! not posix!\n");
+ exit(130);
+ }
+ yaffs_truncate(fd, (off_t)0);
+}
+
+
+void
+doread(unsigned offset, unsigned size)
+{
+ off_t ret;
+ unsigned iret;
+
+ offset -= offset % readbdy;
+ if (size == 0) {
+ if (!quiet && testcalls > simulatedopcount)
+ prt("skipping zero size read\n");
+ log4(OP_SKIPPED, OP_READ, offset, size);
+ return;
+ }
+ if (size + offset > file_size) {
+ if (!quiet && testcalls > simulatedopcount)
+ prt("skipping seek/read past end of file\n");
+ log4(OP_SKIPPED, OP_READ, offset, size);
+ return;
+ }
+
+ log4(OP_READ, offset, size, 0);
+
+ if (testcalls <= simulatedopcount)
+ return;
+
+ if (!quiet && ((progressinterval &&
+ testcalls % progressinterval == 0) ||
+ (debug &&
+ (monitorstart == -1 ||
+ (offset + size > monitorstart &&
+ (monitorend == -1 || offset <= monitorend))))))
+ prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
+ offset, offset + size - 1, size);
+ ret = yaffs_lseek(fd, (off_t)offset, SEEK_SET);
+ if (ret == (off_t)-1) {
+ prterr("doread: lseek");
+ report_failure(140);
+ }
+ iret = yaffs_read(fd, temp_buf, size);
+ if (iret != size) {
+ if (iret == -1)
+ prterr("doread: read");
+ else
+ prt("short read: 0x%x bytes instead of 0x%x\n",
+ iret, size);
+ report_failure(141);
+ }
+ check_buffers(offset, size);
+}
+
+
+
+
+
+void
+gendata(char *original_buf, char *good_buf, unsigned offset, unsigned size)
+{
+ while (size--) {
+ good_buf[offset] = testcalls % 256;
+ if (offset % 2)
+ good_buf[offset] += original_buf[offset];
+ offset++;
+ }
+}
+
+
+void
+dowrite(unsigned offset, unsigned size)
+{
+ off_t ret;
+ unsigned iret;
+
+ offset -= offset % writebdy;
+ if (size == 0) {
+ if (!quiet && testcalls > simulatedopcount)
+ prt("skipping zero size write\n");
+ log4(OP_SKIPPED, OP_WRITE, offset, size);
+ return;
+ }
+
+ log4(OP_WRITE, offset, size, file_size);
+
+ gendata(original_buf, good_buf, offset, size);
+ if (file_size < offset + size) {
+ if (file_size < offset)
+ memset(good_buf + file_size, '\0', offset - file_size);
+ file_size = offset + size;
+ if (lite) {
+ warn("Lite file size bug in fsx!");
+ report_failure(149);
+ }
+ }
+
+ if (testcalls <= simulatedopcount)
+ return;
+
+ if (!quiet && ((progressinterval &&
+ testcalls % progressinterval == 0) ||
+ (debug &&
+ (monitorstart == -1 ||
+ (offset + size > monitorstart &&
+ (monitorend == -1 || offset <= monitorend))))))
+ prt("%lu write\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
+ offset, offset + size - 1, size);
+ ret = yaffs_lseek(fd, (off_t)offset, SEEK_SET);
+ if (ret == (off_t)-1) {
+ prterr("dowrite: lseek");
+ report_failure(150);
+ }
+ iret = yaffs_write(fd, good_buf + offset, size);
+ if (iret != size) {
+ if (iret == -1)
+ prterr("dowrite: write");
+ else
+ prt("short write: 0x%x bytes instead of 0x%x\n",
+ iret, size);
+ report_failure(151);
+ }
+}
+
+
+
+void
+dotruncate(unsigned size)
+{
+ int oldsize = file_size;
+
+ size -= size % truncbdy;
+ if (size > biggest) {
+ biggest = size;
+ if (!quiet && testcalls > simulatedopcount)
+ prt("truncating to largest ever: 0x%x\n", size);
+ }
+
+ log4(OP_TRUNCATE, size, (unsigned)file_size, 0);
+
+ if (size > file_size)
+ memset(good_buf + file_size, '\0', size - file_size);
+ file_size = size;
+
+ if (testcalls <= simulatedopcount)
+ return;
+
+ if ((progressinterval && testcalls % progressinterval == 0) ||
+ (debug && (monitorstart == -1 || monitorend == -1 ||
+ size <= monitorend)))
+ prt("%lu trunc\tfrom 0x%x to 0x%x\n", testcalls, oldsize, size);
+ if (yaffs_truncate(fd, (off_t)size) == -1) {
+ prt("ftruncate1: %x\n", size);
+ prterr("dotruncate: ftruncate");
+ report_failure(160);
+ }
+}
+
+
+void
+writefileimage()
+{
+ ssize_t iret;
+
+ if (yaffs_lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) {
+ prterr("writefileimage: lseek");
+ report_failure(171);
+ }
+ iret = yaffs_write(fd, good_buf, file_size);
+ if ((off_t)iret != file_size) {
+ if (iret == -1)
+ prterr("writefileimage: write");
+ else
+ prt("short write: 0x%x bytes instead of 0x%llx\n",
+ iret, (unsigned long long)file_size);
+ report_failure(172);
+ }
+ if (lite ? 0 : yaffs_truncate(fd, file_size) == -1) {
+ prt("ftruncate2: %llx\n", (unsigned long long)file_size);
+ prterr("writefileimage: ftruncate");
+ report_failure(173);
+ }
+}
+
+
+void
+docloseopen(void)
+{
+ if (testcalls <= simulatedopcount)
+ return;
+
+ if (debug)
+ prt("%lu close/open\n", testcalls);
+ if (yaffs_close(fd)) {
+ prterr("docloseopen: close");
+ report_failure(180);
+ }
+ fd = yaffs_open(fname, O_RDWR, 0);
+ if (fd < 0) {
+ prterr("docloseopen: open");
+ report_failure(181);
+ }
+}
+
+
+void
+test(void)
+{
+ unsigned long offset;
+ unsigned long size = maxoplen;
+ unsigned long rv = random();
+ unsigned long op = rv % (3 + !lite + mapped_writes);
+
+ /* turn off the map read if necessary */
+
+ if (op == 2 && !mapped_reads)
+ op = 0;
+
+ if (simulatedopcount > 0 && testcalls == simulatedopcount)
+ writefileimage();
+
+ testcalls++;
+
+ if (closeprob)
+ closeopen = (rv >> 3) < (1 << 28) / closeprob;
+
+ if (debugstart > 0 && testcalls >= debugstart)
+ debug = 1;
+
+ if (!quiet && testcalls < simulatedopcount && testcalls % 100000 == 0)
+ prt("%lu...\n", testcalls);
+
+ /*
+ * READ: op = 0
+ * WRITE: op = 1
+ * MAPREAD: op = 2
+ * TRUNCATE: op = 3
+ * MAPWRITE: op = 3 or 4
+ */
+ if (lite ? 0 : op == 3 && (style & 1) == 0) /* vanilla truncate? */
+ dotruncate(random() % maxfilelen);
+ else {
+ if (randomoplen)
+ size = random() % (maxoplen+1);
+ if (lite ? 0 : op == 3)
+ dotruncate(size);
+ else {
+ offset = random();
+ if (op == 1 || op == (lite ? 3 : 4)) {
+ offset %= maxfilelen;
+ if (offset + size > maxfilelen)
+ size = maxfilelen - offset;
+ dowrite(offset, size);
+ } else {
+ if (file_size)
+ offset %= file_size;
+ else
+ offset = 0;
+ if (offset + size > file_size)
+ size = file_size - offset;
+ doread(offset, size);
+ }
+ }
+ }
+ if (sizechecks && testcalls > simulatedopcount)
+ check_size();
+ if (closeopen)
+ docloseopen();
+}
+
+
+void
+cleanup(sig)
+ int sig;
+{
+ if (sig)
+ prt("signal %d\n", sig);
+ prt("testcalls = %lu\n", testcalls);
+ exit(sig);
+}
+
+
+void
+usage(void)
+{
+ fprintf(stdout, "usage: %s",
+ "fsx [-dnqLOW] [-b opnum] [-c Prob] [-l flen] [-m start:end] [-o oplen] [-p progressinterval] [-r readbdy] [-s style] [-t truncbdy] [-w writebdy] [-D startingop] [-N numops] [-P dirpath] [-S seed] fname\n\
+ -b opnum: beginning operation number (default 1)\n\
+ -c P: 1 in P chance of file close+open at each op (default infinity)\n\
+ -d: debug output for all operations\n\
+ -l flen: the upper bound on file size (default 262144)\n\
+ -m startop:endop: monitor (print debug output) specified byte range (default 0:infinity)\n\
+ -n: no verifications of file size\n\
+ -o oplen: the upper bound on operation size (default 65536)\n\
+ -p progressinterval: debug output at specified operation interval\n\
+ -q: quieter operation\n\
+ -r readbdy: 4096 would make reads page aligned (default 1)\n\
+ -s style: 1 gives smaller truncates (default 0)\n\
+ -t truncbdy: 4096 would make truncates page aligned (default 1)\n\
+ -w writebdy: 4096 would make writes page aligned (default 1)\n\
+ -D startingop: debug output starting at specified operation\n\
+ -L: fsxLite - no file creations & no file size changes\n\
+ -N numops: total # operations to do (default infinity)\n\
+ -O: use oplen (see -o flag) for every op (default random)\n\
+ -P dirpath: save .fsxlog and .fsxgood files in dirpath (default ./)\n\
+ -S seed: for random # generator (default 1) 0 gets timestamp\n\
+ fname: this filename is REQUIRED (no default)\n");
+ exit(90);
+}
+
+
+int
+getnum(char *s, char **e)
+{
+ int ret = -1;
+
+ *e = (char *) 0;
+ ret = strtol(s, e, 0);
+ if (*e)
+ switch (**e) {
+ case 'b':
+ case 'B':
+ ret *= 512;
+ *e = *e + 1;
+ break;
+ case 'k':
+ case 'K':
+ ret *= 1024;
+ *e = *e + 1;
+ break;
+ case 'm':
+ case 'M':
+ ret *= 1024*1024;
+ *e = *e + 1;
+ break;
+ case 'w':
+ case 'W':
+ ret *= 4;
+ *e = *e + 1;
+ break;
+ }
+ return (ret);
+}
+
+
+int
+main(int argc, char **argv)
+{
+ int i, style, ch;
+ char *endp;
+ char goodfile[1024];
+ char logfile[1024];
+
+ goodfile[0] = 0;
+ logfile[0] = 0;
+
+ page_size = getpagesize();
+ page_mask = page_size - 1;
+
+ setvbuf(stdout, (char *)0, _IOLBF, 0); /* line buffered stdout */
+
+ while ((ch = getopt(argc, argv, "b:c:dl:m:no:p:qr:s:t:w:D:LN:OP:RS:W"))
+ != EOF)
+ switch (ch) {
+ case 'b':
+ simulatedopcount = getnum(optarg, &endp);
+ if (!quiet)
+ fprintf(stdout, "Will begin at operation %ld\n",
+ simulatedopcount);
+ if (simulatedopcount == 0)
+ usage();
+ simulatedopcount -= 1;
+ break;
+ case 'c':
+ closeprob = getnum(optarg, &endp);
+ if (!quiet)
+ fprintf(stdout,
+ "Chance of close/open is 1 in %d\n",
+ closeprob);
+ if (closeprob <= 0)
+ usage();
+ break;
+ case 'd':
+ debug = 1;
+ break;
+ case 'l':
+ maxfilelen = getnum(optarg, &endp);
+ if (maxfilelen <= 0)
+ usage();
+ break;
+ case 'm':
+ monitorstart = getnum(optarg, &endp);
+ if (monitorstart < 0)
+ usage();
+ if (!endp || *endp++ != ':')
+ usage();
+ monitorend = getnum(endp, &endp);
+ if (monitorend < 0)
+ usage();
+ if (monitorend == 0)
+ monitorend = -1; /* aka infinity */
+ debug = 1;
+ case 'n':
+ sizechecks = 0;
+ break;
+ case 'o':
+ maxoplen = getnum(optarg, &endp);
+ if (maxoplen <= 0)
+ usage();
+ break;
+ case 'p':
+ progressinterval = getnum(optarg, &endp);
+ if (progressinterval < 0)
+ usage();
+ break;
+ case 'q':
+ quiet = 1;
+ break;
+ case 'r':
+ readbdy = getnum(optarg, &endp);
+ if (readbdy <= 0)
+ usage();
+ break;
+ case 's':
+ style = getnum(optarg, &endp);
+ if (style < 0 || style > 1)
+ usage();
+ break;
+ case 't':
+ truncbdy = getnum(optarg, &endp);
+ if (truncbdy <= 0)
+ usage();
+ break;
+ case 'w':
+ writebdy = getnum(optarg, &endp);
+ if (writebdy <= 0)
+ usage();
+ break;
+ case 'D':
+ debugstart = getnum(optarg, &endp);
+ if (debugstart < 1)
+ usage();
+ break;
+ case 'L':
+ lite = 1;
+ break;
+ case 'N':
+ numops = getnum(optarg, &endp);
+ if (numops < 0)
+ usage();
+ break;
+ case 'O':
+ randomoplen = 0;
+ break;
+ case 'P':
+ strncpy(goodfile, optarg, sizeof(goodfile));
+ strcat(goodfile, "/");
+ strncpy(logfile, optarg, sizeof(logfile));
+ strcat(logfile, "/");
+ break;
+ case 'R':
+ mapped_reads = 0;
+ break;
+ case 'S':
+ seed = getnum(optarg, &endp);
+ if (seed == 0)
+ seed = time(0) % 10000;
+ if (!quiet)
+ fprintf(stdout, "Seed set to %d\n", seed);
+ if (seed < 0)
+ usage();
+ break;
+ case 'W':
+ mapped_writes = 0;
+ if (!quiet)
+ fprintf(stdout, "mapped writes DISABLED\n");
+ break;
+
+ default:
+ usage();
+ /* NOTREACHED */
+ }
+ argc -= optind;
+ argv += optind;
+
+ yaffs_StartUp();
+ yaffs_mount("/flash/flash");
+
+ fname = "/flash/flash/fsxdata";
+
+ signal(SIGHUP, cleanup);
+ signal(SIGINT, cleanup);
+ signal(SIGPIPE, cleanup);
+ signal(SIGALRM, cleanup);
+ signal(SIGTERM, cleanup);
+ signal(SIGXCPU, cleanup);
+ signal(SIGXFSZ, cleanup);
+ signal(SIGVTALRM, cleanup);
+ signal(SIGUSR1, cleanup);
+ signal(SIGUSR2, cleanup);
+
+ initstate(seed, state, 256);
+ setstate(state);
+ fd = yaffs_open(fname, O_RDWR|(lite ? 0 : O_CREAT|O_TRUNC), 0666);
+ if (fd < 0) {
+ prterr(fname);
+ exit(91);
+ }
+ strncat(goodfile, fname, 256);
+ strcat (goodfile, ".fsxgood");
+ fsxgoodfd = yaffs_open(goodfile, O_RDWR|O_CREAT|O_TRUNC, 0666);
+ if (fsxgoodfd < 0) {
+ prterr(goodfile);
+ exit(92);
+ }
+ strncat(logfile, "fsx", 256);
+ strcat (logfile, ".fsxlog");
+ fsxlogf = fopen(logfile, "w");
+ if (fsxlogf == NULL) {
+ prterr(logfile);
+ exit(93);
+ }
+ if (lite) {
+ off_t ret;
+ file_size = maxfilelen = yaffs_lseek(fd, (off_t)0, SEEK_END);
+ if (file_size == (off_t)-1) {
+ prterr(fname);
+ warn("main: lseek eof");
+ exit(94);
+ }
+ ret = yaffs_lseek(fd, (off_t)0, SEEK_SET);
+ if (ret == (off_t)-1) {
+ prterr(fname);
+ warn("main: lseek 0");
+ exit(95);
+ }
+ }
+ original_buf = (char *) malloc(maxfilelen);
+ for (i = 0; i < maxfilelen; i++)
+ original_buf[i] = random() % 256;
+ good_buf = (char *) malloc(maxfilelen);
+ memset(good_buf, '\0', maxfilelen);
+ temp_buf = (char *) malloc(maxoplen);
+ memset(temp_buf, '\0', maxoplen);
+ if (lite) { /* zero entire existing file */
+ ssize_t written;
+
+ written = yaffs_write(fd, good_buf, (size_t)maxfilelen);
+ if (written != maxfilelen) {
+ if (written == -1) {
+ prterr(fname);
+ warn("main: error on write");
+ } else
+ warn("main: short write, 0x%x bytes instead of 0x%x\n",
+ (unsigned)written, maxfilelen);
+ exit(98);
+ }
+ } else
+ check_trunc_hack();
+
+ while (numops == -1 || numops--)
+ test();
+
+ if (yaffs_close(fd)) {
+ prterr("close");
+ report_failure(99);
+ }
+
+ yaffs_close(fsxgoodfd);
+
+ yaffs_unmount("flash/flash");
+ prt("All operations completed A-OK!\n");
+
+ exit(0);
+ return 0;
+}
+
diff --git a/fs/yaffs2/direct/yaffs_fileem.c b/fs/yaffs2/direct/yaffs_fileem.c
new file mode 100644
index 0000000000..e3cc30eb8a
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_fileem.c
@@ -0,0 +1,218 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * This provides a YAFFS nand emulation on a file.
+ * This is only intended as test code to test persistence etc.
+ */
+
+const char *yaffs_flashif_c_version = "$Id: yaffs_fileem.c,v 1.3 2007/02/14 01:09:06 wookey Exp $";
+
+
+#include "yportenv.h"
+
+#include "yaffs_flashif.h"
+#include "yaffs_guts.h"
+
+#include "devextras.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+
+#define SIZE_IN_MB 16
+
+#define BLOCK_SIZE (32 * 528)
+#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
+
+
+
+typedef struct
+{
+ __u8 data[528]; // Data + spare
+} yflash_Page;
+
+typedef struct
+{
+ yflash_Page page[32]; // The pages in the block
+
+} yflash_Block;
+
+
+
+typedef struct
+{
+ int handle;
+ int nBlocks;
+} yflash_Device;
+
+static yflash_Device filedisk;
+
+static int CheckInit(yaffs_Device *dev)
+{
+ static int initialised = 0;
+
+ int i;
+
+
+ int fSize;
+ int written;
+
+ yflash_Page p;
+
+ if(initialised)
+ {
+ return YAFFS_OK;
+ }
+
+ initialised = 1;
+
+
+ filedisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
+
+ filedisk.handle = open("yaffsemfile", O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
+
+ if(filedisk.handle < 0)
+ {
+ perror("Failed to open yaffs emulation file");
+ return YAFFS_FAIL;
+ }
+
+
+ fSize = lseek(filedisk.handle,0,SEEK_END);
+
+ if(fSize < SIZE_IN_MB * 1024 * 1024)
+ {
+ printf("Creating yaffs emulation file\n");
+
+ lseek(filedisk.handle,0,SEEK_SET);
+
+ memset(&p,0xff,sizeof(yflash_Page));
+
+ for(i = 0; i < SIZE_IN_MB * 1024 * 1024; i+= 512)
+ {
+ written = write(filedisk.handle,&p,sizeof(yflash_Page));
+
+ if(written != sizeof(yflash_Page))
+ {
+ printf("Write failed\n");
+ return YAFFS_FAIL;
+ }
+ }
+ }
+
+ return 1;
+}
+
+int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare)
+{
+ int written;
+
+ CheckInit(dev);
+
+
+
+ if(data)
+ {
+ lseek(filedisk.handle,chunkInNAND * 528,SEEK_SET);
+ written = write(filedisk.handle,data,512);
+
+ if(written != 512) return YAFFS_FAIL;
+ }
+
+ if(spare)
+ {
+ lseek(filedisk.handle,chunkInNAND * 528 + 512,SEEK_SET);
+ written = write(filedisk.handle,spare,16);
+
+ if(written != 16) return YAFFS_FAIL;
+ }
+
+
+ return YAFFS_OK;
+
+}
+
+
+int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)
+{
+ int nread;
+
+ CheckInit(dev);
+
+
+
+ if(data)
+ {
+ lseek(filedisk.handle,chunkInNAND * 528,SEEK_SET);
+ nread = read(filedisk.handle,data,512);
+
+ if(nread != 512) return YAFFS_FAIL;
+ }
+
+ if(spare)
+ {
+ lseek(filedisk.handle,chunkInNAND * 528 + 512,SEEK_SET);
+ nread= read(filedisk.handle,spare,16);
+
+ if(nread != 16) return YAFFS_FAIL;
+ }
+
+
+ return YAFFS_OK;
+
+}
+
+
+int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+
+ int i;
+
+ CheckInit(dev);
+
+ if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
+ {
+ T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+ return YAFFS_FAIL;
+ }
+ else
+ {
+
+ yflash_Page pg;
+
+ memset(&pg,0xff,sizeof(yflash_Page));
+
+ lseek(filedisk.handle, blockNumber * 32 * 528, SEEK_SET);
+
+ for(i = 0; i < 32; i++)
+ {
+ write(filedisk.handle,&pg,528);
+ }
+ return YAFFS_OK;
+ }
+
+}
+
+int yflash_InitialiseNAND(yaffs_Device *dev)
+{
+ dev->useNANDECC = 1; // force on useNANDECC which gets faked.
+ // This saves us doing ECC checks.
+
+ return YAFFS_OK;
+}
+
+
diff --git a/fs/yaffs2/direct/yaffs_fileem2k.c b/fs/yaffs2/direct/yaffs_fileem2k.c
new file mode 100644
index 0000000000..7a3b299996
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_fileem2k.c
@@ -0,0 +1,441 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * This provides a YAFFS nand emulation on a file for emulating 2kB pages.
+ * This is only intended as test code to test persistence etc.
+ */
+
+const char *yaffs_flashif_c_version = "$Id: yaffs_fileem2k.c,v 1.12 2007/02/14 01:09:06 wookey Exp $";
+
+
+#include "yportenv.h"
+
+#include "yaffs_flashif.h"
+#include "yaffs_guts.h"
+#include "devextras.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "yaffs_fileem2k.h"
+#include "yaffs_packedtags2.h"
+
+//#define SIMULATE_FAILURES
+
+typedef struct
+{
+ __u8 data[PAGE_SIZE]; // Data + spare
+} yflash_Page;
+
+typedef struct
+{
+ yflash_Page page[PAGES_PER_BLOCK]; // The pages in the block
+
+} yflash_Block;
+
+
+
+#define MAX_HANDLES 20
+#define BLOCKS_PER_HANDLE 8000
+
+typedef struct
+{
+ int handle[MAX_HANDLES];
+ int nBlocks;
+} yflash_Device;
+
+static yflash_Device filedisk;
+
+int yaffs_testPartialWrite = 0;
+
+
+
+
+static __u8 localBuffer[PAGE_SIZE];
+
+static char *NToName(char *buf,int n)
+{
+ sprintf(buf,"emfile%d",n);
+ return buf;
+}
+
+static char dummyBuffer[BLOCK_SIZE];
+
+static int GetBlockFileHandle(int n)
+{
+ int h;
+ int requiredSize;
+
+ char name[40];
+ NToName(name,n);
+ int fSize;
+ int i;
+
+ h = open(name, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
+ if(h >= 0){
+ fSize = lseek(h,0,SEEK_END);
+ requiredSize = BLOCKS_PER_HANDLE * BLOCK_SIZE;
+ if(fSize < requiredSize){
+ for(i = 0; i < BLOCKS_PER_HANDLE; i++)
+ if(write(h,dummyBuffer,BLOCK_SIZE) != BLOCK_SIZE)
+ return -1;
+
+ }
+ }
+
+ return h;
+
+}
+
+static int CheckInit(void)
+{
+ static int initialised = 0;
+ int h;
+ int i;
+
+
+ off_t fSize;
+ off_t requiredSize;
+ int written;
+ int blk;
+
+ yflash_Page p;
+
+ if(initialised)
+ {
+ return YAFFS_OK;
+ }
+
+ initialised = 1;
+
+ memset(dummyBuffer,0xff,sizeof(dummyBuffer));
+
+
+ filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
+
+ for(i = 0; i < MAX_HANDLES; i++)
+ filedisk.handle[i] = -1;
+
+ for(i = 0,blk = 0; blk < filedisk.nBlocks; blk+=BLOCKS_PER_HANDLE,i++)
+ filedisk.handle[i] = GetBlockFileHandle(i);
+
+
+ return 1;
+}
+
+
+int yflash_GetNumberOfBlocks(void)
+{
+ CheckInit();
+
+ return filedisk.nBlocks;
+}
+
+int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int written;
+ int pos;
+ int h;
+ int i;
+ int nRead;
+ int error;
+
+ T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
+
+ CheckInit();
+
+
+
+ if(data)
+ {
+ pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+ h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+
+ lseek(h,pos,SEEK_SET);
+ nRead = read(h, localBuffer,dev->nDataBytesPerChunk);
+ for(i = error = 0; i < dev->nDataBytesPerChunk && !error; i++){
+ if(localBuffer[i] != 0xFF){
+ printf("nand simulation: chunk %d data byte %d was %0x2\n",
+ chunkInNAND,i,localBuffer[i]);
+ error = 1;
+ }
+ }
+
+ for(i = 0; i < dev->nDataBytesPerChunk; i++)
+ localBuffer[i] &= data[i];
+
+ if(memcmp(localBuffer,data,dev->nDataBytesPerChunk))
+ printf("nand simulator: data does not match\n");
+
+ lseek(h,pos,SEEK_SET);
+ written = write(h,localBuffer,dev->nDataBytesPerChunk);
+
+ if(yaffs_testPartialWrite){
+ close(h);
+ exit(1);
+ }
+
+#ifdef SIMULATE_FAILURES
+ if((chunkInNAND >> 6) == 100)
+ written = 0;
+
+ if((chunkInNAND >> 6) == 110)
+ written = 0;
+#endif
+
+
+ if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL;
+ }
+
+ if(tags)
+ {
+ pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
+ h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+
+ lseek(h,pos,SEEK_SET);
+
+ if( 0 && dev->isYaffs2)
+ {
+
+ written = write(h,tags,sizeof(yaffs_ExtendedTags));
+ if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
+ }
+ else
+ {
+ yaffs_PackedTags2 pt;
+ yaffs_PackTags2(&pt,tags);
+ __u8 * ptab = (__u8 *)&pt;
+
+ nRead = read(h,localBuffer,sizeof(pt));
+ for(i = error = 0; i < sizeof(pt) && !error; i++){
+ if(localBuffer[i] != 0xFF){
+ printf("nand simulation: chunk %d oob byte %d was %0x2\n",
+ chunkInNAND,i,localBuffer[i]);
+ error = 1;
+ }
+ }
+
+ for(i = 0; i < sizeof(pt); i++)
+ localBuffer[i] &= ptab[i];
+
+ if(memcmp(localBuffer,&pt,sizeof(pt)))
+ printf("nand sim: tags corruption\n");
+
+ lseek(h,pos,SEEK_SET);
+
+ written = write(h,localBuffer,sizeof(pt));
+ if(written != sizeof(pt)) return YAFFS_FAIL;
+ }
+ }
+
+
+ return YAFFS_OK;
+
+}
+
+int yaffs_CheckAllFF(const __u8 *ptr, int n)
+{
+ while(n)
+ {
+ n--;
+ if(*ptr!=0xFF) return 0;
+ ptr++;
+ }
+ return 1;
+}
+
+
+static int fail300 = 1;
+static int fail320 = 1;
+
+static int failRead10 = 2;
+
+int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int nread;
+ int pos;
+ int h;
+
+ T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
+
+ CheckInit();
+
+
+
+ if(data)
+ {
+
+ pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+ h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+ lseek(h,pos,SEEK_SET);
+ nread = read(h,data,dev->nDataBytesPerChunk);
+
+
+ if(nread != dev->nDataBytesPerChunk) return YAFFS_FAIL;
+ }
+
+ if(tags)
+ {
+ pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
+ h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+ lseek(h,pos,SEEK_SET);
+
+ if(0 && dev->isYaffs2)
+ {
+ nread= read(h,tags,sizeof(yaffs_ExtendedTags));
+ if(nread != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
+ if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
+ {
+ yaffs_InitialiseTags(tags);
+ }
+ else
+ {
+ tags->chunkUsed = 1;
+ }
+ }
+ else
+ {
+ yaffs_PackedTags2 pt;
+ nread= read(h,&pt,sizeof(pt));
+ yaffs_UnpackTags2(tags,&pt);
+#ifdef SIMULATE_FAILURES
+ if((chunkInNAND >> 6) == 100) {
+ if(fail300 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
+ tags->eccResult = YAFFS_ECC_RESULT_FIXED;
+ fail300 = 0;
+ }
+
+ }
+ if((chunkInNAND >> 6) == 110) {
+ if(fail320 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
+ tags->eccResult = YAFFS_ECC_RESULT_FIXED;
+ fail320 = 0;
+ }
+ }
+#endif
+ if(failRead10>0 && chunkInNAND == 10){
+ failRead10--;
+ nread = 0;
+ }
+
+ if(nread != sizeof(pt)) return YAFFS_FAIL;
+ }
+ }
+
+
+ return YAFFS_OK;
+
+}
+
+
+int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+ int written;
+ int h;
+
+ yaffs_PackedTags2 pt;
+
+ CheckInit();
+
+ memset(&pt,0,sizeof(pt));
+ h = filedisk.handle[(blockNo / ( BLOCKS_PER_HANDLE))];
+ lseek(h,((blockNo % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
+ written = write(h,&pt,sizeof(pt));
+
+ if(written != sizeof(pt)) return YAFFS_FAIL;
+
+
+ return YAFFS_OK;
+
+}
+
+int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+
+ int i;
+ int h;
+
+ CheckInit();
+
+ printf("erase block %d\n",blockNumber);
+
+ if(blockNumber == 320)
+ fail320 = 1;
+
+ if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
+ {
+ T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+ return YAFFS_FAIL;
+ }
+ else
+ {
+
+ __u8 pg[PAGE_SIZE];
+ int syz = PAGE_SIZE;
+ int pos;
+
+ memset(pg,0xff,syz);
+
+
+ h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))];
+ lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE,SEEK_SET);
+ for(i = 0; i < dev->nChunksPerBlock; i++)
+ {
+ write(h,pg,PAGE_SIZE);
+ }
+ pos = lseek(h, 0,SEEK_CUR);
+
+ return YAFFS_OK;
+ }
+
+}
+
+int yflash_InitialiseNAND(yaffs_Device *dev)
+{
+ CheckInit();
+
+ return YAFFS_OK;
+}
+
+
+
+
+int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber)
+{
+ yaffs_ExtendedTags tags;
+ int chunkNo;
+
+ *sequenceNumber = 0;
+
+ chunkNo = blockNo * dev->nChunksPerBlock;
+
+ yflash_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
+ if(tags.blockBad)
+ {
+ *state = YAFFS_BLOCK_STATE_DEAD;
+ }
+ else if(!tags.chunkUsed)
+ {
+ *state = YAFFS_BLOCK_STATE_EMPTY;
+ }
+ else if(tags.chunkUsed)
+ {
+ *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
+ *sequenceNumber = tags.sequenceNumber;
+ }
+ return YAFFS_OK;
+}
+
diff --git a/fs/yaffs2/direct/yaffs_fileem2k.h b/fs/yaffs2/direct/yaffs_fileem2k.h
new file mode 100644
index 0000000000..e694c9258f
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_fileem2k.h
@@ -0,0 +1,50 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __FILEEM2K_H__
+#define __FILEEM2K_H__
+
+#if 1
+
+#define SIZE_IN_MB 128
+//#define SIZE_IN_MB 8000
+#define PAGE_DATA_SIZE (2048)
+#define PAGE_SPARE_SIZE (64)
+#define PAGE_SIZE (PAGE_DATA_SIZE + PAGE_SPARE_SIZE)
+#define PAGES_PER_BLOCK (64)
+#define BLOCK_DATA_SIZE (PAGE_DATA_SIZE * PAGES_PER_BLOCK)
+#define BLOCK_SIZE (PAGES_PER_BLOCK * (PAGE_SIZE))
+#define BLOCKS_PER_MB ((1024*1024)/BLOCK_DATA_SIZE)
+#define SIZE_IN_BLOCKS (BLOCKS_PER_MB * SIZE_IN_MB)
+
+#else
+
+#define SIZE_IN_MB 128
+#define PAGE_DATA_SIZE (512)
+#define SPARE_SIZE (16)
+#define PAGE_SIZE (PAGE_DATA_SIZE + SPARE_SIZE)
+#define PAGES_PER_BLOCK (32)
+#define BLOCK_DATA_SIZE (PAGE_SIZE * PAGES_PER_BLOCK)
+#define BLOCK_SIZE (PAGES_PER_BLOCK * (PAGE_SIZE))
+#define BLOCKS_PER_MB ((1024*1024)/BLOCK_DATA_SIZE)
+#define SIZE_IN_BLOCKS (BLOCKS_PER_MB * SIZE_IN_MB)
+
+#endif
+
+
+int yflash_GetNumberOfBlocks(void);
+
+#endif
+
diff --git a/fs/yaffs2/direct/yaffs_flashif.c b/fs/yaffs2/direct/yaffs_flashif.c
new file mode 100644
index 0000000000..5178cb2ac3
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_flashif.c
@@ -0,0 +1,229 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+
+const char *yaffs_flashif_c_version = "$Id: yaffs_flashif.c,v 1.3 2007/02/14 01:09:06 wookey Exp $";
+
+
+#include "yportenv.h"
+
+#include "yaffs_flashif.h"
+#include "yaffs_guts.h"
+#include "devextras.h"
+
+
+#define SIZE_IN_MB 16
+
+#define BLOCK_SIZE (32 * 528)
+#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
+
+
+
+typedef struct
+{
+ __u8 data[528]; // Data + spare
+} yflash_Page;
+
+typedef struct
+{
+ yflash_Page page[32]; // The pages in the block
+
+} yflash_Block;
+
+
+
+typedef struct
+{
+ yflash_Block **block;
+ int nBlocks;
+} yflash_Device;
+
+static yflash_Device ramdisk;
+
+static int CheckInit(yaffs_Device *dev)
+{
+ static int initialised = 0;
+
+ int i;
+ int fail = 0;
+ int nAllocated = 0;
+
+ if(initialised)
+ {
+ return YAFFS_OK;
+ }
+
+ initialised = 1;
+
+
+ ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
+
+ ramdisk.block = YMALLOC(sizeof(yflash_Block *) * ramdisk.nBlocks);
+
+ if(!ramdisk.block) return 0;
+
+ for(i=0; i <ramdisk.nBlocks; i++)
+ {
+ ramdisk.block[i] = NULL;
+ }
+
+ for(i=0; i <ramdisk.nBlocks && !fail; i++)
+ {
+ if((ramdisk.block[i] = YMALLOC(sizeof(yflash_Block))) == 0)
+ {
+ fail = 1;
+ }
+ else
+ {
+ yflash_EraseBlockInNAND(dev,i);
+ nAllocated++;
+ }
+ }
+
+ if(fail)
+ {
+ for(i = 0; i < nAllocated; i++)
+ {
+ YFREE(ramdisk.block[i]);
+ }
+ YFREE(ramdisk.block);
+
+ T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
+ nAllocated/64,ramdisk.nBlocks * YAFFS_BYTES_PER_BLOCK));
+ return 0;
+ }
+
+
+
+ return 1;
+}
+
+int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int blk;
+ int pg;
+
+
+ CheckInit(dev);
+
+ blk = chunkInNAND/32;
+ pg = chunkInNAND%32;
+
+
+ if(data)
+ {
+ memcpy(ramdisk.block[blk]->page[pg].data,data,512);
+ }
+
+
+ if(tags)
+ {
+ yaffs_PackedTags pt;
+ yaffs_PackTags(&pt,tags);
+ memcpy(&ramdisk.block[blk]->page[pg].data[512],&pt,sizeof(pt));
+ }
+
+ return YAFFS_OK;
+
+}
+
+
+int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Tags *tags)
+{
+ int blk;
+ int pg;
+
+
+ CheckInit(dev);
+
+ blk = chunkInNAND/32;
+ pg = chunkInNAND%32;
+
+
+ if(data)
+ {
+ memcpy(data,ramdisk.block[blk]->page[pg].data,512);
+ }
+
+
+ if(tags)
+ {
+ yaffs_PackedTags pt;
+ memcpy(&pt,&ramdisk.block[blk]->page[pg].data[512],sizeof(yaffs_PackedTags));
+ yaffs_UnpackTags(tags,&pt);
+ }
+
+ return YAFFS_OK;
+}
+
+
+int yflash_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
+{
+ int blk;
+ int pg;
+ int i;
+
+
+ CheckInit(dev);
+
+ blk = chunkInNAND/32;
+ pg = chunkInNAND%32;
+
+
+ for(i = 0; i < 528; i++)
+ {
+ if(ramdisk.block[blk]->page[pg].data[i] != 0xFF)
+ {
+ return YAFFS_FAIL;
+ }
+ }
+
+ return YAFFS_OK;
+
+}
+
+int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+
+ CheckInit(dev);
+
+ if(blockNumber < 0 || blockNumber >= ramdisk.nBlocks)
+ {
+ T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+ return YAFFS_FAIL;
+ }
+ else
+ {
+ memset(ramdisk.block[blockNumber],0xFF,sizeof(yflash_Block));
+ return YAFFS_OK;
+ }
+
+}
+
+int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+ return YAFFS_OK;
+
+}
+int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber)
+{
+ *state = YAFFS_BLOCK_STATE_EMPTY;
+ *sequenceNumber = 0;
+}
+
+
+int yflash_InitialiseNAND(yaffs_Device *dev)
+{
+ return YAFFS_OK;
+}
+
diff --git a/fs/yaffs2/direct/yaffs_flashif.h b/fs/yaffs2/direct/yaffs_flashif.h
new file mode 100644
index 0000000000..f7f4e4227d
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_flashif.h
@@ -0,0 +1,31 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_FLASH_H__
+#define __YAFFS_FLASH_H__
+
+
+#include "yaffs_guts.h"
+int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
+int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare);
+int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags);
+int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare);
+int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
+int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
+int yflash_InitialiseNAND(yaffs_Device *dev);
+int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
+int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
+
+#endif
diff --git a/fs/yaffs2/direct/yaffs_malloc.h b/fs/yaffs2/direct/yaffs_malloc.h
new file mode 100644
index 0000000000..245f9c9634
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_malloc.h
@@ -0,0 +1,23 @@
+#ifndef __YAFFS_MALLOC_H__
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#include <stdlib.h>
+
+void *yaffs_malloc(size_t size);
+void yaffs_free(void *ptr);
+
+#endif
+
diff --git a/fs/yaffs2/direct/yaffs_ramdisk.c b/fs/yaffs2/direct/yaffs_ramdisk.c
new file mode 100644
index 0000000000..6afee81f4c
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_ramdisk.c
@@ -0,0 +1,234 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * yaffs_ramdisk.c: yaffs ram disk component
+ * This provides a ram disk under yaffs.
+ * NB this is not intended for NAND emulation.
+ * Use this with dev->useNANDECC enabled, then ECC overheads are not required.
+ */
+
+const char *yaffs_ramdisk_c_version = "$Id: yaffs_ramdisk.c,v 1.4 2007/02/14 01:09:06 wookey Exp $";
+
+
+#include "yportenv.h"
+
+#include "yaffs_ramdisk.h"
+#include "yaffs_guts.h"
+#include "devextras.h"
+#include "yaffs_packedtags1.h"
+
+
+
+#define SIZE_IN_MB 2
+
+#define BLOCK_SIZE (32 * 528)
+#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
+
+
+
+
+
+typedef struct
+{
+ __u8 data[528]; // Data + spare
+} yramdisk_Page;
+
+typedef struct
+{
+ yramdisk_Page page[32]; // The pages in the block
+
+} yramdisk_Block;
+
+
+
+typedef struct
+{
+ yramdisk_Block **block;
+ int nBlocks;
+} yramdisk_Device;
+
+static yramdisk_Device ramdisk;
+
+static int CheckInit(yaffs_Device *dev)
+{
+ static int initialised = 0;
+
+ int i;
+ int fail = 0;
+ //int nBlocks;
+ int nAllocated = 0;
+
+ if(initialised)
+ {
+ return YAFFS_OK;
+ }
+
+ initialised = 1;
+
+
+ ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
+
+ ramdisk.block = YMALLOC(sizeof(yramdisk_Block *) * ramdisk.nBlocks);
+
+ if(!ramdisk.block) return 0;
+
+ for(i=0; i <ramdisk.nBlocks; i++)
+ {
+ ramdisk.block[i] = NULL;
+ }
+
+ for(i=0; i <ramdisk.nBlocks && !fail; i++)
+ {
+ if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_Block))) == 0)
+ {
+ fail = 1;
+ }
+ else
+ {
+ yramdisk_EraseBlockInNAND(dev,i);
+ nAllocated++;
+ }
+ }
+
+ if(fail)
+ {
+ for(i = 0; i < nAllocated; i++)
+ {
+ YFREE(ramdisk.block[i]);
+ }
+ YFREE(ramdisk.block);
+
+ T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
+ nAllocated/64,ramdisk.nBlocks * 528));
+ return 0;
+ }
+
+
+ return 1;
+}
+
+int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int blk;
+ int pg;
+
+
+ CheckInit(dev);
+
+ blk = chunkInNAND/32;
+ pg = chunkInNAND%32;
+
+
+ if(data)
+ {
+ memcpy(ramdisk.block[blk]->page[pg].data,data,512);
+ }
+
+
+ if(tags)
+ {
+ yaffs_PackedTags1 pt;
+
+ yaffs_PackTags1(&pt,tags);
+ memcpy(&ramdisk.block[blk]->page[pg].data[512],&pt,sizeof(pt));
+ }
+
+ return YAFFS_OK;
+
+}
+
+
+int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int blk;
+ int pg;
+
+
+ CheckInit(dev);
+
+ blk = chunkInNAND/32;
+ pg = chunkInNAND%32;
+
+
+ if(data)
+ {
+ memcpy(data,ramdisk.block[blk]->page[pg].data,512);
+ }
+
+
+ if(tags)
+ {
+ yaffs_PackedTags1 pt;
+
+ memcpy(&pt,&ramdisk.block[blk]->page[pg].data[512],sizeof(pt));
+ yaffs_UnpackTags1(tags,&pt);
+
+ }
+
+ return YAFFS_OK;
+}
+
+
+int yramdisk_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
+{
+ int blk;
+ int pg;
+ int i;
+
+
+ CheckInit(dev);
+
+ blk = chunkInNAND/32;
+ pg = chunkInNAND%32;
+
+
+ for(i = 0; i < 528; i++)
+ {
+ if(ramdisk.block[blk]->page[pg].data[i] != 0xFF)
+ {
+ return YAFFS_FAIL;
+ }
+ }
+
+ return YAFFS_OK;
+
+}
+
+int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+
+ CheckInit(dev);
+
+ if(blockNumber < 0 || blockNumber >= ramdisk.nBlocks)
+ {
+ T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+ return YAFFS_FAIL;
+ }
+ else
+ {
+ memset(ramdisk.block[blockNumber],0xFF,sizeof(yramdisk_Block));
+ return YAFFS_OK;
+ }
+
+}
+
+int yramdisk_InitialiseNAND(yaffs_Device *dev)
+{
+ //dev->useNANDECC = 1; // force on useNANDECC which gets faked.
+ // This saves us doing ECC checks.
+
+ return YAFFS_OK;
+}
+
+
diff --git a/fs/yaffs2/direct/yaffs_ramdisk.h b/fs/yaffs2/direct/yaffs_ramdisk.h
new file mode 100644
index 0000000000..045ab42db5
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_ramdisk.h
@@ -0,0 +1,32 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/*
+ * yaffs_ramdisk.h: yaffs ram disk component
+ */
+
+#ifndef __YAFFS_RAMDISK_H__
+#define __YAFFS_RAMDISK_H__
+
+
+#include "yaffs_guts.h"
+int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
+int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags);
+int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
+int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
+int yramdisk_InitialiseNAND(yaffs_Device *dev);
+int yramdisk_MarkNANDBlockBad(yaffs_Device *dev,int blockNumber);
+int yramdisk_QueryNANDBlock(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
+#endif
diff --git a/fs/yaffs2/direct/yaffs_ramem2k.c b/fs/yaffs2/direct/yaffs_ramem2k.c
new file mode 100644
index 0000000000..1ab053c467
--- /dev/null
+++ b/fs/yaffs2/direct/yaffs_ramem2k.c
@@ -0,0 +1,363 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * yaffs_ramem2k.c: RAM emulation in-kernel for 2K pages (YAFFS2)
+ */
+
+
+const char *yaffs_ramem2k_c_version = "$Id: yaffs_ramem2k.c,v 1.3 2007/02/14 01:09:06 wookey Exp $";
+
+#ifndef __KERNEL__
+#define CONFIG_YAFFS_RAM_ENABLED
+#else
+#include <linux/config.h>
+#endif
+
+#ifdef CONFIG_YAFFS_RAM_ENABLED
+
+#include "yportenv.h"
+
+#include "yaffs_nandemul2k.h"
+#include "yaffs_guts.h"
+#include "yaffsinterface.h"
+#include "devextras.h"
+#include "yaffs_packedtags2.h"
+
+
+
+#define EM_SIZE_IN_MEG (32)
+#define PAGE_DATA_SIZE (2048)
+#define PAGE_SPARE_SIZE (64)
+#define PAGES_PER_BLOCK (64)
+
+
+
+#define EM_SIZE_IN_BYTES (EM_SIZE_IN_MEG * (1<<20))
+
+#define PAGE_TOTAL_SIZE (PAGE_DATA_SIZE+PAGE_SPARE_SIZE)
+
+#define BLOCK_TOTAL_SIZE (PAGES_PER_BLOCK * PAGE_TOTAL_SIZE)
+
+#define BLOCKS_PER_MEG ((1<<20)/(PAGES_PER_BLOCK * PAGE_DATA_SIZE))
+
+
+typedef struct
+{
+ __u8 data[PAGE_TOTAL_SIZE]; // Data + spare
+ int empty; // is this empty?
+} nandemul_Page;
+
+
+typedef struct
+{
+ nandemul_Page *page[PAGES_PER_BLOCK];
+ int damaged;
+} nandemul_Block;
+
+
+
+typedef struct
+{
+ nandemul_Block**block;
+ int nBlocks;
+} nandemul_Device;
+
+static nandemul_Device ned;
+
+static int sizeInMB = EM_SIZE_IN_MEG;
+
+
+static void nandemul_yield(int n)
+{
+#ifdef __KERNEL__
+ if(n > 0) schedule_timeout(n);
+#endif
+
+}
+
+
+static void nandemul_ReallyEraseBlock(int blockNumber)
+{
+ int i;
+
+ nandemul_Block *blk;
+
+ if(blockNumber < 0 || blockNumber >= ned.nBlocks)
+ {
+ return;
+ }
+
+ blk = ned.block[blockNumber];
+
+ for(i = 0; i < PAGES_PER_BLOCK; i++)
+ {
+ memset(blk->page[i],0xff,sizeof(nandemul_Page));
+ blk->page[i]->empty = 1;
+ }
+ nandemul_yield(2);
+}
+
+
+static int nandemul2k_CalcNBlocks(void)
+{
+ return EM_SIZE_IN_MEG * BLOCKS_PER_MEG;
+}
+
+
+
+static int CheckInit(void)
+{
+ static int initialised = 0;
+
+ int i,j;
+
+ int fail = 0;
+ int nBlocks;
+
+ int nAllocated = 0;
+
+ if(initialised)
+ {
+ return YAFFS_OK;
+ }
+
+
+ ned.nBlocks = nBlocks = nandemul2k_CalcNBlocks();
+
+
+ ned.block = YMALLOC(sizeof(nandemul_Block*) * nBlocks );
+
+ if(!ned.block) return YAFFS_FAIL;
+
+
+
+
+
+ for(i=fail=0; i <nBlocks; i++)
+ {
+
+ nandemul_Block *blk;
+
+ if(!(blk = ned.block[i] = YMALLOC(sizeof(nandemul_Block))))
+ {
+ fail = 1;
+ }
+ else
+ {
+ for(j = 0; j < PAGES_PER_BLOCK; j++)
+ {
+ if((blk->page[j] = YMALLOC(sizeof(nandemul_Page))) == 0)
+ {
+ fail = 1;
+ }
+ }
+ nandemul_ReallyEraseBlock(i);
+ ned.block[i]->damaged = 0;
+ nAllocated++;
+ }
+ }
+
+ if(fail)
+ {
+ //Todo thump pages
+
+ for(i = 0; i < nAllocated; i++)
+ {
+ YFREE(ned.block[i]);
+ }
+ YFREE(ned.block);
+
+ T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
+ nAllocated/64,sizeInMB));
+ return 0;
+ }
+
+ ned.nBlocks = nBlocks;
+
+ initialised = 1;
+
+ return 1;
+}
+
+int nandemul2k_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int blk;
+ int pg;
+ int i;
+
+ __u8 *x;
+
+
+ blk = chunkInNAND/PAGES_PER_BLOCK;
+ pg = chunkInNAND%PAGES_PER_BLOCK;
+
+
+ if(data)
+ {
+ x = ned.block[blk]->page[pg]->data;
+
+ for(i = 0; i < PAGE_DATA_SIZE; i++)
+ {
+ x[i] &=data[i];
+ }
+
+ ned.block[blk]->page[pg]->empty = 0;
+ }
+
+
+ if(tags)
+ {
+ x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE];
+
+ yaffs_PackTags2((yaffs_PackedTags2 *)x,tags);
+
+ }
+
+ if(tags || data)
+ {
+ nandemul_yield(1);
+ }
+
+ return YAFFS_OK;
+}
+
+
+int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
+{
+ int blk;
+ int pg;
+
+ __u8 *x;
+
+
+
+ blk = chunkInNAND/PAGES_PER_BLOCK;
+ pg = chunkInNAND%PAGES_PER_BLOCK;
+
+
+ if(data)
+ {
+ memcpy(data,ned.block[blk]->page[pg]->data,PAGE_DATA_SIZE);
+ }
+
+
+ if(tags)
+ {
+ x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE];
+
+ yaffs_UnpackTags2(tags,(yaffs_PackedTags2 *)x);
+ }
+
+ return YAFFS_OK;
+}
+
+
+static int nandemul2k_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
+{
+ int blk;
+ int pg;
+ int i;
+
+
+
+ blk = chunkInNAND/PAGES_PER_BLOCK;
+ pg = chunkInNAND%PAGES_PER_BLOCK;
+
+
+ for(i = 0; i < PAGE_TOTAL_SIZE; i++)
+ {
+ if(ned.block[blk]->page[pg]->data[i] != 0xFF)
+ {
+ return YAFFS_FAIL;
+ }
+ }
+
+ return YAFFS_OK;
+
+}
+
+int nandemul2k_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+
+
+ if(blockNumber < 0 || blockNumber >= ned.nBlocks)
+ {
+ T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+ }
+ else if(ned.block[blockNumber]->damaged)
+ {
+ T(YAFFS_TRACE_ALWAYS,("Attempt to erase damaged block %d\n",blockNumber));
+ }
+ else
+ {
+ nandemul_ReallyEraseBlock(blockNumber);
+ }
+
+ return YAFFS_OK;
+}
+
+int nandemul2k_InitialiseNAND(yaffs_Device *dev)
+{
+ CheckInit();
+ return YAFFS_OK;
+}
+
+int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+
+ __u8 *x;
+
+ x = &ned.block[blockNo]->page[0]->data[PAGE_DATA_SIZE];
+
+ memset(x,0,sizeof(yaffs_PackedTags2));
+
+
+ return YAFFS_OK;
+
+}
+
+int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber)
+{
+ yaffs_ExtendedTags tags;
+ int chunkNo;
+
+ *sequenceNumber = 0;
+
+ chunkNo = blockNo * dev->nChunksPerBlock;
+
+ nandemul2k_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
+ if(tags.blockBad)
+ {
+ *state = YAFFS_BLOCK_STATE_DEAD;
+ }
+ else if(!tags.chunkUsed)
+ {
+ *state = YAFFS_BLOCK_STATE_EMPTY;
+ }
+ else if(tags.chunkUsed)
+ {
+ *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
+ *sequenceNumber = tags.sequenceNumber;
+ }
+ return YAFFS_OK;
+}
+
+int nandemul2k_GetBytesPerChunk(void) { return PAGE_DATA_SIZE;}
+
+int nandemul2k_GetChunksPerBlock(void) { return PAGES_PER_BLOCK; }
+int nandemul2k_GetNumberOfBlocks(void) {return nandemul2k_CalcNBlocks();}
+
+
+#endif //YAFFS_RAM_ENABLED
+
diff --git a/fs/yaffs2/direct/yaffscfg.c b/fs/yaffs2/direct/yaffscfg.c
new file mode 100644
index 0000000000..b1d311e569
--- /dev/null
+++ b/fs/yaffs2/direct/yaffscfg.c
@@ -0,0 +1,144 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * yaffscfg.c The configuration for the "direct" use of yaffs.
+ *
+ * This file is intended to be modified to your requirements.
+ * There is no need to redistribute this file.
+ */
+
+#include "yaffscfg.h"
+#include "yaffsfs.h"
+#include <errno.h>
+
+unsigned yaffs_traceMask = 0xFFFFFFFF;
+
+
+void yaffsfs_SetError(int err)
+{
+ //Do whatever to set error
+ errno = err;
+}
+
+void yaffsfs_Lock(void)
+{
+}
+
+void yaffsfs_Unlock(void)
+{
+}
+
+__u32 yaffsfs_CurrentTime(void)
+{
+ return 0;
+}
+
+void *yaffs_malloc(size_t size)
+{
+ return malloc(size);
+}
+
+void yaffs_free(void *ptr)
+{
+ free(ptr);
+}
+
+void yaffsfs_LocalInitialisation(void)
+{
+ // Define locking semaphore.
+}
+
+// Configuration for:
+// /ram 2MB ramdisk
+// /boot 2MB boot disk (flash)
+// /flash 14MB flash disk (flash)
+// NB Though /boot and /flash occupy the same physical device they
+// are still disticnt "yaffs_Devices. You may think of these as "partitions"
+// using non-overlapping areas in the same device.
+//
+
+#include "yaffs_ramdisk.h"
+#include "yaffs_flashif.h"
+
+static yaffs_Device ramDev;
+static yaffs_Device bootDev;
+static yaffs_Device flashDev;
+
+static yaffsfs_DeviceConfiguration yaffsfs_config[] = {
+
+ { "/ram", &ramDev},
+ { "/boot", &bootDev},
+ { "/flash", &flashDev},
+ {(void *)0,(void *)0}
+};
+
+
+int yaffs_StartUp(void)
+{
+ // Stuff to configure YAFFS
+ // Stuff to initialise anything special (eg lock semaphore).
+ yaffsfs_LocalInitialisation();
+
+ // Set up devices
+
+ // /ram
+ ramDev.nBytesPerChunk = 512;
+ ramDev.nChunksPerBlock = 32;
+ ramDev.nReservedBlocks = 2; // Set this smaller for RAM
+ ramDev.startBlock = 1; // Can't use block 0
+ ramDev.endBlock = 127; // Last block in 2MB.
+ ramDev.useNANDECC = 1;
+ ramDev.nShortOpCaches = 0; // Disable caching on this device.
+ ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat.
+ ramDev.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
+ ramDev.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
+ ramDev.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
+ ramDev.initialiseNAND = yramdisk_InitialiseNAND;
+
+ // /boot
+ bootDev.nBytesPerChunk = 612;
+ bootDev.nChunksPerBlock = 32;
+ bootDev.nReservedBlocks = 5;
+ bootDev.startBlock = 1; // Can't use block 0
+ bootDev.endBlock = 127; // Last block in 2MB.
+ bootDev.useNANDECC = 0; // use YAFFS's ECC
+ bootDev.nShortOpCaches = 10; // Use caches
+ bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
+ bootDev.writeChunkToNAND = yflash_WriteChunkToNAND;
+ bootDev.readChunkFromNAND = yflash_ReadChunkFromNAND;
+ bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
+ bootDev.initialiseNAND = yflash_InitialiseNAND;
+
+ // /flash
+ flashDev.nBytesPerChunk = 512;
+ flashDev.nChunksPerBlock = 32;
+ flashDev.nReservedBlocks = 5;
+ flashDev.startBlock = 128; // First block after 2MB
+ flashDev.endBlock = 1023; // Last block in 16MB
+ flashDev.useNANDECC = 0; // use YAFFS's ECC
+ flashDev.nShortOpCaches = 10; // Use caches
+ flashDev.genericDevice = (void *) 2; // Used to identify the device in fstat.
+ flashDev.writeChunkToNAND = yflash_WriteChunkToNAND;
+ flashDev.readChunkFromNAND = yflash_ReadChunkFromNAND;
+ flashDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
+ flashDev.initialiseNAND = yflash_InitialiseNAND;
+
+ yaffs_initialise(yaffsfs_config);
+
+ return 0;
+}
+
+
+
+
diff --git a/fs/yaffs2/direct/yaffscfg.h b/fs/yaffs2/direct/yaffscfg.h
new file mode 100644
index 0000000000..2a60dc132c
--- /dev/null
+++ b/fs/yaffs2/direct/yaffscfg.h
@@ -0,0 +1,45 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/*
+ * Header file for using yaffs in an application via
+ * a direct interface.
+ */
+
+
+#ifndef __YAFFSCFG_H__
+#define __YAFFSCFG_H__
+
+
+#include "devextras.h"
+
+#define YAFFSFS_N_HANDLES 200
+
+
+typedef struct {
+ const char *prefix;
+ struct yaffs_DeviceStruct *dev;
+} yaffsfs_DeviceConfiguration;
+
+
+void yaffsfs_Lock(void);
+void yaffsfs_Unlock(void);
+
+__u32 yaffsfs_CurrentTime(void);
+
+void yaffsfs_SetError(int err);
+
+#endif
+
diff --git a/fs/yaffs2/direct/yaffscfg2k.c b/fs/yaffs2/direct/yaffscfg2k.c
new file mode 100644
index 0000000000..6d5f542fc4
--- /dev/null
+++ b/fs/yaffs2/direct/yaffscfg2k.c
@@ -0,0 +1,229 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * yaffscfg2k.c The configuration for the "direct" use of yaffs.
+ *
+ * This file is intended to be modified to your requirements.
+ * There is no need to redistribute this file.
+ */
+
+#include "yaffscfg.h"
+#include "yaffsfs.h"
+#include "yaffs_fileem2k.h"
+#include "yaffs_nandemul2k.h"
+
+#include <errno.h>
+
+unsigned yaffs_traceMask =
+
+ YAFFS_TRACE_SCAN |
+ YAFFS_TRACE_GC | YAFFS_TRACE_GC_DETAIL |
+ YAFFS_TRACE_ERASE |
+ YAFFS_TRACE_TRACING |
+ YAFFS_TRACE_ALLOCATE |
+ YAFFS_TRACE_CHECKPOINT |
+ YAFFS_TRACE_BAD_BLOCKS |
+ YAFFS_TRACE_VERIFY |
+ YAFFS_TRACE_VERIFY_NAND |
+ YAFFS_TRACE_VERIFY_FULL |
+// (~0) |
+
+ 0;
+
+
+
+void yaffsfs_SetError(int err)
+{
+ //Do whatever to set error
+ errno = err;
+}
+
+void yaffsfs_Lock(void)
+{
+}
+
+void yaffsfs_Unlock(void)
+{
+}
+
+__u32 yaffsfs_CurrentTime(void)
+{
+ return 0;
+}
+
+
+static int yaffs_kill_alloc = 0;
+static size_t total_malloced = 0;
+static size_t malloc_limit = 0 & 6000000;
+
+void *yaffs_malloc(size_t size)
+{
+ size_t this;
+ if(yaffs_kill_alloc)
+ return NULL;
+ if(malloc_limit && malloc_limit <(total_malloced + size) )
+ return NULL;
+
+ this = malloc(size);
+ if(this)
+ total_malloced += size;
+ return this;
+}
+
+void yaffs_free(void *ptr)
+{
+ free(ptr);
+}
+
+void yaffsfs_LocalInitialisation(void)
+{
+ // Define locking semaphore.
+}
+
+// Configuration for:
+// /ram 2MB ramdisk
+// /boot 2MB boot disk (flash)
+// /flash 14MB flash disk (flash)
+// NB Though /boot and /flash occupy the same physical device they
+// are still disticnt "yaffs_Devices. You may think of these as "partitions"
+// using non-overlapping areas in the same device.
+//
+
+#include "yaffs_ramdisk.h"
+#include "yaffs_flashif.h"
+#include "yaffs_nandemul2k.h"
+
+static yaffs_Device ramDev;
+static yaffs_Device bootDev;
+static yaffs_Device flashDev;
+static yaffs_Device ram2kDev;
+
+static yaffsfs_DeviceConfiguration yaffsfs_config[] = {
+#if 0
+ { "/ram", &ramDev},
+ { "/boot", &bootDev},
+ { "/flash/", &flashDev},
+ { "/ram2k", &ram2kDev},
+ {(void *)0,(void *)0}
+#else
+ { "/", &ramDev},
+ { "/flash/boot", &bootDev},
+ { "/flash/flash", &flashDev},
+ { "/ram2k", &ram2kDev},
+ {(void *)0,(void *)0} /* Null entry to terminate list */
+#endif
+};
+
+
+int yaffs_StartUp(void)
+{
+ // Stuff to configure YAFFS
+ // Stuff to initialise anything special (eg lock semaphore).
+ yaffsfs_LocalInitialisation();
+
+ // Set up devices
+ // /ram
+ memset(&ramDev,0,sizeof(ramDev));
+ ramDev.nDataBytesPerChunk = 512;
+ ramDev.nChunksPerBlock = 32;
+ ramDev.nReservedBlocks = 2; // Set this smaller for RAM
+ ramDev.startBlock = 0; // Can use block 0
+ ramDev.endBlock = 127; // Last block in 2MB.
+ //ramDev.useNANDECC = 1;
+ ramDev.nShortOpCaches = 0; // Disable caching on this device.
+ ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat.
+ ramDev.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
+ ramDev.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
+ ramDev.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
+ ramDev.initialiseNAND = yramdisk_InitialiseNAND;
+
+ // /boot
+ memset(&bootDev,0,sizeof(bootDev));
+ bootDev.nDataBytesPerChunk = 512;
+ bootDev.nChunksPerBlock = 32;
+ bootDev.nReservedBlocks = 5;
+ bootDev.startBlock = 0; // Can use block 0
+ bootDev.endBlock = 63; // Last block
+ //bootDev.useNANDECC = 0; // use YAFFS's ECC
+ bootDev.nShortOpCaches = 10; // Use caches
+ bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
+ bootDev.writeChunkWithTagsToNAND = yflash_WriteChunkWithTagsToNAND;
+ bootDev.readChunkWithTagsFromNAND = yflash_ReadChunkWithTagsFromNAND;
+ bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
+ bootDev.initialiseNAND = yflash_InitialiseNAND;
+ bootDev.markNANDBlockBad = yflash_MarkNANDBlockBad;
+ bootDev.queryNANDBlock = yflash_QueryNANDBlock;
+
+
+
+ // /flash
+ // Set this puppy up to use
+ // the file emulation space as
+ // 2kpage/64chunk per block/128MB device
+ memset(&flashDev,0,sizeof(flashDev));
+
+ flashDev.nDataBytesPerChunk = 2048;
+ flashDev.nChunksPerBlock = 64;
+ flashDev.nReservedBlocks = 5;
+ flashDev.nCheckpointReservedBlocks = 5;
+ //flashDev.checkpointStartBlock = 1;
+ //flashDev.checkpointEndBlock = 20;
+ flashDev.startBlock = 0;
+ flashDev.endBlock = 200; // Make it smaller
+ //flashDev.endBlock = yflash_GetNumberOfBlocks()-1;
+ flashDev.isYaffs2 = 1;
+ flashDev.wideTnodesDisabled=0;
+ flashDev.nShortOpCaches = 10; // Use caches
+ flashDev.genericDevice = (void *) 2; // Used to identify the device in fstat.
+ flashDev.writeChunkWithTagsToNAND = yflash_WriteChunkWithTagsToNAND;
+ flashDev.readChunkWithTagsFromNAND = yflash_ReadChunkWithTagsFromNAND;
+ flashDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
+ flashDev.initialiseNAND = yflash_InitialiseNAND;
+ flashDev.markNANDBlockBad = yflash_MarkNANDBlockBad;
+ flashDev.queryNANDBlock = yflash_QueryNANDBlock;
+
+ // /ram2k
+ // Set this puppy up to use
+ // the file emulation space as
+ // 2kpage/64chunk per block/128MB device
+ memset(&ram2kDev,0,sizeof(ram2kDev));
+
+ ram2kDev.nDataBytesPerChunk = nandemul2k_GetBytesPerChunk();
+ ram2kDev.nChunksPerBlock = nandemul2k_GetChunksPerBlock();
+ ram2kDev.nReservedBlocks = 5;
+ ram2kDev.startBlock = 0; // First block after /boot
+ //ram2kDev.endBlock = 127; // Last block in 16MB
+ ram2kDev.endBlock = nandemul2k_GetNumberOfBlocks() - 1; // Last block in 512MB
+ ram2kDev.isYaffs2 = 1;
+ ram2kDev.nShortOpCaches = 10; // Use caches
+ ram2kDev.genericDevice = (void *) 3; // Used to identify the device in fstat.
+ ram2kDev.writeChunkWithTagsToNAND = nandemul2k_WriteChunkWithTagsToNAND;
+ ram2kDev.readChunkWithTagsFromNAND = nandemul2k_ReadChunkWithTagsFromNAND;
+ ram2kDev.eraseBlockInNAND = nandemul2k_EraseBlockInNAND;
+ ram2kDev.initialiseNAND = nandemul2k_InitialiseNAND;
+ ram2kDev.markNANDBlockBad = nandemul2k_MarkNANDBlockBad;
+ ram2kDev.queryNANDBlock = nandemul2k_QueryNANDBlock;
+
+ yaffs_initialise(yaffsfs_config);
+
+ return 0;
+}
+
+
+
+void SetCheckpointReservedBlocks(int n)
+{
+ flashDev.nCheckpointReservedBlocks = n;
+}
+
diff --git a/fs/yaffs2/direct/yaffsfs.c b/fs/yaffs2/direct/yaffsfs.c
new file mode 100644
index 0000000000..a8519c28e7
--- /dev/null
+++ b/fs/yaffs2/direct/yaffsfs.c
@@ -0,0 +1,1505 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "yaffsfs.h"
+#include "yaffs_guts.h"
+#include "yaffscfg.h"
+#include <string.h> // for memset
+#include "yportenv.h"
+
+#define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+
+const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.18 2007/07/18 19:40:38 charles Exp $";
+
+// configurationList is the list of devices that are supported
+static yaffsfs_DeviceConfiguration *yaffsfs_configurationList;
+
+
+/* Some forward references */
+static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path, int symDepth);
+static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj);
+
+
+// Handle management.
+//
+
+
+unsigned int yaffs_wr_attempts;
+
+typedef struct
+{
+ __u8 inUse:1; // this handle is in use
+ __u8 readOnly:1; // this handle is read only
+ __u8 append:1; // append only
+ __u8 exclusive:1; // exclusive
+ __u32 position; // current position in file
+ yaffs_Object *obj; // the object
+}yaffsfs_Handle;
+
+
+static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
+
+// yaffsfs_InitHandle
+/// Inilitalise handles on start-up.
+//
+static int yaffsfs_InitHandles(void)
+{
+ int i;
+ for(i = 0; i < YAFFSFS_N_HANDLES; i++)
+ {
+ yaffsfs_handle[i].inUse = 0;
+ yaffsfs_handle[i].obj = NULL;
+ }
+ return 0;
+}
+
+yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
+{
+ if(h < 0 || h >= YAFFSFS_N_HANDLES)
+ {
+ return NULL;
+ }
+
+ return &yaffsfs_handle[h];
+}
+
+yaffs_Object *yaffsfs_GetHandleObject(int handle)
+{
+ yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+
+ if(h && h->inUse)
+ {
+ return h->obj;
+ }
+
+ return NULL;
+}
+
+
+//yaffsfs_GetHandle
+// Grab a handle (when opening a file)
+//
+
+static int yaffsfs_GetHandle(void)
+{
+ int i;
+ yaffsfs_Handle *h;
+
+ for(i = 0; i < YAFFSFS_N_HANDLES; i++)
+ {
+ h = yaffsfs_GetHandlePointer(i);
+ if(!h)
+ {
+ // todo bug: should never happen
+ }
+ if(!h->inUse)
+ {
+ memset(h,0,sizeof(yaffsfs_Handle));
+ h->inUse=1;
+ return i;
+ }
+ }
+ return -1;
+}
+
+// yaffs_PutHandle
+// Let go of a handle (when closing a file)
+//
+static int yaffsfs_PutHandle(int handle)
+{
+ yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+
+ if(h)
+ {
+ h->inUse = 0;
+ h->obj = NULL;
+ }
+ return 0;
+}
+
+
+
+// Stuff to search for a directory from a path
+
+
+int yaffsfs_Match(char a, char b)
+{
+ // case sensitive
+ return (a == b);
+}
+
+// yaffsfs_FindDevice
+// yaffsfs_FindRoot
+// Scan the configuration list to find the root.
+// Curveballs: Should match paths that end in '/' too
+// Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
+static yaffs_Device *yaffsfs_FindDevice(const char *path, char **restOfPath)
+{
+ yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
+ const char *leftOver;
+ const char *p;
+ yaffs_Device *retval = NULL;
+ int thisMatchLength;
+ int longestMatch = -1;
+
+ // Check all configs, choose the one that:
+ // 1) Actually matches a prefix (ie /a amd /abc will not match
+ // 2) Matches the longest.
+ while(cfg && cfg->prefix && cfg->dev)
+ {
+ leftOver = path;
+ p = cfg->prefix;
+ thisMatchLength = 0;
+
+ while(*p && //unmatched part of prefix
+ strcmp(p,"/") && // the rest of the prefix is not / (to catch / at end)
+ *leftOver &&
+ yaffsfs_Match(*p,*leftOver))
+ {
+ p++;
+ leftOver++;
+ thisMatchLength++;
+ }
+ if((!*p || strcmp(p,"/") == 0) && // end of prefix
+ (!*leftOver || *leftOver == '/') && // no more in this path name part
+ (thisMatchLength > longestMatch))
+ {
+ // Matched prefix
+ *restOfPath = (char *)leftOver;
+ retval = cfg->dev;
+ longestMatch = thisMatchLength;
+ }
+ cfg++;
+ }
+ return retval;
+}
+
+static yaffs_Object *yaffsfs_FindRoot(const char *path, char **restOfPath)
+{
+
+ yaffs_Device *dev;
+
+ dev= yaffsfs_FindDevice(path,restOfPath);
+ if(dev && dev->isMounted)
+ {
+ return dev->rootDir;
+ }
+ return NULL;
+}
+
+static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
+{
+
+ while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+ {
+ char *alias = obj->variant.symLinkVariant.alias;
+
+ if(*alias == '/')
+ {
+ // Starts with a /, need to scan from root up
+ obj = yaffsfs_FindObject(NULL,alias,symDepth++);
+ }
+ else
+ {
+ // Relative to here, so use the parent of the symlink as a start
+ obj = yaffsfs_FindObject(obj->parent,alias,symDepth++);
+ }
+ }
+ return obj;
+}
+
+
+// yaffsfs_FindDirectory
+// Parse a path to determine the directory and the name within the directory.
+//
+// eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
+static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *path,char **name,int symDepth)
+{
+ yaffs_Object *dir;
+ char *restOfPath;
+ char str[YAFFS_MAX_NAME_LENGTH+1];
+ int i;
+
+ if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
+ {
+ return NULL;
+ }
+
+ if(startDir)
+ {
+ dir = startDir;
+ restOfPath = (char *)path;
+ }
+ else
+ {
+ dir = yaffsfs_FindRoot(path,&restOfPath);
+ }
+
+ while(dir)
+ {
+ // parse off /.
+ // curve ball: also throw away surplus '/'
+ // eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
+ while(*restOfPath == '/')
+ {
+ restOfPath++; // get rid of '/'
+ }
+
+ *name = restOfPath;
+ i = 0;
+
+ while(*restOfPath && *restOfPath != '/')
+ {
+ if (i < YAFFS_MAX_NAME_LENGTH)
+ {
+ str[i] = *restOfPath;
+ str[i+1] = '\0';
+ i++;
+ }
+ restOfPath++;
+ }
+
+ if(!*restOfPath)
+ {
+ // got to the end of the string
+ return dir;
+ }
+ else
+ {
+ if(strcmp(str,".") == 0)
+ {
+ // Do nothing
+ }
+ else if(strcmp(str,"..") == 0)
+ {
+ dir = dir->parent;
+ }
+ else
+ {
+ dir = yaffs_FindObjectByName(dir,str);
+
+ while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+ {
+
+ dir = yaffsfs_FollowLink(dir,symDepth);
+
+ }
+
+ if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
+ {
+ dir = NULL;
+ }
+ }
+ }
+ }
+ // directory did not exist.
+ return NULL;
+}
+
+static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,const char *path,char **name,int symDepth)
+{
+ return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
+}
+
+// yaffsfs_FindObject turns a path for an existing object into the object
+//
+static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path,int symDepth)
+{
+ yaffs_Object *dir;
+ char *name;
+
+ dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
+
+ if(dir && *name)
+ {
+ return yaffs_FindObjectByName(dir,name);
+ }
+
+ return dir;
+}
+
+
+
+int yaffs_open(const char *path, int oflag, int mode)
+{
+ yaffs_Object *obj = NULL;
+ yaffs_Object *dir = NULL;
+ char *name;
+ int handle = -1;
+ yaffsfs_Handle *h = NULL;
+ int alreadyOpen = 0;
+ int alreadyExclusive = 0;
+ int openDenied = 0;
+ int symDepth = 0;
+ int errorReported = 0;
+
+ int i;
+
+
+ // todo sanity check oflag (eg. can't have O_TRUNC without WRONLY or RDWR
+
+
+ yaffsfs_Lock();
+
+ handle = yaffsfs_GetHandle();
+
+ if(handle >= 0)
+ {
+
+ h = yaffsfs_GetHandlePointer(handle);
+
+
+ // try to find the exisiting object
+ obj = yaffsfs_FindObject(NULL,path,0);
+
+ if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+ {
+
+ obj = yaffsfs_FollowLink(obj,symDepth++);
+ }
+
+ if(obj)
+ {
+ // Check if the object is already in use
+ alreadyOpen = alreadyExclusive = 0;
+
+ for(i = 0; i <= YAFFSFS_N_HANDLES; i++)
+ {
+
+ if(i != handle &&
+ yaffsfs_handle[i].inUse &&
+ obj == yaffsfs_handle[i].obj)
+ {
+ alreadyOpen = 1;
+ if(yaffsfs_handle[i].exclusive)
+ {
+ alreadyExclusive = 1;
+ }
+ }
+ }
+
+ if(((oflag & O_EXCL) && alreadyOpen) || alreadyExclusive)
+ {
+ openDenied = 1;
+ }
+
+ // Open should fail if O_CREAT and O_EXCL are specified
+ if((oflag & O_EXCL) && (oflag & O_CREAT))
+ {
+ openDenied = 1;
+ yaffsfs_SetError(-EEXIST);
+ errorReported = 1;
+ }
+
+ // Check file permissions
+ if( (oflag & (O_RDWR | O_WRONLY)) == 0 && // ie O_RDONLY
+ !(obj->yst_mode & S_IREAD))
+ {
+ openDenied = 1;
+ }
+
+ if( (oflag & O_RDWR) &&
+ !(obj->yst_mode & S_IREAD))
+ {
+ openDenied = 1;
+ }
+
+ if( (oflag & (O_RDWR | O_WRONLY)) &&
+ !(obj->yst_mode & S_IWRITE))
+ {
+ openDenied = 1;
+ }
+
+ }
+
+ else if((oflag & O_CREAT))
+ {
+ // Let's see if we can create this file
+ dir = yaffsfs_FindDirectory(NULL,path,&name,0);
+ if(dir)
+ {
+ obj = yaffs_MknodFile(dir,name,mode,0,0);
+ }
+ else
+ {
+ yaffsfs_SetError(-ENOTDIR);
+ }
+ }
+
+ if(obj && !openDenied)
+ {
+ h->obj = obj;
+ h->inUse = 1;
+ h->readOnly = (oflag & (O_WRONLY | O_RDWR)) ? 0 : 1;
+ h->append = (oflag & O_APPEND) ? 1 : 0;
+ h->exclusive = (oflag & O_EXCL) ? 1 : 0;
+ h->position = 0;
+
+ obj->inUse++;
+ if((oflag & O_TRUNC) && !h->readOnly)
+ {
+ //todo truncate
+ yaffs_ResizeFile(obj,0);
+ }
+
+ }
+ else
+ {
+ yaffsfs_PutHandle(handle);
+ if(!errorReported)
+ {
+ yaffsfs_SetError(-EACCESS);
+ errorReported = 1;
+ }
+ handle = -1;
+ }
+
+ }
+
+ yaffsfs_Unlock();
+
+ return handle;
+}
+
+int yaffs_close(int fd)
+{
+ yaffsfs_Handle *h = NULL;
+ int retVal = 0;
+
+ yaffsfs_Lock();
+
+ h = yaffsfs_GetHandlePointer(fd);
+
+ if(h && h->inUse)
+ {
+ // clean up
+ yaffs_FlushFile(h->obj,1);
+ h->obj->inUse--;
+ if(h->obj->inUse <= 0 && h->obj->unlinked)
+ {
+ yaffs_DeleteFile(h->obj);
+ }
+ yaffsfs_PutHandle(fd);
+ retVal = 0;
+ }
+ else
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ retVal = -1;
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+}
+
+int yaffs_read(int fd, void *buf, unsigned int nbyte)
+{
+ yaffsfs_Handle *h = NULL;
+ yaffs_Object *obj = NULL;
+ int pos = 0;
+ int nRead = -1;
+ int maxRead;
+
+ yaffsfs_Lock();
+ h = yaffsfs_GetHandlePointer(fd);
+ obj = yaffsfs_GetHandleObject(fd);
+
+ if(!h || !obj)
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ }
+ else if( h && obj)
+ {
+ pos= h->position;
+ if(yaffs_GetObjectFileLength(obj) > pos)
+ {
+ maxRead = yaffs_GetObjectFileLength(obj) - pos;
+ }
+ else
+ {
+ maxRead = 0;
+ }
+
+ if(nbyte > maxRead)
+ {
+ nbyte = maxRead;
+ }
+
+
+ if(nbyte > 0)
+ {
+ nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
+ if(nRead >= 0)
+ {
+ h->position = pos + nRead;
+ }
+ else
+ {
+ //todo error
+ }
+ }
+ else
+ {
+ nRead = 0;
+ }
+
+ }
+
+ yaffsfs_Unlock();
+
+
+ return (nRead >= 0) ? nRead : -1;
+
+}
+
+int yaffs_write(int fd, const void *buf, unsigned int nbyte)
+{
+ yaffsfs_Handle *h = NULL;
+ yaffs_Object *obj = NULL;
+ int pos = 0;
+ int nWritten = -1;
+ int writeThrough = 0;
+
+ yaffsfs_Lock();
+ h = yaffsfs_GetHandlePointer(fd);
+ obj = yaffsfs_GetHandleObject(fd);
+
+ if(!h || !obj)
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ }
+ else if( h && obj && h->readOnly)
+ {
+ // todo error
+ }
+ else if( h && obj)
+ {
+ if(h->append)
+ {
+ pos = yaffs_GetObjectFileLength(obj);
+ }
+ else
+ {
+ pos = h->position;
+ }
+
+ nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
+
+ if(nWritten >= 0)
+ {
+ h->position = pos + nWritten;
+ }
+ else
+ {
+ //todo error
+ }
+
+ }
+
+ yaffsfs_Unlock();
+
+
+ return (nWritten >= 0) ? nWritten : -1;
+
+}
+
+int yaffs_truncate(int fd, off_t newSize)
+{
+ yaffsfs_Handle *h = NULL;
+ yaffs_Object *obj = NULL;
+ int result = 0;
+
+ yaffsfs_Lock();
+ h = yaffsfs_GetHandlePointer(fd);
+ obj = yaffsfs_GetHandleObject(fd);
+
+ if(!h || !obj)
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ }
+ else
+ {
+ // resize the file
+ result = yaffs_ResizeFile(obj,newSize);
+ }
+ yaffsfs_Unlock();
+
+
+ return (result) ? 0 : -1;
+
+}
+
+off_t yaffs_lseek(int fd, off_t offset, int whence)
+{
+ yaffsfs_Handle *h = NULL;
+ yaffs_Object *obj = NULL;
+ int pos = -1;
+ int fSize = -1;
+
+ yaffsfs_Lock();
+ h = yaffsfs_GetHandlePointer(fd);
+ obj = yaffsfs_GetHandleObject(fd);
+
+ if(!h || !obj)
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ }
+ else if(whence == SEEK_SET)
+ {
+ if(offset >= 0)
+ {
+ pos = offset;
+ }
+ }
+ else if(whence == SEEK_CUR)
+ {
+ if( (h->position + offset) >= 0)
+ {
+ pos = (h->position + offset);
+ }
+ }
+ else if(whence == SEEK_END)
+ {
+ fSize = yaffs_GetObjectFileLength(obj);
+ if(fSize >= 0 && (fSize + offset) >= 0)
+ {
+ pos = fSize + offset;
+ }
+ }
+
+ if(pos >= 0)
+ {
+ h->position = pos;
+ }
+ else
+ {
+ // todo error
+ }
+
+
+ yaffsfs_Unlock();
+
+ return pos;
+}
+
+
+int yaffsfs_DoUnlink(const char *path,int isDirectory)
+{
+ yaffs_Object *dir = NULL;
+ yaffs_Object *obj = NULL;
+ char *name;
+ int result = YAFFS_FAIL;
+
+ yaffsfs_Lock();
+
+ obj = yaffsfs_FindObject(NULL,path,0);
+ dir = yaffsfs_FindDirectory(NULL,path,&name,0);
+ if(!dir)
+ {
+ yaffsfs_SetError(-ENOTDIR);
+ }
+ else if(!obj)
+ {
+ yaffsfs_SetError(-ENOENT);
+ }
+ else if(!isDirectory && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+ {
+ yaffsfs_SetError(-EISDIR);
+ }
+ else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
+ {
+ yaffsfs_SetError(-ENOTDIR);
+ }
+ else
+ {
+ result = yaffs_Unlink(dir,name);
+
+ if(result == YAFFS_FAIL && isDirectory)
+ {
+ yaffsfs_SetError(-ENOTEMPTY);
+ }
+ }
+
+ yaffsfs_Unlock();
+
+ // todo error
+
+ return (result == YAFFS_FAIL) ? -1 : 0;
+}
+int yaffs_rmdir(const char *path)
+{
+ return yaffsfs_DoUnlink(path,1);
+}
+
+int yaffs_unlink(const char *path)
+{
+ return yaffsfs_DoUnlink(path,0);
+}
+
+int yaffs_rename(const char *oldPath, const char *newPath)
+{
+ yaffs_Object *olddir = NULL;
+ yaffs_Object *newdir = NULL;
+ yaffs_Object *obj = NULL;
+ char *oldname;
+ char *newname;
+ int result= YAFFS_FAIL;
+ int renameAllowed = 1;
+
+ yaffsfs_Lock();
+
+ olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0);
+ newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
+ obj = yaffsfs_FindObject(NULL,oldPath,0);
+
+ if(!olddir || !newdir || !obj)
+ {
+ // bad file
+ yaffsfs_SetError(-EBADF);
+ renameAllowed = 0;
+ }
+ else if(olddir->myDev != newdir->myDev)
+ {
+ // oops must be on same device
+ // todo error
+ yaffsfs_SetError(-EXDEV);
+ renameAllowed = 0;
+ }
+ else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+ {
+ // It is a directory, check that it is not being renamed to
+ // being its own decendent.
+ // Do this by tracing from the new directory back to the root, checking for obj
+
+ yaffs_Object *xx = newdir;
+
+ while( renameAllowed && xx)
+ {
+ if(xx == obj)
+ {
+ renameAllowed = 0;
+ }
+ xx = xx->parent;
+ }
+ if(!renameAllowed) yaffsfs_SetError(-EACCESS);
+ }
+
+ if(renameAllowed)
+ {
+ result = yaffs_RenameObject(olddir,oldname,newdir,newname);
+ }
+
+ yaffsfs_Unlock();
+
+ return (result == YAFFS_FAIL) ? -1 : 0;
+}
+
+
+static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
+{
+ int retVal = -1;
+
+ if(obj)
+ {
+ obj = yaffs_GetEquivalentObject(obj);
+ }
+
+ if(obj && buf)
+ {
+ buf->st_dev = (int)obj->myDev->genericDevice;
+ buf->st_ino = obj->objectId;
+ buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits
+
+ if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+ {
+ buf->st_mode |= S_IFDIR;
+ }
+ else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+ {
+ buf->st_mode |= S_IFLNK;
+ }
+ else if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
+ {
+ buf->st_mode |= S_IFREG;
+ }
+
+ buf->st_nlink = yaffs_GetObjectLinkCount(obj);
+ buf->st_uid = 0;
+ buf->st_gid = 0;;
+ buf->st_rdev = obj->yst_rdev;
+ buf->st_size = yaffs_GetObjectFileLength(obj);
+ buf->st_blksize = obj->myDev->nDataBytesPerChunk;
+ buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
+ buf->yst_atime = obj->yst_atime;
+ buf->yst_ctime = obj->yst_ctime;
+ buf->yst_mtime = obj->yst_mtime;
+ retVal = 0;
+ }
+ return retVal;
+}
+
+static int yaffsfs_DoStatOrLStat(const char *path, struct yaffs_stat *buf,int doLStat)
+{
+ yaffs_Object *obj;
+
+ int retVal = -1;
+
+ yaffsfs_Lock();
+ obj = yaffsfs_FindObject(NULL,path,0);
+
+ if(!doLStat && obj)
+ {
+ obj = yaffsfs_FollowLink(obj,0);
+ }
+
+ if(obj)
+ {
+ retVal = yaffsfs_DoStat(obj,buf);
+ }
+ else
+ {
+ // todo error not found
+ yaffsfs_SetError(-ENOENT);
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+
+}
+
+int yaffs_stat(const char *path, struct yaffs_stat *buf)
+{
+ return yaffsfs_DoStatOrLStat(path,buf,0);
+}
+
+int yaffs_lstat(const char *path, struct yaffs_stat *buf)
+{
+ return yaffsfs_DoStatOrLStat(path,buf,1);
+}
+
+int yaffs_fstat(int fd, struct yaffs_stat *buf)
+{
+ yaffs_Object *obj;
+
+ int retVal = -1;
+
+ yaffsfs_Lock();
+ obj = yaffsfs_GetHandleObject(fd);
+
+ if(obj)
+ {
+ retVal = yaffsfs_DoStat(obj,buf);
+ }
+ else
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+}
+
+static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
+{
+ int result;
+
+ if(obj)
+ {
+ obj = yaffs_GetEquivalentObject(obj);
+ }
+
+ if(obj)
+ {
+ obj->yst_mode = mode;
+ obj->dirty = 1;
+ result = yaffs_FlushFile(obj,0);
+ }
+
+ return result == YAFFS_OK ? 0 : -1;
+}
+
+
+int yaffs_chmod(const char *path, mode_t mode)
+{
+ yaffs_Object *obj;
+
+ int retVal = -1;
+
+ yaffsfs_Lock();
+ obj = yaffsfs_FindObject(NULL,path,0);
+
+ if(obj)
+ {
+ retVal = yaffsfs_DoChMod(obj,mode);
+ }
+ else
+ {
+ // todo error not found
+ yaffsfs_SetError(-ENOENT);
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+
+}
+
+
+int yaffs_fchmod(int fd, mode_t mode)
+{
+ yaffs_Object *obj;
+
+ int retVal = -1;
+
+ yaffsfs_Lock();
+ obj = yaffsfs_GetHandleObject(fd);
+
+ if(obj)
+ {
+ retVal = yaffsfs_DoChMod(obj,mode);
+ }
+ else
+ {
+ // bad handle
+ yaffsfs_SetError(-EBADF);
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+}
+
+
+int yaffs_mkdir(const char *path, mode_t mode)
+{
+ yaffs_Object *parent = NULL;
+ yaffs_Object *dir = NULL;
+ char *name;
+ int retVal= -1;
+
+ yaffsfs_Lock();
+ parent = yaffsfs_FindDirectory(NULL,path,&name,0);
+ if(parent)
+ dir = yaffs_MknodDirectory(parent,name,mode,0,0);
+ if(dir)
+ {
+ retVal = 0;
+ }
+ else
+ {
+ yaffsfs_SetError(-ENOSPC); // just assume no space for now
+ retVal = -1;
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+}
+
+int yaffs_mount(const char *path)
+{
+ int retVal=-1;
+ int result=YAFFS_FAIL;
+ yaffs_Device *dev=NULL;
+ char *dummy;
+
+ T(YAFFS_TRACE_ALWAYS,("yaffs: Mounting %s\n",path));
+
+ yaffsfs_Lock();
+ dev = yaffsfs_FindDevice(path,&dummy);
+ if(dev)
+ {
+ if(!dev->isMounted)
+ {
+ result = yaffs_GutsInitialise(dev);
+ if(result == YAFFS_FAIL)
+ {
+ // todo error - mount failed
+ yaffsfs_SetError(-ENOMEM);
+ }
+ retVal = result ? 0 : -1;
+
+ }
+ else
+ {
+ //todo error - already mounted.
+ yaffsfs_SetError(-EBUSY);
+ }
+ }
+ else
+ {
+ // todo error - no device
+ yaffsfs_SetError(-ENODEV);
+ }
+ yaffsfs_Unlock();
+ return retVal;
+
+}
+
+int yaffs_unmount(const char *path)
+{
+ int retVal=-1;
+ yaffs_Device *dev=NULL;
+ char *dummy;
+
+ yaffsfs_Lock();
+ dev = yaffsfs_FindDevice(path,&dummy);
+ if(dev)
+ {
+ if(dev->isMounted)
+ {
+ int i;
+ int inUse;
+
+ yaffs_FlushEntireDeviceCache(dev);
+ yaffs_CheckpointSave(dev);
+
+ for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++)
+ {
+ if(yaffsfs_handle[i].inUse && yaffsfs_handle[i].obj->myDev == dev)
+ {
+ inUse = 1; // the device is in use, can't unmount
+ }
+ }
+
+ if(!inUse)
+ {
+ yaffs_Deinitialise(dev);
+
+ retVal = 0;
+ }
+ else
+ {
+ // todo error can't unmount as files are open
+ yaffsfs_SetError(-EBUSY);
+ }
+
+ }
+ else
+ {
+ //todo error - not mounted.
+ yaffsfs_SetError(-EINVAL);
+
+ }
+ }
+ else
+ {
+ // todo error - no device
+ yaffsfs_SetError(-ENODEV);
+ }
+ yaffsfs_Unlock();
+ return retVal;
+
+}
+
+loff_t yaffs_freespace(const char *path)
+{
+ loff_t retVal=-1;
+ yaffs_Device *dev=NULL;
+ char *dummy;
+
+ yaffsfs_Lock();
+ dev = yaffsfs_FindDevice(path,&dummy);
+ if(dev && dev->isMounted)
+ {
+ retVal = yaffs_GetNumberOfFreeChunks(dev);
+ retVal *= dev->nDataBytesPerChunk;
+
+ }
+ else
+ {
+ yaffsfs_SetError(-EINVAL);
+ }
+
+ yaffsfs_Unlock();
+ return retVal;
+}
+
+
+
+void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList)
+{
+
+ yaffsfs_DeviceConfiguration *cfg;
+
+ yaffsfs_configurationList = cfgList;
+
+ yaffsfs_InitHandles();
+
+ cfg = yaffsfs_configurationList;
+
+ while(cfg && cfg->prefix && cfg->dev)
+ {
+ cfg->dev->isMounted = 0;
+ cfg->dev->removeObjectCallback = yaffsfs_RemoveObjectCallback;
+ cfg++;
+ }
+
+
+}
+
+
+//
+// Directory search stuff.
+
+//
+// Directory search context
+//
+// NB this is an opaque structure.
+
+
+typedef struct
+{
+ __u32 magic;
+ yaffs_dirent de; /* directory entry being used by this dsc */
+ char name[NAME_MAX+1]; /* name of directory being searched */
+ yaffs_Object *dirObj; /* ptr to directory being searched */
+ yaffs_Object *nextReturn; /* obj to be returned by next readddir */
+ int offset;
+ struct list_head others;
+} yaffsfs_DirectorySearchContext;
+
+
+
+static struct list_head search_contexts;
+
+
+static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
+{
+ if(dsc &&
+ dsc->dirObj &&
+ dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+
+ dsc->offset = 0;
+
+ if( list_empty(&dsc->dirObj->variant.directoryVariant.children)){
+ dsc->nextReturn = NULL;
+ } else {
+ dsc->nextReturn = list_entry(dsc->dirObj->variant.directoryVariant.children.next,
+ yaffs_Object,siblings);
+ }
+ } else {
+ /* Hey someone isn't playing nice! */
+ }
+}
+
+static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
+{
+ if(dsc &&
+ dsc->dirObj &&
+ dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+
+ if( dsc->nextReturn == NULL ||
+ list_empty(&dsc->dirObj->variant.directoryVariant.children)){
+ dsc->nextReturn = NULL;
+ } else {
+ struct list_head *next = dsc->nextReturn->siblings.next;
+
+ if( next == &dsc->dirObj->variant.directoryVariant.children)
+ dsc->nextReturn = NULL; /* end of list */
+ else
+ dsc->nextReturn = list_entry(next,yaffs_Object,siblings);
+ }
+ } else {
+ /* Hey someone isn't playing nice! */
+ }
+}
+
+static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
+{
+
+ struct list_head *i;
+ yaffsfs_DirectorySearchContext *dsc;
+
+ /* if search contexts not initilised then skip */
+ if(!search_contexts.next)
+ return;
+
+ /* Iteratethrough the directory search contexts.
+ * If any are the one being removed, then advance the dsc to
+ * the next one to prevent a hanging ptr.
+ */
+ list_for_each(i, &search_contexts) {
+ if (i) {
+ dsc = list_entry(i, yaffsfs_DirectorySearchContext,others);
+ if(dsc->nextReturn == obj)
+ yaffsfs_DirAdvance(dsc);
+ }
+ }
+
+}
+
+yaffs_DIR *yaffs_opendir(const char *dirname)
+{
+ yaffs_DIR *dir = NULL;
+ yaffs_Object *obj = NULL;
+ yaffsfs_DirectorySearchContext *dsc = NULL;
+
+ yaffsfs_Lock();
+
+ obj = yaffsfs_FindObject(NULL,dirname,0);
+
+ if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+ {
+
+ dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
+ dir = (yaffs_DIR *)dsc;
+ if(dsc)
+ {
+ memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
+ dsc->magic = YAFFS_MAGIC;
+ dsc->dirObj = obj;
+ strncpy(dsc->name,dirname,NAME_MAX);
+ INIT_LIST_HEAD(&dsc->others);
+
+ if(!search_contexts.next)
+ INIT_LIST_HEAD(&search_contexts);
+
+ list_add(&dsc->others,&search_contexts);
+ yaffsfs_SetDirRewound(dsc); }
+
+ }
+
+ yaffsfs_Unlock();
+
+ return dir;
+}
+
+struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
+{
+ yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
+ struct yaffs_dirent *retVal = NULL;
+
+ yaffsfs_Lock();
+
+ if(dsc && dsc->magic == YAFFS_MAGIC){
+ yaffsfs_SetError(0);
+ if(dsc->nextReturn){
+ dsc->de.d_ino = yaffs_GetEquivalentObject(dsc->nextReturn)->objectId;
+ dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
+ dsc->de.d_off = dsc->offset++;
+ yaffs_GetObjectName(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
+ if(strlen(dsc->de.d_name) == 0)
+ {
+ // this should not happen!
+ strcpy(dsc->de.d_name,"zz");
+ }
+ dsc->de.d_reclen = sizeof(struct yaffs_dirent);
+ retVal = &dsc->de;
+ yaffsfs_DirAdvance(dsc);
+ } else
+ retVal = NULL;
+ }
+ else
+ {
+ yaffsfs_SetError(-EBADF);
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+
+}
+
+
+void yaffs_rewinddir(yaffs_DIR *dirp)
+{
+ yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
+
+ yaffsfs_Lock();
+
+ yaffsfs_SetDirRewound(dsc);
+
+ yaffsfs_Unlock();
+}
+
+
+int yaffs_closedir(yaffs_DIR *dirp)
+{
+ yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
+
+ yaffsfs_Lock();
+ dsc->magic = 0;
+ list_del(&dsc->others); /* unhook from list */
+ YFREE(dsc);
+ yaffsfs_Unlock();
+ return 0;
+}
+
+// end of directory stuff
+
+
+int yaffs_symlink(const char *oldpath, const char *newpath)
+{
+ yaffs_Object *parent = NULL;
+ yaffs_Object *obj;
+ char *name;
+ int retVal= -1;
+ int mode = 0; // ignore for now
+
+ yaffsfs_Lock();
+ parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
+ obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath);
+ if(obj)
+ {
+ retVal = 0;
+ }
+ else
+ {
+ yaffsfs_SetError(-ENOSPC); // just assume no space for now
+ retVal = -1;
+ }
+
+ yaffsfs_Unlock();
+
+ return retVal;
+
+}
+
+int yaffs_readlink(const char *path, char *buf, int bufsiz)
+{
+ yaffs_Object *obj = NULL;
+ int retVal;
+
+
+ yaffsfs_Lock();
+
+ obj = yaffsfs_FindObject(NULL,path,0);
+
+ if(!obj)
+ {
+ yaffsfs_SetError(-ENOENT);
+ retVal = -1;
+ }
+ else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK)
+ {
+ yaffsfs_SetError(-EINVAL);
+ retVal = -1;
+ }
+ else
+ {
+ char *alias = obj->variant.symLinkVariant.alias;
+ memset(buf,0,bufsiz);
+ strncpy(buf,alias,bufsiz - 1);
+ retVal = 0;
+ }
+ yaffsfs_Unlock();
+ return retVal;
+}
+
+int yaffs_link(const char *oldpath, const char *newpath)
+{
+ // Creates a link called newpath to existing oldpath
+ yaffs_Object *obj = NULL;
+ yaffs_Object *target = NULL;
+ int retVal = 0;
+
+
+ yaffsfs_Lock();
+
+ obj = yaffsfs_FindObject(NULL,oldpath,0);
+ target = yaffsfs_FindObject(NULL,newpath,0);
+
+ if(!obj)
+ {
+ yaffsfs_SetError(-ENOENT);
+ retVal = -1;
+ }
+ else if(target)
+ {
+ yaffsfs_SetError(-EEXIST);
+ retVal = -1;
+ }
+ else
+ {
+ yaffs_Object *newdir = NULL;
+ yaffs_Object *link = NULL;
+
+ char *newname;
+
+ newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0);
+
+ if(!newdir)
+ {
+ yaffsfs_SetError(-ENOTDIR);
+ retVal = -1;
+ }
+ else if(newdir->myDev != obj->myDev)
+ {
+ yaffsfs_SetError(-EXDEV);
+ retVal = -1;
+ }
+ if(newdir && strlen(newname) > 0)
+ {
+ link = yaffs_Link(newdir,newname,obj);
+ if(link)
+ retVal = 0;
+ else
+ {
+ yaffsfs_SetError(-ENOSPC);
+ retVal = -1;
+ }
+
+ }
+ }
+ yaffsfs_Unlock();
+
+ return retVal;
+}
+
+int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev);
+
+int yaffs_DumpDevStruct(const char *path)
+{
+ char *rest;
+
+ yaffs_Object *obj = yaffsfs_FindRoot(path,&rest);
+
+ if(obj)
+ {
+ yaffs_Device *dev = obj->myDev;
+
+ printf("\n"
+ "nPageWrites.......... %d\n"
+ "nPageReads........... %d\n"
+ "nBlockErasures....... %d\n"
+ "nGCCopies............ %d\n"
+ "garbageCollections... %d\n"
+ "passiveGarbageColl'ns %d\n"
+ "\n",
+ dev->nPageWrites,
+ dev->nPageReads,
+ dev->nBlockErasures,
+ dev->nGCCopies,
+ dev->garbageCollections,
+ dev->passiveGarbageCollections
+ );
+
+ }
+ return 0;
+}
+
diff --git a/fs/yaffs2/direct/yaffsfs.h b/fs/yaffs2/direct/yaffsfs.h
new file mode 100644
index 0000000000..9afe60a1ce
--- /dev/null
+++ b/fs/yaffs2/direct/yaffsfs.h
@@ -0,0 +1,233 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/*
+ * Header file for using yaffs in an application via
+ * a direct interface.
+ */
+
+
+#ifndef __YAFFSFS_H__
+#define __YAFFSFS_H__
+
+#include "yaffscfg.h"
+#include "yportenv.h"
+
+
+//typedef long off_t;
+//typedef long dev_t;
+//typedef unsigned long mode_t;
+
+
+#ifndef NAME_MAX
+#define NAME_MAX 256
+#endif
+
+#ifndef O_RDONLY
+#define O_RDONLY 00
+#endif
+
+#ifndef O_WRONLY
+#define O_WRONLY 01
+#endif
+
+#ifndef O_RDWR
+#define O_RDWR 02
+#endif
+
+#ifndef O_CREAT
+#define O_CREAT 0100
+#endif
+
+#ifndef O_EXCL
+#define O_EXCL 0200
+#endif
+
+#ifndef O_TRUNC
+#define O_TRUNC 01000
+#endif
+
+#ifndef O_APPEND
+#define O_APPEND 02000
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#endif
+
+#ifndef SEEK_CUR
+#define SEEK_CUR 1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END 2
+#endif
+
+#ifndef EBUSY
+#define EBUSY 16
+#endif
+
+#ifndef ENODEV
+#define ENODEV 19
+#endif
+
+#ifndef EINVAL
+#define EINVAL 22
+#endif
+
+#ifndef EBADF
+#define EBADF 9
+#endif
+
+#ifndef EACCESS
+#define EACCESS 13
+#endif
+
+#ifndef EXDEV
+#define EXDEV 18
+#endif
+
+#ifndef ENOENT
+#define ENOENT 2
+#endif
+
+#ifndef ENOSPC
+#define ENOSPC 28
+#endif
+
+#ifndef ENOTEMPTY
+#define ENOTEMPTY 39
+#endif
+
+#ifndef ENOMEM
+#define ENOMEM 12
+#endif
+
+#ifndef EEXIST
+#define EEXIST 17
+#endif
+
+#ifndef ENOTDIR
+#define ENOTDIR 20
+#endif
+
+#ifndef EISDIR
+#define EISDIR 21
+#endif
+
+
+// Mode flags
+
+#ifndef S_IFMT
+#define S_IFMT 0170000
+#endif
+
+#ifndef S_IFLNK
+#define S_IFLNK 0120000
+#endif
+
+#ifndef S_IFDIR
+#define S_IFDIR 0040000
+#endif
+
+#ifndef S_IFREG
+#define S_IFREG 0100000
+#endif
+
+#ifndef S_IREAD
+#define S_IREAD 0000400
+#endif
+
+#ifndef S_IWRITE
+#define S_IWRITE 0000200
+#endif
+
+
+
+
+struct yaffs_dirent{
+ long d_ino; /* inode number */
+ off_t d_off; /* offset to this dirent */
+ unsigned short d_reclen; /* length of this d_name */
+ char d_name [NAME_MAX+1]; /* file name (null-terminated) */
+ unsigned d_dont_use; /* debug pointer, not for public consumption */
+};
+
+typedef struct yaffs_dirent yaffs_dirent;
+
+
+typedef struct __opaque yaffs_DIR;
+
+
+
+struct yaffs_stat{
+ int st_dev; /* device */
+ int st_ino; /* inode */
+ mode_t st_mode; /* protection */
+ int st_nlink; /* number of hard links */
+ int st_uid; /* user ID of owner */
+ int st_gid; /* group ID of owner */
+ unsigned st_rdev; /* device type (if inode device) */
+ off_t st_size; /* total size, in bytes */
+ unsigned long st_blksize; /* blocksize for filesystem I/O */
+ unsigned long st_blocks; /* number of blocks allocated */
+ unsigned long yst_atime; /* time of last access */
+ unsigned long yst_mtime; /* time of last modification */
+ unsigned long yst_ctime; /* time of last change */
+};
+
+int yaffs_open(const char *path, int oflag, int mode) ;
+int yaffs_read(int fd, void *buf, unsigned int nbyte) ;
+int yaffs_write(int fd, const void *buf, unsigned int nbyte) ;
+int yaffs_close(int fd) ;
+off_t yaffs_lseek(int fd, off_t offset, int whence) ;
+int yaffs_truncate(int fd, off_t newSize);
+
+int yaffs_unlink(const char *path) ;
+int yaffs_rename(const char *oldPath, const char *newPath) ;
+
+int yaffs_stat(const char *path, struct yaffs_stat *buf) ;
+int yaffs_lstat(const char *path, struct yaffs_stat *buf) ;
+int yaffs_fstat(int fd, struct yaffs_stat *buf) ;
+
+int yaffs_chmod(const char *path, mode_t mode);
+int yaffs_fchmod(int fd, mode_t mode);
+
+int yaffs_mkdir(const char *path, mode_t mode) ;
+int yaffs_rmdir(const char *path) ;
+
+yaffs_DIR *yaffs_opendir(const char *dirname) ;
+struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp) ;
+void yaffs_rewinddir(yaffs_DIR *dirp) ;
+int yaffs_closedir(yaffs_DIR *dirp) ;
+
+int yaffs_mount(const char *path) ;
+int yaffs_unmount(const char *path) ;
+
+int yaffs_symlink(const char *oldpath, const char *newpath);
+int yaffs_readlink(const char *path, char *buf, int bufsiz);
+
+int yaffs_link(const char *oldpath, const char *newpath);
+int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev);
+
+loff_t yaffs_freespace(const char *path);
+
+void yaffs_initialise(yaffsfs_DeviceConfiguration *configList);
+
+int yaffs_StartUp(void);
+
+#endif
+
+
diff --git a/fs/yaffs2/direct/ydirectenv.h b/fs/yaffs2/direct/ydirectenv.h
new file mode 100644
index 0000000000..0c2820579e
--- /dev/null
+++ b/fs/yaffs2/direct/ydirectenv.h
@@ -0,0 +1,88 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ * for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/*
+ * ydirectenv.h: Environment wrappers for YAFFS direct.
+ */
+
+#ifndef __YDIRECTENV_H__
+#define __YDIRECTENV_H__
+
+// Direct interface
+
+#include "devextras.h"
+
+#include "stdlib.h"
+#include "stdio.h"
+#include "string.h"
+#include "yaffs_malloc.h"
+
+#include "assert.h"
+#define YBUG() assert(1)
+
+#define YCHAR char
+#define YUCHAR unsigned char
+#define _Y(x) x
+#define yaffs_strcpy(a,b) strcpy(a,b)
+#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
+#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
+#define yaffs_strlen(s) strlen(s)
+#define yaffs_sprintf sprintf
+#define yaffs_toupper(a) toupper(a)
+
+#ifdef NO_Y_INLINE
+#define Y_INLINE
+#else
+#define Y_INLINE inline
+#endif
+
+#define YMALLOC(x) yaffs_malloc(x)
+#define YFREE(x) free(x)
+#define YMALLOC_ALT(x) yaffs_malloc(x)
+#define YFREE_ALT(x) free(x)
+
+#define YMALLOC_DMA(x) yaffs_malloc(x)
+
+#define YYIELD() do {} while(0)
+
+
+
+//#define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s))
+//#define YALERT(s) YINFO(s)
+
+
+#define TENDSTR "\n"
+#define TSTR(x) x
+#define TOUT(p) printf p
+
+
+#define YAFFS_LOSTNFOUND_NAME "lost+found"
+#define YAFFS_LOSTNFOUND_PREFIX "obj"
+//#define YPRINTF(x) printf x
+
+#include "yaffscfg.h"
+
+#define Y_CURRENT_TIME yaffsfs_CurrentTime()
+#define Y_TIME_CONVERT(x) x
+
+#define YAFFS_ROOT_MODE 0666
+#define YAFFS_LOSTNFOUND_MODE 0666
+
+#define yaffs_SumCompare(x,y) ((x) == (y))
+#define yaffs_strcmp(a,b) strcmp(a,b)
+
+#endif
+
+
generated by cgit (git 2.34.1) at 2024-12-29 15:13:24 +0000