Message

Reply | Reply all

Date Prev | Date Next | Thread Prev | Thread Next Date Index | Thread Index

From: cvs at opencores.org<cvs@o...>
Date: Thu Jun 7 16:37:31 CEST 2007
Subject: [cvs-checkins] MODIFIED: jop ...
Date: 00/07/06 07:16:37

Added: jop/java/target/src/common/yaffs2/port CFG_H.java
Dtest_C.java ECC_C.java ECC_H.java Guts_H.java
Template.java devextras.java
devextrasEnumeration.java iattr.java list_head.java
yaffs_BlockIndex.java yaffs_BlockInfo.java
yaffs_CheckpointDevice.java
yaffs_CheckpointObject.java
yaffs_CheckpointValidity.java yaffs_ChunkCache.java
yaffs_DIR.java yaffs_Device.java
yaffs_DirectoryStructure.java yaffs_ECCOther.java
yaffs_ExtendedTags.java yaffs_FileStructure.java
yaffs_HardLinkStructure.java yaffs_NANDSpare.java
yaffs_Object.java yaffs_ObjectBucket.java
yaffs_ObjectHeader.java yaffs_ObjectList.java
yaffs_ObjectVariant.java yaffs_PackedTags1.java
yaffs_PackedTags2.java
yaffs_PackedTags2TagsPart.java yaffs_Spare.java
yaffs_SuperBlockHeader.java
yaffs_SymLinkStructure.java yaffs_Tags.java
yaffs_TempBuffer.java yaffs_Tnode.java
yaffs_TnodeList.java yaffs_Tnode_internal.java
yaffs_Tnode_level0.java yaffs_checkptrw_C.java
yaffs_checkptrw_H.java yaffs_dirent.java
yaffs_fileem2k_C.java yaffs_fileem2k_H.java
yaffs_guts_C.java yaffs_nand_C.java
yaffs_packedtags1_C.java yaffs_packedtags1_H.java
yaffs_packedtags2_C.java yaffs_packedtags2_H.java
yaffs_qsort_C.java yaffs_ramdisk_C.java
yaffs_stat.java yaffs_tagscompat_C.java
yaffs_tagscompat_H.java yaffs_tagsvalidity_C.java
yaffs_tagsvalidity_H.java yaffscfg2k_C.java
yaffscfg_C.java yaffsfs_C.java
yaffsfs_DeviceConfiguration.java
yaffsfs_DirectorySearchContext.java yaffsfs_H.java
yaffsfs_Handle.java ydirectenv.java
yflash_Block.java yflash_Device.java
yflash_Page.java yportenv.java yramdisk_Block.java
yramdisk_Device.java yramdisk_Page.java
Log:
Java port of YAFFS, a NAND flash file system. Under development.


Revision Changes Path
1.1 jop/java/target/src/common/yaffs2/port/CFG_H.java

http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/CFG_H.java?rev=1.1&content-type=text/x-cvsweb-markup

Index: CFG_H.java
===================================================================
package yaffs2.port;

public abstract class CFG_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@a...>
*
* 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.
*/


static final int YAFFSFS_N_HANDLES = 200;

}



1.1 jop/java/target/src/common/yaffs2/port/Dtest_C.java

http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/Dtest_C.java?rev=1.1&content-type=text/x-cvsweb-markup

Index: Dtest_C.java
===================================================================
package yaffs2.port;

import java.io.RandomAccessFile;

import static yaffs2.port.yaffsfs_C.*;
import static yaffs2.port.yaffsfs_H.*;
import static yaffs2.utils.Unix.*;
import static yaffs2.utils.emulation.FileEmulationUnix.*;
import static yaffs2.utils.emulation.Utils.*;
import static yaffs2.utils.Constants.*;
import static yaffs2.utils.Utils.*;

public class Dtest_C {
/*
* 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@a...> * * 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. */ //void dumpDir(const char *dname); static byte[] xx = new byte[600];//char xx[600]; static final int xxIndex = 0; static void copy_in_a_file(String yaffsName, String inName) { RandomAccessFile inh; int outh; /*unsigned char buffer[100];*/ byte[] buffer = new byte[100]; final int bufferIndex = 0; int ni,no; inh = open(inName,O_RDONLY); outh = yaffs_open(StringToByteArray(yaffsName), 0, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); while((ni = read(inh,buffer,bufferIndex,100)) > 0) { no = yaffs_write(outh,buffer,bufferIndex,ni); if(ni != no) { printf("problem writing yaffs file\n"); } } yaffs_close(outh); close(inh); } static void make_a_file(byte[] yaffsName,int yaffsNameIndex,byte bval,int sizeOfFile) { int outh; int i; //unsigned char buffer[100]; byte[] buffer = new byte[100]; final int bufferIndex = 0; outh = yaffs_open(yaffsName, yaffsNameIndex, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); memset(buffer,bufferIndex,bval,100); do{ i = sizeOfFile; if(i > 100) i = 100; sizeOfFile -= i; yaffs_write(outh,buffer,bufferIndex,i); } while (sizeOfFile > 0); yaffs_close(outh); } static void make_pattern_file(byte[] fn,int fnIndex,int size) { int outh; int marker; int i; outh = yaffs_open(fn, fnIndex, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); yaffs_lseek(outh,size-1,SEEK_SET); yaffs_write(outh,new byte[] {'A'},0,1); for(i = 0; i < size; i+=256) { marker = ~i; yaffs_lseek(outh,i,SEEK_SET); yaffs_write(outh,IntToByteArray(marker),0,SIZEOF_INT); } yaffs_close(outh); } static boolean check_pattern_file(byte[] fn, int fnIndex) { int h; byte[] marker = new byte[SIZEOF_INT]; int i; int size; boolean ok = true; h = yaffs_open(fn, fnIndex, 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,0,SIZEOF_INT); ok = (getIntFromByteArray(marker,0) == ~i); if(!ok) { printf("pattern check failed on file %a, size %d at position %d. Got %x instead of %x\n", fn,fnIndex,size,i,getIntFromByteArray(marker,0),~i); } } yaffs_close(h); return ok; } static boolean dump_file_data(byte[] fn, int fnIndex) { int h; int marker; int i = 0; int size; boolean ok = true; /*unsigned*/ byte[] b = new byte[1]; h = yaffs_open(fn, fnIndex, O_RDWR,0); printf("%a\n",fn,fnIndex); while(yaffs_read(h,b,0,1)> 0) { printf("%02x",b); i++; if(i > 32) { printf("\n"); i = 0;; } } printf("\n"); yaffs_close(h); return ok; } static void dump_file(byte[] fn, int fnIndex) { int i; int size; int h; h = yaffs_open(fn,fnIndex,O_RDONLY,0); if(h < 0) { printf("*****\nDump file %a does not exist\n",fn,fnIndex); } else { size = yaffs_lseek(h,0,SEEK_SET); printf("*****\nDump file %a size %d\n",fn,fnIndex,size); for(i = 0; i < size; i++) { } } } static void create_file_of_size(byte[] fn,int fnIndex,int syze) { int h; int n; //char xx[200]; byte[] xx = new byte[200]; final int xxIndex = 0; int iterations = (syze + /*strlen*/(fn.length) -1)/ /*strlen*/(fn.length); h = yaffs_open(fn, fnIndex, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); while (iterations > 0) { sprintf(xx,xxIndex,"%a %8d",fn,fnIndex,iterations); yaffs_write(h,xx,xxIndex,strlen(xx, xxIndex)); iterations--; } yaffs_close (h); } static void verify_file_of_size(byte[] fn,int fnIndex,int syze) { int h; int n; byte[] xx = new byte[200]; final int xxIndex = 0; byte[] yy = new byte[200]; final int yyIndex = 0; int l; int iterations = (syze + strlen(fn,fnIndex) -1)/ strlen(fn,fnIndex); h = yaffs_open(fn, fnIndex, O_RDONLY, S_IREAD | S_IWRITE); while (iterations > 0) { sprintf(xx,xxIndex,"%a %8d",fn,fnIndex,iterations); l = strlen(xx,xxIndex); yaffs_read(h,yy,xxIndex,l); yy[l] = 0; if(strcmp(xx,xxIndex,yy,yyIndex) != 0){ printf("=====>>>>> verification of file %a failed near position %d\n",fn,fnIndex,yaffs_lseek(h,0,SEEK_CUR)); } iterations--; } yaffs_close (h); } static void create_resized_file_of_size(/*const char **/ byte[] fn,int fnIndex, int syze1,int reSyze, int syze2) { int h; int n; int iterations; h = yaffs_open(fn, fnIndex, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); iterations = (syze1 + strlen(fn,fnIndex) -1)/ strlen(fn,fnIndex); while (iterations > 0) { yaffs_write(h,fn,fnIndex,strlen(fn,fnIndex)); iterations--; } yaffs_truncate(h,reSyze); yaffs_lseek(h,0,SEEK_SET); iterations = (syze2 + strlen(fn,fnIndex) -1)/ strlen(fn,fnIndex); while (iterations > 0) { yaffs_write(h,fn,fnIndex,strlen(fn,fnIndex)); iterations--; } yaffs_close (h); } static void do_some_file_stuff(byte[] path, int pathIndex) { byte[] fn = new byte[100]; final int fnIndex = 0; sprintf(fn,fnIndex,"%a/%s",path,pathIndex,"f1"); create_file_of_size(fn,fnIndex,10000); sprintf(fn,fnIndex,"%a/%s",path,pathIndex,"fdel"); create_file_of_size(fn,fnIndex,10000); yaffs_unlink(fn,fnIndex); sprintf(fn,fnIndex,"%a/%s",path,pathIndex,"f2"); create_resized_file_of_size(fn,fnIndex,10000,3000,4000); } static void yaffs_backward_scan_test(byte[] path, int pathIndex) { byte[] fn = new byte[100]; final int fnIndex = 0; yaffs2.utils.Globals.configuration.yaffs_StartUp(); yaffs_mount(path,pathIndex); do_some_file_stuff(path,pathIndex); sprintf(fn,fnIndex,"%a/ddd",path,pathIndex); yaffs_mkdir(fn,fnIndex,0); do_some_file_stuff(fn,fnIndex); yaffs_unmount(path,pathIndex); yaffs_mount(path,pathIndex); } static byte[] xxzz = new byte[2000]; static int xxzzIndex = 0; static void yaffs_device_flush_test(byte[] path, int pathIndex) { byte[] fn = new byte[100]; int fnIndex = 0; int h; int i; yaffs2.utils.Globals.configuration.yaffs_StartUp(); yaffs_mount(path, pathIndex); do_some_file_stuff(path, pathIndex); // Open and add some data to a few files for(i = 0; i < 10; i++) { sprintf(fn,fnIndex,"%a/ff%d",path,pathIndex,i); h = yaffs_open(fn, fnIndex, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD); yaffs_write(h,xxzz,xxzzIndex,2000); yaffs_write(h,xxzz,xxzzIndex,2000); } yaffs_unmount(path,pathIndex); yaffs_mount(path,pathIndex); } static void short_scan_test(byte[] path, int pathIndex, int fsize, int niterations) { int i; byte[] fn = new byte[100]; final int fnIndex = 0; sprintf(fn,fnIndex,"%a/%s",path,pathIndex,"f1"); yaffs2.utils.Globals.configuration.yaffs_StartUp(); for(i = 0; i < niterations; i++) { printf("\n*****************\nIteration %d\n",i); yaffs_mount(path,pathIndex); printf("\nmount: Directory look-up of %a\n",path,pathIndex); dumpDir(path, pathIndex); make_a_file(fn, fnIndex,(byte)1,fsize); yaffs_unmount(path, pathIndex); } } static void scan_pattern_test(byte[] path, int pathIndex, int fsize, int niterations) { int i; int j; byte[][] fn = new byte[3][100]; final int fnIndex = 0; boolean result; sprintf(fn[0],fnIndex,"%a/%s",path,pathIndex,"f0"); sprintf(fn[1],fnIndex,"%a/%s",path,pathIndex,"f1"); sprintf(fn[2],fnIndex,"%a/%s",path,pathIndex,"f2"); yaffs2.utils.Globals.configuration.yaffs_StartUp(); for(i = 0; i < niterations; i++) { printf("\n*****************\nIteration %d\n",i); yaffs_mount(path, pathIndex); printf("\nmount: Directory look-up of %a\n",path,pathIndex); dumpDir(path, pathIndex); for(j = 0; j < 3; j++) { result = dump_file_data(fn[j],fnIndex); result = check_pattern_file(fn[j],fnIndex); make_pattern_file(fn[j],fnIndex,fsize); result = dump_file_data(fn[j],fnIndex); result = check_pattern_file(fn[j],fnIndex); } yaffs_unmount(path, pathIndex); } } static void fill_disk(byte[] path, int pathIndex, int nfiles) { int h; int n; int result; int f; byte[] str = new byte[50]; final int strIndex = 0; for(n = 0; n < nfiles; n++) { sprintf(str,strIndex,"%a/%d",path,pathIndex,n); h = yaffs_open(str, strIndex, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); printf("writing file %a handle %d ",str,strIndex,h); while ((result = yaffs_write(h,xx,xxIndex,600)) == 600) { f = yaffs_freespace(path, pathIndex); } result = yaffs_close(h); printf(" close %d\n",result); } } static void fill_disk_and_delete(byte[] path, int pathIndex, int nfiles, int ncycles) { int i,j; byte[] str = new byte[50]; final int strIndex = 0; int result; for(i = 0; i < ncycles; i++) { printf("@@@@@@@@@@@@@@ cycle %d\n",i); fill_disk(path,pathIndex,nfiles); for(j = 0; j < nfiles; j++) { sprintf(str,strIndex,"%a/%d",path,pathIndex,j); result = yaffs_unlink(str,strIndex); printf("unlinking file %a, result %d\n",str,strIndex,result); } } } static void fill_files(byte[] path, int pathIndex, int flags, int maxIterations, int siz) { int i; int j; byte[] str = new byte[50]; final int strIndex = 0; int h; i = 0; do{ sprintf(str,strIndex,"%a/%d",path,pathIndex,i); h = yaffs_open(str, strIndex, 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,strIndex,1); } } if((flags & 1) != 0) { yaffs_unlink(str, strIndex); } i++; } while(h >= 0 && i < maxIterations); if((flags & 2) != 0) { i = 0; do{ sprintf(str, strIndex, "%a/%d", path, pathIndex, i); printf("unlink %a\n",str,strIndex); i++; } while(yaffs_unlink(str,strIndex) >= 0); } } static void leave_unlinked_file(byte[] path, int pathIndex,int maxIterations,int siz) { int i; byte[] str = new byte[50]; final int strIndex = 0; int h; i = 0; do{ sprintf(str, strIndex,"%a/%d",path, pathIndex,i); printf("create %a\n",str, strIndex); h = yaffs_open(str, strIndex, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE); if(h >= 0) { yaffs_unlink(str, strIndex); } i++; } while(h < 0 && i < maxIterations); if(h >= 0) { for(i = 0; i < siz; i++) { yaffs_write(h,str, strIndex,1); } } printf("Leaving file %a open\n",str, strIndex); } static void dumpDirFollow(byte[] dname, int dnameIndex) { yaffs_DIR d; yaffs_dirent de; yaffs_stat s = new yaffs_stat(); byte[] str = new byte[100]; final int strIndex = 0; d = yaffs_opendir(dname, dnameIndex); if(!(d != null)) { printf("opendir failed\n"); } else { while((de = yaffs_readdir(d)) != null) { sprintf(str, strIndex,"%a/%a",dname, dnameIndex,de.d_name,de.d_nameIndex); yaffs_stat(str, strIndex, s); printf("%a length %d mode %X ",de.d_name,de.d_nameIndex,(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, strIndex,str, strIndex,100) < 0) printf("no alias"); else printf("\"%a\"",str, strIndex); break; default: printf("unknown"); break; } printf("\n"); } yaffs_closedir(d); } printf("\n"); printf("Free space in %a is %d\n\n",dname,dnameIndex,(int)yaffs_freespace(dname, dnameIndex)); } static void dump_directory_tree_worker(byte[] dname, int dnameIndex, int recursive) { yaffs_DIR d; yaffs_dirent de; yaffs_stat s = new yaffs_stat(); byte[] str = new byte[1000]; final int strIndex = 0; d = yaffs_opendir(dname, dnameIndex); if(!(d != null)) { printf("opendir failed\n"); } else { while((de = yaffs_readdir(d)) != null) { sprintf(str, strIndex,"%a/%a",dname,dnameIndex,de.d_name,de.d_nameIndex); yaffs_lstat(str, strIndex,s); printf("%a inode %d obj %x length %d mode %X ",str,strIndex,s.st_ino, yaffs2.utils.Utils.hashCode(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, strIndex,str, strIndex,100) < 0) printf("no alias"); else printf("\"%a\"",str, strIndex); break; default: printf("unknown"); break; } printf("\n"); if((s.st_mode & S_IFMT) == S_IFDIR && recursive != 0) dump_directory_tree_worker(str, strIndex,1); } yaffs_closedir(d); } } static void dump_directory_tree(byte[] dname, int dnameIndex) { dump_directory_tree_worker(dname, dnameIndex,1); printf("\n"); printf("Free space in %a is %d\n\n",dname,dnameIndex,(int)yaffs_freespace(dname, dnameIndex)); } static void dumpDir(byte[] dname, int dnameIndex) { dump_directory_tree_worker(dname, dnameIndex,0); printf("\n"); printf("Free space in %a is %d\n\n",dname, dnameIndex,(int)yaffs_freespace(dname, dnameIndex)); } static void PermissionsCheck(byte[] path, int pathIndex, /*mode_t*/ int tmode, int tflags,int expectedResult) { int fd; if(yaffs_chmod(path, pathIndex,tmode)< 0) printf("chmod failed\n"); fd = yaffs_open(path, pathIndex,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); } // XXX translate // static 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; // // } // // static 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; // } // // static int yaffs_scan_test(const char *path) // { // } // // // static 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); // // } // // static 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; // // } // // // static 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; // // } // // static 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; // // } // // static 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; // // } // // static 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; // // } // // static 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; // } // // // static 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; // } // // static 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; // // } // // // // // // static 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); // } // // } // // // // static 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); // // } // // static 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"); // // } // // static 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); // // // } // // static 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"); // // // // } // // // static 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); // } // // // // // } // // // static void write_10k(int h) // { // int i; // const char *s="0123456789"; // for(i = 0; i < 1000; i++) // yaffs_write(h,s,10); // // } // static 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); // // } // // // static 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); // // } // // // static 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); // } // // } // // // static 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); // } // } // // // static 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); // } // } static boolean early_exit; static byte[] _STATIC_LOCAL_small_overwrite_test_xx = new byte[8000]; static void small_overwrite_test(String mountpt,int nmounts) { byte[] a = new byte[30]; final int aIndex = 0; byte[] b = new byte[30]; final int bIndex = 0; byte[] c = new byte[30]; final int cIndex = 0; int i; int j; int h0; int h1; int len0; int len1; int nread; sprintf(a,aIndex,"%s/a",mountpt); yaffs2.utils.Globals.configuration.yaffs_StartUp(); for(i = 0; i < nmounts; i++){ // static char xx[8000]; printf("############### Iteration %d Start\n",i); if(true) yaffs_mount(StringToByteArray(mountpt), 0); dump_directory_tree(StringToByteArray(mountpt), 0); yaffs_mkdir(a, aIndex,0); sprintf(_STATIC_LOCAL_small_overwrite_test_xx,0,"%a/0",a,aIndex); h0 = yaffs_open(_STATIC_LOCAL_small_overwrite_test_xx,0, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE); sprintf(_STATIC_LOCAL_small_overwrite_test_xx,0,"%a/1",a,aIndex); h1 = yaffs_open(_STATIC_LOCAL_small_overwrite_test_xx,0, 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,_STATIC_LOCAL_small_overwrite_test_xx,0,7000); yaffs_write(h1,_STATIC_LOCAL_small_overwrite_test_xx,0,7000); if(early_exit) System.exit(0); } yaffs_close(h0); printf("########### %d\n",i); dump_directory_tree(StringToByteArray(mountpt), 0); if(true) yaffs_unmount(StringToByteArray(mountpt), 0); } } // XXX translate // static void yaffs_touch(const char *fn) // { // yaffs_chmod(fn, S_IREAD | S_IWRITE); // } // // static 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); // } // } // // // static 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); // // static 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); // } // } // // static 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"); // // // } // } /** * @param args */ public static void main(String[] args) { yaffs2.utils.Globals.startUp( new yaffs2.platform.emulation.yaffscfg2k_C(), new yaffs2.platform.emulation.PortConfiguration(), new yaffs2.platform.emulation.DebugConfiguration()); small_overwrite_test("/flash/boot",1); //return long_test(argc,argv); //return cache_read_test(); //resize_stress_test_no_grow("/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); //checkpoint_upgrade_test("/flash/flash",20); // 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; } } 1.1 jop/java/target/src/common/yaffs2/port/ECC_C.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/ECC_C.java?rev=1.1&content-type=text/x-cvsweb-markup Index: ECC_C.java =================================================================== package yaffs2.port; import yaffs2.utils.*; import static yaffs2.utils.Utils.*; public class ECC_C { /* * 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@a...> * * 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 code implements the ECC algorithm used in SmartMedia. * * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. * The two unused bit are set to 1. * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC * blocks are used on a 512-byte NAND page. * */ /* Table generated by gen-ecc.c * Using a table means we do not have to calculate p1..p4 and p1'..p4' * for each byte of data. These are instead provided in a table in bits7..2. * Bit 0 of each entry indicates whether the entry has an odd or even parity, and therefore * this bytes influence on the line parity. */ static final String yaffs_ecc_c_version = "$Id: ECC_C.java,v 1.1 2007/06/07 14:37:29 peter.hilber Exp $"; static final byte[] column_parity_table = { // XXX first it was mistakenly a short[] (byte)0x00, (byte)0x55, (byte)0x59, (byte)0x0c, (byte)0x65, (byte)0x30, (byte)0x3c, (byte)0x69, (byte)0x69, (byte)0x3c, (byte)0x30, (byte)0x65, (byte)0x0c, (byte)0x59, (byte)0x55, (byte)0x00, (byte)0x95, (byte)0xc0, (byte)0xcc, (byte)0x99, (byte)0xf0, (byte)0xa5, (byte)0xa9, (byte)0xfc, (byte)0xfc, (byte)0xa9, (byte)0xa5, (byte)0xf0, (byte)0x99, (byte)0xcc, (byte)0xc0, (byte)0x95, (byte)0x99, (byte)0xcc, (byte)0xc0, (byte)0x95, (byte)0xfc, (byte)0xa9, (byte)0xa5, (byte)0xf0, (byte)0xf0, (byte)0xa5, (byte)0xa9, (byte)0xfc, (byte)0x95, (byte)0xc0, (byte)0xcc, (byte)0x99, (byte)0x0c, (byte)0x59, (byte)0x55, (byte)0x00, (byte)0x69, (byte)0x3c, (byte)0x30, (byte)0x65, (byte)0x65, (byte)0x30, (byte)0x3c, (byte)0x69, (byte)0x00, (byte)0x55, (byte)0x59, (byte)0x0c, (byte)0xa5, (byte)0xf0, (byte)0xfc, (byte)0xa9, (byte)0xc0, (byte)0x95, (byte)0x99, (byte)0xcc, (byte)0xcc, (byte)0x99, (byte)0x95, (byte)0xc0, (byte)0xa9, (byte)0xfc, (byte)0xf0, (byte)0xa5, (byte)0x30, (byte)0x65, (byte)0x69, (byte)0x3c, (byte)0x55, (byte)0x00, (byte)0x0c, (byte)0x59, (byte)0x59, (byte)0x0c, (byte)0x00, (byte)0x55, (byte)0x3c, (byte)0x69, (byte)0x65, (byte)0x30, (byte)0x3c, (byte)0x69, (byte)0x65, (byte)0x30, (byte)0x59, (byte)0x0c, (byte)0x00, (byte)0x55, (byte)0x55, (byte)0x00, (byte)0x0c, (byte)0x59, (byte)0x30, (byte)0x65, (byte)0x69, (byte)0x3c, (byte)0xa9, (byte)0xfc, (byte)0xf0, (byte)0xa5, (byte)0xcc, (byte)0x99, (byte)0x95, (byte)0xc0, (byte)0xc0, (byte)0x95, (byte)0x99, (byte)0xcc, (byte)0xa5, (byte)0xf0, (byte)0xfc, (byte)0xa9, (byte)0xa9, (byte)0xfc, (byte)0xf0, (byte)0xa5, (byte)0xcc, (byte)0x99, (byte)0x95, (byte)0xc0, (byte)0xc0, (byte)0x95, (byte)0x99, (byte)0xcc, (byte)0xa5, (byte)0xf0, (byte)0xfc, (byte)0xa9, (byte)0x3c, (byte)0x69, (byte)0x65, (byte)0x30, (byte)0x59, (byte)0x0c, (byte)0x00, (byte)0x55, (byte)0x55, (byte)0x00, (byte)0x0c, (byte)0x59, (byte)0x30, (byte)0x65, (byte)0x69, (byte)0x3c, (byte)0x30, (byte)0x65, (byte)0x69, (byte)0x3c, (byte)0x55, (byte)0x00, (byte)0x0c, (byte)0x59, (byte)0x59, (byte)0x0c, (byte)0x00, (byte)0x55, (byte)0x3c, (byte)0x69, (byte)0x65, (byte)0x30, (byte)0xa5, (byte)0xf0, (byte)0xfc, (byte)0xa9, (byte)0xc0, (byte)0x95, (byte)0x99, (byte)0xcc, (byte)0xcc, (byte)0x99, (byte)0x95, (byte)0xc0, (byte)0xa9, (byte)0xfc, (byte)0xf0, (byte)0xa5, (byte)0x0c, (byte)0x59, (byte)0x55, (byte)0x00, (byte)0x69, (byte)0x3c, (byte)0x30, (byte)0x65, (byte)0x65, (byte)0x30, (byte)0x3c, (byte)0x69, (byte)0x00, (byte)0x55, (byte)0x59, (byte)0x0c, (byte)0x99, (byte)0xcc, (byte)0xc0, (byte)0x95, (byte)0xfc, (byte)0xa9, (byte)0xa5, (byte)0xf0, (byte)0xf0, (byte)0xa5, (byte)0xa9, (byte)0xfc, (byte)0x95, (byte)0xc0, (byte)0xcc, (byte)0x99, (byte)0x95, (byte)0xc0, (byte)0xcc, (byte)0x99, (byte)0xf0, (byte)0xa5, (byte)0xa9, (byte)0xfc, (byte)0xfc, (byte)0xa9, (byte)0xa5, (byte)0xf0, (byte)0x99, (byte)0xcc, (byte)0xc0, (byte)0x95, (byte)0x00, (byte)0x55, (byte)0x59, (byte)0x0c, (byte)0x65, (byte)0x30, (byte)0x3c, (byte)0x69, (byte)0x69, (byte)0x3c, (byte)0x30, (byte)0x65, (byte)0x0c, (byte)0x59, (byte)0x55, (byte)0x00 }; /* Count the bits in an unsigned char or a U32 */ static int yaffs_CountBits(byte x) { int r = 0; while (x != 0) { if ((x & 1) != 0) r++; x >>>= 1; } return r; } static int yaffs_CountBits32(int x) { int r = 0; while (x != 0) { if ((x & 1) != 0) r++; x >>>= 1; } return r; } // XXX make several versions? // ??? /* Calculate the ECC for a 256-byte block of data */ static void yaffs_ECCCalculate(byte[] data, int dataIndex, byte[] ecc, int eccIndex) { int i; int col_parity = 0; int line_parity = 0; int line_parity_prime = 0; int t; int b; for (i = 0; i < 256; i++) { b = column_parity_table[byteAsUnsignedByte(data[dataIndex+i])]; col_parity ^= b; if ((b & 0x01) != 0) // odd number of bits in the byte { line_parity ^= i; line_parity_prime ^= ~i; } } ecc[eccIndex+2] = (byte)((~col_parity) | 0x03); t = 0; if ((line_parity & 0x80) != 0) t |= 0x80; if ((line_parity_prime & 0x80) != 0) t |= 0x40; if ((line_parity & 0x40) != 0) t |= 0x20; if ((line_parity_prime & 0x40) != 0) t |= 0x10; if ((line_parity & 0x20) != 0) t |= 0x08; if ((line_parity_prime & 0x20) != 0) t |= 0x04; if ((line_parity & 0x10) != 0) t |= 0x02; if ((line_parity_prime & 0x10) != 0) t |= 0x01; ecc[eccIndex+1] = (byte)~t; t = 0; if ((line_parity & 0x08) != 0) t |= 0x80; if ((line_parity_prime & 0x08) != 0) t |= 0x40; if ((line_parity & 0x04) != 0) t |= 0x20; if ((line_parity_prime & 0x04) != 0) t |= 0x10; if ((line_parity & 0x02) != 0) t |= 0x08; if ((line_parity_prime & 0x02) != 0) t |= 0x04; if ((line_parity & 0x01) != 0) t |= 0x02; if ((line_parity_prime & 0x01) != 0) t |= 0x01; ecc[eccIndex+0] = (byte)~t; /*#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER // Swap the bytes into the wrong order t = ecc[0]; ecc[0] = ecc[1]; ecc[1] = t; #endif*/ } /* Correct the ECC on a 256 byte block of data */ static int yaffs_ECCCorrect(byte[] data, int dataIndex, byte[] read_ecc, int read_eccIndex, byte[] test_ecc, int test_eccIndex) { int d0, d1, d2; /* deltas */ d0 = (read_ecc[read_eccIndex+0] ^ test_ecc[test_eccIndex+0]); d1 = (read_ecc[read_eccIndex+1] ^ test_ecc[test_eccIndex+1]); d2 = (read_ecc[read_eccIndex+2] ^ test_ecc[test_eccIndex+2]); if ((d0 | d1 | d2) == 0) return 0; /* no error */ if (((d0 ^ (d0 >>> 1)) & 0x55) == 0x55 && ((d1 ^ (d1 >>> 1)) & 0x55) == 0x55 && ((d2 ^ (d2 >>> 1)) & 0x54) == 0x54) { /* Single bit (recoverable) error in data */ int _byte; int bit; /*#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER // swap the bytes to correct for the wrong order unsigned char t; t = d0; d0 = d1; d1 = t; #endif*/ bit = _byte = 0; if ((d1 & 0x80) != 0) _byte |= 0x80; if ((d1 & 0x20) != 0) _byte |= 0x40; if ((d1 & 0x08) != 0) _byte |= 0x20; if ((d1 & 0x02) != 0) _byte |= 0x10; if ((d0 & 0x80) != 0) _byte |= 0x08; if ((d0 & 0x20) != 0) _byte |= 0x04; if ((d0 & 0x08) != 0) _byte |= 0x02; if ((d0 & 0x02) != 0) _byte |= 0x01; if ((d2 & 0x80) != 0) bit |= 0x04; if ((d2 & 0x20) != 0) bit |= 0x02; if ((d2 & 0x08) != 0) bit |= 0x01; /*data[_byte] ^= (1 << bit);*/ data[dataIndex + _byte] ^= (1 << bit); return 1; /* Corrected the error */ } if ((yaffs_CountBits((byte)d0) + yaffs_CountBits((byte)d1) + yaffs_CountBits((byte)d2)) == 1) { /* Reccoverable error in ecc */ read_ecc[read_eccIndex+0] = test_ecc[test_eccIndex+0]; read_ecc[read_eccIndex+1] = test_ecc[test_eccIndex+1]; read_ecc[read_eccIndex+2] = test_ecc[test_eccIndex+2]; return 1; /* Corrected the error */ } /* Unrecoverable error */ return -1; } /* * ECCxxxOther does ECC calcs on arbitrary n bytes of data */ static void yaffs_ECCCalculateOther(SerializableObject data/*, int nBytes*/ , yaffs_ECCOther eccOther) { int nBytes = data.getSerializedLength(); // PORT int i; int col_parity = 0; int line_parity = 0; int line_parity_prime = 0; int b; for (i = 0; i < nBytes; i++) { b = column_parity_table[byteAsUnsignedByte(data.serialized[data.offset+i])]; col_parity ^= b; if ((b & 0x01) != 0) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; } } eccOther.setcolParity((byte)((col_parity >>> 2) & 0x3f)); eccOther.setlineParity(line_parity); eccOther.setlineParityPrime(line_parity_prime); } static int yaffs_ECCCorrectOther(SerializableObject data/*, int nBytes*/ , yaffs_ECCOther read_ecc, yaffs_ECCOther test_ecc) { int nBytes = data.getSerializedLength(); int cDelta; /* column parity delta */ int lDelta; /* line parity delta */ int lDeltaPrime; /* line parity delta */ int bit; cDelta = read_ecc.colParity() ^ test_ecc.colParity(); lDelta = read_ecc.lineParity() ^ test_ecc.lineParity(); lDeltaPrime = read_ecc.lineParityPrime() ^ test_ecc.lineParityPrime(); if ((cDelta | lDelta | lDeltaPrime) == 0) return 0; /* no error */ if (lDelta == ~lDeltaPrime && (((cDelta ^ (cDelta >>> 1)) & 0x15) == 0x15)) { /* Single bit (recoverable) error in data */ bit = 0; if ((cDelta & 0x20) != 0) bit |= 0x04; if ((cDelta & 0x08) != 0) bit |= 0x02; if ((cDelta & 0x02) != 0) bit |= 0x01; if(lDelta >= nBytes) return -1; data.serialized[data.offset+(int)lDelta] ^= (1 << bit); return 1; /* corrected */ } if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) + yaffs_CountBits((byte)cDelta)) == 1) { /* Reccoverable error in ecc */ read_ecc = test_ecc; return 1; /* corrected */ } /* Unrecoverable error */ return -1; } } 1.1 jop/java/target/src/common/yaffs2/port/ECC_H.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/ECC_H.java?rev=1.1&content-type=text/x-cvsweb-markup Index: ECC_H.java =================================================================== package yaffs2.port; abstract public class ECC_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@a...> * * 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. */ /* * This code implements the ECC algorithm used in SmartMedia. * * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. * The two unused bit are set to 1. * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC * blocks are used on a 512-byte NAND page. * */ /** * @param data const unsigned char * * @param ecc unsigned char * */ abstract void yaffs_ECCCalculate(byte[] data, byte[] ecc); /** * @param data unsigned char * * @param read_ecc unsigned char * * @param test_ecc const unsigned char * * @return */ abstract int yaffs_ECCCorrect(byte[] data, byte[] read_ecc, byte[] test_ecc); /** * @param data const unsigned char * @param nBytes unsigned * @param ecc yaffs_ECCOther * */ abstract void yaffs_ECCCalculateOther(byte[] data, long nBytes, yaffs_ECCOther ecc); /** * @param data unsigned char * * @param nBytes unsigned * @param read_ecc yaffs_ECCOther * * @param test_ecc const yaffs_ECCOther * * @return */ abstract int yaffs_ECCCorrectOther(byte[] data, long nBytes, yaffs_ECCOther read_ecc, yaffs_ECCOther test_ecc); } 1.1 jop/java/target/src/common/yaffs2/port/Guts_H.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/Guts_H.java?rev=1.1&content-type=text/x-cvsweb-markup Index: Guts_H.java =================================================================== package yaffs2.port; import static yaffs2.port.yportenv.*; import static yaffs2.port.ydirectenv.*; public abstract class Guts_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@a...> * * 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. */ static final boolean YAFFS_OK = /*1*/ true; static final boolean YAFFS_FAIL = /*0*/ false; /* Give us a Y=0x59, * Give us an A=0x41, * Give us an FF=0xFF * Give us an S=0x53 * And what have we got... */ static final int YAFFS_MAGIC = 0x5941FF53; static final int YAFFS_NTNODES_LEVEL0 = 16; static final int YAFFS_TNODES_LEVEL0_BITS = 4; static final int YAFFS_TNODES_LEVEL0_MASK = 0xf; static final int YAFFS_NTNODES_INTERNAL = (YAFFS_NTNODES_LEVEL0 / 2); static final int YAFFS_TNODES_INTERNAL_BITS = (YAFFS_TNODES_LEVEL0_BITS - 1); static final int YAFFS_TNODES_INTERNAL_MASK = 0x7; static final int YAFFS_TNODES_MAX_LEVEL = 6; //#ifndef CONFIG_YAFFS_NO_YAFFS1 static final int YAFFS_BYTES_PER_SPARE = 16; static final int YAFFS_BYTES_PER_CHUNK = 512; static final int YAFFS_CHUNK_SIZE_SHIFT = 9; static final int YAFFS_CHUNKS_PER_BLOCK = 32; static final int YAFFS_BYTES_PER_BLOCK = (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK); //#endif static final int YAFFS_MIN_YAFFS2_CHUNK_SIZE = 1024; static final int YAFFS_MIN_YAFFS2_SPARE_SIZE = 32; static final int YAFFS_MAX_CHUNK_ID = 0x000FFFFF; static final int YAFFS_UNUSED_OBJECT_ID = 0x0003FFFF; static final int YAFFS_ALLOCATION_NOBJECTS = 100; static final int YAFFS_ALLOCATION_NTNODES = 100; static final int YAFFS_ALLOCATION_NLINKS = 100; static final int YAFFS_NOBJECT_BUCKETS = 256; static final int YAFFS_OBJECT_SPACE = 0x40000; static final int YAFFS_NCHECKPOINT_OBJECTS = 5000; static final int YAFFS_CHECKPOINT_VERSION = 2; /*#ifdef CONFIG_YAFFS_UNICODE #define YAFFS_MAX_NAME_LENGTH 127 #define YAFFS_MAX_ALIAS_LENGTH 79 #else*/ static final int YAFFS_MAX_NAME_LENGTH = 255; static final int YAFFS_MAX_ALIAS_LENGTH = 159; /*#endif*/ static final int YAFFS_SHORT_NAME_LENGTH = 15; /* Some special object ids for pseudo objects */ static final int YAFFS_OBJECTID_ROOT = 1; static final int YAFFS_OBJECTID_LOSTNFOUND = 2; static final int YAFFS_OBJECTID_UNLINKED = 3; static final int YAFFS_OBJECTID_DELETED = 4; /* Sseudo object ids for checkpointing */ static final int YAFFS_OBJECTID_SB_HEADER = 0x10; static final int YAFFS_OBJECTID_CHECKPOINT_DATA = 0x20; static final int YAFFS_SEQUENCE_CHECKPOINT_DATA = 0x21; /* */ static final int YAFFS_MAX_SHORT_OP_CACHES = 20; static final int YAFFS_N_TEMP_BUFFERS = 4; /* Sequence numbers are used in YAFFS2 to determine block allocation order. * The range is limited slightly to help distinguish bad numbers from good. * This also allows us to perhaps in the future use special numbers for * special purposes. * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years, * and is a larger number than the lifetime of a 2GB device. */ static final long YAFFS_LOWEST_SEQUENCE_NUMBER = 0x00001000l; static final long YAFFS_HIGHEST_SEQUENCE_NUMBER = 0xEFFFFF00l; /* Stuff used for extended tags in YAFFS2 */ //typedef enum { static final int YAFFS_ECC_RESULT_UNKNOWN = 0; static final int YAFFS_ECC_RESULT_NO_ERROR = 1; static final int YAFFS_ECC_RESULT_FIXED = 2; static final int YAFFS_ECC_RESULT_UNFIXED = 3; //} yaffs_ECCResult; //typedef enum { static final int YAFFS_OBJECT_TYPE_UNKNOWN = 0; static final int YAFFS_OBJECT_TYPE_FILE = 1; static final int YAFFS_OBJECT_TYPE_SYMLINK = 2; static final int YAFFS_OBJECT_TYPE_DIRECTORY = 3; static final int YAFFS_OBJECT_TYPE_HARDLINK = 4; static final int YAFFS_OBJECT_TYPE_SPECIAL = 5; //} yaffs_ObjectType; /*Special structure for passing through to mtd */ /*struct yaffs_NANDSpare { yaffs_Spare spare; int eccres1; int eccres2; };*/ /* Block data in RAM */ //typedef enum { static final int YAFFS_BLOCK_STATE_UNKNOWN = 0; static final int YAFFS_BLOCK_STATE_SCANNING = 1; static final int YAFFS_BLOCK_STATE_NEEDS_SCANNING = 2; /* The block might have something on it (ie it is allocating or full, perhaps empty) * but it needs to be scanned to determine its true state. * This state is only valid during yaffs_Scan. * NB We tolerate empty because the pre-scanner might be incapable of deciding * However, if this state is returned on a YAFFS2 device, then we expect a sequence number */ static final int YAFFS_BLOCK_STATE_EMPTY = 3; /* This block is empty */ static final int YAFFS_BLOCK_STATE_ALLOCATING = 4; /* This block is partially allocated. * At least one page holds valid data. * This is the one currently being used for page * allocation. Should never be more than one of these */ static final int YAFFS_BLOCK_STATE_FULL = 5; /* All the pages in this block have been allocated. */ static final int YAFFS_BLOCK_STATE_DIRTY = 6; /* All pages have been allocated and deleted. * Erase me, reuse me. */ static final int YAFFS_BLOCK_STATE_CHECKPOINT = 7; /* This block is assigned to holding checkpoint data. */ static final int YAFFS_BLOCK_STATE_COLLECTING = 8; /* This block is being garbage collected */ static final int YAFFS_BLOCK_STATE_DEAD = 9; /* This block has failed and is not in use */ //} yaffs_BlockState; /*------------------------ Object -----------------------------*/ /* An object can be one of: * - a directory (no data, has children links * - a regular file (data.... not prunes :->). * - a symlink [symbolic link] (the alias). * - a hard link */ /* Function to manipulate block info */ static /*Y_INLINE*/ yaffs_BlockInfo yaffs_GetBlockInfo(yaffs_Device dev, int blk) { if (blk < dev.internalStartBlock || blk > dev.internalEndBlock) { T(YAFFS_TRACE_ERROR, TSTR ("**>> yaffs: getBlockInfo block %d is not valid" + TENDSTR), blk); yaffs2.utils.Globals.portConfiguration.YBUG(); } return dev.blockInfo[blk - dev.internalStartBlock]; } /*----------------------- YAFFS Functions -----------------------*/ // public static int yaffs_GutsInitialise(yaffs_Device dev); // public static void yaffs_Deinitialise(yaffs_Device dev); // // public static int yaffs_GetNumberOfFreeChunks(yaffs_Device dev); // // public static int yaffs_RenameObject(yaffs_Object oldDir, byte[] oldName, // yaffs_Object newDir, byte[] newName); // // public static int yaffs_Unlink(yaffs_Object dir, byte[] name); // public static int yaffs_DeleteFile(yaffs_Object obj); // // int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize); // int yaffs_GetObjectFileLength(yaffs_Object * obj); // int yaffs_GetObjectInode(yaffs_Object * obj); // unsigned yaffs_GetObjectType(yaffs_Object * obj); // int yaffs_GetObjectLinkCount(yaffs_Object * obj); // // int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr); // int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr); // // /* File operations */ // int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset, // int nBytes); // int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset, // int nBytes, int writeThrough); // int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize); // // yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name, // __u32 mode, __u32 uid, __u32 gid); // int yaffs_FlushFile(yaffs_Object * obj, int updateTime); // // /* Flushing and checkpointing */ // void yaffs_FlushEntireDeviceCache(yaffs_Device *dev); // // int yaffs_CheckpointSave(yaffs_Device *dev); // int yaffs_CheckpointRestore(yaffs_Device *dev); // // /* Directory operations */ // yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name, // __u32 mode, __u32 uid, __u32 gid); // yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name); // int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir, // int (*fn) (yaffs_Object *)); // // yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number); // // /* Link operations */ // yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name, // yaffs_Object * equivalentObject); // // yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj); // // /* Symlink operations */ // yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name, // __u32 mode, __u32 uid, __u32 gid, // const YCHAR * alias); // YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj); // // /* Special inodes (fifos, sockets and devices) */ // yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name, // __u32 mode, __u32 uid, __u32 gid, __u32 rdev); // // /* Special directories */ // yaffs_Object *yaffs_Root(yaffs_Device * dev); // yaffs_Object *yaffs_LostNFound(yaffs_Device * dev); // // #ifdef CONFIG_YAFFS_WINCE // /* CONFIG_YAFFS_WINCE special stuff */ // void yfsd_WinFileTimeNow(__u32 target[2]); // #endif // // #ifdef __KERNEL__ // // void yaffs_HandleDeferedFree(yaffs_Object * obj); // #endif // // /* Debug dump */ // int yaffs_DumpObject(yaffs_Object * obj); // // void yaffs_GutsTest(yaffs_Device * dev); // // /* A few useful functions */ // void yaffs_InitialiseTags(yaffs_ExtendedTags * tags); // void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn); // int yaffs_CheckFF(__u8 * buffer, int nBytes); // void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi); } 1.1 jop/java/target/src/common/yaffs2/port/Template.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/Template.java?rev=1.1&content-type=text/x-cvsweb-markup Index: Template.java =================================================================== package yaffs2.port; import yaffs2.utils.*; import yaffs2.assertions.*; import yaffs2.port.*; import static yaffs2.utils.Utils.*; import static yaffs2.utils.Constants.*; import static yaffs2.assertions.Assert.*; import static yaffs2.utils.Unix.*; import static yaffs2.port.yaffs_ObjectHeader.*; import static yaffs2.port.Guts_H.*; import static yaffs2.port.yaffs_BlockInfo.*; import static yaffs2.port.yaffs_Spare.*; import static yaffs2.port.yaffs_ExtendedTags.*; import static yaffs2.port.yaffs_Tags.*; import static yaffs2.port.yaffs_ChunkCache.*; import static yaffs2.port.CFG_H.*; import static yaffs2.port.yaffsfs_DeviceConfiguration.*; import static yaffs2.port.ECC_C.*; import static yaffs2.port.yaffs_ECCOther.*; import static yaffs2.port.yportenv.*; import static yaffs2.port.ydirectenv.*; import static yaffs2.port.yaffs_tagsvalidity_C.*; import static yaffs2.port.yaffs_tagscompat_C.*; /** * Copy the imports above to avoid a lot of typing. * XXX Add new classes. * @author Peter Hilber (peter.hilber@s...) * */ public class Template { public static void main(String[] args) { } } 1.1 jop/java/target/src/common/yaffs2/port/devextras.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/devextras.java?rev=1.1&content-type=text/x-cvsweb-markup Index: devextras.java =================================================================== package yaffs2.port; public class devextras { /* * 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@a...> * * 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. */ /* * This file is just holds extra declarations used during development. * Most of these are from kernel includes placed here so we can use them in * applications. * */ /*#if defined WIN32 #define __inline__ __inline #define new newHack #endif*/ //#if !(defined __KERNEL__) || (defined WIN32) /* User space defines */ /*typedef unsigned char __u8; typedef unsigned short __u16; typedef unsigned __u32;*/ /* * Simple doubly linked list implementation. * * Some of the internal functions ("__xxx") are useful when * manipulating whole lists rather than single entries, as * sometimes we already know the next/prev entries and we can * generate better code by using them directly rather than * using the generic single-entry routines. */ // #define prefetch(x) 1 // PORT Removed. // #define LIST_HEAD_INIT(name) { &(name), &(name) } static list_head LIST_HEAD_INIT(Object list_entry) { list_head result = new list_head(list_entry); INIT_LIST_HEAD(result); return result; } // #define LIST_HEAD(name) \ // struct list_head name = LIST_HEAD_INIT(name) // PORT list_head example = LIST_HEAD_INIT(); static void INIT_LIST_HEAD(list_head ptr) { (ptr).next = (ptr); (ptr).prev = (ptr); } /* * Insert a new entry between two known consecutive entries. * * This is only for internal list manipulation where we know * the prev/next entries already! */ static /*__inline__*/ void __list_add(list_head _new, list_head prev, list_head next) { next.prev = _new; _new.next = next; _new.prev = prev; prev.next = _new; } /** * list_add - add a new entry * @new: new entry to be added * @head: list head to add it after * * Insert a new entry after the specified head. * This is good for implementing stacks. */ static /*__inline__*/ void list_add(list_head _new, list_head head) { __list_add(_new, head, head.next()); } /** * list_add_tail - add a new entry * @new: new entry to be added * @head: list head to add it before * * Insert a new entry before the specified head. * This is useful for implementing queues. */ static /*__inline__*/ void list_add_tail(list_head _new, list_head head) { __list_add(_new, head.prev(), head); } /* * Delete a list entry by making the prev/next entries * point to each other. * * This is only for internal list manipulation where we know * the prev/next entries already! */ static /*__inline__*/ void __list_del(list_head prev, list_head next) { next.prev = prev; prev.next = next; } /** * list_del - deletes entry from list. * @entry: the element to delete from the list. * Note: list_empty on entry does not return true after this, the entry is * in an undefined state. */ static /*__inline__*/ void list_del(list_head entry) { __list_del(entry.prev(), entry.next()); } /** * list_del_init - deletes entry from list and reinitialize it. * @entry: the element to delete from the list. */ static /*__inline__*/ void list_del_init(list_head entry) { __list_del(entry.prev(), entry.next()); INIT_LIST_HEAD(entry); } /** * list_empty - tests whether a list is empty * @head: the list to test. */ static /*__inline__*/ boolean list_empty(list_head head) { return head.next == head; } /** * list_splice - join two lists * @list: the new list to add. * @head: the place to add it in the first list. */ static /*__inline__*/ void list_splice(list_head list, list_head head) { list_head first = list.next(); if (first != list) { list_head last = list.prev(); list_head at = head.next(); first.prev = head; head.next = first; last.next = at; at.prev = last; } } /** * list_entry - get the struct for this entry * @ptr: the &struct list_head pointer. * @type: the type of the struct this is embedded in. * @member: the name of the list_struct within the struct. */ // #define list_entry(ptr, type, member) \ // ((type *)((char *)(ptr)-(unsigned long)(&((type *)0).member))) // PORT Introduced list_entry field in list_head, which gives the same // result as this macro. /** * list_for_each - iterate over a list * @pos: the &struct list_head to use as a loop counter. * @head: the head for your list. */ // #define list_for_each(pos, head) \ // for (pos = (head).next, prefetch(pos.next); pos != (head); \ // pos = pos.next, prefetch(pos.next)) // PORT The corresponding code was inserted where this macro has been used. // PORT prefetch() doesnt do anything, so it was omitted. /** * list_for_each_safe - iterate over a list safe against removal * of list entry * @pos: the &struct list_head to use as a loop counter. * @n: another &struct list_head to use as temporary storage * @head: the head for your list. */ // #define list_for_each_safe(pos, n, head) \ // for (pos = (head).next, n = pos.next; pos != (head); \ // pos = n, n = pos.next) // PORT The corresponding code was inserted where this macro has been used. /* * File types */ static final int DT_UNKNOWN = 0; static final int DT_FIFO = 1; static final int DT_CHR = 2; static final int DT_DIR = 4; static final int DT_BLK = 6; static final int DT_REG = 8; static final int DT_LNK = 10; static final int DT_SOCK = 12; static final int DT_WHT = 14; /*#ifndef WIN32 #include <sys/stat.h> #endif*/ /* * Attribute flags. These should be or-ed together to figure out what * has been changed! */ static final int ATTR_MODE = 1; static final int ATTR_UID = 2; static final int ATTR_GID = 4; static final int ATTR_SIZE = 8; static final int ATTR_ATIME = 16; static final int ATTR_MTIME = 32; static final int ATTR_CTIME = 64; static final int ATTR_ATIME_SET = 128; static final int ATTR_MTIME_SET = 256; static final int ATTR_FORCE = 512; /* Not a change, but a change it */ static final int ATTR_ATTR_FLAG = 1024; /*#define KERN_DEBUG #else #ifndef WIN32 #include <linux/types.h> #include <linux/list.h> #include <linux/fs.h> #include <linux/stat.h> #endif #endif #if defined WIN32 #undef new #endif*/ } 1.1 jop/java/target/src/common/yaffs2/port/devextrasEnumeration.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/devextrasEnumeration.java?rev=1.1&content-type=text/x-cvsweb-markup Index: devextrasEnumeration.java =================================================================== package yaffs2.port; public class devextrasEnumeration { /** * list_for_each - iterate over a list * @pos: the &struct list_head to use as a loop counter. * @head: the head for your list. */ // XXX #define list_for_each(pos, head) \ // for (pos = (head).next, prefetch(pos.next); pos != (head); \ // pos = pos.next, prefetch(pos.next)) public abstract class enumerate { public abstract void callback(list_head pos); public void list_for_each(list_head head) { list_head pos; for (pos = head.next/*, prefetch(pos.next)*/; pos != head; pos = pos.next/*, prefetch(pos.next)*/) { callback(pos); } } } /** * list_for_each_safe - iterate over a list safe against removal * of list entry * @pos: the &struct list_head to use as a loop counter. * @n: another &struct list_head to use as temporary storage * @head: the head for your list. */ // XXX #define list_for_each_safe(pos, n, head) \ // for (pos = (head).next, n = pos.next; pos != (head); \ // pos = n, n = pos.next) } 1.1 jop/java/target/src/common/yaffs2/port/iattr.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/iattr.java?rev=1.1&content-type=text/x-cvsweb-markup Index: iattr.java =================================================================== package yaffs2.port; public class iattr { //struct iattr { /*unsigned int*/ int ia_valid; /*unsigned*/ int ia_mode; /*unsigned*/ int ia_uid; /*unsigned*/ int ia_gid; /*unsigned*/ int ia_size; /*unsigned*/ int ia_atime; /*unsigned*/ int ia_mtime; /*unsigned*/ int ia_ctime; /*unsigned int*/ int ia_attr_flags; //}; } 1.1 jop/java/target/src/common/yaffs2/port/list_head.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/list_head.java?rev=1.1&content-type=text/x-cvsweb-markup Index: list_head.java =================================================================== package yaffs2.port; import yaffs2.utils.*; public class list_head implements list_head_or_yaffs_Object { /** * PORT Since we can't do pointer arithmetic, we have to save the object the list_head belongs to. * @param owner */ public list_head(Object owner) // XXX check later if it should be reset somewhere (not in memset()!) { this.list_entry = owner; } /** * PORT Since we can't do pointer arithmetic, we have to save the object it belongs to. */ public Object list_entry; //struct list_head { public list_head_or_yaffs_Object next, prev; public list_head next() // XXX see if these typecasts will always succeed { return (list_head)next; } public list_head prev() // XXX see if these typecasts will always succeed { return (list_head)prev; } //}; } 1.1 jop/java/target/src/common/yaffs2/port/yaffs_BlockIndex.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/yaffs_BlockIndex.java?rev=1.1&content-type=text/x-cvsweb-markup Index: yaffs_BlockIndex.java =================================================================== package yaffs2.port; public class yaffs_BlockIndex { // typedef struct { /**int*/ int seq; int block; //} yaffs_BlockIndex; } 1.1 jop/java/target/src/common/yaffs2/port/yaffs_BlockInfo.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/yaffs_BlockInfo.java?rev=1.1&content-type=text/x-cvsweb-markup Index: yaffs_BlockInfo.java =================================================================== package yaffs2.port; import yaffs2.utils.SerializableObject; import static yaffs2.utils.Utils.*; public class yaffs_BlockInfo extends yaffs2.utils.SerializableObject { // int softDeletions:10; /* number of soft deleted pages */ // int pagesInUse:10; /* number of pages in use */ // yaffs_BlockState blockState:4; /* One of the above block states */ // __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */ // /* and retire the block. */ // __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */ // __u32 gcPrioritise: 1; /* An ECC check or bank check has failed on this block. // It should be prioritised for GC */ // __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ // // #ifdef CONFIG_YAFFS_YAFFS2 // __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */ // __u32 sequenceNumber; /* block sequence number for yaffs2 */ //#endif public yaffs_BlockInfo(SerializableObject owner, int offset) { super(owner, offset); } public yaffs_BlockInfo(byte[] array, int offset) { super(array, offset); } public yaffs_BlockInfo() { super(SERIALIZED_LENGTH); } static final int SERIALIZED_LENGTH = 4+4; int softDeletions() { return byteAsUnsignedByte(serialized[offset+0]) | ((serialized[offset+1] & 0x3) << 8); } void setSoftDeletions(int value) { serialized[offset+0] = (byte)value; serialized[offset+1] = (byte)(serialized[offset+1] & ~0x3 | ((value & 0x3) >>> 8)); } int pagesInUse() { return (byteAsUnsignedByte(serialized[offset+1]) >>> 2) | ((serialized[offset+2] & 0xf ) << 2); } void setPagesInUse(int value) { serialized[offset+1] = (byte)(serialized[offset+1] & 0x3 | (value << 2)); serialized[offset+2] = (byte)(serialized[offset+2] & ~0xf | ((value & 0xf00) >>> 8)); } int blockState() { return (byteAsUnsignedByte(serialized[offset+2]) >>> 4); } void setBlockState(int value) { serialized[offset+2] = (byte)(serialized[offset+2] & ~0xF0 | (value << 4)); } boolean needsRetiring() { return (serialized[offset+3] & 0x1) != 0; } void setNeedsRetiring(boolean value) { serialized[offset+3] = (byte)(serialized[offset+3] & ~0x1 | (value ? 0x1 : 0)); } boolean skipErasedCheck() { return (serialized[offset+3] & 0x2) != 0; } void setSkipErasedCheck(boolean value) { serialized[offset+3] = (byte)(serialized[offset+3] & ~0x2 | (value ? 0x2 : 0)); } boolean gcPrioritise() { return (serialized[offset+3] & 0x4) != 0; } void setGcPrioritise(boolean value) { serialized[offset+3] = (byte)(serialized[offset+3] & ~0x4 | (value ? 0x4 : 0)); } int chunkErrorStrikes() { return (serialized[offset+3] >>> 3) & 0x7; } void setChunkErrorStrikes(int value) { serialized[offset+3] = (byte)(serialized[offset+3] & (~0x7 << 3) | ((value & 0x7) << 3)); } //#ifdef CONFIG_YAFFS_YAFFS2 /*__u32*/ boolean hasShrinkHeader() /* This block has at least one shrink object header */ { return ((serialized[offset+3] >>> 6) & 0x1) != 0; } void setHasShrinkHeader(boolean value) { serialized[offset+3] = (byte)(serialized[offset+3] & ~0x40 | (value ? 0x40 : 0)); } // XXX PORT may be larger than Integer.MAX_VALUE, which causes sign extension for longs! // XXX check every invocation /*__u32*/ int sequenceNumber() /* block sequence number for yaffs2 */ { return yaffs2.utils.Utils.getIntFromByteArray(serialized, offset+4); } void setSequenceNumber(/*__u32*/ int value) { yaffs2.utils.Utils.writeIntToByteArray(serialized, offset+4, value); } //#endif @Override public int getSerializedLength() { return SERIALIZED_LENGTH; } } 1.1 jop/java/target/src/common/yaffs2/port/yaffs_CheckpointDevice.java http://www.opencores.org/cvsweb.shtml/jop/java/target/src/common/yaffs2/port/yaffs_CheckpointDevice.java?rev=1.1&content-type=text/x-cvsweb-markup Index: yaffs_CheckpointDevice.java =================================================================== package yaffs2.port; import yaffs2.utils.*; import static yaffs2.utils.Utils.*; public class yaffs_CheckpointDevice extends SerializableObject { static final int SERIALIZED_LENGTH = 10*4; public yaffs_CheckpointDevice() { super(SERIALIZED_LENGTH); } /* The CheckpointDevice structure holds the device information that changes at runtime and * must be preserved over unmount/mount cycles. */ //typedef struct { int structType() { return getIntFromByteArray(serialized, offset+0); } void setStructType(int value) { writeIntToByteArray(serialized, offset+0, value); } int nErasedBlocks() { return getIntFromByteArray(serialized, offset+4); } void setNErasedBlocks(int value) { writeIntToByteArray(serialized, offset+4, value); } int allocationBlock() /* Current block being allocated off */ { return getIntFromByteArray(serialized, offset+8); } void setAllocationBlock(int value) { writeIntToByteArray(serialized, offset+8, value); } /**__u32*/ int allocationPage() { return getIntFromByteArray(serialized, offset+12); } void setAllocationPage(int value) { writeIntToByteArray(serialized, offset+12, value); } int nFreeChunks() { return getIntFromByteArray(serialized, offset+16); } void setNFreeChunks(int value) { writeIntToByteArray(serialized, offset+16, value); } int nDeletedFiles() /* Count of files awaiting deletion;*/ { return getIntFromByteArray(serialized, offset+20); } void setNDeletedFiles(int value) { writeIntToByteArray(serialized, offset+20, value); } int nUnlinkedFiles() /* Count of unlinked files. */ { return getIntFromByteArray(serialized, offset+24); } void setNUnlinkedFiles(int value) { writeIntToByteArray(serialized, offset+24, value); } int nBackgroundDeletions() /* Count of background deletions. */ { return getIntFromByteArray(serialized, offset+28); } void setNBackgroundDeletions(int value) { writeIntToByteArray(serialized, offset+28, value); } /* yaffs2 runtime stuff */ // XXX check conversion /**unsigned*/ int sequenceNumber() /* Sequence number of currently allocating block */ { return getIntFromByteArray(serialized, offset+32); } /**@param value unsigned*/ void setSequenceNumber(int value) { writeIntToByteArray(serialized, offset+32, value); } /**unsigned*/ int oldestDirtySequence() // XXX check conversion { return getIntFromByteArray(serialized, offset+36); } /**@param value unsigned*/ void setOldestDirtySequence(int value) { writeIntToByteArray(serialized, offset+36, value); } @Override public int getSerializedLength() { return SERIALIZED_LENGTH; } //} yaffs_CheckpointDevice; } 1.1 jop/java/target/src/common/yaffs2/port/yaffs_CheckpointObject.java