From cefeada5db633fd3c37cde66e2e62c73052c18bd Mon Sep 17 00:00:00 2001
From: aleph1 <aleph1>
Date: Mon, 20 May 2002 17:41:34 +0000
Subject: [PATCH] Initial revision

---
 Documentation/sv9349341.gif             |  Bin 0 -> 4150 bytes
 Documentation/sv9929930.gif             |  Bin 0 -> 4870 bytes
 Documentation/taffs-todo.html           |   34 +
 Documentation/tnode.drawing.sda         |  Bin 0 -> 33792 bytes
 Documentation/yaffs-0.3.html            |  504 ++++
 Documentation/yaffs-notes2.html         |  719 ++++++
 Documentation/yaffs_report20020211.html |   81 +
 Documentation/yaffs_report20020304.html |   57 +
 Makefile                                |   38 +
 devextras.h                             |  257 ++
 snMakefile                              |   79 +
 utils/Makefile                          |   34 +
 utils/mkyaffs                           |  Bin 0 -> 6382 bytes
 utils/mkyaffs.c                         |  150 ++
 yaffs-header.c                          |   13 +
 yaffs_fileem.c                          |  145 ++
 yaffs_fs.c                              |  879 +++++++
 yaffs_guts.c                            | 3079 +++++++++++++++++++++++
 yaffs_guts.h                            |  431 ++++
 yaffs_mtdif.c                           |  104 +
 yaffs_mtdif.h                           |   29 +
 yaffs_nandemul.h                        |   34 +
 yaffs_ramem.c                           |  291 +++
 yaffs_super.c                           |  401 +++
 yaffsdev                                |  Bin 0 -> 93829 bytes
 yaffsdev.c                              |  303 +++
 yaffsdev.proj                           |  Bin 0 -> 28672 bytes
 yaffsinterface.h                        |   23 +
 yportenv.h                              |   56 +
 29 files changed, 7741 insertions(+)
 create mode 100644 Documentation/sv9349341.gif
 create mode 100644 Documentation/sv9929930.gif
 create mode 100644 Documentation/taffs-todo.html
 create mode 100644 Documentation/tnode.drawing.sda
 create mode 100644 Documentation/yaffs-0.3.html
 create mode 100644 Documentation/yaffs-notes2.html
 create mode 100644 Documentation/yaffs_report20020211.html
 create mode 100644 Documentation/yaffs_report20020304.html
 create mode 100644 Makefile
 create mode 100644 devextras.h
 create mode 100644 snMakefile
 create mode 100644 utils/Makefile
 create mode 100755 utils/mkyaffs
 create mode 100644 utils/mkyaffs.c
 create mode 100644 yaffs-header.c
 create mode 100644 yaffs_fileem.c
 create mode 100644 yaffs_fs.c
 create mode 100644 yaffs_guts.c
 create mode 100644 yaffs_guts.h
 create mode 100644 yaffs_mtdif.c
 create mode 100644 yaffs_mtdif.h
 create mode 100644 yaffs_nandemul.h
 create mode 100644 yaffs_ramem.c
 create mode 100644 yaffs_super.c
 create mode 100755 yaffsdev
 create mode 100644 yaffsdev.c
 create mode 100644 yaffsdev.proj
 create mode 100644 yaffsinterface.h
 create mode 100644 yportenv.h

diff --git a/Documentation/sv9349341.gif b/Documentation/sv9349341.gif
new file mode 100644
index 0000000000000000000000000000000000000000..4e8ea84fb64c598a7f2ccb424cdfc4af9f3960e7
GIT binary patch
literal 4150
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

literal 0
HcmV?d00001

diff --git a/Documentation/sv9929930.gif b/Documentation/sv9929930.gif
new file mode 100644
index 0000000000000000000000000000000000000000..0bb870a7638afe013784f92dfb3caf3b7255637c
GIT binary patch
literal 4870
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

literal 0
HcmV?d00001

diff --git a/Documentation/taffs-todo.html b/Documentation/taffs-todo.html
new file mode 100644
index 0000000..1a81f4c
--- /dev/null
+++ b/Documentation/taffs-todo.html
@@ -0,0 +1,34 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE></TITLE>
+	<META NAME="GENERATOR" CONTENT="StarOffice/5.2 (Linux)">
+	<META NAME="AUTHOR" CONTENT=" ">
+	<META NAME="CREATED" CONTENT="20020501;19062800">
+	<META NAME="CHANGEDBY" CONTENT=" ">
+	<META NAME="CHANGED" CONTENT="20020513;21165500">
+</HEAD>
+<BODY>
+<P>YAFFS Todo</P>
+<OL>
+	<LI><P>Locking</P>
+	<LI><P>Fix statfs. df does not give correct results.</P>
+	<LI><P>Fix disk full condition. 
+	</P>
+	<LI><P>ECC and write failure handling.</P>
+	<LI><P>Add symlinks and links to VFS interface.</P>
+	<LI><P>Add memory mapping (to allow file execution).</P>
+	<LI><P>Test with nandemul mtd.</P>
+	<LI><P>Discuss improved NAND page interface with mtd group.</P>
+</OL>
+<P>NANDEmul MTD</P>
+<OL>
+	<LI><P>Complete and test.</P>
+	<LI><P></P>
+	<P></P>
+</OL>
+<P><BR><BR>
+</P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/Documentation/tnode.drawing.sda b/Documentation/tnode.drawing.sda
new file mode 100644
index 0000000000000000000000000000000000000000..13f1465c277951dc8b4fa8f9112d0608c268cbe6
GIT binary patch
literal 33792
zcmeI534GPXwfN`WJ6Q<J4Xc0x7Z7ihi0q3iU=UE2NKmi15lDb&NH7G&N^SgC-?Oc+
zuXUkS6w#t0YQ?G*7ZmNHt=iH)_1ULwZL9Ag?$%aCAph@~`Tg$i{*vD>xg^F<-zx*>
zcjum&Ip@ronKNgW-_4F+cYpoX`}_Y%H3`S4nA+FaN#$nXBgBt)zZWVMB`&yqjg5^i
zn&^S>zeodn9a*IfHI10#v}Ycl`9LS20O$;K0lEU+fH*)GP~CwZKu@3-&>QFj90c?Q
z`T_lcgMmYU0l+|D5Rd={14DqJz@fk};4mNw6aj|=M*t#UF`q{QBY>lTk-#WmG%yAj
z3ycHC0~3IWz$D;k;27Xo;5a~Noxta0C+?`=pYmg#s^wojZ81&N@L8uWK`YsZKJ=JO
z#br}6(_UngzqLFE_<I^?O;?hhseg&P;EsQ>`Pq(tw`|k#FZcuDA729zdP58YFOqJ^
z`NoKCSN^8^H+HCo!{69)zu5nhy7G&wYL*(iUshjUC*Kp}Mu_P(f%#wDfHnsTM}FDZ
zSW16c_-#yn?S4{<tFk4lOKKOdT3%UGKeJ{@EfZB2ypo7Yv>dLxbW~*i-%2A9)pEYX
z^<>;rU4dM!WL$O1$Byu=WNa<DRZbmFpfv{n=;`g&V0$Z=tE4X`M*8RkO6BAnm37Y1
zS?3(ndQR!E?nu~qWiKUDfCO=s7@3UjfRKqTQ1hphol-oqcvSI>0yRn^Bjrm#u|U*5
zRt}l;+)RRd{mNTD`fTp9!n?nluZAZd_?;M?PXX~m#V=h3h;LdCh=1Auh<|!DAbGwI
zhz;8aNX51QGPgYr$o%#!ApY))Kn!>t5M%ZZAU>+Z#iyJMsD789Ahb<<>n|P>l*AiO
z+i~v0>z|64_{Kk-y_~pPHbHvRxLa4j?@yfU9TFaUEQ;+H(vh2bsY0f4jc=ctyQ;pT
z@}imbmCH+OYpYe?80Z8r3Oz;C&RAUUjJ*}x6?;4OPVC*-d$IRpAH+V4eH8m^?Bm$q
zVt<c)68kjvS!{Rg^Vpu)-dJbdMR(QRbX*te?z)HWse9?(x{p3c_tpJ$e|@k%L`R`|
zcpz1e&c0Z#&eQq2lP=KN&>Wx-(@9;V57$TN;ksBKsYmFe^hiBkPtX(fBz?3#MxUln
z*JtRIK2tByXX&%`IXZ?UivuMItKYs@BMOS>sE%o^bA0t0pa<$fI-v*aA$q7jR1XW0
zX_OwV$LO(ooKL!A^>O-meS)5>r|7BrL|vk%>67$yJwwmbC+k!6EInJ#(Q|dFK2^`t
zWqN)<ea_YA>4mynFVc&3g|5^~^isV{SLyTh1-e=<*EPCUuh19jI=xcYYfbIz+g1Dh
zZKHoY{amN7*K76n^!N1*`bND@-=uHW>-8;qgT7Up)o%sk<vrjXhVU8PF)}07*{Ybq
z^GI?hBZU8q?|ckIR9(my8C2qu$f7yL>N(X*sYjD<*__2TXGGm=az@D`&X|;nm?gD+
zQpA*fEV+w(m@`(v!Xc*qm@X$JB5Ex;qkPJ;*l=S#o<g3-lW&s~i4!izo?;b+mgU$W
z-)xy}$#=-h|Mf1HhfH3-bP>$wl)Adwi$!3OLacFS5GyA^gm>d2T1GJ;TOoOzAV&E+
z2<Zklo|(tgirs`%nNm+A-?fr%b|t+)Y&sgq)ML9@21xx?S42K{JK&<^yM)X<X{pas
z>dEALR_b&s-tI_UOx>jwAEyGsRP>SAirbU#H!1l?Q!=L9l2SrSiVT@0pGtl}Nywr(
z+c!I#-90eEFk<r3ho4S<NIt|MF8LyAgqu&Ye1w@d$uzbkD>Z}Uzhe4@igW>sJs0f9
zOb7nF^<e+T6ye8y6YSraHvHHPU_W6h@ne4s_EV-8KlXXB4<>hmr8;yqTfz6h${a6}
z6%sR5q%%I0{G6Ql0PAedTy>>51X4CV6t-?{Y&11WV;TseST|2&<MYqoa6`=a4ra(U
z$g{Cg_~ojp)vGEK6Xd&UP)exfg3nXa>nba2+=Szfd;9I<jx%B<5RW07DgjOhYLxnM
za*tIiJ6g6SUiFKKC=!H;y9GO%abICZlu&&*xz{SH$fXd^mlElU$`^tRPzh3IYjPi4
z$uT72a6L}EEnk_bvoA7ql)8u%h^xsCM6f4iCDhbO2W?a@pFagAJNVV-zFRi4;3p%y
ze0<-^tN(r5n`iIr{FS#3+M_OS>{+mR?bz|xFSv4Q&A@dNSNHw5?>=+*s2@Fl-2)?z
z-FfGAQ-{C5;rS~zb&mhxwqK7OdGw09yd?!U{_Df<uDS63clP}Gm*-rzZTO5oy?y;<
zYd$z5=iQSY@BhK&yLZnX^x>lIe_uav!@fUXUi!PqyUX{~K7Zm*uf6=0v$j2Z>sKDn
zAAi|tm%jSPuOGX4+e;_huKs1u+T2T@tlM+k@L%oy<m2zHd2rL->z^EP*X%)WzWTL+
zt3P_+kT<92-EmOCYj@u-+G>=!Uphs)<DVhg(qdLKvCF|m@DcpjuY--^H~6tPfQ{ix
z__6na#l2{P{TbLCd=CHMdlhW1&TW$SL$G;xP=303A~{}_A3FeSCp;}bb`018ye~g?
zCfLq+WPa><V7uV?`LV0OcEua?W4{Hq8y=z`dn?#DUZWrTFxWyoNk8@lu-)-4{n)>N
z?SaSX$9@L3Ctj!@8)psC3(wS#9R{{H-l`va4A?$+uzu{RV2>#p4wliAwz3z3HFIeM
zOOdv+#rUHpU&0-kx0-xnvCL=|YeSGeb|jvwp)kbejjHENUhUZYsBe}SftTyg{aFjS
zkHRDN*Ww`7P9yP>{n#VHj?$x=U{3@)8qd|A_e`*3@MitkTCijBaQ)aT!H&c0^<&q8
z9gipM$KDTiCZ4Y!`wZBV@rKRf?j)<B9F-%hHAdjprSgoZDZ@nDQFZp=GC0ME+liqY
zqgQmCa=fI}VZ=u$bqe0Kza1wTie|7w(3D|@{94hhCi0v?zS;QYekqrOorACL$9^5`
zT>N)G_6D$}`1F44ePB<;&o@$Gu<eZS99UZ;k!T*P0Dq}BNiSn%V6fEDmWq+rV0cQo
z`K%oL<pzK~jn#zVmi7cDI^|6DPiN_5I$C<ZJ=Y}59BIsvRV<>O!4k_)ehoQOEW7;J
zYrvk#Qp}It1a<+-Ge7nTuxGJk^J8BGdp65BKXw<`b6DE>vEq-P$KuG3?E`ip3no9d
z7;HI<C_i>8*hMU?{MZ!O#Voe`*cz}EEWrHOE5KH=DDz`)1p65aXtU3;(KcG18X+!>
z>AIrb0v2kIB$awA_9)L?vB!A69ebSTJF#s%-;F)N^S#)UJl~IP=lMbGDV`t3p5|%&
z7%heh|42^ia?S7%nh}Ri9=j@0Lnmq|MAPkQ9F((Z!9~C_;47T?vFtVSZnE;`t3NpM
zM%3rAhmzPn>|a#vjy(u}!Q}8w2BM_oWZ;$B6Z<iF_QoFOxi7Yrr%3A3$uXygR$igz
z;`7OoNk7-h+aLLg0dcNQ2Qp+nf{g)VHb|3!fkBl6O(T`<!6LD6$0~TW7m5ka7}-WJ
zrRUqyIqIq=rA20~hU;UBl(GijnsV1fTiRGAKWz>!Q^(_1v&=VM>Q+lXSIy`_R!2H9
zW_QL1B@5JD@qS79CKCT3KAgB{v{2m`UwVX6H^pzFH{B91K!y$R$>{Rd_!OSE#Ygd!
z{7T&(AI$TP_(AAWXhsZ8r8dV0g1<XHfag8&zC7=ZAHws8@%}vB-ZL~)elee-X*S<d
z>y=u<c7y2^+udH#1!E$0h!~@7rH-0-ByDs>Yu2P&Gi=SCYj32LB{k~gw~K4RVD_Oa
zZ8DTRnWgf;=a^F3l!`b;(V94+9P#&-laXI~xb*HCpaHU25p$@#g3rys%RmGC#?y`~
zfX%>ffe(Q^2JZl13@{To4_F0!3wQ_+6SW@rEr7hL4^RwD1yVo_a0PH9um$)z@EY(D
zke|mI2N(;S3@ijL0<H#b1GWOc0^R_21BLm>4O9Tv0Na6=fp>r?K4D*A1W*Dj09FA1
z0=xo<U)u*L2Brcjpa%Fhuo3t<@EY(rAik1#M&bu81-=Sg3)}@f3A_Zn4Mdo+#mf+%
zLOclZ7dkOdZ38|B&O*_H=(Lc`SEb0XnK>jfbeJk+0*i6qU|L00{j{2;RW+6AEy|73
z9}}cja0MYkf4?t&OZ?XOZSfz(H^y&|-x0qvzA1iJd~^Kn_&xD^<M+pZ6n`KdCEo+&
z+t5PJA3|x1$^BqFrf!Zu7{58bKA?<8+m^5#9*jQ}H~nTj)mQ?o8$_K(axdcUu_)<?
z8<Bw)TGQ9qpIr6ck>sJLMyWhzh9JG2HaD>$=F|U>kyH#SU&;C0)bje3Hhm7A3<VO*
z{s5n5i^gEmj|Lk%5*mI!oAz$eTcm5ILr3w+&y()#g^uF0u+u{6&gsxme71JpN*DJ+
zNAW4_Rw(u;9Xg87vchF%9(Nga6rb%qwwu|lqxtmh-B&Itr9(&6XT?D)<Puamd{KP*
zJ7YE2KBSm>{Nan@d%!+ey|&k`9<UE>n~x6IhwSv$AAdo{YOsBfQ}1Ve2I7Ey$WTXv
zjR*Nd2mFWZ`d`y|;(-6qHobM6{~)^qVjmXJ*{!Yc))#B`d^vvqm&0eRdVNnvjN4Nj
zAI#I+roCT=KfYFN+S?KHU{HNJs{b{$4~at(9F=&XqvoR>i5&@#i>#|VX5HK{tYO%f
z!Dr+VBai3^J`31Kk)6FD|Di6Ep%V|&V<Cg1t@{tcXJ<^V(s-ex`0U8rk=6b~d+U>}
z-``$78`#bAv=-ja+so&wo>!TjT$fizwNJKosJ-<`9h{Pvl+vN2>N9!J<UwgBL^_I3
z(a@ry9l@u+*<+7#12<@Ya?{>a)V~K2R=+BC7u#wdhA<Ci>!-ArPqzD$?d7vD%l*mr
z^2yc?wU<w}{!n}QWV^m-FQ07vuJ-cDc7Jkz`N(^i=F$SULsE0{Io0Z-Qr|9AsUP-I
z>*DK}GdRg&K*~8Nw^v5ECx>h(rqB0}2W#)x%cyov%s895nKKc&A}+57OZlj}ikxyr
z{hde!B`Q?kJr!zojyafIonujg2DLA8-I;y&7|90n;z7}RD+yHXRfT&DPfm!8^aVw?
zaALx_)iL&RT8{e5Q6f{0oRKt0OoHF8WS)#f<WM7`1`jdkEX1-dD0IDoa^9LHM}I+k
zIWQ|xoq}~%)LfL8B}Xy9o~TB()9n#v>JdIaQfhK?0}aN${yeM3ZfbzMNo!u4@LC6i
zw6ZjmKq@MqRNSJTb<m(>MOo~$^cq?kCCj1g<Xl_ubx<6>NY%G?wx~^eD-`D!awT$E
zp@-rKKu&7=_V!ThqRYYlv;9023x-ahRuA-0`1S>$iiUb9-0;qzUP*c=JmxOaO&!Ta
z2y_)Emy5EWrc>Gum!eaqII2sD23awumIDpIwZI*KX!LpDj{urY<#5+1d28HUfc&QI
z#QEwuqg~kuu)>I1<(8)WljHi0DDSt#MUj%{W4_y4N)=`Z*<<Yrqh!&U<PrVnp;U>>
zKhw_4$>s*rXg(Q?sgnWc(!;3aZFXq&bB9(Ja>>v^CfO4d0>hI(Ky)1MBAY3uCYnt2
zJlM+GO-5hLGGmOUVAvzMv5ECqK$*eG+bxzHb|kMclt4B>j3E3DO5Op&voR5M2e~2~
znZ}}#95ugcc_rtWl5<e<PDXxLrG8}Tbx{+?NY2h`POJjFbjz{y(5^;_ak^etqr$&y
ziHQO)HL0S$_fT(Fl*bJU6O#_M%;b}P^{Sy)0OhAliO$d|H1y=n!YY%`D4T0DsUZNz
zuPM%VQ<DKv_<Z18U>Q&ctWoNOqD@V7bQ#k3OWp+*ZL?w&9mUiSz{*7fdJ&2i8<T5T
z^@I%U1|~OKGJLm6{iRdD=x9Ll?k34^WhVDc-a|6VX2C6`Q71jy+-opx>vB3Id2bUk
zBi($GrGN5=O_JwkCJ#&AXOpqQ!bPbnlFO1?nqa>Mc1ZI6CfMu29-RD96RaGTn`88~
zDB&L9WgtOEo(%jeJ?u?<_e-hP2H-_t7f{HL4IB-83Up%*I{`Qs_$qKa@KfL~z-K@l
zpL`hbghu94y2eA3+~fJ+rLef5*}A&zJu=GH)om}IY+c><@>!UrtJ_{a*}A&z<&&+e
z+g?7|y1MP<ldY@UUOw5ny6xqY?H0oR^6BqfuEXIpZfTb8ncoGq^Q1c`+W8PSAU*fl
zdC$&7cD~3pmT;uzQWvlixE#0^xJ9d2H%upjL`D}fS;-Hz$hD~9YQhY$##|AqsVJ|j
z$c!@|5T1BTeuSkxS4zE$ok15k!!AK~^d&`8Iew;Q?xOQ67uP2)uBu;_D3^EEJY@tV
zTAe(JPVyX`$OT*XVys-S#fji*Z6xDrt!P_94<E0U%gQS<nFXa<ZrkBzFN@+#o3{fp
zFN<2*Ju_+7uBuNgsj9B_Y7&@isXqmE-U&0;Wi2hO=2xz+_X^wZHuuxymN#<cGH_;@
zPNqy^QEkN~Ucn5cE&UTp%UiTwX}MHt(?mbQ*U(6uziMUulB!BBCb~T{DAktyX)~&F
zdDYc=cXd)#-OBnzHJ1VtRW%j-9E3+SAkotN88qdMS5H#uj}dcG)}<^XvA(*}qvjwi
zg`YQ*O6uzFT<6-dqrAc{#+H7D(w#E++l$c=b7eTQ7w`@qZ*{oWd+iln+lmgo(akuF
zwj7>?LuYe6JZdgoM?+~#&7-E~QFBE&lN+|hggiB)vb=&H1o7CVQI_8?nrT$78{4bO
zu151+Dj9n5aF)(5p_7xLnTV0e(#bK`lbcb?&_SA-qlM?7mK#DX*P$jCoL!pTR0%7O
znw3?xHHlgDD6hIrQ>?VlL*KO&Vjb+Yd21u=<#~4;N!z*S4ZYNi+U1p(&6<DN^lAn{
zW!<Wpr3qGw!T5dmHL}M1HJl24HIa6UnVHD;+nCW5ONqd%-T7Hv?Y6BQD97kP?5IHO
zXe;v$WR97hrHyRbTr%(E^r^s-V*;_kyvJBBze#h+F<f$-tL!b*Wo#gqVBTXbm*1wj
z<Qguy&L#X7xQq+r63ly?<?<hCE_sGaUh7=O2XYDKJ>GJ8G0i1ETP_m<xdii`V7a`M
z=F%x!E)xT}1oNI~xxAd_Qjjf|Nr7B~c~7!j{xi*`a{!mF>G8~rQCTfJrS1SX2utGy
zXvBRZ*uJPB<5)W$rG1T~>1!FC_han#NV7hzroOVS-U<|iwNm{asr+`ulPbrNY6Gv2
zba7rWX)0Tn{g5r5mTgXLebrYgYeXTgrW}-&>c5bxi%(bfb(W^wvwLC1j?w;URx_$Z
zHA^wO6}7mB7t~kECb=s}^HeL-E65c7Qjg`)Gl+`3Q6E6uQvDrNgFG(B*^tT5xFPJ>
zPF70#kQ<nrRxP4^tC8M|+kDchZs?(=mM^|wX<aSVO-Owg%c}xGSX)-=>4t)gva-GI
zQL=eOdN<@KnoxG_oQTaKE$N0%ir<$pjvA9)#uuAYW;i!^iKD&fC@;z)N7Nw`j2pbf
zF<vyI^cY)2W(zlX`Nn$DjM8Im5i$L4@bZoGq8X*f*&<@c-QeXL??p38kGDm{D7(SS
zH^GZ$l%8OVh=p~7mv5pM%_u$577=sl1~1<vFPc$$k}V>(FCEwhRQY&I^}r6`5d5H0
z;5uLzP=W{C0Q?y!#d}-}ya7yPzj{4zJWJG#Kmoqc3gBhn*nD1J0`fcYiV?6ISj#42
zFW#qE4Ll9J0d(OoXa-OZtOd3Me+3R>bNEc)YT!xWBVd>adLV>qprmegMWK3=9nhD7
zlWQwyV~ou&tIE%U6@4r}kf)UU8+dN~>Ti^p%>|dNEDvZng8XKNEHs0Hn-W!XrDsqm
z!tV>tx}?zjIxKd6)|4}+%{!0h+|%aEPY+5G`?xC7)k&Iq;wjVT%_(uy5~M}DyJ=Hw
z;@qih!P~Oz`?4S6q@Or<&ir|EXO+2$gGtmqoW$AFrj(sFZ`!PxbEcULvr7xrQ^-pX
zCCIWsRD*`pGu29+j&yQqC=-P2>{*4>LPAO1+(m`vSJcW*FR44kygvFV!$?Y8Q>4_C
z!^GOB1N8ZCxQR-dmmNc$rR)o5wNy41SXTJ<9AWuhF)NI3PGDK#D`kamc-cJ4rc&lD
zVm8hD<#g|!v$UW03m{e{wz5n3;Dj#{>6h*#&acdQu8Fr8qKlXy$`N(ZZTJkrN)8E)
zhAd4%15N^I8}MOL+y<1!lSaH0f|md{0N)ehRHA7EHh`4|jF|>>OKdxp5psTJFQ*Eo
z7D@8EZ{o^l$b8Q^gDPxF4V)9CepxGY4w;QYdu5|gS52PqE~e2iw~D(8by&siBe|*K
zGJCzmgB14%u%ftLMsbgFIP*Uk@^up#OCx<fkbI)K!9pe-BF!D=uanrTDIK=}XLz<k
zt4|+0b(EURx4+4OR)n9SKC!xL@db(c+QjnOiz*ZK%PJEqtE(z1n|bEixx}zOek|it
zUYE`>D^_+>onV_q#->b!QoBM^yVvO7&x}#(s_C3(ofA~Mq2!knarvnrc?LMUSCgf%
zDJ6%oiYzB44Q1<>BIeX@pjW?2-ibB!s}b)jv81+cd3k*RCtJ~o@+z8ZD(a3>dG~rh
z`X7hO`_cc*IHQDAMou_wu-|Ol?T4jHnU+A=ez=&J+Yei_z;rTb)00aI&5N=2_f*VJ
zB!xW8U`tSpZ6o%_*;ifJvK2dtyx9*rGCNh3ib`;;lvHv7ZzI}DzTV5LWNTKcX(c1h
zk3fag5VW0EhM{xmx)IZL#j|_!P<|_d0oqNBSF`ZG75UqLZEU=SL`!59G0!ZzM27Xm
zoeLx)bGW>kFJnON+jzTaQS(y{h2bQ;LFZ?BGR#Es@qOCNG@L{j(|Is^3#P|&=p3xB
zR%;qgB8+JX%>Emu;ce6^({K`&DRZ|If;!2yeU*BE4l*4fUK5w9S#UbZ&d(bgmw)2+
zG=F=!M7{>0R|1K&T8nTJVXE5*Gm-o|IBsoZ8crgN={+!e7^dGJ9Hy>TYZ^`>jOluq
zJqXkAHfoh=I0?(N<xV1ZDS8cKhB|`3u@GnkoKDgY1N19;P>>~YiEN=ZlLCpfT8nTJ
zVXAuxW+M4hhqjq%IEgT(zlT|0nErxV2CJ*pnue1IWBO~D^=`3^T4fqe!ZK~zN&H6O
zG%o7=iAin>1|Zk>a=dF&L;$&dCNH4Gm@Asi6yYSoYP|$z!gOAuC8jM-PvIoOnAX7T
zO_(mg^(zRisa#46ofE@JgfU$Rvp>VM(_w998crgN>EnlU{Q%3eshA%SYMWsXClSW<
z1(*rbM~-SU({K`DOkaZ8l`wsZ3yPcDR?~12VN9Qa+5dy-ig7J7ZJ{HDlL%va7i+cu
zVe{;KI@38gTFrws6#3!3H=KmW^abd8%cwhHI5W=gz;;*avL4M@np=xFkGY1a{E}*>
zak!WQg<&Kj;@?C7yM8*6n6rM;+#1L{+LsHLa+y7Id1Oyjm2(1Te{2g11b3+<Yr=o$
zyHqA>9P5Z^j>?Rq=??F0GB<gM2Icl{==gW@M;h2u10Md+{fSqmTJ!FWETCk(ACDJ5
zAJaO6xI3}>#fjrXK7kn5z;zEIH4pnOPQ!~q;@l7MTkw)UfZ@T0k)7xL;=Ir3k!8>5
z;YvOC#fWnzey6QfrgnDl<ru^{6|ZC$8Vc5qG}cd0KnzjNWqxcP_FFq+e-$Lo5JcEW
z-KEjKdZ@4o($0}^8v$II;1>25BhI(p2ok3oqQrrXgRJ8iEKYw?MLRp0Rer$?(>(0A
zc0PGONSx1MB-+V?(as^lCP+IslOo;tCYp5Y7b8wGaAaKu@s)`47!zDss5sk5eS?0}
z@2ECwCy|G9!UEkL=#T6S($0G7`!ni2k=@vE?cBx0cnP`IF>QR;^suJQ)oNpP5#ygB
z&aStD#QElt3}LkMC?|MZOfv*ERs~v_4#)iQZSKnQ>#h%Fh%;+fkT}!WRV+fBB-5m<
zfr9(ae_|-FVnl6ZdZ|I5%|ol&p(5(h-CkpT^R*yxe!?79MK|8c=fBZITyg%3m^b4+
z5T~<~`Ut`wOT#q}B91rX$<=iCnp{*}L0VxLiAW`>-i%kuH)qD{u1d?7vOic=V>S!9
zKbUd3sqNFBe_v@kz2YvKq5e32;1E4D56)_^H?zQw{|??VaEaVAmK9?l5m8Tzj(a!>
zO;OupR}u3zvwj0Jk$l^PHZu(;5ytd)FuNC~KRY^1U9HwMoJ1JY=U}!Orr~YWD${Th
zmTBf{kU0BDgfDt$)etp(U1HV=D5;a3)m*k3a!v9YhJw3&?Cz|F9b-(SMCSIf{C%93
zgY8GhQcn7jJ?slRsxZWjv?7^%*!O#<Z1V$!q34j~3o@$3;CcrNfwyNG$l^Ot$fOi0
zC)G0#v-swihaTR6LU~0+!ki_1iH8WijZ}zZ&(q|3ihE<mI~Al^O^^z-e29=r<w%~B
zc=j+9<xGeWjWsq-udJ!8t6H2WtuwcP1pTFkvgy<2l+K%<D6L&tU$(feYDK-DeIGVJ
zW;j*NQ48nexmUB3@vfYLUW3aZ74h&=wgM=Q6i2F8)XCR>+E7usq<mF%{dpIzs$3=W
z;6Gb%dRB|o?u3Pw9#m3y`o)E+lqi0dv0n|~aRE)-{_R|`YGg2n-15i2<hNP8KY1f@
zq2zuNHK7+zDLDljJgfW?4%Iwr_+d_PsW}JeTnvy`vh5$Q5vscZ`D77isNqmWUXwv>
zg4jXfkuZ52r28SoWZc^<lGO%o5Sc=FU2b%gin!4+UUaOAh@iq?vUz$1O1x;PSKw3?
zd71*eb=>lV;kt}go}g!I<xA>jWZX3gj-%3+{<5ai0jzq{GRR>(%H%1{EokzY{vh!K
z;s2TjzR17-EZwE)-;fQ`7Y0LZcgAo;oygyxUanSfYh#f*KPY>PxE}0*$s{Q>Wze*k
zIU|vUi3t(-R;#wp5(RM29IP2ELZhN5v5pc}z`IVZR8@fd74AwS&2m2FuW_%mnOb-b
zfxnDU9D=OtFZyELWkMN0O1@f^&<2auD%!#FoeB3P;93s}_)Al|I%vIwZ7caHd<mBS
z8PvZ9|D{%4oJE~&N&D>M=wH0)Y}=nX#QE(amwy?$zQkz0jK3;c$-iuLFA@xFL;H)Y
zf0-er#e*v|dS9-}&EH;kHD5<tlp{qII;pW)1D{3kmz$USqkowai;QiT`qvxIC2%iC
r`%Qbom_V)`^3XQapIu)y{7{cZdt+|hvu%I*+vM%#nOXjSGyne&)_65v

literal 0
HcmV?d00001

diff --git a/Documentation/yaffs-0.3.html b/Documentation/yaffs-0.3.html
new file mode 100644
index 0000000..ae4b46c
--- /dev/null
+++ b/Documentation/yaffs-0.3.html
@@ -0,0 +1,504 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE></TITLE>
+	<META NAME="GENERATOR" CONTENT="StarOffice/5.2 (Linux)">
+	<META NAME="AUTHOR" CONTENT=" ">
+	<META NAME="CREATED" CONTENT="20011219;22024300">
+	<META NAME="CHANGEDBY" CONTENT=" ">
+	<META NAME="CHANGED" CONTENT="20020128;21063000">
+</HEAD>
+<BODY>
+<H1 ALIGN=CENTER>YAFFS (yet another Flash File System)</H1>
+<H4 ALIGN=LEFT>Version 0.3<BR>Charles Manning (and Wookey), December 2001</H4>
+<P ALIGN=LEFT><BR><BR>
+</P>
+<H2>Revision History</H2>
+<TABLE WIDTH=548 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=88>
+	<COL WIDTH=72>
+	<COL WIDTH=350>
+	<THEAD>
+		<TR>
+			<TH WIDTH=88 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">V0.0</P>
+			</TH>
+			<TH WIDTH=72 VALIGN=BOTTOM SDVAL="37245" SDNUM="5129;0;D/MM/YY">
+				<P ALIGN=LEFT STYLE="font-style: normal">20/12/01</P>
+			</TH>
+			<TH WIDTH=350 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">First draft</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR>
+			<TD WIDTH=88 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">V0.1</P>
+			</TD>
+			<TD WIDTH=72 VALIGN=BOTTOM SDVAL="37267" SDNUM="5129;0;D/MM/YY">
+				<P ALIGN=LEFT STYLE="font-style: normal">11/01/02</P>
+			</TD>
+			<TD WIDTH=350 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">Minor corrections &amp;
+				cosmetics.<BR>Change use of data status byte.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=88 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">V0.2</P>
+			</TD>
+			<TD WIDTH=72 VALIGN=BOTTOM SDVAL="37284" SDNUM="5129;0;D/MM/YY">
+				<P ALIGN=RIGHT STYLE="font-style: normal">28/01/02</P>
+			</TD>
+			<TD WIDTH=350 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">Added observations about
+				inodes, file headers and hard links.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=88 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">V0.3</P>
+			</TD>
+			<TD WIDTH=72 VALIGN=BOTTOM SDVAL="37285" SDNUM="5129;0;D/MM/YY">
+				<P ALIGN=RIGHT STYLE="font-style: normal">26/02/02</P>
+			</TD>
+			<TD WIDTH=350 VALIGN=TOP>
+				<P ALIGN=LEFT STYLE="font-style: normal">W:Added some general 
+				observations on compatibility, partitions and bootloading.</P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P ALIGN=LEFT><BR><BR>
+</P>
+<H2>Scope</H2>
+<P>The purpose of this document is to outline a potential
+NAND-friendly file system for Linux.</P>
+<H2>Background</H2>
+<P>There are already various flash-file systems (FFSs) or block
+drivers for flash (on top of which a regular FS runs). There are pros
+and cons with all of these. 
+</P>
+<P>Flash memory has quite a few constraints which will not be
+addressed here. Various approaches are available to work around these
+constraints to provide a file system. It is important to recognise
+that &quot;flash&quot; includes both NOR and NAND flash which have
+different sets of constraints. It is easy to be mislead by the
+generic term &quot;flash&quot; into thinking that approaches
+appropriate for NOR flash are immediately suitable for NAND flash.</P>
+<P>The NAND block drivers (eg. SmartMedia [currently not available
+for Linux] and DiskOnChip NFTL) typically use FAT16 as the file
+system. This isn't too robust and nor is it that flash-friendly.
+These block drivers provide a logical to physical mapping layer to
+emulate rewritable blocks that look like disk sectors. When used with
+FAT16, these file systems work reasonably well. They have a low
+memory footprint and scale well. Like all FAT based systems they are
+prone to corruption (&quot;lost clusters etc&quot;).</P>
+<P>The other approach is to design an entire file system which does
+not work through a block driver layer and is flash-friendly. This
+allows more scope to work around issues.</P>
+<P>Currently, two Linux file systems that support NOR flash very well
+are JFFS and its derivative JFFS2. Both of these are based on the
+principles of journaling (hence the leading J) which significantly
+increases robustness - a particularly important feature in embedded
+systems. Unfortunately neither of these file systems scale
+particularly well in both boot time and RAM usage. Scaling is
+particularly relevant when one considers that a 16MB NOR array would
+be considered large while a 128MB NAND is available as a single chip.</P>
+<P>JFFS requires a RAM-based jffs_node structure for each journalling
+node in the flash. Each of these nodes is 48 bytes. JFFS2 makes a
+significant improvement here by reducing the equivalent structure
+(jffs2_raw_node_ref) to 16 bytes. Still, at say an average node-size
+of 512 bytes, a 128MB NAND might need 250000 of these ... 4MB!</P>
+<P>Both JFFS and JFFS2 require scanning the flash array at boot time
+to find the journaling nodes and determine the file structures. Since
+NAND is large, slow, serially accessed and needs ECC this does not
+scale well and will take an unacceptably long boot time for the
+target systems. As a thumb-suck, the scanning of a 128MB NAND array
+might take approx 25 seconds.</P>
+<P>The intentions of the design sketched here are:</P>
+<UL>
+	<LI><P>Be NAND-flash friendly.</P>
+	<LI><P>Robustness through journaling strategies.</P>
+	<LI><P>Significantly reduce the RAM overheads and boot times
+	associated with JFFSx.</P>
+</UL>
+<p>This FS is intended primarily for internal NAND rather than removable NAND
+(SM cards). On removable SM cards Smartmedia compatibility is likely to be
+important so SM/FAT will normally be used, although of course YAFFS makes a
+lot of sense if reliability is more important than compatibility.</p>
+
+<H2>Overview</H2>
+<P>Here follows a simplified overview of YAFFS.</P>
+<P>YAFFS uses a physical flash format similar to SmartMedia. This is
+done for various reasons:</P>
+<UL>
+	<LI><P>Some of the formatting, eg placement of bad block markers is
+	determined by the NAND manufacturers and can't be changed.</P>
+	<LI><P>Potential to reuse code.</P>
+	<LI><P>If it ain't broke don't fix.</P>
+</UL>
+<P>Some of the fields are obviously different to reflect the
+different usage. Despite the similarities YAFFS is not actually compatible
+with SM/FAT. SM cards need to be reformatted to switch from using SM/FAT to
+YAFFS or vice versa.</P>
+<P>File data is stored in fixed size &quot;chunks&quot; consistent
+with the size of a page (ie. 512 bytes). Each page is marked with a
+file id and chunk number. These tags are stored in the &quot;spare
+data&quot; region of the flash. The chunk number is determined by
+dividing the file position by the chunk size.</P>
+<P>When data in a file is overwritten, the relevant chunks are
+replaced by writing new pages to flash containing the new data but
+the same tags. The overwritten data is marked as &quot;discarded&quot;.
+</P>
+<P>File &quot;headers&quot; are stored as a single page, marked so as
+to be differentiated from data pages.</P>
+<P>Pages are also marked with a short (2 bit) serial number that
+increments each time the page at this position is incremented. The
+reason for this is that if power loss/crash/other act of demonic
+forces happens before the replaced page is marked as discarded, it is
+possible to have two pages with the same tags. The serial number is
+used to arbitrate.</P>
+<P>A block containing only discarded pages (termed a <I>dirty block</I>)
+is an obvious candidate for garbage collection. Otherwise valid pages
+can be copied off a block thus rendering the whole block discarded
+and ready for garbage collection.</P>
+<P>In theory you don't need to hold the file structure in RAM... you
+could just scan the whole flash looking for pages when you need them.
+In practice though you'd want better file access times than that! The
+mechanism proposed here is to have a list of __u16 page addresses
+associated with each file. Since there are 2<SUP>18</SUP> pages in a
+128MB NAND, a __u16 is insufficient to uniquely identify a page but
+is does identify a group of 4 pages - a small enough region to search
+exhaustively. This mechanism is clearly expandable to larger NAND
+devices - within reason. The RAM overhead with this approach is
+approx 2 bytes per page - 512kB of RAM for a whole 128MB NAND.</P>
+<P>Boot-time scanning to build the file structure lists should
+require just one pass reading NAND. Since only the the spare data
+needs to be read, this should be relatively fast ( approx 3 seconds
+for 128MB). Improvements can be achieved by partitioning the NAND.
+ie. mount the critical partition first then mount the data partition
+afterwards.</P>
+<P>Various runtime improvements can be achieved by changing the
+&quot;chunk size&quot; to 1024 bytes or more. However this would
+likely reduce flash efficiency. As always, life is a compromise....</P>
+<P><BR><BR>
+</P>
+<H3>Spare area details</H3>
+<P>The following table summarizes the layout of the spare area of
+each page.</P>
+<TABLE WIDTH=674 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=96>
+	<COL WIDTH=249>
+	<COL WIDTH=291>
+	<THEAD>
+		<TR VALIGN=TOP>
+			<TH WIDTH=96>
+				<P>Byte #</P>
+			</TH>
+			<TH WIDTH=249>
+				<P>SmartMedia usage</P>
+			</TH>
+			<TH WIDTH=291>
+				<P>YAFFS usage</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR VALIGN=TOP>
+			<TD WIDTH=96>
+				<P>0..511</P>
+			</TD>
+			<TD WIDTH=249>
+				<P>Data</P>
+			</TD>
+			<TD WIDTH=291>
+				<P>Data. either file data or file header depending on tags</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=96>
+				<P>512..515</P>
+			</TD>
+			<TD WIDTH=249>
+				<P>Reserved</P>
+			</TD>
+			<TD WIDTH=291>
+				<P>Tags</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=96 VALIGN=BOTTOM SDVAL="516" SDNUM="5129;">
+				<P ALIGN=RIGHT>516</P>
+			</TD>
+			<TD WIDTH=249 VALIGN=TOP>
+				<P>Data status byte. Not used in SM code from Samsung</P>
+			</TD>
+			<TD WIDTH=291 VALIGN=TOP>
+				<P>Data status byte. If more than 4 bits are zero, then this page
+				is discarded.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=96 VALIGN=BOTTOM SDVAL="517" SDNUM="5129;">
+				<P ALIGN=RIGHT>517</P>
+			</TD>
+			<TD WIDTH=249 VALIGN=TOP>
+				<P>Block status byte</P>
+			</TD>
+			<TD WIDTH=291 VALIGN=TOP>
+				<P>Block status byte</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=96>
+				<P ALIGN=LEFT>518..519</P>
+			</TD>
+			<TD WIDTH=249>
+				<P>Block address</P>
+			</TD>
+			<TD WIDTH=291>
+				<P>Tags</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=96>
+				<P ALIGN=LEFT>520..522</P>
+			</TD>
+			<TD WIDTH=249>
+				<P>ECC on second 256 bytes part of data</P>
+			</TD>
+			<TD WIDTH=291>
+				<P>ECC on second 256 bytes of data</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=96>
+				<P ALIGN=LEFT>523..524</P>
+			</TD>
+			<TD WIDTH=249>
+				<P>Block address</P>
+			</TD>
+			<TD WIDTH=291>
+				<P>Tags</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=96>
+				<P ALIGN=LEFT>525..527</P>
+			</TD>
+			<TD WIDTH=249>
+				<P>ECC on first 256 bytes part of data</P>
+			</TD>
+			<TD WIDTH=291>
+				<P>ECC on first 256 bytes part of data</P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P><BR><BR>
+</P>
+<P>The block status is a reserved value that shows whether the block
+is damaged.</P>
+<P>The data status tracks whether the page is valid. If less than 4
+bits are zero, then the page is valid otherwise it is discarded.</P>
+<P>There are 8 bytes (64 bits) for use by YAFFS tags. This is
+partitioned as follows:</P>
+<TABLE WIDTH=596 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=146>
+	<COL WIDTH=423>
+	<THEAD>
+		<TR VALIGN=TOP>
+			<TH WIDTH=146>
+				<P>Number of bits</P>
+			</TH>
+			<TH WIDTH=423>
+				<P>Usage</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="18" SDNUM="5129;">
+				<P ALIGN=RIGHT>18</P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P>18-bit file id. ie. Limit of 2<SUP>18</SUP> (over 260000)
+				files. File id 0 is not valid and indicates a deleted page. File
+				Id 0x3FFFF i is also not valid.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="2" SDNUM="5129;">
+				<P ALIGN=RIGHT>2</P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P ALIGN=LEFT>2-bit serial number.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="20" SDNUM="5129;">
+				<P ALIGN=RIGHT>20</P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P>20-bit page id within file. Limit of 2<SUP>20</SUP> pages per
+				file. ie. over 500MB file max size. Page id 0 means the file
+				header for this file.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="10" SDNUM="5129;">
+				<P ALIGN=RIGHT>10</P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P>10-bit counter of the number of bytes used in the page.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="12" SDNUM="5129;">
+				<P ALIGN=RIGHT>12</P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P>12-bit ECC on tags.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="2" SDNUM="5129;">
+				<P ALIGN=RIGHT>2</P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P>Unused. Keep as 1.</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=146 VALIGN=BOTTOM SDVAL="64" SDNUM="5129;">
+				<P ALIGN=RIGHT><B>64</B></P>
+			</TD>
+			<TD WIDTH=423 VALIGN=TOP>
+				<P><B>Total</B></P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P><BR><BR>
+</P>
+<P>A bit of explanation on the usage of some of these fields:</P>
+<P>file Id is synonymous with inode.</P>
+<P>The serial number is incremented each time a page with the same
+file_id:page_id is rewritten (because of data changes or copy during
+garbage collection). When a page is replaced, there is a brief period
+during which there are two pages with the same id. The serial number
+resolves this. Since there should never be a difference of less than
+more than one, a two-bit counter is sufficient to determine which is
+the current page.</P>
+<P>When the page is rewritten, the file id, these data status byte
+and the 12-bit ECC are all written to zero.</P>
+<P>The byte counter indicates how many bytes are valid in this page.
+Since the page would not exist if it contains zero bytes, this field
+should thus hold 512 for all pages except the last page in the file.
+The use of counters means that the file length integrity is preserved
+while the file is open without having to constantly update the file
+length in the file header. The file header only needs to be refreshed
+when the file is closed (rather than whenever it is appended to).
+This field is wide enough to allow expansion to 1024-byte &quot;chunks&quot;.</P>
+<P>File &quot;headers&quot; come in two flavours:</P>
+<UL>
+	<LI><P>file info ( the mode, ower id, group id, length,...)</P>
+	<LI><P>the hard link(s) that refers to the file.</P>
+</UL>
+<P>A directory also appears as a file (ie. has an inode and hard
+link(s)) but has no data.</P>
+<P>The 12-bit ECC applies to only the tag data uses a similar
+algorithm to the 22-bit ECCs used for file system data. They are kept
+independent.</P>
+<H3>RAM data details</H3>
+<P>Block management details are reasonably obvious and, I feel, don't
+need to be addressed here apart from stating that there will be a
+structure to track block status (eg. number of pages in use, failed
+blocks, and which are candidates for garbage collection etc).</P>
+<P>The files need an indexing structure of sorts to locate and track
+the pages in the file. Some sort of tree structure should work rather
+well. The look-up needs to be quite efficient in both CPU time and
+space.</P>
+<H3>Page allocation and garbage collection</H3>
+<P>Pages are allocated sequentially from the currently selected
+block. When all the pages in the block are filled, another clean
+block is selected for allocation. At least two or three clean blocks
+are reserved for garbage collection purposes. If there are
+insufficient clean blocks available, then a dirty block ( ie one
+containing only discarded pages) is erased to free it up as a clean
+block. If no dirty blocks are available, then the dirtiest block is
+selected for garbage collection.</P>
+<P>Garbage collection is performed by copying the valid data pages
+into new data pages thus rendering all the pages in this block dirty
+and freeing it up for erasure. I also like the idea of selecting a
+block at random some small percentage of the time - thus reducing the
+chance of wear differences.</P>
+<P>Relative to NOR, NAND writes and erases very fast. Therefore
+garbage collection might be performed on-demand (eg. during a write)
+without significant degradation in performance. Alternatively garbage
+collection might be delegated to a kernel tasklet.</P>
+<P>Relative to JFFSx, the garbage collection presented here is
+incredibly simple - thanks mainly to the use of fixed-size pages
+instead of journaling nodes.</P>
+<H3>Flash writing</H3>
+<P>As presented here, YAFFS only writes to the page's data area once
+and to the spare area twice (once when new page is written and once when it
+gets stomped on) before an erasure. This is within the limits of the most
+restrictive NAND flashes.</P>
+
+<H3>Wear leveling</H3>
+<P>No wear leveling is explicitly used here. Instead we rely on two
+&quot;strategies&quot;:</P>
+<UL>
+	<LI><P>Reserving some blocks to cater for failure. You need to do
+	this anyway with NAND. The main purpose behind wear leveling is to
+	prevent some blocks getting more wear and failing. Since we expect,
+	and handle, failure this is no longer as important.</P>
+	<LI><P>The infrequent random block selection should prevent low-wear
+	blocks getting &quot;stuck&quot;.</P>
+</UL>
+<h3>Partitioning</h3>
+<p> Partitioning is not included in this spec, but could be added if
+required.</p>
+<h3>Bootloading</h3>
+<p>Bootloaders cannot just read files direct from NAND due to the high
+probability of bad blocks. Because YAFFS is quite simple it will be
+relatively straightforward for bootloaders to read from it (eg reading a
+kernel).</p>
+
+<H3>Conclusion</H3>
+<P>YAFFS is very simple. It is also NAND-friendly, is relatively
+frugal with resources (especially RAM) and boots quickly. Like JFFSx
+it has journaling which makes it far more robust than FAT.</P>
+<P>While it might seem high-risk to develop YAFFS, it is probably
+about the same amount of effort as implementing changes to JFFS to
+get it to work effectively within the constraints of NAND. A
+resulting JFFSx system would still require significant amounts of RAM
+and have long boot times.</P>
+<P>While YAFFS is indeed a new file system internally, much of the
+file system glue code (including inode management, link management
+etc) can likely be stolen from JFFSx. 
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/Documentation/yaffs-notes2.html b/Documentation/yaffs-notes2.html
new file mode 100644
index 0000000..a2f2344
--- /dev/null
+++ b/Documentation/yaffs-notes2.html
@@ -0,0 +1,719 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE></TITLE>
+	<META NAME="GENERATOR" CONTENT="StarOffice/5.2 (Linux)">
+	<META NAME="AUTHOR" CONTENT=" ">
+	<META NAME="CREATED" CONTENT="20020429;14311100">
+	<META NAME="CHANGEDBY" CONTENT=" ">
+	<META NAME="CHANGED" CONTENT="20020513;21133100">
+</HEAD>
+<BODY>
+<H1 ALIGN=CENTER>YAFFS Development Notes</H1>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<H3>Build options</H3>
+<P>Yaffs can be built as either a kernel module (ie. a Linux file
+system) or as an application.</P>
+<P>Of course the goal is to build yaffs as a file system running on
+top of real NAND flash, but yaffs can be built to run on a RAM
+emulation layer for in-kernel testing without NAND flash in the
+system.</P>
+<P>Building as an application allows the yaffs_guts algorithms to be
+tested/debugged in a more friendly debugging environment. The test
+harness is in yaffsdev.c</P>
+<H3>Trying it out</H3>
+<P>YAFFS can be built to run with either mtd or RAM emulation, or
+both. The file system that interfaces to mtd is called <B>yaffs</B>,
+the file system that uses internal ram is called <B>yaffsram</B>.
+YAFFS simultaneously supports both if they are enabled.</P>
+<OL>
+	<LI><P>Hack the Makefile and change the KERNELDIR define to your
+	kernel directory.</P>
+	<LI><P>If you don't have mtd support in your kernel, then you might
+	need to turn off USE_MTD otherwise the yaffs module might not load.</P>
+	<LI><P>Type <B><FONT FACE="Courier, monospace">make clean; make</FONT></B>
+	to build yaffs</P>
+	<LI><P>Load yaffs as a module by typing <B><FONT FACE="Courier, monospace">/sbin/insmod
+	yaffs.o</FONT></B> (ya gotta be root!).</P>
+	<LI><P>Create a mount point eg. <B><FONT FACE="Courier, monospace">mkdir
+	/mnt/y</FONT></B></P>
+	<LI><P>To mount the RAM emulation version of yaffs,  <B><FONT FACE="Courier, monospace">mount
+	-t yaffsram none /mnt/y</FONT></B></P>
+	<LI><P><FONT FACE="Courier, monospace"><SPAN STYLE="font-weight: medium"><FONT FACE="Times, serif">Alternatively,
+	to mount the mtd version of yaffs,</FONT></SPAN><B> mount -t yaffs
+	/dev/mtd0 /mnt/y</B></FONT></P>
+</OL>
+<P><BR><BR>
+</P>
+<H3>YAFFS Data structures</H3>
+<P>All data types are defined in yaffs_guts.h</P>
+<P>Yaffs uses the following major objects:</P>
+<UL>
+	<LI><P>yaffs_Object: A yaffs_Object can be a file, directory,
+	symlink or hardlink. The yaffs_Objects &quot;know&quot; about their
+	corresponding yaffs_ObjectHeader in NAND and the data for that
+	object. yaffs_Objects also bind together the directory structure as
+	follows:</P>
+	<LI><P>parent: pointer to the yaffs_Object that is a parent of this
+	yaffs_Object in the directory structure.</P>
+	<LI><P>siblings: this field is used to link together a list of all
+	the yaffs_Objects in the same directory.</P>
+	<LI><P>children: if the object is a directory, then children holds
+	the head of the list of objects in the directory.</P>
+	<LI><P>yaffs_Tnode: yaffs_Tnodes form a tree structure that speeds
+	up the search for data chunks in a file. As the file grows in size,
+	the levels increase. The Tnodes are a constant size (32 bytes).
+	Level 0 (ie the lowest level) comprise 16 2-byte entries giving an
+	index used to search for the chunkId. Tnodes at other levels
+	comprise 8 4-byte pointer entries to other tnodes lower in the tree.</P>
+	<LI><P>yaffs_Device: this holds the device context and is in some
+	ways analogous to the VFS superblock. It stores the data used to
+	access the mtd as well as function pointers to access the NAND data.</P>
+</UL>
+<P>The Tnodes and Objects are allocated in groups to reduce memory
+allocation/freeing overheads. Freed up tnodes and objects are kept in
+a free list and re-used.</P>
+<H3>yaffs_Object</H3>
+<P><BR><BR>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>struct
+ yaffs_ObjectStruct</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>{</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u8
+fake:1;		    // A fake object has no presence on NAND.</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u8
+renameAllowed:1;           // Are we allowed to rename it?</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u8
+unlinkAllowed:1;           // Are we allowed to unlink it?</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u8
+dirty:1;		    // the object needs to be written to flash</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u8
+valid:1;		    // When the file system is being loaded up, this </FONT></FONT>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>				
+   // object might be created before the data</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>				
+   // is available (ie. file data records appear before the header).</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u8
+serial;		    // serial number of chunk in NAND. Store here so we
+don't have to</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>				
+   // read back the old one to update.</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u16
+sum;		    // sum of the name to speed searching</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	struct
+yaffs_DeviceStruct *myDev; // The device I'm on</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>								</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	struct
+list_head hashLink;	// list of objects in this hash bucket</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>							</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><BR>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	struct
+list_head hardLinks; // all the equivalent hard linked objects</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>				//
+live on this list</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	//
+directory structure stuff</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	struct
+yaffs_ObjectStruct  *parent;	//my parent directory</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	struct
+list_head siblings;	          // siblings in a directory</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>					
+// also used for linking up the free list</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>		</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	//
+Where's my data in NAND?</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	int
+chunkId;		// where it lives</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+objectId;		// the object id value</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_mode;  	// protection</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_uid;   	// user ID of owner</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_gid;    	// group ID of owner </FONT></FONT>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_atime; 	// time of last access</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_mtime; 	// time of last modification</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_ctime; 	// time of last change</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><BR>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	yaffs_ObjectType
+variantType;</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	yaffs_ObjectVariant
+variant;</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>};</FONT></FONT></P>
+<P><BR><BR>
+</P>
+<P>Obvious stuff skipped....</P>
+<P>fake, renameAllowed, unlinkAllowed are special flags for handling
+&quot;fake&quot; objects which live in the file system but do not
+live on NAND. Currently there are only two such objects: the root
+object and the lost+found directory. None of these may be renamed or
+unlinked.</P>
+<P>serial, sum: see yaffs_ObjectHeader.</P>
+<P>dirty indicates that the object's contents has changed and a new
+yaffs_ObjectHeader must be written to flash.</P>
+<P>valid indicates that the object has been loaded up. This is only
+used during scanning (yaffs_Scan()) since we can know of an object's
+existance - and thus need to create the object header - before we
+encounter the associated yaffs_ObjectHeader.</P>
+<P>hashlink is a list of Objects in the same hash bucket. 
+</P>
+<P>The four variants hold extra info:</P>
+<P>Files hold the file size and the top level and pointer to the
+tnode tree for the file.</P>
+<P>Directories hold a list of children objects.</P>
+<P>Symlinks hold a pointer to the alias string. This is probably
+inefficient, but that probably does not matter since we don't expect
+to see many of these. 
+</P>
+<P>Hardlinks hold information to identify the equivalent object.</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<H3>File structure (tnodes)</H3>
+<P>File structures are done with a tiered indexing structure</P>
+<P><BR><BR>
+</P>
+<P><IMG SRC="sv9349341.gif" NAME="Graphic2" ALIGN=LEFT WIDTH=491 HEIGHT=294 BORDER=0><BR CLEAR=LEFT><BR><BR>
+</P>
+<P>The file structure is maintained by a tree structure. Depending
+where it is in the tree, each tree node (<B><I>tnode</I></B>) (the
+blue/things) holds either:</P>
+<UL>
+	<LI><P>.... if it is at the lowest level, then 16 __u16s which
+	identify the page.</P>
+	<LI><P>.... if it is at a higher level (ie an internal tnode), then
+	8 pointers to lowest-level tnodes.</P>
+</UL>
+<P>When the file starts out, it is assigned only one low-level tnode.
+When the file expands past what a single tnode can hold, then it is
+assigned a second tnode and an internal node is added to point to the
+two tnodes. As the file grows, more low-level tnodes and high level
+tnodes are added.</P>
+<P>Traversing the tnode tree to find a particular page in a file is
+quite simple: each internal tnode is selected from by using 3 bits of
+the page offset in the file. The level 0 page resolves 4 bits.</P>
+<P>For example, finding page 0x235 (ie. the one starting at file
+position 0x46800 would proceed as follows:</P>
+<P>0x235 is 0000001000110101, partitioned as follows.
+000.000.100.011.0101</P>
+<TABLE WIDTH=496 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=140>
+	<COL WIDTH=160>
+	<COL WIDTH=158>
+	<THEAD>
+		<TR VALIGN=TOP>
+			<TH WIDTH=140>
+				<P>Level</P>
+			</TH>
+			<TH WIDTH=160>
+				<P>Bits</P>
+			</TH>
+			<TH WIDTH=158>
+				<P>Selected value</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR VALIGN=TOP>
+			<TD WIDTH=140>
+				<P>3 or more if they exist</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>&gt;= 10</P>
+			</TD>
+			<TD WIDTH=158>
+				<P>Zero</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=140 VALIGN=BOTTOM SDVAL="2" SDNUM="5129;">
+				<P ALIGN=RIGHT>2</P>
+			</TD>
+			<TD WIDTH=160 VALIGN=TOP>
+				<P ALIGN=LEFT>9 to 7</P>
+			</TD>
+			<TD WIDTH=158 VALIGN=TOP>
+				<P>100 binary = 4</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=140 VALIGN=BOTTOM SDVAL="1" SDNUM="5129;">
+				<P ALIGN=RIGHT>1</P>
+			</TD>
+			<TD WIDTH=160 VALIGN=TOP>
+				<P ALIGN=LEFT>6 to 4</P>
+			</TD>
+			<TD WIDTH=158 VALIGN=TOP>
+				<P>011 binary = 3</P>
+			</TD>
+		</TR>
+		<TR>
+			<TD WIDTH=140 VALIGN=BOTTOM SDVAL="0" SDNUM="5129;">
+				<P ALIGN=RIGHT>0</P>
+			</TD>
+			<TD WIDTH=160 VALIGN=TOP>
+				<P ALIGN=LEFT>3 to 0</P>
+			</TD>
+			<TD WIDTH=158 VALIGN=TOP>
+				<P>0101 binary = 5</P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P><BR><BR>
+</P>
+<P>Free tnodes are stored in a list. When the list is exhausted, more
+are allocated.</P>
+<P>Each tnode takes 32 bytes. Each file needs at least one level 0
+tnode. How many do we need? A full 16MB file system needs at least
+16MB/512/16 = 2000 level zero tnodes. More for internal tnodes. More
+for files smaller than optimal.</P>
+<P>The tree grows as required. When the file is resized to a smaller
+size then it is pruned.</P>
+<P><BR><BR>
+</P>
+<H3>NAND data</H3>
+<P>Data is stored on NAND in &quot;chunks&quot;. Currently each chunk
+is the same size as a NAND flash page (ie. 512 bytes + 16 byte
+spare). In the future we might decide to allow for different chunk
+sizes. Chunks can hold either:</P>
+<UL>
+	<LI><P>A yaffs_ObjectHeader. This is the way a yaffs_Object gets
+	stored on NAND.</P>
+	<LI><P>A chunk of file data.</P>
+</UL>
+<P>The 16 byte spare area contains:</P>
+<UL>
+	<LI><P>8 bytes of tags,</P>
+	<LI><P>6 bytes of ECC data</P>
+	<LI><P>1 byte block status (used to identify damaged blocks)</P>
+	<LI><P>1 byte data status (currently unused).</P>
+</UL>
+<P>The tags are made up as follows:</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>typedef
+struct</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>{</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+   unsigned chunkId:20;     //chunk number in file</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+   unsigned serialNumber:2; //serial number for chunk</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+   unsigned byteCount:10;   //number of bytes of data used in this
+chunk</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+   unsigned objectId:18;    //the object id that this chunk belongs
+to. </FONT></FONT>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+   unsigned ecc:12;         //ECC on tags</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+   unsigned unusedStuff:2;  //unused</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>}
+yaffs_Tags;</FONT></FONT></P>
+<P STYLE="margin-bottom: 0cm"><BR>
+</P>
+<P>A chunkId of zero indicates that this chunk holds a
+yaffs_ObjectHeader. A non zero value indicates that this is a data
+chunk and  the position of the chunk in the file (ie. the first chunk
+- at offset 0 - has chunkId 1). See yaffs_guts.c:yaffs_Scan () to see
+how this is done.</P>
+<P>When a chunk is repalced (eg. file details changed or a part of a
+file was overwritten), the new chunk is written before the old chunk
+is deleted. This means that we don't lose data if there is a power
+loss after the new chunk is created but before the old one is
+discarded, but it does mean that we can encounter the situation where
+we find both the old and the new chunks in flash. The serialNumber is
+incremented each time the chunk is written. 2 bits is sufficient to
+resolve any ambiguity.</P>
+<P>bytecount applies only to data chunks and tells how many of the
+data bytes are valid.</P>
+<P>objectId says which object this chunk belongs to.</P>
+<P>ecc is used to perform error correction on the tags. Another ecc
+field is used to error correct the data.</P>
+<P><BR><BR>
+</P>
+<H3>yaffs_ObjectHeader</H3>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>typedef
+struct</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>{</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	yaffs_ObjectType
+type;</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><BR>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	//
+Apply to everything	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	int
+  parentObjectId;</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u16
+sum;	// checksum of name</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	char
+ name[YAFFS_MAX_NAME_LENGTH + 1];</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><BR>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	//
+Thes following apply to directories, files, symlinks - not hard links</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_mode;  // protection</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_uid;   // user ID of owner</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_gid;    // group ID of owner </FONT></FONT>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_atime; // time of last access</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_mtime; // time of last modification</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	__u32
+st_ctime; // time of last change</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	//
+File size  applies to files only</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	int
+fileSize; </FONT></FONT>
+</P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>		</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	//
+Equivalent object id applies to hard links only.</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	int
+ equivalentObjectId;</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>
+        // alias only applies to symlinks</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	char
+alias[YAFFS_MAX_ALIAS_LENGTH + 1];</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>	</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><FONT FACE="Courier, monospace"><FONT SIZE=2>}
+yaffs_ObjectHeader;</FONT></FONT></P>
+<P STYLE="margin-left: 2cm; margin-bottom: 0cm"><BR>
+</P>
+<P>A yaffs_ObjectHeader is stored in NAND for every yaffs_Object.</P>
+<P>type holds the type of yaffs_Object (file,directory,hardlink or
+symlink).</P>
+<P>parentObject is the objectId of this object's parent. name holds
+the object's name. Together these form the directory structure of the
+file system. Also worth mention is sum. This is a &quot;checksum&quot;
+on the name which speeds directory searching (ie. when searching the
+directory we only compare the name for those entries where sum
+matches).</P>
+<P>Obvious stuff skipped....</P>
+<P>equivalentObjectId is used by hardlinks. A hardlink to an object
+uses this field to specify the object that this links to. This way of
+doing things is a bit different than the normal Linux way of doing
+things (ie. keeping the links distinct from the inode) but is simpler
+and uses less space except for a few corner cases with hardlinks.</P>
+<P>alias is used by symlinks to hold the symlink alias string. This
+limits the size of the symlink alias. In future we should expand
+YAFFS to use data chunks to store aliases too long to fit into the
+yaffs_ObjectHeader.</P>
+<P><BR><BR>
+</P>
+<H3>NAND Interface</H3>
+<P>All NAND access is performed via four functions pointed to by
+yaffs_Device. At the moment a chunk is a page.</P>
+<UL>
+	<LI><P><FONT FACE="Courier, monospace"><FONT SIZE=2>int
+	WriteChunkToNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND,
+	const __u8 *data, yaffs_Spare *spare)</FONT></FONT></P>
+	<LI><P><FONT FACE="Courier, monospace"><FONT SIZE=2>int
+	ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND,
+	__u8 *data, yaffs_Spare *spare);</FONT></FONT></P>
+	<LI><P><FONT FACE="Courier, monospace"><FONT SIZE=2>int
+	EraseBlockInNAND(struct yaffs_DeviceStruct *dev,int blockInNAND);</FONT></FONT></P>
+	<LI><P><FONT FACE="Courier, monospace"><FONT SIZE=2>int
+	InitialiseNAND(struct yaffs_DeviceStruct *dev);</FONT></FONT></P>
+</UL>
+<P>In the Readxxx and Writexxx functions, the data and/or spare
+pointers may be NULL in which case these data transfers are ignored.</P>
+<P>A quick note about NAND:</P>
+<UL>
+	<LI><P>NAND is not random access, but page oriented. Thus, we do all
+	reads &amp; writes in pages.</P>
+	<LI><P>Each NAND page holds 512 bytes of data and 16 &quot;spare&quot;
+	bytes. Yaffs structures the spare area with tags used to identify
+	what is stored in the data area. There are 32 such pages to a block.</P>
+	<LI><P>NAND writes will only change 1 bits to 0. eg. if a byte holds
+	10110011 and you write 11011010 to it you will get the logical and
+	of the two values: 10010010. The only way to get 1s again is to
+	erase the entire block. 
+	</P>
+	<LI><P>You may only write to a page a few times before erasing the
+	entire block. Yaffs lives within these limitations. Each page only
+	gets written to twice (once when written and once when discarded).</P>
+	<LI><P>ECC is normally used with NAND to correct for single bit
+	errors. YAFFS applies the ECC itself, so the MTD should not do this.</P>
+	<LI><P>The current mtd interfaces are not particularly well suited
+	to YAFFS and we will address the issue with the mtd group. (The mtd
+	interface does not support page-oriented read/write which YAFFS
+	would prefer).</P>
+</UL>
+<P><BR><BR>
+</P>
+<H3>mkyaffs</H3>
+<P>mkyaffs is the tool to format a NAND mtd to be used for YAFFS.
+This is quite simple, just erase all the undamaged blocks. YAFFS
+treats erased blocks as free (empty) space.</P>
+<P><BR><BR>
+</P>
+<H2>Expected performance</H2>
+<P>The following numbers should give an indication of the performance
+we should expect from YAFFS.</P>
+<P>As an example, I'll use the following numbers. Since the hardware
+is capable of 50ns read/write, these numbers allow for some other
+ovberheads. Clearly though, the performance can be degraded in
+various ways.</P>
+<TABLE WIDTH=233 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=103>
+	<COL WIDTH=103>
+	<THEAD>
+		<TR VALIGN=TOP>
+			<TH WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">Seek</P>
+			</TH>
+			<TH WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">10uS/page</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR VALIGN=TOP>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">Read</P>
+			</TD>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">100nS/byte</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">Write</P>
+			</TD>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">100nS/byte</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">Program</P>
+			</TD>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">200uS/page</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">Erase</P>
+			</TD>
+			<TD WIDTH=103>
+				<P ALIGN=LEFT STYLE="font-style: normal">2mS/block</P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P><BR><BR>
+</P>
+<P>From this we can derive some higher-level numbers:</P>
+<TABLE WIDTH=706 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=204>
+	<COL WIDTH=160>
+	<COL WIDTH=304>
+	<THEAD>
+		<TR VALIGN=TOP>
+			<TH WIDTH=204>
+				<P>Operation</P>
+			</TH>
+			<TH WIDTH=160>
+				<P>Time</P>
+			</TH>
+			<TH WIDTH=304>
+				<P>Calculation</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR VALIGN=TOP>
+			<TD WIDTH=204>
+				<P>Read spare</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>12uS</P>
+			</TD>
+			<TD WIDTH=304>
+				<P>seek + 16 * read</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=204>
+				<P>Read page</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>63 uS</P>
+			</TD>
+			<TD WIDTH=304>
+				<P>seek + 528 * read</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=204>
+				<P>Write page</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>326 uS</P>
+			</TD>
+			<TD WIDTH=304>
+				<P>seek + 528 * write + program + read page (for verification)</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=204>
+				<P>Discard page</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>212 uS</P>
+			</TD>
+			<TD WIDTH=304>
+				<P>seek + 16 * write + program</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=204>
+				<P>Overwrite page</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>538 uS</P>
+			</TD>
+			<TD WIDTH=304>
+				<P>write page + discard page</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=204>
+				<P>Erase overhead per page</P>
+			</TD>
+			<TD WIDTH=160>
+				<P>63uS</P>
+			</TD>
+			<TD WIDTH=304>
+				<P>erase/32</P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P><BR><BR>
+</P>
+<P>From this we can infer the following flash access times:</P>
+<TABLE WIDTH=704 BORDER=1 CELLPADDING=4 CELLSPACING=3>
+	<COL WIDTH=196>
+	<COL WIDTH=167>
+	<COL WIDTH=303>
+	<THEAD>
+		<TR VALIGN=TOP>
+			<TH WIDTH=196>
+				<P>Operation</P>
+			</TH>
+			<TH WIDTH=167>
+				<P>Time</P>
+			</TH>
+			<TH WIDTH=303>
+				<P>Calculation</P>
+			</TH>
+		</TR>
+	</THEAD>
+	<TBODY>
+		<TR VALIGN=TOP>
+			<TD WIDTH=196>
+				<P>Read 1MB file</P>
+			</TD>
+			<TD WIDTH=167>
+				<P>0.13s (about 7.5 MB/s)</P>
+			</TD>
+			<TD WIDTH=303>
+				<P>2000 * read page</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=196>
+				<P>Write 1MB (clean system)</P>
+			</TD>
+			<TD WIDTH=167>
+				<P>0.53s (about 1.8 MB/s)</P>
+			</TD>
+			<TD WIDTH=303>
+				<P>2000 * write page</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=196>
+				<P>Overwrite 1MB file (no gc)</P>
+			</TD>
+			<TD WIDTH=167>
+				<P>1.08s (about 0.9MB/s)</P>
+			</TD>
+			<TD WIDTH=303>
+				<P>2000 * overwrite page</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=196>
+				<P>Overwrite 1MB with 50% gc</P>
+			</TD>
+			<TD WIDTH=167>
+				<P>2.4s (about 0.4 MB/s)</P>
+			</TD>
+			<TD WIDTH=303>
+				<P>2000 * overwrite page + 2000 * page copy (== overwrite page) +
+				4000 * erase overhead</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=196>
+				<P>Delete 1MB file</P>
+			</TD>
+			<TD WIDTH=167>
+				<P>0.43s (about 2.2 MB/s)</P>
+			</TD>
+			<TD WIDTH=303>
+				<P>2000 * discard page</P>
+			</TD>
+		</TR>
+		<TR VALIGN=TOP>
+			<TD WIDTH=196>
+				<P>Delete 1MB file with 50% gc</P>
+			</TD>
+			<TD WIDTH=167>
+				<P>0.49s (about 2.0MB/s)</P>
+			</TD>
+			<TD WIDTH=303>
+				<P>2000 * discard page + 1000 * erase overhead</P>
+			</TD>
+		</TR>
+	</TBODY>
+</TABLE>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/Documentation/yaffs_report20020211.html b/Documentation/yaffs_report20020211.html
new file mode 100644
index 0000000..212eb88
--- /dev/null
+++ b/Documentation/yaffs_report20020211.html
@@ -0,0 +1,81 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE></TITLE>
+	<META NAME="GENERATOR" CONTENT="StarOffice/5.2 (Linux)">
+	<META NAME="AUTHOR" CONTENT=" ">
+	<META NAME="CREATED" CONTENT="20020211;20201700">
+	<META NAME="CHANGEDBY" CONTENT=" ">
+	<META NAME="CHANGED" CONTENT="20020211;21005100">
+</HEAD>
+<BODY>
+<H3>YAFFS Progress 11 Feb 2002</H3>
+<H3>Approach</H3>
+<P><I>C. A. R. Hoare, in his 1980 ACM Turing Award lecture, told of
+two ways of constructing a software design: &quot;One way is to make
+it so simple that there are obviously no deficiencies and the other
+way is to make it so complicated that there are no obvious
+deficiencies.&quot;</I></P>
+<P>The approach I'm taking with Yaffs is to design and make notes up
+front as much as possible. I find this helps make the coding/debug
+phase go way faster and more predictably.</P>
+<P>Although obviously the code ends up in the kernel, I'm abstracting
+out kernel services so that I develop/debug in user space using
+vanilla dev tools. I like to use Source Navigator because it has a
+nice xref capability though a few quirks too). Thus, yaffs code will
+be tested in application space wrapped in a test harness which calls
+the yaffs functions. and sits on top of a NAND emulation layer (just
+two big disk files).  I can then do things like force ecc failures
+etc at will to test recovery logic and check booting etc. This
+general approach has served me well in the past and I expect it will
+this time too.</P>
+<H3>Design</H3>
+<P>At this stage all the major design work is done. Basically there
+are 3 in RAM management &quot;objects&quot;:</P>
+<UL>
+	<LI><P> inodes: An inode maps to the normal file system concept of
+	an inode. It is thus either a file or a directory. <BR>A file type
+	inode points to a tnode tree which is a layered tree that is used to
+	quickly find the pages of data in NAND.<BR>A directory type inode
+	has a list of children links (ie. the links in that directory).<BR>An
+	inode knows which hard links are associated with it.<BR>inode
+	look-up uses a hashing table.</P>
+	<LI><P>links: Links are hard or soft links. All links have a parent
+	inode (ie. the directory they're in). <BR>Hard links point to an
+	inode.<BR>Soft links are just alias strings.<BR>Instead of storing
+	the link name in RAM (big and wasteful and variable size), the
+	location in NAND is stored instead and a u16 &quot;checksum&quot;
+	value is stored in RAM to help in quickly scanning links [ie. say
+	the checksum for &quot;freddies_file&quot; is 123 then when I go
+	search for it I don't need to go look at every link in NAND (slow),
+	just those that match checksum 123]. 
+	</P>
+	<LI><P>tnodes: Tnodes are a tiered tree system to rapidly get from
+	inodes to their data pages in RAM.</P>
+</UL>
+<P>There is a need for speed in certain areas, such as rapidly
+locating inodes, links data pages during certain scenarios (eg.
+garbage collection). These have been identified and suitable  look-up
+structures are in place.</P>
+<P>All dynamic data structures are allocated from pools rather than
+one at a time. This is more efficient time-wise and simplifies
+clean-up.</P>
+<H3>Code</H3>
+<P>Much of the code for the management layers is already in place, as
+is some of the tag management code. Some of the code has already been
+tested.</P>
+<P>I have started with coding the management layer since this is the
+most critical part to get right. Every now and then I have coded up
+some other section to verify that what I have will work.</P>
+<H3>Time</H3>
+<P>So far I've logged 65 hours on yaffs (though it chews up
+significant null cycles too :-)). I believe this is comfortably
+within budget. I was not able to make much progress through Christmas
+and the week of January, but am able to give a lot more effort now.</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/Documentation/yaffs_report20020304.html b/Documentation/yaffs_report20020304.html
new file mode 100644
index 0000000..afc7569
--- /dev/null
+++ b/Documentation/yaffs_report20020304.html
@@ -0,0 +1,57 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
+	<TITLE></TITLE>
+	<META NAME="GENERATOR" CONTENT="StarOffice/5.2 (Linux)">
+	<META NAME="AUTHOR" CONTENT=" ">
+	<META NAME="CREATED" CONTENT="20020211;20201700">
+	<META NAME="CHANGEDBY" CONTENT=" ">
+	<META NAME="CHANGED" CONTENT="20020304;21123700">
+</HEAD>
+<BODY>
+<H3>YAFFS Progress 4 March 2002</H3>
+<H3><BR><BR>
+</H3>
+<H3>Design</H3>
+<P>A few of the design areas needed to be tweaked slightly without
+significant impact.</P>
+<P>The only real significance is that what is termed a yaffs_Inode
+really becomes an object Id. Where an 'object' is a file, directory,
+symlink or hard link. This differs from the *nix concept of an inode
+in that a hard link is not an inode. yaffs_Inode should really be
+renamed to yaffs_Object to reflect this.</P>
+<P>Rge reason for introducing the object is to provide identifiers
+for the objects stored on NAND. For example, each hardlink (which
+does not have a distinct inode) needs an object Id for storage on 
+</P>
+<H3>Code</H3>
+<P>Pretty much all the guts of the code is there except for:</P>
+<UL>
+	<LI><P>symlink handling (a doddle)</P>
+	<LI><P>hard link handling.</P>
+	<LI><P>some of start-up scanning</P>
+	<LI><P>ECC on tags</P>
+	<LI><P>superblock handling (ie hook-up to mtd and the Linux VFS).
+	Some of this code to be pinched from JFFS2.</P>
+</UL>
+<P>Some of the code has already been tested.</P>
+<P>I will now be testing out the guts on a NAND emulation layer in an
+application. This provides better debugging. I hope to have this
+running by 11/03/2002. 
+</P>
+<P>Once the guts looks solid on the NAND emulation, I will graft it
+on to the VFS and mtd -  at which point it becomes a real file
+system.</P>
+<H3>Time</H3>
+<P>So far I've logged 90 hours on yaffs. I will not be charging for
+approx 15 hours I have spent swotting up on the Linux VFS. I still
+believe this is on budget.</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+<P><BR><BR>
+</P>
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..a0d8138
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,38 @@
+#Makefile for YAFFS as a module
+#
+# NB this is not yet suitable for putting into the kernel tree.
+# YAFFS: Yet another FFS. A NAND-flash specific file system. 
+#
+# Copyright (C) 2002 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.
+
+## Change or override  KERNELDIR to your kernel
+## comment out USE_xxxx if you don't want these features.
+
+KERNELDIR = /usr/src/kernel-headers-2.4.18
+USE_RAM_FOR_TEST = -DYAFFS_RAM_ENABLED
+USE_MTD = -DYAFFS_MTD_ENABLED
+
+
+CFLAGS = -D__KERNEL__ -DMODULE $(USE_RAM_FOR_TEST) $(USE_MTD)  -I$(KERNELDIR)/include -O2 -Wall
+
+
+OBJS = yaffs_fs.o yaffs_guts.o yaffs_ramem.o yaffs_mtdif.o
+
+
+all: yaffs.o
+
+$(OBJS): %.o: %.c
+	gcc -c $(CFLAGS) $< -o $@
+
+yaffs.o: $(OBJS)
+	ld -r $(OBJS) -o $@
+
+clean:
+	rm -f $(OBJS) core
diff --git a/devextras.h b/devextras.h
new file mode 100644
index 0000000..a28135f
--- /dev/null
+++ b/devextras.h
@@ -0,0 +1,257 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * devextras.h
+ *
+ * Copyright (C) 2002 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 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.
+ *
+ */
+ 
+#ifndef __EXTRAS_H__
+#define __EXTRAS_H__
+
+#ifndef __KERNEL__
+
+// 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
+ 
+
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+	struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * 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(struct list_head * new,
+	struct list_head * prev,
+	struct 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(struct list_head *new, struct 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(struct list_head *new, struct 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(struct list_head * prev,
+				  struct 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(struct 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(struct 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__ int list_empty(struct 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(struct list_head *list, struct list_head *head)
+{
+	struct list_head *first = list->next;
+
+	if (first != list) {
+		struct list_head *last = list->prev;
+		struct 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)))
+
+/**
+ * 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))
+
+/**
+ * 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)
+
+
+
+#define CURRENT_TIME 0
+
+
+/*
+ * File types
+ */
+#define DT_UNKNOWN	0
+#define DT_FIFO		1
+#define DT_CHR		2
+#define DT_DIR		4
+#define DT_BLK		6
+#define DT_REG		8
+#define DT_LNK		10
+#define DT_SOCK		12
+#define DT_WHT		14
+
+#include <sys/stat.h>
+
+/*
+ * Attribute flags.  These should be or-ed together to figure out what
+ * has been changed!
+ */
+#define ATTR_MODE	1
+#define ATTR_UID	2
+#define ATTR_GID	4
+#define ATTR_SIZE	8
+#define ATTR_ATIME	16
+#define ATTR_MTIME	32
+#define ATTR_CTIME	64
+#define ATTR_ATIME_SET	128
+#define ATTR_MTIME_SET	256
+#define ATTR_FORCE	512	/* Not a change, but a change it */
+#define ATTR_ATTR_FLAG	1024
+
+
+struct iattr {
+	unsigned int	ia_valid;
+	unsigned		ia_mode;
+	unsigned		ia_uid;
+	unsigned		ia_gid;
+	unsigned		ia_size;
+	unsigned		ia_atime;
+	unsigned	ia_mtime;
+	unsigned	ia_ctime;
+	unsigned int	ia_attr_flags;
+};
+
+#define KERN_DEBUG
+
+
+#else
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/fs.h>
+#include <linux/stat.h>
+
+
+#endif
+
+
+
+
+#endif
+
diff --git a/snMakefile b/snMakefile
new file mode 100644
index 0000000..4557fa5
--- /dev/null
+++ b/snMakefile
@@ -0,0 +1,79 @@
+#########################################################
+# Makefile auto generated by Cygnus Source Navigator.
+# Target: yaffsdev_RAM Date: May 03 2002 Time: 07:11:35 PM
+#
+
+
+.SUFFIXES: .cc .class .java .cxx .C .cpp .o .c .l .y
+
+
+VPATH = /opt/aleph1/yaffs/.
+
+
+YACC = bison
+LEX = flex
+JAVA = gcj
+CC = gcc
+CPP = g++
+YACC_FLAGS =      
+LEX_FLAGS =      
+JAVA_FLAGS =      
+CC_FLAGS =  -g  -Wall  
+CPP_FLAGS =      
+YACC_INCLUDES = 
+LEX_INCLUDES = 
+JAVA_INCLUDES = 
+CC_INCLUDES = 
+CPP_INCLUDES = 
+YACC_DEFINES = 
+LEX_DEFINES = 
+JAVA_DEFINES = 
+CC_DEFINES = 
+CPP_DEFINES = 
+yaffsdev_RAM_LIBS = 
+LINKER = gcc
+LINKER_FLAGS = 
+LINKER_ENTRY = 
+yaffsdev_RAM_OBJECTS = yaffs_guts.o yaffs_ramem.o yaffsdev.o
+
+all: yaffsdev
+
+yaffsdev: $(yaffsdev_RAM_OBJECTS)
+	$(LINKER) -o yaffsdev $(LINKER_ENTRY) $(LINKER_FLAGS) $(yaffsdev_RAM_OBJECTS) $(yaffsdev_RAM_LIBS)
+
+.y.c:
+	$(YACC) $< $(YACC_FLAGS) $(YACC_DEFINES) $(YACC_INCLUDES)
+
+
+.l.c:
+	$(LEX) -t $< > $@ $(LEX_FLAGS) $(LEX_DEFINES) $(LEX_INCLUDES)
+
+
+.java.o:
+	$(JAVA) -c $< $(JAVA_FLAGS) $(JAVA_DEFINES) $(JAVA_INCLUDES)
+.class:
+	$(JAVA) -c $< $(JAVA_FLAGS) $(JAVA_DEFINES) $(JAVA_INCLUDES)
+
+
+.c.o:
+	$(CC) -c $< $(CC_FLAGS) $(CC_DEFINES) $(CC_INCLUDES)
+
+
+.cpp.o:
+	$(CPP) -c $< $(CPP_FLAGS) $(CPP_DEFINES) $(CPP_INCLUDES)
+.C.o:
+	$(CPP) -c $< $(CPP_FLAGS) $(CPP_DEFINES) $(CPP_INCLUDES)
+.cc.o:
+	$(CPP) -c $< $(CPP_FLAGS) $(CPP_DEFINES) $(CPP_INCLUDES)
+.cxx.o:
+	$(CPP) -c $< $(CPP_FLAGS) $(CPP_DEFINES) $(CPP_INCLUDES)
+
+
+yaffs_guts.o: /opt/aleph1/yaffs/yaffs_guts.h /opt/aleph1/yaffs/yaffsinterface.h /opt/aleph1/yaffs/yportenv.h
+yaffs_ramem.o: yaffs_nandemul.h /opt/aleph1/yaffs/devextras.h /opt/aleph1/yaffs/yaffs_guts.h /opt/aleph1/yaffs/yaffsinterface.h /opt/aleph1/yaffs/yportenv.h
+yaffsdev.o: yaffs_nandemul.h /usr/include/stdio.h /usr/include/stdlib.h /usr/include/string.h /opt/aleph1/yaffs/yaffs_guts.h /opt/aleph1/yaffs/yaffsinterface.h
+
+clean:
+	rm -f *.o
+	rm -f yaffsdev
+
diff --git a/utils/Makefile b/utils/Makefile
new file mode 100644
index 0000000..fdc64a3
--- /dev/null
+++ b/utils/Makefile
@@ -0,0 +1,34 @@
+#Makefile for mkyaffs
+#
+# NB this is not yet suitable for putting into the kernel tree.
+# YAFFS: Yet another FFS. A NAND-flash specific file system. 
+#
+# Copyright (C) 2002 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.
+
+## Change or override  KERNELDIR to your kernel
+
+KERNELDIR = /usr/src/kernel-headers-2.4.18
+
+CFLAGS =   -I$(KERNELDIR)/include -O2 -Wall
+
+
+OBJS = mkyaffs.o
+
+
+all: mkyaffs
+
+$(OBJS): %.o: %.c
+	gcc -c $(CFLAGS) $< -o $@
+
+mkyaffs: $(OBJS)
+	gcc -o $@ $(OBJS)
+
+clean:
+	rm -f $(OBJS) core
diff --git a/utils/mkyaffs b/utils/mkyaffs
new file mode 100755
index 0000000000000000000000000000000000000000..27e3a086d46a85f525a1695a96617c9ac95d9968
GIT binary patch
literal 6382
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
J#bqzT{|0<b2ZR6s

literal 0
HcmV?d00001

diff --git a/utils/mkyaffs.c b/utils/mkyaffs.c
new file mode 100644
index 0000000..7fd2b0b
--- /dev/null
+++ b/utils/mkyaffs.c
@@ -0,0 +1,150 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * mkyaffs.c Format a chunk of NAND for YAFFS.
+ *
+ * Copyright (C) 2002 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.
+ *
+ *  Acknowledgement:
+ *  This file is crafted from nandtest.c by  Miguel Freitas (miguel@cetuc.puc-rio.br)
+ *  and Steven J. Hill (sjhill@cotw.com)
+ *
+ * Overview:
+ * Formatting a YAFFS device is very simple. Just erase all undamaged blocks. 
+ * NB Don't erase blocks maked as damaged.
+ */
+
+#define _GNU_SOURCE
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <asm/types.h>
+#include <linux/config.h>
+#include <linux/mtd/mtd.h>
+
+
+// countBits is a quick way of counting the number of bits in a byte.
+// ie. countBits[n] holds the number of 1 bits in a byte with the value n.
+
+static const char countBits[256] =
+{
+0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
+};
+
+/*
+ * Buffer arrays used for running tests
+ */
+
+unsigned char oobbuf[16];
+
+
+/*
+ * Main program
+ */
+int main(int argc, char **argv)
+{
+	unsigned long addr;
+	int bs, fd, i;
+	struct mtd_oob_buf oob = {0, 16, (unsigned char *) &oobbuf};
+	mtd_info_t meminfo;
+	erase_info_t erase;
+
+	/* Make sure a device was specified */
+	if(argc < 2) {
+		printf("usage: %s <mtdname>\n", argv[0]);
+		exit(1);
+	}
+
+	/* Open the device */
+	if((fd = open(argv[1], O_RDWR)) == -1) {
+		perror("open flash");
+		exit(1);
+	}
+
+	/* Fill in MTD device capability structure */
+	if(ioctl(fd, MEMGETINFO, &meminfo) != 0) {
+		perror("MEMGETINFO");
+		close(fd);
+		exit(1);
+	}
+
+	/* Make sure device page sizes are valid */
+	if( !(meminfo.oobsize == 16 && meminfo.oobblock == 512)) 
+	{
+		printf("Unknown flash (not normal NAND)\n");
+		close(fd);
+		exit(1);
+	}
+	
+	
+	for(addr = 0; addr < meminfo.size; addr += meminfo.erasesize)
+	{
+		/* Read the OOB data to determine if the block is valid.
+		 * If the block is damaged, then byte 5 of the OOB data will
+		 * have at least 2 zero bits.
+		 */
+		oob.start = addr;
+		oob.length = 16;
+		oob.ptr = oobbuf;
+		if (ioctl(fd, MEMREADOOB, &oob) != 0) 
+		{
+			perror("ioctl(MEMREADOOB)");
+			close(fd);
+			exit(1);
+		}
+		
+		if(countBits[oobbuf[5]] < 7)
+		{
+			printf("Block at 0x08%lx is damaged and is not being formatted\n",addr);
+		}
+		else
+		{
+			/* Erase this block */
+			erase.start = addr;
+			erase.length = meminfo.erasesize;
+			printf("Erasing block at 0x08%lx\n",addr);
+			if(ioctl(fd, MEMERASE, &erase) != 0) 
+			{
+				perror("\nMTD Erase failure\n");
+				close(fd);
+				exit(1);
+			}
+			
+		}
+
+	}
+
+
+	/* All the tests succeeded */
+	printf("OK\n");
+	close(fd);
+	return 0;
+}
+
diff --git a/yaffs-header.c b/yaffs-header.c
new file mode 100644
index 0000000..7cb71e0
--- /dev/null
+++ b/yaffs-header.c
@@ -0,0 +1,13 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
diff --git a/yaffs_fileem.c b/yaffs_fileem.c
new file mode 100644
index 0000000..a137fb4
--- /dev/null
+++ b/yaffs_fileem.c
@@ -0,0 +1,145 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yaffs_fileem.c  NAND emulation on top of files
+ *
+ * Copyright (C) 2002 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_fileem.c
+
+#include "yaffs_nandif.h"
+#include "yaffs_guts.h"
+#include "yaffsinterface.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#define FILE_SIZE_IN_MEG 2
+
+#define BLOCK_SIZE (32 * 528)
+#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
+#define FILE_SIZE_IN_BLOCKS (FILE_SIZE_IN_MEG * BLOCKS_PER_MEG)
+#define FILE_SIZE_IN_BYTES (FILE_SIZE_IN_BLOCKS * BLOCK_SIZE)
+
+
+static int h;
+static __u8 ffChunk[528];
+
+
+
+static void  CheckInit(void)
+{
+	static int initialised = 0;
+
+	int length;
+
+	
+	if(!initialised)
+	{
+		memset(ffChunk,0xFF,528);
+		
+		h = open("yaffs-em-file" , O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
+		if(h < 0)
+		{
+			perror("Fatal error opening yaffs emulation file");
+			exit(1);
+		}
+		initialised = 1;
+		
+		length = lseek(h,0,SEEK_END);
+		if(length !=  FILE_SIZE_IN_BYTES)
+		{
+			// Create file contents
+			int i;
+			
+			printf("Creating emulation file...\n");
+			for(i = 0; i < FILE_SIZE_IN_BLOCKS; i++)
+			{
+				yaffs_EraseBlockInNAND(i);
+			}
+		}
+	}
+}
+
+int yaffs_WriteChunkToNAND(int chunkInNAND,__u8 *data, yaffs_Spare *spare)
+{
+	int pos;
+	
+	pos = chunkInNAND * 528;
+	
+	CheckInit();
+	
+	
+	if(data)
+	{
+		lseek(h,pos,SEEK_SET);
+		write(h,data,512);
+	}
+	
+	pos += 512;
+	
+	if(spare)
+	{
+		lseek(h,pos,SEEK_SET);
+		write(h,spare,16);	
+	}
+
+	return YAFFS_OK;
+}
+
+
+int yaffs_ReadChunkFromNAND(int chunkInNAND, __u8 *data, yaffs_Spare *spare)
+{
+	int pos;
+
+	pos = chunkInNAND * 528;
+	
+	
+	CheckInit();
+	
+	if(data)
+	{
+		lseek(h,pos,SEEK_SET);
+		read(h,data,512);
+	}
+	
+	pos += 512;
+	
+	if(spare)
+	{
+		lseek(h,pos,SEEK_SET);
+		read(h,spare,16);	
+	}
+
+	return YAFFS_OK;
+}
+
+
+int yaffs_EraseBlockInNAND(int blockInNAND)
+{
+	int i;
+	
+	CheckInit();
+	
+	printf("Erasing block %d\n",blockInNAND);
+	
+	lseek(h,blockInNAND * BLOCK_SIZE,SEEK_SET);
+	for(i = 0; i < 32; i++)
+	{
+		write(h,ffChunk,528);
+	}
+	return YAFFS_OK;
+}
+
diff --git a/yaffs_fs.c b/yaffs_fs.c
new file mode 100644
index 0000000..a0ada39
--- /dev/null
+++ b/yaffs_fs.c
@@ -0,0 +1,879 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ * yaffs_fs.c
+ *
+ * Copyright (C) 2002 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 is the file system front-end to YAFFS that hooks it up to
+ * the VFS.
+ *
+ * Special notes:
+ * >> sb->u.generic_sbp points to the yaffs_Device associated with this superblock
+ * >> inode->u.generic_ip points to the associated yaffs_Object.
+ */
+
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <linux/pagemap.h>
+#include <linux/mtd/mtd.h>
+#include <linux/interrupt.h>
+#include <linux/string.h>
+#include <linux/locks.h>
+
+#include <asm/uaccess.h>
+
+#include "yaffs_guts.h"
+
+#ifdef YAFFS_RAM_ENABLED
+#include "yaffs_nandemul.h"
+// 2 MB of RAM for emulation
+#define YAFFS_RAM_EMULATION_SIZE  0x200000
+#endif // YAFFS_RAM_ENABLED
+
+#ifdef YAFFS_MTD_ENABLED
+#include <linux/mtd/mtd.h>
+#include "yaffs_mtdif.h"
+#endif //YAFFS_MTD_ENABLED
+
+#define T(x) printk x
+
+
+
+#define yaffs_InodeToObject(iptr) ((yaffs_Object *)((iptr)->u.generic_ip))
+#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
+#define yaffs_SuperToDevice(sb)	((yaffs_Device *)sb->u.generic_sbp)
+
+
+
+static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos);
+static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos);
+
+static int yaffs_sync_object(struct file * file, struct dentry *dentry, int datasync);
+
+static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
+
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
+static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry);
+static int yaffs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry);
+static int yaffs_unlink(struct inode * dir, struct dentry *dentry);
+static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname);
+static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode);
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev);
+static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry);
+static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
+
+static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
+static void yaffs_read_inode (struct inode *inode);
+static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent);
+static void yaffs_put_inode (struct inode *inode);
+
+//static int yaffs_readpage(struct file*,struct page *
+
+static struct address_space_operations yaffs_address_ops = {
+//	readpage:		yaffs_readpage,
+//	prepare_write:	yaffs_prepare_write,
+//	commit_write:	yaffs_commit_write
+};
+
+
+static struct file_operations yaffs_file_operations = {
+	read:		yaffs_file_read,
+	write:		yaffs_file_write,
+//	mmap:		generic_file_mmap,
+	fsync:		yaffs_sync_object,
+};
+
+
+static struct inode_operations yaffs_file_inode_operations = {
+	setattr:	yaffs_setattr,
+};
+
+
+
+static struct file_operations yaffs_dir_operations = {
+	read:		generic_read_dir,
+	readdir:	yaffs_readdir,
+	fsync:		yaffs_sync_object,
+};
+
+static struct inode_operations yaffs_dir_inode_operations = {
+	create:		yaffs_create,
+	lookup:		yaffs_lookup,
+	link:		yaffs_link,
+	unlink:		yaffs_unlink,
+	symlink:	yaffs_symlink,
+	mkdir:		yaffs_mkdir,
+	rmdir:		yaffs_unlink,
+	mknod:		yaffs_mknod,
+	rename:		yaffs_rename,
+	setattr:	yaffs_setattr,
+};
+
+static struct super_operations yaffs_super_ops = {
+	statfs:			yaffs_statfs,
+	read_inode:		yaffs_read_inode,
+	put_inode:		yaffs_put_inode,
+//	read_inode:
+//	remount_fs:
+//	clear_inode:
+};
+
+
+struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Object *obj);
+
+/*
+ * Lookup is used to find objects in the fs
+ */
+static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry)
+{
+	yaffs_Object *obj;
+	struct inode *inode;
+
+
+	T((KERN_DEBUG"yaffs_lookup for %d:%s\n",yaffs_InodeToObject(dir)->objectId,dentry->d_name.name));
+
+	obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir),dentry->d_name.name);
+
+	if(obj)
+	{
+		T((KERN_DEBUG"yaffs_lookup found %d\n",obj->objectId));
+
+		inode = yaffs_get_inode(dir->i_sb, obj->st_mode,0,obj);
+
+		if(inode)
+		{
+			T((KERN_DEBUG"yaffs_loookup looks good\n"));
+			dget(dentry); // try to solve directory bug
+			d_add(dentry,inode);
+			return dentry;
+		}
+
+	}
+	else
+	{
+		T((KERN_DEBUG"yaffs_lookup not found\n"));
+
+	}
+	return NULL;
+
+}
+
+// For now put inode is just for debugging
+static void yaffs_put_inode(struct inode *inode)
+{
+	T(("yaffs_put_inode: ino %d, count %d\n",(int)inode->i_ino, atomic_read(&inode->i_count)));
+}
+
+#ifdef YAFFS_ADDRESS_OPS
+static int yaffs_readpage(struct file *file, struct page * page)
+{
+	T((KERN_DEBUG"yaffs_readpage\n"));
+
+	// TODO
+	return 0;
+}
+
+static int yaffs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to)
+{
+	T((KERN_DEBUG"yaffs_prepare_write\n"));
+
+	//TODO
+	return 0;
+}
+
+static int yaffs_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to)
+{
+
+	struct inode *inode = page->mapping->host;
+	loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
+
+	T((KERN_DEBUG"yaffs_commit_write\n"));
+
+	return 0;
+}
+
+#endif //YAFFS_ADDRESS_OPS
+
+
+static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj)
+{
+	if (inode && obj)
+	{
+		inode->i_ino = obj->objectId;
+		inode->i_mode = obj->st_mode;
+		inode->i_uid = obj->st_uid;
+		inode->i_gid = obj->st_gid;
+		inode->i_blksize = YAFFS_BYTES_PER_CHUNK;
+		inode->i_blocks = 0;
+		inode->i_rdev = NODEV;
+		inode->i_mapping->a_ops = &yaffs_address_ops;
+		inode->i_atime = obj->st_atime;
+		inode->i_mtime = obj->st_mtime;
+		inode->i_ctime = obj->st_ctime;
+		inode->i_size = yaffs_GetObjectFileLength(obj);
+		inode->i_nlink = yaffs_GetObjectLinkCount(obj);
+
+		T((KERN_DEBUG"yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
+				inode->i_mode, inode->i_uid, inode->i_gid, (int)inode->i_size, atomic_read(&inode->i_count)));
+
+		switch (obj->st_mode & S_IFMT)
+		{
+			default:
+			//	init_special_inode(inode, mode, dev);
+				break;
+			case S_IFREG:	// file
+				inode->i_op = &yaffs_file_inode_operations;
+				inode->i_fop = &yaffs_file_operations;
+				break;
+			case S_IFDIR:	// directory
+				inode->i_op = &yaffs_dir_inode_operations;
+				inode->i_fop = &yaffs_dir_operations;
+				break;
+			case S_IFLNK:	// symlink
+				inode->i_op = &page_symlink_inode_operations;
+				break;
+		}
+
+
+		inode->u.generic_ip = obj;
+
+	}
+	else
+	{
+		T((KERN_DEBUG"yaffs_FileInode invalid parameters\n"));
+	}
+
+}
+
+struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Object *obj)
+{
+	struct inode * inode;
+
+	T((KERN_DEBUG"yaffs_get_inode for object %d\n",obj->objectId));
+
+	inode = iget(sb,obj->objectId);
+
+	// No need to call this since iget calls it via the read_inode callback
+	// yaffs_FillInodeFromObject(inode,obj);
+
+	return inode;
+}
+
+static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos)
+{
+	yaffs_Object *obj;
+	int nRead,ipos;
+	struct inode *inode;
+
+	T((KERN_DEBUG"yaffs_file_read\n"));
+
+	obj  = yaffs_DentryToObject(f->f_dentry);
+	inode = f->f_dentry->d_inode;
+
+	if (*pos < inode->i_size)
+	{
+			if (*pos + n > inode->i_size)
+			{
+				n = inode->i_size - *pos;
+			}
+	}
+	else
+	{
+		n = 0;
+	}
+
+	nRead = yaffs_ReadDataFromFile(obj,buf,*pos,n);
+	if(nRead > 0)
+	{
+		f->f_pos += nRead;
+	}
+	ipos = *pos;
+	T((KERN_DEBUG"yaffs_file_read read %d bytes, %d read at %d\n",n,nRead,ipos));
+	return nRead;
+
+}
+
+static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos)
+{
+	yaffs_Object *obj;
+	int nWritten,ipos;
+	struct inode *inode;
+
+	obj  = yaffs_DentryToObject(f->f_dentry);
+	inode = f->f_dentry->d_inode;
+	nWritten = yaffs_WriteDataToFile(obj,buf,*pos,n);
+	ipos = *pos;
+	T((KERN_DEBUG"yaffs_file_write writing %d bytes, %d written at %d\n",n,nWritten,ipos));
+	if(nWritten > 0)
+	{
+		*pos += nWritten;
+		ipos = *pos;
+		if(*pos > inode->i_size)
+		{
+			inode->i_size = *pos;
+			T((KERN_DEBUG"yaffs_file_write size updated to %d\n",ipos));
+		}
+
+	}
+	return nWritten;
+}
+
+
+static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
+{
+	yaffs_Object *obj;
+	struct inode *inode = f->f_dentry->d_inode;
+	unsigned long offset, curoffs;
+	struct list_head *i;
+	yaffs_Object *l;
+
+	char name[YAFFS_MAX_NAME_LENGTH	+1];
+
+	obj =  yaffs_DentryToObject(f->f_dentry);
+
+	offset = f->f_pos;
+
+	T(("yaffs_readdir: starting at %d\n",(int)offset));
+
+	if(offset == 0)
+	{
+        T((KERN_DEBUG"yaffs_readdir: entry . ino %d \n",(int)inode->i_ino));
+		if(filldir(dirent,".",1,offset,inode->i_ino,DT_DIR) < 0)
+		{
+			goto out;
+		}
+		offset++;
+		f->f_pos++;
+	}
+	if(offset == 1)
+	{
+		T((KERN_DEBUG"yaffs_readdir: entry .. ino %d \n",(int)f->f_dentry->d_parent->d_inode->i_ino));
+		if(filldir(dirent,"..",2,offset,f->f_dentry->d_parent->d_inode->i_ino,DT_DIR) < 0)
+		{
+			goto out;
+		}
+		offset++;
+		f->f_pos++;
+	}
+
+	curoffs = 1;
+
+	//down(&obj->sem);
+
+
+	list_for_each(i,&obj->variant.directoryVariant.children)
+	{
+		curoffs++;
+		if(curoffs >= offset)
+		{
+			l = list_entry(i, yaffs_Object,siblings);
+
+			yaffs_GetObjectName(l,name,YAFFS_MAX_NAME_LENGTH+1);
+			T((KERN_DEBUG"yaffs_readdir: %s inode %d\n",name,yaffs_GetObjectInode(l)));
+
+			if(filldir(dirent,
+					   name,
+					   strlen(name),
+					   offset,
+					   yaffs_GetObjectInode(l),
+					   yaffs_GetObjectType(l))
+					   < 0)
+			{
+				goto up_and_out;
+			}
+
+			offset++;
+			f->f_pos++;
+		}
+	}
+
+  up_and_out:
+
+	//up(&obj->sem);
+
+  out:
+	return 0;
+}
+
+
+/*
+ * File creation. Allocate an inode, and we're done..
+ */
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev)
+{
+	struct inode *inode;
+
+	yaffs_Object *obj = NULL;
+	yaffs_Object *parent = yaffs_InodeToObject(dir);
+
+	int error = -ENOSPC;
+
+	if(parent)
+	{
+		T((KERN_DEBUG"yaffs_mknod: parent object %d type %d\n",
+					 parent->objectId,parent->variantType));
+	}
+	else
+	{
+		T((KERN_DEBUG"yaffs_mknod: could not get parent object\n"));
+		return -EPERM;
+	}
+
+	T(("yaffs_mknod: making oject for %s, mode %x\n",
+				dentry->d_name.name, mode));
+
+	switch (mode & S_IFMT)
+	{
+		default:
+
+			break;
+		case S_IFREG:	// file
+			T((KERN_DEBUG"yaffs_mknod: making file\n"));
+			obj = yaffs_MknodFile(parent,dentry->d_name.name,mode,current->uid, current->gid);
+			break;
+		case S_IFDIR:	// directory
+			T((KERN_DEBUG"yaffs_mknod: making directory\n"));
+			obj = yaffs_MknodDirectory(parent,dentry->d_name.name,mode,current->uid, current->gid);
+			break;
+		case S_IFLNK:	// symlink
+			T((KERN_DEBUG"yaffs_mknod: making file\n"));
+			obj = NULL; // Todo
+			break;
+	}
+
+	if(obj)
+	{
+		inode = yaffs_get_inode(dir->i_sb, mode, dev, obj);
+
+// did not fix dir bug		if((mode & S_IFMT) == S_IFDIR)	atomic_inc(&inode->i_count);
+
+		d_instantiate(dentry, inode);
+		T((KERN_DEBUG"yaffs_mknod created object %d count = %d\n",obj->objectId,atomic_read(&inode->i_count)));
+		error = 0;
+	}
+	else
+	{
+		T((KERN_DEBUG"yaffs_mknod failed making object\n"));
+		error = -ENOMEM;
+	}
+
+
+	return error;
+}
+
+static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
+{
+	int retVal;
+	T((KERN_DEBUG"yaffs_mkdir\n"));
+	retVal =  yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
+#if 0
+ // attempt to fix dir bug - didn't work
+	if(!retVal)
+	{
+		dget(dentry);
+	}
+#endif
+	return retVal;
+}
+
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
+{
+	T((KERN_DEBUG"yaffs_create\n"));
+	return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
+}
+
+
+static int yaffs_unlink(struct inode * dir, struct dentry *dentry)
+{
+
+	T((KERN_DEBUG"yaffs_unlink\n"));
+
+	if(yaffs_Unlink(yaffs_InodeToObject(dir),dentry->d_name.name) == YAFFS_OK)
+	{
+		return 0;
+	}
+	else
+	{
+		return -ENOTEMPTY;
+	}
+}
+
+
+/*
+ * Link a file..
+ */
+static int yaffs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry)
+{
+	struct inode *inode = old_dentry->d_inode;
+
+	T((KERN_DEBUG"yaffs_link\n"));
+
+	return -EPERM; //Todo
+
+
+	if (S_ISDIR(inode->i_mode))
+		return -EPERM;
+
+
+	return 0;
+}
+
+
+static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
+{
+	int error;
+
+	T((KERN_DEBUG"yaffs_symlink\n"));
+
+
+	return -ENOMEM; //Todo
+
+	error = yaffs_mknod(dir, dentry, S_IFLNK | S_IRWXUGO, 0);
+	return error;
+}
+
+static int yaffs_sync_object(struct file * file, struct dentry *dentry, int datasync)
+{
+
+	T((KERN_DEBUG"yaffs_sync_object\n"));
+	yaffs_FlushFile(yaffs_DentryToObject(dentry));
+	return 0;
+}
+
+/*
+ * The VFS layer already does all the dentry stuff for rename.
+ */
+static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry)
+{
+
+
+	if( yaffs_RenameObject(yaffs_InodeToObject(old_dir),old_dentry->d_name.name,
+	                       yaffs_InodeToObject(new_dir),new_dentry->d_name.name) == YAFFS_OK)
+	{
+		return 0;
+	}
+	else
+	{
+		return -ENOTEMPTY;
+	}
+
+
+}
+
+static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
+{
+	struct inode *inode = dentry->d_inode;
+	int error;
+
+	T((KERN_DEBUG"yaffs_setattr\n"));
+
+	if((error = inode_change_ok(inode,attr)) == 0)
+	{
+
+		if(yaffs_SetAttributes(yaffs_InodeToObject(inode),attr) == YAFFS_OK)
+		{
+			error = 0;
+		}
+		else
+		{
+			error = -EPERM;
+		}
+
+		inode_setattr(inode,attr);
+	}
+	return error;
+}
+
+static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
+{
+	T((KERN_DEBUG"yaffs_statfs\n"));
+
+	buf->f_type = YAFFS_MAGIC;
+	buf->f_bsize = YAFFS_BYTES_PER_CHUNK;
+	buf->f_namelen = 255;
+	buf->f_blocks = yaffs_SuperToDevice(sb)->nBlocks * YAFFS_CHUNKS_PER_BLOCK;
+	buf->f_files = 0;
+	buf->f_ffree = 0;
+	buf->f_bavail = yaffs_GetNumberOfFreeChunks(yaffs_SuperToDevice(sb));
+	return 0;
+}
+
+static void yaffs_read_inode (struct inode *inode)
+{
+
+	yaffs_Object *obj ;
+
+	T((KERN_DEBUG"yaffs_read_inode for %d\n",(int)inode->i_ino));
+
+	obj  = yaffs_FindObjectByNumber(yaffs_SuperToDevice(inode->i_sb),inode->i_ino);
+
+	yaffs_FillInodeFromObject(inode,obj);
+}
+
+
+static struct super_block *yaffs_internal_read_super(int useRam, struct super_block * sb, void * data, int silent)
+{
+	struct inode * inode;
+	struct dentry * root;
+	yaffs_Device *dev;
+
+
+	T(("yaffs_read_super:\n"));
+	sb->s_blocksize = YAFFS_BYTES_PER_CHUNK;
+	sb->s_blocksize_bits = YAFFS_CHUNK_SIZE_SHIFT;
+	sb->s_magic = YAFFS_MAGIC;
+	sb->s_op = &yaffs_super_ops;
+
+	if(!sb)
+		printk(KERN_INFO"sb is NULL\n");
+	else if(!sb->s_dev)
+		printk(KERN_INFO"sb->s_dev is NULL\n");
+	else if(! kdevname(sb->s_dev))
+		printk(KERN_INFO"kdevname is NULL\n");
+	else
+		printk(KERN_INFO"dev is %d name is \"%s\"\n", sb->s_dev, kdevname(sb->s_dev));
+
+
+	if(useRam)
+	{
+
+#if YAFFS_RAM_ENABLED
+		// Set the yaffs_Device up for ram emulation
+
+		sb->u.generic_sbp =	dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
+		if(!dev)
+		{
+			// Deep shit could not allocate device structure
+			printk(KERN_DEBUG"yaffs_read_super: Failed trying to allocate yaffs_Device. Terminating debug.\n");
+			return NULL;
+		}
+
+		memset(dev,0,sizeof(yaffs_Device));
+		dev->genericDevice = NULL; // Not used for RAM emulation.
+
+		dev->nBlocks = YAFFS_RAM_EMULATION_SIZE / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
+		dev->startBlock = 1;  // Don't use block 0
+		dev->endBlock = dev->nBlocks - 1;
+
+		dev->writeChunkToNAND = nandemul_WriteChunkToNAND;
+		dev->readChunkFromNAND = nandemul_ReadChunkFromNAND;
+		dev->eraseBlockInNAND = nandemul_EraseBlockInNAND;
+		dev->initialiseNAND = nandemul_InitialiseNAND;
+#endif
+
+	}
+	else
+	{
+#ifdef YAFFS_MTD_ENABLED
+		struct mtd_info *mtd;
+
+		// Hope it's a NAND mtd
+		mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
+		if (!mtd)
+		{
+			printk(KERN_DEBUG "yaffs: MTD device #%u doesn't appear to exist\n", MINOR(sb->s_dev));
+			return NULL;
+		}
+		if(mtd->type != MTD_NANDFLASH)
+		{
+			printk(KERN_DEBUG "yaffs: MTD device is not NAND it's type %d\n", mtd->type);
+			return NULL;
+		}
+
+		if(!mtd->erase ||
+		   !mtd->read  ||
+		   !mtd->write ||
+		   !mtd->read_oob ||
+		   !mtd->write_oob)
+		{
+			printk(KERN_DEBUG "yaffs: MTD device does not support required functions\n");
+			return NULL;
+		}
+
+		if(mtd->oobblock != YAFFS_BYTES_PER_CHUNK ||
+		   mtd->oobsize != YAFFS_BYTES_PER_SPARE)
+		{
+			printk(KERN_DEBUG "yaffs: MTD device does not support have the right page sizes\n");
+			return NULL;
+		}
+
+
+		// OK, so if we got here, we have an MTD that's NAND and looks
+		// like it has the right capabilities
+		// Set the yaffs_Device up for ram emulation
+
+		sb->u.generic_sbp =	dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
+		if(!dev)
+		{
+			// Deep shit could not allocate device structure
+			printk(KERN_DEBUG"yaffs_read_super: Failed trying to allocate yaffs_Device. Terminating debug.\n");
+			return NULL;
+		}
+
+		memset(dev,0,sizeof(yaffs_Device));
+		dev->genericDevice = mtd;
+
+		// Set up the memory size parameters....
+
+		dev->nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
+		dev->startBlock = 1;  // Don't use block 0
+		dev->endBlock = dev->nBlocks - 1;
+
+		// ... and the functions.
+		dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
+		dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
+		dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
+		dev->initialiseNAND = nandmtd_InitialiseNAND;
+
+#endif
+	}
+
+
+
+	yaffs_GutsInitialise(yaffs_SuperToDevice(sb));
+	T(("yaffs_read_super: guts initialised\n"));
+
+	// Create root inode
+	inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,yaffs_Root(yaffs_SuperToDevice(sb)));
+	if (!inode)
+		return NULL;
+
+	T(("yaffs_read_super: got root inode\n"));
+
+
+	root = d_alloc_root(inode);
+
+	T(("yaffs_read_super: d_alloc_root done\n"));
+
+	if (!root) {
+		iput(inode);
+		return NULL;
+	}
+	sb->s_root = root;
+
+	T(("yaffs_read_super: done\n"));
+	return sb;
+}
+
+#ifdef YAFFS_MTD_ENABLED
+static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent)
+{
+	return yaffs_internal_read_super(0,sb,data,silent);
+}
+
+static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV);
+#endif
+
+#ifdef YAFFS_RAM_ENABLED
+
+static struct super_block *yaffs_ram_read_super(struct super_block * sb, void * data, int silent)
+{
+	return yaffs_internal_read_super(1,sb,data,silent);
+}
+
+static DECLARE_FSTYPE(yaffs_ram_fs_type, "yaffsram", yaffs_ram_read_super, FS_SINGLE);
+#endif // YAFFS_RAM_ENABLED
+
+
+static struct proc_dir_entry *my_proc_entry;
+
+
+static int  yaffs_proc_read(
+        char *page,
+	char **start,
+	off_t offset,
+	int count,
+	int *eof,
+	void *data
+	)
+{
+
+	static char my_buffer[1000];
+
+	if (offset > 0) return 0;
+
+	/* Fill the buffer and get its length */
+	sprintf( my_buffer,
+		"YAFFS built:"__DATE__ " "__TIME__"\n"
+
+	);
+
+	strcpy(page,my_buffer);
+	return strlen(my_buffer);
+}
+
+static int __init init_yaffs_fs(void)
+{
+	int error = 0;
+
+	printk(KERN_DEBUG "yaffs " __DATE__ " " __TIME__ " Initialisation\n");
+    /* Install the proc_fs entry */
+    my_proc_entry = create_proc_read_entry("yaffs",
+                                           S_IRUGO | S_IFREG,
+					   &proc_root,
+					   yaffs_proc_read,
+					   NULL);
+    if(!my_proc_entry)
+    {
+       return -ENOMEM;
+    }
+
+#ifdef YAFFS_RAM_ENABLED
+
+    error = register_filesystem(&yaffs_ram_fs_type);
+    if(error)
+    {
+    	return error;
+    }
+#endif //YAFFS_RAM_ENABLED
+
+#ifdef YAFFS_MTD_ENABLED
+	error = register_filesystem(&yaffs_fs_type);
+	if(error)
+	{
+#ifdef YAFFS_RAM_ENABLED
+		unregister_filesystem(&yaffs_ram_fs_type);
+#endif //YAFFS_RAM_ENABLED
+	}
+#endif // YAFFS_MTD_ENABLED
+
+	return error;
+}
+
+static void __exit exit_yaffs_fs(void)
+{
+	printk(KERN_DEBUG "yaffs " __DATE__ " " __TIME__ " Clean up\n");
+
+    remove_proc_entry("yaffs",&proc_root);
+
+#ifdef YAFFS_RAM_ENABLED
+	unregister_filesystem(&yaffs_ram_fs_type);
+#endif
+#ifdef YAFFS_MTD_ENABLED
+	unregister_filesystem(&yaffs_fs_type);
+#endif
+
+}
+
+module_init(init_yaffs_fs)
+module_exit(exit_yaffs_fs)
+
+MODULE_DESCRIPTION("YAFFS - a NAND specific flash file system");
+MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002");
+MODULE_LICENSE("GPL");
+
diff --git a/yaffs_guts.c b/yaffs_guts.c
new file mode 100644
index 0000000..6bc6136
--- /dev/null
+++ b/yaffs_guts.c
@@ -0,0 +1,3079 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ * yaffs_guts.c  The main guts of YAFFS
+ *
+ * Copyright (C) 2002 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_guts.c
+
+#include "yportenv.h"
+
+#include "yaffsinterface.h"
+#include "yaffs_guts.h"
+
+
+#if 0
+#define T(x) printf x
+#else
+#define T(x)
+#endif
+
+
+// countBits is a quick way of counting the number of bits in a byte.
+// ie. countBits[n] holds the number of 1 bits in a byte with the value n.
+
+static const char yaffs_countBits[256] =
+{
+0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
+};
+
+
+
+// Device info
+//static yaffs_Device *yaffs_device;
+//yaffs_Object *yaffs_rootDir;
+//yaffs_Object *yaffs_lostNFound;
+
+
+
+// Local prototypes
+static int yaffs_CheckObjectHashSanity(yaffs_Device *dev);
+static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr);
+static void yaffs_GetTagsFromSpare(yaffs_Spare *sparePtr,yaffs_Tags *tagsPtr);
+static int yaffs_PutChunkIntoFile(yaffs_Object *in,int chunkInInode, int chunkInNAND);
+
+static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectType type);
+static void yaffs_AddObjectToDirectory(yaffs_Object *directory, yaffs_Object *obj);
+static int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name);
+static void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId);
+static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj);
+static int yaffs_CheckStructures(void);
+static yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj);
+
+loff_t yaffs_GetFileSize(yaffs_Object *obj);
+
+
+static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve);
+
+#if YAFFS_PARANOID
+static int yaffs_CheckFileSanity(yaffs_Object *in)
+#else
+#define yaffs_CheckFileSanity(in)
+#endif
+
+static int __inline__ yaffs_HashFunction(int n)
+{
+	return (n % YAFFS_NOBJECT_BUCKETS);
+}
+
+
+yaffs_Object *yaffs_Root(yaffs_Device *dev)
+{
+	return dev->rootDir;
+}
+
+yaffs_Object *yaffs_LostNFound(yaffs_Device *dev)
+{
+	return dev->lostNFoundDir;
+}
+
+
+static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_Spare *spare)
+{
+	return dev->writeChunkToNAND(dev,chunkInNAND,data,spare);
+}
+
+int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)
+{
+	return dev->readChunkFromNAND(dev,chunkInNAND,data,spare);
+}
+
+int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,int blockInNAND)
+{
+	return dev->eraseBlockInNAND(dev,blockInNAND);
+}
+
+int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev)
+{
+	return dev->initialiseNAND(dev);
+}
+
+static int yaffs_WriteNewChunkToNAND(struct yaffs_DeviceStruct *dev, const __u8 *data, yaffs_Spare *spare,int useReserve)
+{
+	int chunk;
+	
+	int writeOk = 0;
+	
+	do{
+		chunk = yaffs_AllocateChunk(dev,useReserve);
+	
+		if(chunk >= 0)
+		{
+			writeOk =  yaffs_WriteChunkToNAND(dev,chunk,data,spare);
+			if(writeOk)
+			{
+				//Todo read-back and verify
+				// If verify fails, then delete this chunk and try again
+			}
+		}
+	} while(chunk >= 0 && ! writeOk);
+	
+	return chunk;
+}
+
+
+
+
+///////////////////////// Object management //////////////////
+// List of spare objects
+// The list is hooked together using the first pointer
+// in the object
+
+// static yaffs_Object *yaffs_freeObjects = NULL;
+
+// static int yaffs_nFreeObjects;
+
+// static yaffs_ObjectList *yaffs_allocatedObjectList = NULL;
+
+// static yaffs_ObjectBucket yaffs_objectBucket[YAFFS_NOBJECT_BUCKETS];
+
+
+static __u16 yaffs_CalcNameSum(const char *name)
+{
+	__u16 sum = 0;
+	__u16 i = 1;
+	
+	__u8 *bname = (__u8 *)name;
+	
+	while (*bname)
+	{
+		sum += (*bname) * i;
+		i++;
+		bname++;
+	}
+	return sum;
+}
+
+
+void yaffs_CalcECC(const __u8 *buffer, yaffs_Spare *spare)
+{
+
+	// Todo do nothing now. Need to put in ecc
+	spare->ecc1[0] = spare->ecc1[1] = spare->ecc1[2] = 0xFF;
+	spare->ecc2[0] = spare->ecc2[1] = spare->ecc2[2] = 0xFF;
+}
+
+void yaffs_CalcTagsECC(yaffs_Tags *tags)
+{
+	// Todo don't do anything yet. Need to calculate ecc
+	tags->ecc = 0xFFFFFFFF;
+}
+
+
+
+///////////////////////// TNODES ///////////////////////
+
+// List of spare tnodes
+// The list is hooked together using the first pointer
+// in the tnode.
+
+//static yaffs_Tnode *yaffs_freeTnodes = NULL;
+
+// static int yaffs_nFreeTnodes;
+
+//static yaffs_TnodeList *yaffs_allocatedTnodeList = NULL;
+
+
+
+// yaffs_CreateTnodes creates a bunch more tnodes and
+// adds them to the tnode free list.
+// Don't use this function directly
+
+static int yaffs_CreateTnodes(yaffs_Device *dev,int nTnodes)
+{
+    int i;
+    yaffs_Tnode *newTnodes;
+    yaffs_TnodeList *tnl;
+    
+    if(nTnodes < 1) return YAFFS_OK;
+   
+	// make these things
+	
+    newTnodes = YMALLOC(nTnodes * sizeof(yaffs_Tnode));
+   
+    if (!newTnodes)
+    {
+		YALERT("Could not malloc tnodes");
+		return YAFFS_FAIL;
+    }
+    
+    // Hook them into the free list
+    for(i = 0; i < nTnodes - 1; i++)
+    {
+    	newTnodes[i].internal[0] = &newTnodes[i+1];
+    }
+    	
+	newTnodes[nTnodes - 1].internal[0] = dev->freeTnodes;
+	dev->freeTnodes = newTnodes;
+	dev->nFreeTnodes+= nTnodes;
+	dev->nTnodesCreated += nTnodes;
+
+	// Now add this bunch of tnodes to a list for freeing up.
+
+	tnl = YMALLOC(sizeof(yaffs_TnodeList));
+	if(!tnl)
+	{
+		YALERT("Could not add tnodes to management list");
+	}
+	else
+	{
+		tnl->tnodes = newTnodes;
+		tnl->next = dev->allocatedTnodeList;
+		dev->allocatedTnodeList = tnl;
+	}
+
+
+	YINFO("Tnodes created");
+
+
+	return YAFFS_OK;
+}
+
+
+// GetTnode gets us a clean tnode. Tries to make allocate more if we run out
+static yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev)
+{
+	yaffs_Tnode *tn = NULL;
+	
+	// If there are none left make more
+	if(!dev->freeTnodes)
+	{
+		yaffs_CreateTnodes(dev,YAFFS_ALLOCATION_NTNODES);
+	}
+	
+	if(dev->freeTnodes)
+	{
+		tn = dev->freeTnodes;
+		dev->freeTnodes = dev->freeTnodes->internal[0];
+		dev->nFreeTnodes--;
+		// zero out
+		memset(tn,0,sizeof(yaffs_Tnode));
+	}
+	
+
+	return tn;
+}
+
+
+// FreeTnode frees up a tnode and puts it back on the free list
+static void yaffs_FreeTnode(yaffs_Device*dev, yaffs_Tnode *tn)
+{
+	tn->internal[0] = dev->freeTnodes;
+	dev->freeTnodes = tn;
+	dev->nFreeTnodes++;
+}
+
+
+static void yaffs_DeinitialiseTnodes(yaffs_Device*dev)
+{
+	// Free the list of allocated tnodes
+	
+	while(dev->allocatedTnodeList)
+	{
+		YFREE(dev->allocatedTnodeList->tnodes);
+		dev->allocatedTnodeList =  dev->allocatedTnodeList->next;
+	}
+	
+	dev->freeTnodes = NULL;
+	dev->nFreeTnodes = 0;
+}
+
+static void yaffs_InitialiseTnodes(yaffs_Device*dev)
+{
+	dev->allocatedTnodeList = NULL;
+	dev->freeTnodes = NULL;
+	dev->nFreeTnodes = 0;
+	dev->nTnodesCreated = 0;
+
+}
+
+void yaffs_TnodeTest(yaffs_Device *dev)
+{
+
+	int i;
+	int j;
+	yaffs_Tnode *tn[1000];
+	
+	YINFO("Testing TNodes");
+	
+	for(j = 0; j < 50; j++)
+	{
+		for(i = 0; i < 1000; i++)
+		{
+			tn[i] = yaffs_GetTnode(dev);
+			if(!tn[i])
+			{
+				YALERT("Getting tnode failed");
+			}
+		}
+		for(i = 0; i < 1000; i+=3)
+		{
+			yaffs_FreeTnode(dev,tn[i]);
+			tn[i] = NULL;
+		}
+		
+	}
+}
+
+////////////////// END OF TNODE MANIPULATION ///////////////////////////
+
+/////////////// Functions to manipulate the look-up tree (made up of tnodes)
+// The look up tree is represented by the top tnode and the number of topLevel
+// in the tree. 0 means only the level 0 tnode is in the tree.
+
+
+// FindLevel0Tnode finds the level 0 tnode, if one exists.
+// Used when reading.....
+static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,yaffs_FileStructure *fStruct, __u32 chunkId)
+{
+	
+	yaffs_Tnode *tn = fStruct->top;
+	__u32 i;
+	int requiredTallness;	
+	int level = fStruct->topLevel;
+	
+	// Check sane level and chunk Id
+	if(level < 0 || level > YAFFS_TNODES_MAX_LEVEL)
+	{
+		char str[50];
+		sprintf(str,"Bad level %d",level);
+		YALERT(str);
+		return NULL;
+	}
+	if(chunkId > YAFFS_MAX_CHUNK_ID)
+	{
+		char str[50];
+		sprintf(str,"Bad chunkId %d",chunkId);
+		YALERT(str);
+		return NULL;
+	}
+
+	// First check we're tall enough (ie enough topLevel)
+	
+	i = chunkId >> (dev->chunkGroupBits + YAFFS_TNODES_LEVEL0_BITS);
+	requiredTallness = 0;
+	while(i)
+	{
+		i >>= YAFFS_TNODES_INTERNAL_BITS;
+		requiredTallness++;
+	}
+	
+	
+	if(requiredTallness > fStruct->topLevel)
+	{
+		// Not tall enough, so we can't find it, return NULL.
+		return NULL;
+	}
+		
+	
+	// Traverse down to level 0
+	while (level > 0 && tn)
+	{
+	    tn = tn->internal[(chunkId >>(dev->chunkGroupBits + YAFFS_TNODES_LEVEL0_BITS + (level-1) * YAFFS_TNODES_INTERNAL_BITS)) & 
+	                       YAFFS_TNODES_INTERNAL_MASK]; 
+		level--;
+	
+	}
+	
+	return tn;		
+}
+
+// AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree.
+// This happens in two steps:
+//  1. If the tree isn't tall enough, then make it taller.
+//  2. Scan down the tree towards the level 0 tnode adding tnodes if required.
+//
+// Used when modifying the tree.
+//
+static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStructure *fStruct, __u32 chunkId)
+{
+	
+	yaffs_Tnode *tn; 
+	
+	int requiredTallness;
+	
+	__u32 i;
+	__u32 l;
+	
+	
+	T(("AddOrFind topLevel=%d, chunk=%d",fStruct->topLevel,chunkId));
+	
+	// Check sane level and page Id
+	if(fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL)
+	{
+		char str[50];
+		sprintf(str,"Bad level %d",fStruct->topLevel);
+		YALERT(str);
+		return NULL;
+	}
+	
+	if(chunkId > YAFFS_MAX_CHUNK_ID)
+	{
+		char str[50];
+		sprintf(str,"Bad chunkId %d",chunkId);
+		YALERT(str);
+		return NULL;
+	}
+	
+	// First check we're tall enough (ie enough topLevel)
+	
+	i = chunkId >> (dev->chunkGroupBits + YAFFS_TNODES_LEVEL0_BITS);
+	requiredTallness = 0;
+	while(i)
+	{
+		i >>= YAFFS_TNODES_INTERNAL_BITS;
+		requiredTallness++;
+	}
+	
+	T((" required=%d",requiredTallness));
+	
+	
+	if(requiredTallness > fStruct->topLevel)
+	{
+		// Not tall enough,gotta make the tree taller
+		for(i = fStruct->topLevel; i < requiredTallness; i++)
+		{
+			T((" add new top"));
+			
+			tn = yaffs_GetTnode(dev);
+			
+			if(tn)
+			{
+				tn->internal[0] = fStruct->top;
+				fStruct->top = tn;
+			}
+			else
+			{
+				YALERT("No more tnodes");
+			}
+		}
+		
+		fStruct->topLevel = requiredTallness;
+	}
+	
+	
+	// Traverse down to level 0, adding anything we need
+	
+	l = fStruct->topLevel;
+	tn = fStruct->top;
+	while (l > 0 && tn)
+	{
+		i = (chunkId >> (dev->chunkGroupBits +YAFFS_TNODES_LEVEL0_BITS + (l-1) * YAFFS_TNODES_INTERNAL_BITS)) & 
+	                       YAFFS_TNODES_INTERNAL_MASK;
+			       
+		T((" [%d:%d]",l,i));
+		
+	    if(!tn->internal[i])
+	    {
+	    	T((" added"));
+		
+	    	tn->internal[i] = yaffs_GetTnode(dev);
+	    }
+	    
+	    tn = 	tn->internal[i];
+		l--;
+	
+	}
+	
+	T(("\n"));
+	
+	return tn;		
+}
+
+
+// Pruning removes any part of the file structure tree that is beyond the
+// bounds of the file.
+// A file should only get pruned when its size is reduced.
+//
+// Before pruning, the chunks must be pulled from the tree and the
+// level 0 tnode entries must be zeroed out.
+// Could also use this for file deletion, but that's probably better handled
+// by a special case.
+
+// yaffs_PruneWorker should only be called by yaffs_PruneFileStructure()
+
+static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn, __u32 level, int del0)
+{
+	int i;
+	int hasData;
+	
+	if(tn)
+	{
+		hasData = 0;
+		
+		for(i = 0; i < YAFFS_NTNODES_INTERNAL; i++)
+		{
+		    if(tn->internal[i] && level > 0)
+		    {
+		    	tn->internal[i] = yaffs_PruneWorker(dev,tn->internal[i],level - 1, ( i == 0) ? del0 : 1);
+		    }
+		    
+		    if(tn->internal[i])
+		    {
+		    	hasData++;
+			}
+		}
+		
+		if(hasData == 0 && del0)
+		{
+			// Free and return NULL
+			
+			yaffs_FreeTnode(dev,tn);
+			tn = NULL;
+		}
+		
+	}
+
+	return tn;
+	
+}
+
+static int yaffs_PruneFileStructure(yaffs_Device *dev, yaffs_FileStructure *fStruct)
+{
+	int i;
+	int hasData;
+	int done = 0;
+	yaffs_Tnode *tn;
+	
+	if(fStruct->topLevel > 0)
+	{
+		fStruct->top = yaffs_PruneWorker(dev,fStruct->top, fStruct->topLevel,0);
+		
+		// Now we have a tree with all the non-zero branches NULL but the height
+		// is the same as it was.
+		// Let's see if we can trim internal tnodes to shorten the tree.
+		// We can do this if only the 0th element in the tnode is in use 
+		// (ie all the non-zero are NULL)
+		
+		while(fStruct->topLevel && !done)
+		{
+			tn = fStruct->top;
+			
+			hasData = 0;
+			for(i = 1; i <YAFFS_NTNODES_INTERNAL; i++)
+			{
+				if(tn->internal[i])
+		    	{
+		    		hasData++;
+				}
+			}
+			
+			if(!hasData)
+			{
+				fStruct->top = tn->internal[0];
+				fStruct->topLevel--;
+				yaffs_FreeTnode(dev,tn);
+			}
+			else
+			{
+				done = 1;
+			}
+		}
+	}
+	
+	return YAFFS_OK;
+}
+
+
+
+
+/////////////////////// End of File Structure functions. /////////////////
+
+// yaffs_CreateFreeObjects creates a bunch more objects and
+// adds them to the object free list.
+static int yaffs_CreateFreeObjects(yaffs_Device *dev, int nObjects)
+{
+    int i;
+    yaffs_Object *newObjects;
+    yaffs_ObjectList *list;
+    
+    if(nObjects < 1) return YAFFS_OK;
+   
+	// make these things
+	
+    newObjects = YMALLOC(nObjects * sizeof(yaffs_Object));
+   
+    if (!newObjects)
+    {
+		YALERT("Could not allocate more objects");
+		return YAFFS_FAIL;
+    }
+    
+    // Hook them into the free list
+    for(i = 0; i < nObjects - 1; i++)
+    {
+    	(yaffs_Object *)newObjects[i].siblings.next = &newObjects[i+1];
+    }
+    	
+	newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
+	dev->freeObjects = newObjects;
+	dev->nFreeObjects+= nObjects;
+	dev->nObjectsCreated+= nObjects;
+	
+	// Now add this bunch of Objects to a list for freeing up.
+	
+	list = YMALLOC(sizeof(yaffs_ObjectList));
+	if(!list)
+	{
+		YALERT("Could not add Objects to management list");
+	}
+	else
+	{
+		list->objects = newObjects;
+		list->next = dev->allocatedObjectList;
+		dev->allocatedObjectList = list;
+	}
+	
+	
+	YINFO("Objects created");
+	
+	
+	return YAFFS_OK;
+}
+
+
+// AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out
+static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev)
+{
+	yaffs_Object *tn = NULL;
+	
+	// If there are none left make more
+	if(!dev->freeObjects)
+	{
+		yaffs_CreateFreeObjects(dev,YAFFS_ALLOCATION_NOBJECTS);
+	}
+	
+	if(dev->freeObjects)
+	{
+		tn = dev->freeObjects;
+		dev->freeObjects = (yaffs_Object *)(dev->freeObjects->siblings.next);
+		dev->nFreeObjects--;
+		
+		// Now sweeten it up...
+	
+		memset(tn,0,sizeof(yaffs_Object));
+		tn->chunkId = -1;
+		tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
+		INIT_LIST_HEAD(&(tn->hardLinks));
+		INIT_LIST_HEAD(&(tn->hashLink));
+		INIT_LIST_HEAD(&tn->siblings);
+		
+		// Add it to the lost and found directory.
+		// NB Can't put root or lostNFound in lostNFound so
+		// check if lostNFound exists first
+		if(dev->lostNFoundDir)
+		{
+			yaffs_AddObjectToDirectory(dev->lostNFoundDir,tn);	
+		}
+	}
+	
+
+	return tn;
+}
+
+static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device *dev,int number,__u32 mode)
+{
+
+	yaffs_Object *obj = yaffs_CreateNewObject(dev,number,YAFFS_OBJECT_TYPE_DIRECTORY);		
+	if(obj)
+	{
+		obj->fake = 1;			// it is fake so it has no NAND presence...
+		obj->renameAllowed= 0;	// ... and we're not allowed to rename it...
+		obj->unlinkAllowed= 0;	// ... or unlink it
+		obj->st_mode = mode;
+		obj->myDev = dev;
+		obj->chunkId = 0; // Not a valid chunk.
+	}
+	
+	return obj;
+	
+}
+
+
+static void yaffs_UnhashObject(yaffs_Object *tn)
+{
+	int bucket;
+	yaffs_Device *dev = tn->myDev;
+	
+	
+	// If it is still linked into the bucket list, free from the list
+	if(!list_empty(&tn->hashLink))
+	{
+		list_del_init(&tn->hashLink);
+		bucket =  yaffs_HashFunction(tn->objectId);
+		dev->objectBucket[bucket].count--;
+	}
+	
+}
+
+
+// FreeObject frees up a Object and puts it back on the free list
+static void yaffs_FreeObject(yaffs_Object *tn)
+{
+
+	yaffs_Device *dev = tn->myDev;
+	
+	yaffs_UnhashObject(tn);
+	
+	// Link into the free list.
+	(yaffs_Object *)(tn->siblings.next) = dev->freeObjects;
+	dev->freeObjects = tn;
+	dev->nFreeObjects++;
+}
+
+
+
+
+static void yaffs_DeinitialiseObjects(yaffs_Device *dev)
+{
+	// Free the list of allocated Objects
+	
+	while( dev->allocatedObjectList)
+	{
+		YFREE(dev->allocatedObjectList->objects);
+		dev->allocatedObjectList =  dev->allocatedObjectList->next;
+	}
+	
+	dev->freeObjects = NULL;
+	dev->nFreeObjects = 0;
+}
+
+static void yaffs_InitialiseObjects(yaffs_Device *dev)
+{
+	int i;
+	
+	dev->allocatedObjectList = NULL;
+	dev->freeObjects = NULL;
+	dev->nFreeObjects = 0;
+	
+	for(i = 0; i < YAFFS_NOBJECT_BUCKETS; i++)
+	{
+		INIT_LIST_HEAD(&dev->objectBucket[i].list);
+		dev->objectBucket[i].count = 0;	
+	}
+
+}
+
+
+
+
+
+
+int yaffs_FindNiceObjectBucket(yaffs_Device *dev)
+{
+	static int x = 0;
+	int i;
+	int l = 999;
+	int lowest = 999999;
+
+		
+	// First let's see if we can find one that's empty.
+	
+	for(i = 0; i < 10 && lowest > 0; i++)
+	 {
+		x++;
+		x %=  YAFFS_NOBJECT_BUCKETS;
+		if(dev->objectBucket[x].count < lowest)
+		{
+			lowest = dev->objectBucket[x].count;
+			l = x;
+		}
+		
+	}
+	
+	// If we didn't find an empty list, then try
+	// looking a bit further for a short one
+	
+	for(i = 0; i < 10 && lowest > 3; i++)
+	 {
+		x++;
+		x %=  YAFFS_NOBJECT_BUCKETS;
+		if(dev->objectBucket[x].count < lowest)
+		{
+			lowest = dev->objectBucket[x].count;
+			l = x;
+		}
+		
+	}
+	
+	return l;
+}
+
+static int yaffs_CreateNewObjectNumber(yaffs_Device *dev)
+{
+	int bucket = yaffs_FindNiceObjectBucket(dev);
+	
+	// Now find an object value that has not already been taken
+	// by scanning the list.
+	
+	int found = 0;
+	struct list_head *i;
+	
+	int n = bucket;
+
+	//yaffs_CheckObjectHashSanity();	
+	
+	while(!found)
+	{
+		found = 1;
+		n +=  YAFFS_NOBJECT_BUCKETS;
+		if(1 ||dev->objectBucket[bucket].count > 0)
+		{
+			list_for_each(i,&dev->objectBucket[bucket].list)
+			{
+				// If there is already one in the list
+				if(list_entry(i, yaffs_Object,hashLink)->objectId == n)
+				{
+					found = 0;
+				}
+			}
+		}
+	}
+	
+	//T(("bucket %d count %d inode %d\n",bucket,yaffs_objectBucket[bucket].count,n);
+	
+	return n;	
+}
+
+void yaffs_HashObject(yaffs_Object *in)
+{
+	int bucket = yaffs_HashFunction(in->objectId);
+	yaffs_Device *dev = in->myDev;
+	
+	if(!list_empty(&in->hashLink))
+	{
+		YINFO("!!!");
+	}
+	
+	
+	list_add(&in->hashLink,&dev->objectBucket[bucket].list);
+	dev->objectBucket[bucket].count++;
+
+}
+
+yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev,int number)
+{
+	int bucket = yaffs_HashFunction(number);
+	struct list_head *i;
+	yaffs_Object *in;
+	
+	list_for_each(i,&dev->objectBucket[bucket].list)
+	{
+		// Lookm if it is in the list
+		in = list_entry(i, yaffs_Object,hashLink);
+		if(in->objectId == number)
+		{
+			return in;
+		}
+	}
+	
+	return NULL;
+}
+
+
+
+yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectType type)
+{
+		
+	yaffs_Object *theObject;
+
+	if(number < 0)
+	{
+		number = yaffs_CreateNewObjectNumber(dev);
+	}
+	
+	theObject = yaffs_AllocateEmptyObject(dev);
+	
+	if(theObject)
+	{
+		theObject->fake = 0;
+		theObject->renameAllowed = 1;
+		theObject->unlinkAllowed = 1;
+		theObject->objectId = number;
+		theObject->myDev = dev;
+		yaffs_HashObject(theObject);
+		theObject->variantType = type;
+		theObject->st_atime = theObject->st_mtime =	theObject->st_ctime = CURRENT_TIME;
+
+		switch(type)
+		{
+			case YAFFS_OBJECT_TYPE_FILE: 
+				theObject->variant.fileVariant.fileSize = 0;
+				theObject->variant.fileVariant.topLevel = 0;
+				theObject->variant.fileVariant.top  = yaffs_GetTnode(dev);
+				break;
+			case YAFFS_OBJECT_TYPE_DIRECTORY:
+				INIT_LIST_HEAD(&theObject->variant.directoryVariant.children);
+				break;
+			case YAFFS_OBJECT_TYPE_SYMLINK:
+				break;
+			case YAFFS_OBJECT_TYPE_HARDLINK:
+				break;
+			case YAFFS_OBJECT_TYPE_UNKNOWN:
+				// todo this should not happen
+		}
+	}
+	
+	return theObject;
+}
+
+yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev, int number,yaffs_ObjectType type)
+{
+	yaffs_Object *theObject = NULL;
+	
+	if(number >= 0)
+	{
+		theObject = yaffs_FindObjectByNumber(dev,number);
+	}
+	
+	if(!theObject)
+	{
+		theObject = yaffs_CreateNewObject(dev,number,type);
+	}
+	
+	return theObject;
+
+}
+
+char *yaffs_CloneString(const char *str)
+{
+	char *newStr = NULL;
+	
+	if(str && *str)
+	{
+		newStr = YMALLOC(strlen(str) + 1);
+		strcpy(newStr,str);
+	}
+
+	return newStr;
+	
+}
+
+//
+// Mknod (create) a new object.
+// equivalentObject only has meaning for a hard link;
+// aliasString only has meaning for a sumlink.
+yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type,
+								 yaffs_Object *parent,
+								 const char *name, 
+								 __u32 mode,
+								 __u32 uid,
+								 __u32 gid,
+								 yaffs_Object *equivalentObject,
+								 const char *aliasString)
+{
+	yaffs_Object *in;
+
+	yaffs_Device *dev = parent->myDev;
+	
+	in = yaffs_CreateNewObject(dev,-1,type);
+	
+	if(in)
+	{
+		in->chunkId = -1;
+		in->valid = 1;
+		in->variantType = type;
+
+		in->st_mode  = mode;
+		in->st_uid   = uid;
+		in->st_gid   = gid;
+		in->st_atime = 	in->st_mtime =	in->st_ctime = CURRENT_TIME;
+
+		in->sum = yaffs_CalcNameSum(name);
+		in->dirty = 1;
+		
+		yaffs_AddObjectToDirectory(parent,in);
+		
+		in->myDev = parent->myDev;
+		
+				
+		switch(type)
+		{
+			case YAFFS_OBJECT_TYPE_SYMLINK:
+				in->variant.symLinkVariant.alias = yaffs_CloneString(aliasString);
+				break;
+			case YAFFS_OBJECT_TYPE_HARDLINK:
+				in->variant.hardLinkVariant.equivalentObject = equivalentObject;
+				in->variant.hardLinkVariant.equivalentObjectId = equivalentObject->objectId;
+				list_add(&in->hardLinks,&equivalentObject->hardLinks);
+				break;
+			case YAFFS_OBJECT_TYPE_FILE: // do nothing
+			case YAFFS_OBJECT_TYPE_DIRECTORY: // do nothing
+			case YAFFS_OBJECT_TYPE_UNKNOWN:
+		}
+
+		yaffs_UpdateObjectHeader(in,name);
+
+	}
+	
+	return in;
+}
+
+yaffs_Object *yaffs_MknodFile(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid)
+{
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE,parent,name,mode,uid,gid,NULL,NULL);
+}
+
+yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid)
+{
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY,parent,name,mode,uid,gid,NULL,NULL);
+}
+
+yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid,const char *alias)
+{
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK,parent,name,mode,uid,gid,NULL,alias);
+}
+
+// NB yaffs_Link returns the object id of the equivalent object.
+yaffs_Object *yaffs_Link(yaffs_Object *parent, const char *name, yaffs_Object *equivalentObject)
+{
+	// Get the real object in case we were fed a hard link as an equivalent object
+	equivalentObject = yaffs_GetEquivalentObject(equivalentObject);
+	
+	if(yaffs_MknodObject(YAFFS_OBJECT_TYPE_HARDLINK,parent,name,0,0,0,equivalentObject,NULL))
+	{
+		return equivalentObject;
+	}
+	else
+	{
+		return NULL;
+	}
+	
+}
+
+
+static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir, const char *newName)
+{
+	//yaffs_Device *dev = obj->myDev;
+
+	if(newDir == NULL)
+	{
+		newDir = obj->parent; // use the old directory
+	}
+	
+	// Only proceed if the new name does not exist and
+	// if we're putting it into a directory.
+	if(!yaffs_FindObjectByName(newDir,newName) &&
+	    newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+	{
+		obj->sum = yaffs_CalcNameSum(newName);
+		obj->dirty = 1;
+		yaffs_AddObjectToDirectory(newDir,obj);
+		
+		return yaffs_UpdateObjectHeader(obj,newName);	
+	}
+	
+	return YAFFS_FAIL;
+}
+
+int yaffs_RenameObject(yaffs_Object *oldDir, const char *oldName, yaffs_Object *newDir, const char *newName)
+{
+	yaffs_Object *obj;
+	
+	obj = yaffs_FindObjectByName(oldDir,oldName);
+	if(obj && obj->renameAllowed)
+	{
+		return yaffs_ChangeObjectName(obj,newDir,newName);
+	}
+	return YAFFS_FAIL;
+}
+
+
+
+static int yaffs_CheckObjectHashSanity(yaffs_Device *dev)
+{
+	// Scan the buckets and check that the lists 
+	// have as many members as the count says there are
+	int bucket;
+	int countEm;
+	struct list_head *j;
+	int ok = YAFFS_OK;
+	
+	for(bucket = 0; bucket < YAFFS_NOBJECT_BUCKETS; bucket++)
+	{
+		countEm = 0;
+		
+		list_for_each(j,&dev->objectBucket[bucket].list)
+		{
+			countEm++;
+		}
+		
+		if(countEm != dev->objectBucket[bucket].count)
+		{
+			YALERT("Inode hash inconsistency");
+			ok = YAFFS_FAIL;
+		}
+	}
+
+	return ok;
+}
+
+void yaffs_ObjectTest(yaffs_Device *dev)
+{
+	yaffs_Object *in[1000];
+	int inNo[1000];
+	yaffs_Object *inold[1000];
+	int i;
+	int j;
+	
+	memset(in,0,1000*sizeof(yaffs_Object *));
+	memset(inold,0,1000*sizeof(yaffs_Object *));
+	
+	yaffs_CheckObjectHashSanity(dev);
+	
+	for(j = 0; j < 10; j++)
+	{
+		T(("%d\n",j));
+		
+		for(i = 0; i < 1000; i++)
+		{
+			in[i] = yaffs_CreateNewObject(dev,-1,YAFFS_OBJECT_TYPE_FILE);
+			if(!in[i])
+			{
+				YINFO("No more inodes");
+			}
+			else
+			{
+				inNo[i] = in[i]->objectId;
+			}
+		}
+		
+		for(i = 0; i < 1000; i++)
+		{
+			if(yaffs_FindObjectByNumber(dev,inNo[i]) != in[i])
+			{
+				T(("Differnce in look up test\n"));
+			}
+			else
+			{
+				// T(("Look up ok\n"));
+			}
+		}
+		
+		yaffs_CheckObjectHashSanity(dev);
+	
+		for(i = 0; i < 1000; i+=3)
+		{
+			yaffs_FreeObject(in[i]);	
+			in[i] = NULL;
+		}
+		
+	
+		yaffs_CheckObjectHashSanity(dev);
+	}
+		
+}
+
+
+
+/////////////////////////// Block Management and Page Allocation ///////////////////
+
+
+static void yaffs_InitialiseBlocks(yaffs_Device *dev)
+{
+	dev->blockInfo = YMALLOC(dev->nBlocks * sizeof(yaffs_BlockInfo));
+	memset(dev->blockInfo,0,dev->nBlocks * sizeof(yaffs_BlockInfo));
+	dev->allocationBlock = -1; // force it to get a new one
+}
+
+static void yaffs_DeinitialiseBlocks(yaffs_Device *dev)
+{
+	YFREE(dev->blockInfo);
+}
+
+// FindDiretiestBlock is used to select the dirtiest block (or close enough)
+// for garbage collection.
+
+static int yaffs_FindDirtiestBlock(yaffs_Device *dev)
+{
+
+	int b = dev->currentDirtyChecker;
+	
+	int i;
+	int dirtiest = -1;
+	int pagesInUse = 100; // silly big number
+	
+	for(i = dev->startBlock; i <= dev->endBlock && pagesInUse > 2 ; i++)
+	{
+		b++;
+		if (b > dev->endBlock)
+		{
+			b =  dev->startBlock;
+		}
+		
+		if(dev->blockInfo[b].blockState == YAFFS_BLOCK_STATE_FULL &&
+		   (dev->blockInfo)[b].pagesInUse < pagesInUse)
+		{
+			dirtiest = b;
+			pagesInUse = (dev->blockInfo)[b].pagesInUse;
+		}
+	}
+	
+	dev->currentDirtyChecker = b;
+	
+	return dirtiest;
+}
+
+
+static int yaffs_FindBlockForAllocation(yaffs_Device *dev,int useReserve)
+{
+	int i;
+	
+	if(useReserve && dev->nErasedBlocks < 1)
+	{
+		// Hoosterman we've got a problem.
+		// Can't get space to gc
+		return -1;
+	}
+	else if(!useReserve && dev->nErasedBlocks <= YAFFS_RESERVED_BLOCKS)
+	{
+		// We are not in GC, so we hold some in reserve so we can get
+		// a gc done.
+	}
+	
+	// Find an empty block.
+	
+	for(i = dev->startBlock; i <= dev->endBlock; i++)
+	{
+			
+		if(dev->blockInfo[i].blockState == YAFFS_BLOCK_STATE_EMPTY)
+		{
+			dev->blockInfo[i].blockState = YAFFS_BLOCK_STATE_ALLOCATING;
+			dev->nErasedBlocks--;
+			if(dev->nErasedBlocks <= YAFFS_RESERVED_BLOCKS)
+			{
+				dev->garbageCollectionRequired = 1;
+			}
+			
+			return i;
+		}
+	}
+	
+	return -1;	
+}
+
+
+static void yaffs_BlockBecameDirty(yaffs_Device *dev,int blockNo)
+{
+	yaffs_BlockInfo *bi = &dev->blockInfo[blockNo];
+	
+	// Mark as dirty, erase it and mark as clean.
+	bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
+	yaffs_EraseBlockInNAND(dev,blockNo);
+	bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
+	dev->nErasedBlocks++;
+	bi->pagesInUse = 0;
+	bi->pageBits = 0;
+	
+	T(("Erased block %d\n",blockNo));
+}
+
+
+static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve)
+{
+	int retVal;
+	
+	if(dev->allocationBlock < 0)
+	{
+		// Get next block to allocate off
+		dev->allocationBlock = yaffs_FindBlockForAllocation(dev,useReserve);
+		dev->allocationPage = 0;
+	}
+	
+	// Next page please....
+	if(dev->allocationBlock >= 0)
+	{
+		retVal = (dev->allocationBlock * YAFFS_CHUNKS_PER_BLOCK) + 
+			  	  dev->allocationPage;
+		dev->blockInfo[dev->allocationBlock].pagesInUse++;
+		dev->blockInfo[dev->allocationBlock].pageBits |= 
+				(1 << (dev->allocationPage));
+
+		dev->allocationPage++;
+		
+		dev->nFreeChunks--;
+		
+		// If the block is full set the state to full
+		if(dev->allocationPage >= YAFFS_CHUNKS_PER_BLOCK)
+		{
+			dev->blockInfo[dev->allocationBlock].blockState = YAFFS_BLOCK_STATE_FULL;
+			dev->allocationBlock = -1;
+		}
+
+#ifdef YAFFS_PARANOID
+		if(yaffs_CheckChunkErased(retVal) == YAFFS_FAIL)
+		{
+			T(("..................Trying to allocate non-erased page %d\n",retVal));
+		}
+#endif		
+		return retVal;
+		
+	}
+	T(("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!\n"));
+
+	return -1;	
+}
+
+
+int  yaffs_GarbageCollectBlock(yaffs_Device *dev,int block)
+{
+	int oldChunk;
+	int newChunk;
+	__u32 mask;
+	
+	
+	yaffs_Spare spare;
+	yaffs_Tags  tags;
+		__u8  buffer[YAFFS_BYTES_PER_CHUNK];
+	
+	yaffs_BlockInfo *bi = &dev->blockInfo[block];
+	
+	yaffs_Object *object;
+
+	T(("Collecting block %d n %d bits %x\n",block, bi->pagesInUse, bi->pageBits));	
+	
+	for(mask = 1,oldChunk = block * YAFFS_CHUNKS_PER_BLOCK; 
+	    mask && bi->pageBits;
+	    mask <<= 1, oldChunk++ )
+	{
+		if(bi->pageBits & mask)
+		{
+			
+			// This page is in use and needs to be copied off
+			
+			T(("copying page %x from %d to %d\n",mask,oldChunk,newChunk));
+			
+			yaffs_ReadChunkFromNAND(dev,oldChunk,buffer, &spare);
+			
+			yaffs_GetTagsFromSpare(&spare,&tags);
+			tags.serialNumber++;
+			yaffs_LoadTagsIntoSpare(&spare,&tags);
+
+#if 0
+			newChunk = yaffs_AllocatePage(dev,1);
+			if(newChunk < 0)
+			{
+				return YAFFS_FAIL;
+			}
+
+			yaffs_WriteChunkToNAND(dev,newChunk, buffer, &spare);
+
+#else
+			newChunk = yaffs_WriteNewChunkToNAND(dev, buffer, &spare,1);
+#endif
+			if(newChunk < 0)
+			{
+				return YAFFS_FAIL;
+			}
+
+			object = yaffs_FindObjectByNumber(dev,tags.objectId);
+			
+			// Ok, now fix up the Tnodes etc.
+			
+			if(tags.chunkId == 0)
+			{
+				// It's a header
+				object->chunkId = newChunk;
+			}
+			else
+			{
+				// It's a data chunk
+				yaffs_PutChunkIntoFile(object, tags.chunkId, newChunk);
+
+			}
+			
+			yaffs_DeleteChunk(dev,oldChunk);			
+			
+		}
+	}
+
+	return YAFFS_OK;
+}
+
+int yaffs_CheckGarbageCollection(yaffs_Device *dev)
+{
+	int block;
+	
+	if(dev->garbageCollectionRequired)
+	{
+		dev->garbageCollectionRequired = 0;
+		block = yaffs_FindDirtiestBlock(dev);
+		if(block >= 0)
+		{
+			return yaffs_GarbageCollectBlock(dev,block);
+		}	
+		else
+		{
+			return YAFFS_FAIL;
+		}
+	}
+
+	return YAFFS_OK;
+}
+
+
+//////////////////////////// TAGS ///////////////////////////////////////
+
+static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
+{
+	yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+	
+	yaffs_CalcTagsECC(tagsPtr);
+	
+	sparePtr->tagByte0 = tu->asBytes[0];
+	sparePtr->tagByte1 = tu->asBytes[1];
+	sparePtr->tagByte2 = tu->asBytes[2];
+	sparePtr->tagByte3 = tu->asBytes[3];
+	sparePtr->tagByte4 = tu->asBytes[4];
+	sparePtr->tagByte5 = tu->asBytes[5];
+	sparePtr->tagByte6 = tu->asBytes[6];
+	sparePtr->tagByte7 = tu->asBytes[7];
+}
+
+static void yaffs_GetTagsFromSpare(yaffs_Spare *sparePtr,yaffs_Tags *tagsPtr)
+{
+	yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+
+	tu->asBytes[0]= sparePtr->tagByte0;
+	tu->asBytes[1]= sparePtr->tagByte1;
+	tu->asBytes[2]= sparePtr->tagByte2;
+	tu->asBytes[3]= sparePtr->tagByte3;
+	tu->asBytes[4]= sparePtr->tagByte4;
+	tu->asBytes[5]= sparePtr->tagByte5;
+	tu->asBytes[6]= sparePtr->tagByte6;
+	tu->asBytes[7]= sparePtr->tagByte7;
+	
+	// Todo Check ECC on tags
+}
+
+static void yaffs_SpareInitialise(yaffs_Spare *spare)
+{
+	memset(spare,0xFF,sizeof(yaffs_Spare));
+}
+
+static int yaffs_ReadChunkTagsFromNAND(yaffs_Device *dev,int chunkInNAND, yaffs_Tags *tags)
+{
+	if(tags)
+	{
+		yaffs_Spare spare;
+		if(yaffs_ReadChunkFromNAND(dev,chunkInNAND,NULL,&spare) == YAFFS_OK)
+		{
+			yaffs_GetTagsFromSpare(&spare,tags);
+			return YAFFS_OK;
+		}
+		else
+		{
+			return YAFFS_FAIL;
+		}
+	}
+	
+	return YAFFS_OK;
+}
+
+static int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND, const __u8 *buffer, yaffs_Tags *tags)
+{
+	// NB There must be tags, data is optional
+	// If there is data, then an ECC is calculated on it.
+	
+	yaffs_Spare spare;
+	
+	if(!tags)
+	{
+		return YAFFS_FAIL;
+	}
+	
+	yaffs_SpareInitialise(&spare);
+	
+
+	if(buffer)
+	{
+		yaffs_CalcECC(buffer,&spare);
+	}
+	
+	yaffs_LoadTagsIntoSpare(&spare,tags);
+	
+	return yaffs_WriteChunkToNAND(dev,chunkInNAND,buffer,&spare);
+	
+}
+
+static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev, const __u8 *buffer, yaffs_Tags *tags, int useReserve)
+{
+	// NB There must be tags, data is optional
+	// If there is data, then an ECC is calculated on it.
+	
+	yaffs_Spare spare;
+	
+	if(!tags)
+	{
+		return YAFFS_FAIL;
+	}
+	
+	yaffs_SpareInitialise(&spare);
+	
+
+	if(buffer)
+	{
+		yaffs_CalcECC(buffer,&spare);
+	}
+	
+	yaffs_LoadTagsIntoSpare(&spare,tags);
+	
+	return yaffs_WriteNewChunkToNAND(dev,buffer,&spare,useReserve);
+	
+}
+
+
+
+
+int yaffs_FindChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags *tags)
+{
+	//Get the Tnode, then get the level 0 offset chunk offset
+    yaffs_Tnode *tn;     
+    int theChunk = -1;
+    yaffs_Tags localTags;
+    int i;
+    int found = 0;
+    yaffs_Device *dev = in->myDev;
+    
+    
+    if(!tags)
+    {
+    	// Passed a NULL, so use our own tags space
+    	tags = &localTags;
+    }
+    
+    tn = yaffs_FindLevel0Tnode(dev,&in->variant.fileVariant, chunkInInode);
+    
+    if(tn)
+    {
+		theChunk = tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK] << dev->chunkGroupBits;
+
+		// Now we need to do the shifting etc and search for it
+		for(i = 0,found = 0; i < dev->chunkGroupSize && !found; i++)
+		{
+			yaffs_ReadChunkTagsFromNAND(dev,theChunk,tags);
+			if(tags->chunkId == chunkInInode &&
+			tags->objectId == in->objectId)
+			{
+				// found it;
+				found = 1;
+			}
+			else
+			{
+				theChunk++;
+			}
+		}
+    }
+    return found ? theChunk : -1;
+}
+
+int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags *tags)
+{
+	//Get the Tnode, then get the level 0 offset chunk offset
+    yaffs_Tnode *tn;     
+    int theChunk = -1;
+    yaffs_Tags localTags;
+    int i;
+    int found = 0;
+    yaffs_Device *dev = in->myDev;
+    
+    if(!tags)
+    {
+    	// Passed a NULL, so use our own tags space
+    	tags = &localTags;
+    }
+    
+    tn = yaffs_FindLevel0Tnode(dev,&in->variant.fileVariant, chunkInInode);
+    
+    if(tn)
+    {
+    
+		theChunk = tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK] << dev->chunkGroupBits;
+    
+		// Now we need to do the shifting etc and search for it
+		for(i = 0,found = 0; i < dev->chunkGroupSize && !found; i++)
+		{
+			yaffs_ReadChunkTagsFromNAND(dev,theChunk,tags);
+			if(tags->chunkId == chunkInInode &&
+			tags->objectId == in->objectId)
+			{
+				// found it;
+				found = 1;
+			}
+			else
+			{
+				theChunk++;
+			}
+		}
+    
+		// Delete the entry in the filestructure
+		if(found)
+		{
+			tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK] = 0;
+		}
+    }
+    else
+    {
+    	T(("No level 0 found for %d\n", chunkInInode));
+    }
+    
+    if(!found)
+    {
+    	T(("Could not find %d to delete\n",chunkInInode));
+    }
+    return found ? theChunk : -1;
+}
+
+
+#if YAFFS_PARANOID
+
+static int yaffs_CheckFileSanity(yaffs_Object *in)
+{
+	int chunk;
+	int nChunks;
+	int fSize;
+	int failed = 0;
+	int objId;
+	yaffs_Tnode *tn;
+    yaffs_Tags localTags;
+    yaffs_Tags *tags = &localTags;
+    int theChunk;
+    
+    	
+	if(in->variantType != YAFFS_OBJECT_TYPE_FILE)
+	{
+		T(("Object not a file\n"));
+		return YAFFS_FAIL;
+	}
+	
+	objId = in->objectId;
+	fSize  = in->variant.fileVariant.fileSize;
+	nChunks = (fSize + YAFFS_BYTES_PER_CHUNK -1)/YAFFS_BYTES_PER_CHUNK;
+	
+	for(chunk = 1; chunk <= nChunks; chunk++)
+	{
+		tn = yaffs_FindLevel0Tnode(&in->variant.fileVariant, chunk);
+    
+		if(tn)
+		{
+    
+			theChunk = tn->level0[chunk & YAFFS_TNODES_LEVEL0_MASK] << dev->chunkGroupBits;
+    
+
+				yaffs_ReadChunkTagsFromNAND(theChunk,tags);
+				if(tags->chunkId == chunk &&
+				tags->objectId == in->objectId)
+				{
+					// found it;
+					
+				}
+				else
+				{
+					//T(("File problem file [%d,%d] NAND %d  tags[%d,%d]\n",
+					//		objId,chunk,theChunk,tags->chunkId,tags->objectId);
+							
+					failed = 1;
+								
+				}
+    
+		}
+		else
+		{
+			T(("No level 0 found for %d\n", chunk));
+		}
+	}
+	
+	return failed ? YAFFS_FAIL : YAFFS_OK;
+}
+
+#endif
+
+static int yaffs_PutChunkIntoFile(yaffs_Object *in,int chunkInInode, int chunkInNAND)
+{
+	yaffs_Tnode *tn;
+	yaffs_Device *dev = in->myDev;
+	
+	tn = yaffs_AddOrFindLevel0Tnode(dev,&in->variant.fileVariant, chunkInInode);
+	tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK] = chunkInNAND;
+	return YAFFS_OK;
+}
+
+
+
+int yaffs_ReadChunkDataFromObject(yaffs_Object *in,int chunkInInode, __u8 *buffer)
+{
+    int chunkInNAND = yaffs_FindChunkInFile(in,chunkInInode,NULL);
+    
+    if(chunkInNAND >= 0)
+    {
+		return yaffs_ReadChunkFromNAND(in->myDev,chunkInNAND,buffer,NULL);
+	}
+	else
+	{
+		return 0;
+	}
+
+}
+
+
+static void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId)
+{
+	int block = chunkId / YAFFS_CHUNKS_PER_BLOCK;
+	int page = chunkId % YAFFS_CHUNKS_PER_BLOCK;
+	yaffs_Tags tags;
+	
+	// Mark the deleted NAND page as deleted
+	tags.chunkId = 0;
+	tags.objectId = 0;
+	tags.byteCount = 0;
+	tags.ecc = 0;
+	
+	yaffs_WriteChunkWithTagsToNAND(dev,chunkId,NULL,&tags);	
+			
+	
+	// Pull out of the management area.
+	if(	dev->blockInfo[block].blockState == YAFFS_BLOCK_STATE_ALLOCATING ||
+	    dev->blockInfo[block].blockState == YAFFS_BLOCK_STATE_FULL)
+	{
+		dev->nFreeChunks++;
+
+		dev->blockInfo[block].pageBits &= ~(1 << page);
+		dev->blockInfo[block].pagesInUse--;
+		
+		if(	dev->blockInfo[block].pagesInUse == 0 &&
+	    dev->blockInfo[block].blockState == YAFFS_BLOCK_STATE_FULL)
+	    {
+	    	yaffs_BlockBecameDirty(dev,block);
+	    }
+
+	}
+	else
+	{
+		T(("Bad news deteing chunk %d\n",chunkId));
+	}
+	
+}
+
+
+
+
+int yaffs_WriteChunkDataToObject(yaffs_Object *in,int chunkInInode, const __u8 *buffer,int nBytes,int useReserve)
+{
+	// Find old chunk Need to do this to get serial number
+	// Write new one and patch into tree.
+	// Invalidate old tags.
+
+    int prevChunkId;
+    yaffs_Tags prevTags;
+    
+    int newChunkId;
+    yaffs_Tags newTags;
+
+    yaffs_Device *dev = in->myDev;    
+
+	yaffs_CheckGarbageCollection(dev);
+
+	// Get the previous chunk at this location in the file if it exists
+    prevChunkId  = yaffs_FindChunkInFile(in,chunkInInode,&prevTags);
+    
+    // Set up new tags
+   	newTags.chunkId = chunkInInode;
+	newTags.objectId = in->objectId;
+	newTags.serialNumber = (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1;
+   	newTags.byteCount = nBytes;
+	newTags.unusedStuff = 0xFFFFFFFF;
+		
+	yaffs_CalcTagsECC(&newTags);
+
+    
+ #if 0
+    // Create new chunk in NAND
+    newChunkId = yaffs_AllocatePage(dev,useReserve);
+ 
+    
+    if(newChunkId >= 0)
+    {
+		
+
+		yaffs_WriteChunkWithTagsToNAND(dev,newChunkId,buffer,&newTags);
+		
+		yaffs_PutChunkIntoFile(in,chunkInInode,newChunkId);
+		
+		
+		if(prevChunkId >= 0)
+		{
+			yaffs_DeleteChunk(dev,prevChunkId);
+	
+		}
+		
+		yaffs_CheckFileSanity(in);
+		
+		return newChunkId;
+    }
+
+     
+    return -1;
+#else
+
+	newChunkId = yaffs_WriteNewChunkWithTagsToNAND(dev,buffer,&newTags,useReserve);
+	if(newChunkId >= 0)
+	{
+		yaffs_PutChunkIntoFile(in,chunkInInode,newChunkId);
+		
+		
+		if(prevChunkId >= 0)
+		{
+			yaffs_DeleteChunk(dev,prevChunkId);
+	
+		}
+		
+		yaffs_CheckFileSanity(in);
+	}
+	return newChunkId;
+
+#endif
+
+
+
+}
+
+
+// UpdateObjectHeader updates the header on NAND for an object.
+// If name is not NULL, then that new name is used.
+//
+int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
+{
+
+	yaffs_Device *dev = in->myDev;
+	
+    int prevChunkId;
+    
+    int newChunkId;
+    yaffs_Tags newTags;
+    __u8 bufferNew[YAFFS_BYTES_PER_CHUNK];
+    __u8 bufferOld[YAFFS_BYTES_PER_CHUNK];
+    
+    yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bufferNew;
+    yaffs_ObjectHeader *ohOld = (yaffs_ObjectHeader *)bufferOld;
+    
+    if(!in->fake)
+    {
+  
+		yaffs_CheckGarbageCollection(dev);		
+    
+		memset(bufferNew,0xFF,YAFFS_BYTES_PER_CHUNK);
+    
+		prevChunkId = in->chunkId;
+    
+		if(prevChunkId >= 0)
+		{
+			yaffs_ReadChunkFromNAND(dev,prevChunkId,bufferOld,NULL);    	
+		}
+
+		// Header data
+		oh->type = in->variantType;
+	
+		oh->st_mode = in->st_mode;
+		oh->st_uid = in->st_uid;
+		oh->st_gid = in->st_gid;
+		oh->st_atime = in->st_atime;
+		oh->st_mtime = in->st_mtime;
+		oh->st_ctime = in->st_ctime;
+	
+		oh->parentObjectId = in->parent->objectId;
+		oh->sum = in->sum;
+		if(name && *name)
+		{
+			memset(oh->name,0,YAFFS_MAX_NAME_LENGTH + 1);
+			strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH);
+		}
+		else
+		{	
+			memcpy(oh->name, ohOld->name,YAFFS_MAX_NAME_LENGTH + 1);
+		}
+	
+		switch(in->variantType)
+		{
+			case YAFFS_OBJECT_TYPE_UNKNOWN: 	// Todo got a problem
+				break;
+			case YAFFS_OBJECT_TYPE_FILE:
+				oh->fileSize = in->variant.fileVariant.fileSize;
+				break;
+			case YAFFS_OBJECT_TYPE_HARDLINK:
+				oh->equivalentObjectId = in->variant.hardLinkVariant.equivalentObjectId;
+				break;
+			case YAFFS_OBJECT_TYPE_DIRECTORY:	// Do nothing
+				break;
+			case YAFFS_OBJECT_TYPE_SYMLINK:
+				strncpy(oh->alias,in->variant.symLinkVariant.alias,YAFFS_MAX_ALIAS_LENGTH);
+				oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
+				break;
+		}
+
+		// Tags
+		in->serial++;
+		newTags.chunkId = 0;
+		newTags.objectId = in->objectId;
+		newTags.serialNumber = in->serial;
+		newTags.byteCount =   0xFFFFFFFF;
+		newTags.unusedStuff = 0xFFFFFFFF;
+	
+		yaffs_CalcTagsECC(&newTags);
+	
+    
+    
+#if 0
+		// Create new chunk in NAND
+		newChunkId = yaffs_AllocatePage(dev,1);
+    
+		if(newChunkId >= 0)
+		{
+
+			yaffs_WriteChunkWithTagsToNAND(dev,newChunkId,bufferNew,&newTags);
+		
+			in->chunkId = newChunkId;		
+		
+			if(prevChunkId >= 0)
+			{
+				yaffs_DeleteChunk(dev,prevChunkId);
+			}
+		
+			in->dirty = 0;
+			return newChunkId;
+		}
+    
+		return -1;
+#else
+		// Create new chunk in NAND
+		newChunkId = yaffs_WriteNewChunkWithTagsToNAND(dev,bufferNew,&newTags,1);
+    
+		if(newChunkId >= 0)
+		{
+		
+			in->chunkId = newChunkId;		
+		
+			if(prevChunkId >= 0)
+			{
+				yaffs_DeleteChunk(dev,prevChunkId);
+			}
+		
+			in->dirty = 0;
+		}
+		
+		return newChunkId;
+
+#endif
+    }
+    return 0;
+}
+
+
+
+///////////////////////// File read/write ///////////////////////////////
+// Read and write have very similar structures.
+// In general the read/write has three parts to it
+// * An incomplete chunk to start with (if the read/write is not chunk-aligned)
+// * Some complete chunks
+// * An incomplete chunk to end off with
+//
+// Curve-balls: the first chunk might also be the last chunk.
+
+int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 * buffer, __u32 offset, int nBytes)
+{
+	
+//	yaffs_Device *dev = in->myDev;
+	
+	__u8 localBuffer[YAFFS_BYTES_PER_CHUNK];
+	
+	int chunk;
+	int start;
+	int nToCopy;
+	int n = nBytes;
+	int nDone = 0;
+	
+	while(n > 0)
+	{
+		chunk = offset / YAFFS_BYTES_PER_CHUNK + 1; // The first chunk is 1
+		start = offset % YAFFS_BYTES_PER_CHUNK;
+
+		// OK now check for the curveball where the start and end are in
+		// the same chunk.	
+		if(	(start + n) < YAFFS_BYTES_PER_CHUNK)
+		{
+			nToCopy = n;
+		}
+		else
+		{
+			nToCopy = YAFFS_BYTES_PER_CHUNK - start;
+		}
+	
+		if(nToCopy != YAFFS_BYTES_PER_CHUNK)
+		{
+			// An incomplete start or end chunk (or maybe both start and end chunk)
+			// Read into the local buffer then copy...
+		
+			yaffs_ReadChunkDataFromObject(in,chunk,localBuffer);		
+			memcpy(buffer,&localBuffer[start],nToCopy);
+		}
+		else
+		{
+			// A full chunk. Read directly into the supplied buffer.
+			yaffs_ReadChunkDataFromObject(in,chunk,buffer);
+		}
+		
+		n -= nToCopy;
+		offset += nToCopy;
+		buffer += nToCopy;
+		nDone += nToCopy;
+		
+	}
+	
+	return nDone;
+}
+
+
+int yaffs_WriteDataToFile(yaffs_Object *in,const __u8 * buffer, __u32 offset, int nBytes)
+{	
+	__u8 localBuffer[YAFFS_BYTES_PER_CHUNK];
+	
+	int chunk;
+	int start;
+	int nToCopy;
+	int n = nBytes;
+	int nDone = 0;
+	int nToWriteBack;
+	int endOfWrite = offset+nBytes;
+	int chunkWritten = 0;
+	
+	while(n > 0 && chunkWritten >= 0)
+	{
+		chunk = offset / YAFFS_BYTES_PER_CHUNK + 1;
+		start = offset % YAFFS_BYTES_PER_CHUNK;
+		
+
+		// OK now check for the curveball where the start and end are in
+		// the same chunk.
+		if(	(start + n) < YAFFS_BYTES_PER_CHUNK)
+		{
+			nToCopy = n;
+			nToWriteBack = (start + n);
+		}
+		else
+		{
+			nToCopy = YAFFS_BYTES_PER_CHUNK - start;
+			nToWriteBack = YAFFS_BYTES_PER_CHUNK;
+		}
+	
+		if(nToCopy != YAFFS_BYTES_PER_CHUNK)
+		{
+			// An incomplete start or end chunk (or maybe both start and end chunk)
+			// Read into the local buffer then copy, then copy over and write back.
+		
+			yaffs_ReadChunkDataFromObject(in,chunk,localBuffer);
+				
+			memcpy(&localBuffer[start],buffer,nToCopy);
+			
+			chunkWritten = yaffs_WriteChunkDataToObject(in,chunk,localBuffer,nToWriteBack,0);
+			
+			T(("Write with readback to chunk %d %d\n",chunk,chunkWritten));
+			
+		}
+		else
+		{
+			// A full chunk. Write directly from the supplied buffer.
+			chunkWritten = yaffs_WriteChunkDataToObject(in,chunk,buffer,YAFFS_BYTES_PER_CHUNK,0);
+			T(("Write to chunk %d %d\n",chunk,chunkWritten));
+		}
+		
+		if(chunkWritten >= 0)
+		{
+			n -= nToCopy;
+			offset += nToCopy;
+			buffer += nToCopy;
+			nDone += nToCopy;
+		}
+		
+	}
+	
+	// Update file object
+	
+	if(endOfWrite > in->variant.fileVariant.fileSize)
+	{
+		in->variant.fileVariant.fileSize = endOfWrite;
+	}
+	
+	in->dirty = 1;
+	in->st_mtime = CURRENT_TIME;
+	
+	return nDone;
+}
+
+
+int yaffs_ResizeFile(yaffs_Object *in, int newSize)
+{
+	int i;
+	int chunkId;
+	int oldFileSize = in->variant.fileVariant.fileSize;
+	int sizeOfLastChunk = newSize % YAFFS_BYTES_PER_CHUNK;
+	
+	yaffs_Device *dev = in->myDev;
+	
+	__u8 localBuffer[YAFFS_BYTES_PER_CHUNK];
+	
+	if(in->variantType != YAFFS_OBJECT_TYPE_FILE)
+	{
+		return yaffs_GetFileSize(in);
+	}
+	
+	if(newSize < oldFileSize)
+	{
+		
+		int lastDel = 1 + oldFileSize/YAFFS_BYTES_PER_CHUNK;
+		
+		int startDel = 1 + (newSize + YAFFS_BYTES_PER_CHUNK - 1)/
+							YAFFS_BYTES_PER_CHUNK;
+
+		for(i = startDel; i <= lastDel; i++)
+		{
+			// NB this could be optimised somewhat,
+			// eg. could retrieve the tags and write them without
+			// using yaffs_DeleteChunk
+			chunkId = yaffs_FindAndDeleteChunkInFile(in,i,NULL);
+			if(chunkId < 0 || chunkId >= (dev->endBlock * 32))
+			{
+				T(("Found daft chunkId %d for %d\n",chunkId,i));
+			}
+			else
+			{
+				yaffs_DeleteChunk(dev,chunkId);
+			}
+		}
+		
+		
+		if(sizeOfLastChunk != 0)
+		{
+			int lastChunk = 1+ newSize/YAFFS_BYTES_PER_CHUNK;
+			
+			// Got to read and rewrite the last chunk with its new size.
+			yaffs_ReadChunkDataFromObject(in,lastChunk,localBuffer);
+			
+			yaffs_WriteChunkDataToObject(in,lastChunk,localBuffer,sizeOfLastChunk,1);
+				
+		}
+		
+		in->variant.fileVariant.fileSize = newSize;
+		
+		yaffs_PruneFileStructure(dev,&in->variant.fileVariant);
+		
+		return newSize;
+		
+	}
+	else
+	{
+		return oldFileSize;
+	}
+}
+
+
+loff_t yaffs_GetFileSize(yaffs_Object *obj)
+{
+	obj = yaffs_GetEquivalentObject(obj);
+	
+	switch(obj->variantType)
+	{
+		case YAFFS_OBJECT_TYPE_FILE: 
+			return obj->variant.fileVariant.fileSize;
+		case YAFFS_OBJECT_TYPE_SYMLINK:
+			return strlen(obj->variant.symLinkVariant.alias);
+		default:
+			return 0;
+	}
+}
+
+
+
+// yaffs_FlushFile() updates the file's
+// objectId in NAND
+
+int yaffs_FlushFile(yaffs_Object *in)
+{
+	int retVal;
+	if(in->dirty)
+	{
+		retVal = yaffs_UpdateObjectHeader(in,NULL);
+	}
+	else
+	{
+		retVal = YAFFS_OK;
+	}
+	
+	return retVal;
+	
+}
+
+
+static int yaffs_DoGenericObjectDeletion(yaffs_Object *in)
+{
+	yaffs_RemoveObjectFromDirectory(in);
+	yaffs_DeleteChunk(in->myDev,in->chunkId);
+	yaffs_FreeObject(in);
+	return YAFFS_OK;
+
+}
+
+// yaffs_DeleteFile deletes the whole file data
+// and the inode associated with the file.
+// It does not delete the links associated with the file.
+static int yaffs_DeleteFile(yaffs_Object *in)
+{
+	// Delete the file data & tnodes
+	yaffs_ResizeFile(in,0);
+	yaffs_FreeTnode(in->myDev,in->variant.fileVariant.top);
+	
+	return  yaffs_DoGenericObjectDeletion(in);
+}
+
+static int yaffs_DeleteDirectory(yaffs_Object *in)
+{
+	//First check that the directory is empty.
+	if(list_empty(&in->variant.directoryVariant.children))
+	{
+		return  yaffs_DoGenericObjectDeletion(in);
+	}
+	
+	return YAFFS_FAIL;
+	
+}
+
+static int yaffs_DeleteSymLink(yaffs_Object *in)
+{
+	YFREE(in->variant.symLinkVariant.alias);
+
+	return  yaffs_DoGenericObjectDeletion(in);
+}
+
+static int yaffs_DeleteHardLink(yaffs_Object *in)
+{
+	// remove this hardlink from the list assocaited with the equivalent
+	// object
+	list_del(&in->hardLinks);
+	return  yaffs_DoGenericObjectDeletion(in);	
+}
+
+
+static int yaffs_UnlinkWorker(yaffs_Object *obj)
+{
+
+	
+	if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
+	{
+		return  yaffs_DeleteHardLink(obj);
+	}
+	else if(!list_empty(&obj->hardLinks))
+	{	
+#if 0
+		// Curve ball: We're unlinking an object that has a hardlink.
+		// Therefore we can't really delete the object.
+		// Instead, we do the following:
+		// - Select a hardlink.
+		// - Re-type a hardlink as the equivalent object and populate the fields, including the
+		//  objectId. Updating the object id is important so that all the hardlinks do not need
+		// to be rewritten.
+		// - Update the equivalet object pointers.
+		// - Delete all object.
+
+		yaffs_Object *hl;
+		struct list_head *i;
+
+
+		yaffs_RemoveObjectFromDirectory(obj);
+
+
+
+		hl =  list_entry(obj->hardLinks.next, yaffs_Object,hardLinks);
+		
+		hl->dirty = 1;
+		hl->st_mode = obj->st_mode;
+		hl->st_uid = obj->st_uid;
+		hl->st_gid = obj->st_gid;
+		hl->st_atime = obj->st_atime;
+		hl->st_mtime = obj->st_mtime;
+		hl->st_ctime = obj->st_ctime;
+		
+		hl->variantType = obj->variantType;
+		
+		switch(hl->variantType)
+		{
+			case YAFFS_OBJECT_TYPE_FILE:
+			case YAFFS_OBJECT_TYPE_SYMLINK:
+				// These types are OK to just copy across.
+				hl->variant = obj->variant;
+				break;
+			case YAFFS_OBJECT_TYPE_DIRECTORY:
+				// Fix the list up
+				list_add(&hl->variant.directoryVariant.children,
+					    &obj->variant.directoryVariant.children);
+				list_del(&obj->variant.directoryVariant.children);
+				
+				// Now change all the directory children to point to the new parent.
+				list_for_each(i,&hl->variant.directoryVariant.children)
+				{
+					list_entry(i,yaffs_Object,siblings)->parent = hl;
+				}
+				break;
+				
+			case YAFFS_OBJECT_TYPE_HARDLINK:
+			case YAFFS_OBJECT_TYPE_UNKNOWN:
+				// Should not be either of these types.
+		}
+		
+		// Now fix up the hardlink chain
+		list_del(&obj->hardLinks);
+
+		list_for_each(i,&hl->hardLinks)
+		{
+			list_entry(i,yaffs_Object,hardLinks)->variant.hardLinkVariant.equivalentObject = hl;
+			list_entry(i,yaffs_Object,hardLinks)->variant.hardLinkVariant.equivalentObjectId = hl->objectId;
+		}
+		
+		// Now fix up the hash links.
+		yaffs_UnhashObject(hl);
+		hl->objectId = obj->objectId;
+		yaffs_HashObject(hl);
+		
+		// Update the hardlink which has become an object
+		yaffs_UpdateObjectHeader(hl,NULL);
+
+		// Finally throw away the deleted object
+		yaffs_DeleteChunk(obj->myDev,obj->chunkId);
+		yaffs_FreeObject(obj);
+		
+		return YAFFS_OK;		
+#else
+		// Curve ball: We're unlinking an object that has a hardlink.
+		//
+		//	This problem arises because we are not strictly following
+		//  The Linux link/inode model.
+		//
+		// We can't really delete the object.
+		// Instead, we do the following:
+		// - Select a hardlink.
+		// - Unhook it from the hard links
+		// - Unhook it from its parent directory (so that the rename can work)
+		// - Rename the object to the hardlink's name.
+		// - Delete the hardlink
+		
+		
+		yaffs_Object *hl;
+		int retVal;
+		char name[YAFFS_MAX_NAME_LENGTH+1];
+		
+		hl = list_entry(obj->hardLinks.next,yaffs_Object,hardLinks);
+		list_del_init(&hl->hardLinks);
+		list_del_init(&hl->siblings);
+		
+		yaffs_GetObjectName(hl,name,YAFFS_MAX_NAME_LENGTH+1);
+		
+		retVal = yaffs_ChangeObjectName(obj, hl->parent, name);
+		if(retVal == YAFFS_OK)
+		{
+			retVal = yaffs_DoGenericObjectDeletion(hl);
+		}
+		return retVal;
+
+#endif
+
+				
+	}
+	else
+	{
+		switch(obj->variantType)
+		{
+			case YAFFS_OBJECT_TYPE_FILE:
+				return yaffs_DeleteFile(obj);
+				break;
+			case YAFFS_OBJECT_TYPE_DIRECTORY:
+				return yaffs_DeleteDirectory(obj);
+				break;
+			case YAFFS_OBJECT_TYPE_SYMLINK:
+				return yaffs_DeleteSymLink(obj);
+				break;
+			case YAFFS_OBJECT_TYPE_HARDLINK:
+			case YAFFS_OBJECT_TYPE_UNKNOWN:
+			default:
+				return YAFFS_FAIL;
+		}
+	}
+}
+
+int yaffs_Unlink(yaffs_Object *dir, const char *name)
+{
+	yaffs_Object *obj;
+	
+	 obj = yaffs_FindObjectByName(dir,name);
+	 
+	 if(obj && obj->unlinkAllowed)
+	 {
+	 	return yaffs_UnlinkWorker(obj);
+	 }
+	 
+	 return YAFFS_FAIL;
+	
+}
+
+//////////////// Initialisation Scanning /////////////////
+
+
+static int yaffs_Scan(yaffs_Device *dev)
+{
+	yaffs_Spare spare;
+	yaffs_Tags tags;
+	int blk;
+	int chunk;
+	int c;
+	int deleted;
+	int inuse;
+	yaffs_BlockState state;
+	yaffs_Object *hardList = NULL;
+	yaffs_Object *hl;
+	
+	__u32 pageBits;
+	
+	yaffs_ObjectHeader *oh;
+	yaffs_Object *in;
+	yaffs_Object *parent;
+	
+	__u8 chunkData[YAFFS_BYTES_PER_CHUNK];
+	
+	for(blk = dev->startBlock; blk <= dev->endBlock; blk++)
+	{
+		deleted = 0;
+		pageBits = 0;
+		inuse = 0;
+		state = YAFFS_BLOCK_STATE_UNKNOWN;
+		
+		for(c = 0; c < YAFFS_CHUNKS_PER_BLOCK && 
+				   state == YAFFS_BLOCK_STATE_UNKNOWN; c++)
+		{
+			// Read the spare area and decide what to do
+			chunk = blk * YAFFS_CHUNKS_PER_BLOCK + c;
+			yaffs_ReadChunkFromNAND(dev,chunk,NULL,&spare);
+
+			
+			// Is this a valid block?
+			if(yaffs_countBits[spare.blockStatus] >= 7)
+			{
+				// This block looks ok, now what's in this chunk?
+				yaffs_GetTagsFromSpare(&spare,&tags);
+				
+				if(tags.objectId == YAFFS_UNUSED_OBJECT_ID)
+				{
+					// An unassigned chunk in the block
+					// This means that either the block is empty or 
+					// this is the one being allocated from
+					
+					if(c == 0)
+					{
+						// the block is unused
+						state = YAFFS_BLOCK_STATE_EMPTY;
+						dev->nErasedBlocks++;
+					}
+					else
+					{
+						// this is the block being allocated from
+						T((" allocating %d %d\n",blk,c));
+						state = YAFFS_BLOCK_STATE_ALLOCATING;
+						dev->allocationBlock = blk;
+						dev->allocationPage = c;
+					}
+
+					dev->nFreeChunks += (YAFFS_CHUNKS_PER_BLOCK - c);
+				}
+				else if(tags.objectId == 0)
+				{
+					// A deleted chunk
+					deleted++;
+					dev->nFreeChunks ++;
+					T((" %d %d deleted\n",blk,c));
+				}
+				else if(tags.chunkId > 0)
+				{
+					// A data chunk.
+					inuse++;
+					pageBits |= ( 1 <<c);				
+					in = yaffs_FindOrCreateObjectByNumber(dev,tags.objectId,YAFFS_OBJECT_TYPE_FILE);
+					// todo check for a clash (two data chunks with
+					// the same chunkId).
+					yaffs_PutChunkIntoFile(in,tags.chunkId,chunk);
+					T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId));	
+				}
+				else
+				{
+					// chunkId == 0, so it is an ObjectHeader.
+					inuse++;				
+					pageBits |= ( 1 <<c);				
+					yaffs_ReadChunkFromNAND(dev,chunk,chunkData,NULL);
+					oh = (yaffs_ObjectHeader *)chunkData;
+					
+					in = yaffs_FindOrCreateObjectByNumber(dev,tags.objectId,oh->type);
+					if(in->valid)
+					{
+						// todo we have already filled this one. We have
+						// a duplicate. Need to fix
+					}
+					
+					// we don't have a duplicate...
+					
+					in->valid = 1;
+					in->variantType = oh->type;
+		
+					in->st_mode  = oh->st_mode;
+					in->st_uid   = oh->st_uid;
+					in->st_gid   = oh->st_gid;
+					in->st_atime = oh->st_atime;
+					in->st_mtime = oh->st_mtime;
+					in->st_ctime = oh->st_ctime;
+					in->chunkId  = chunk;
+
+					in->sum = oh->sum;
+					in->dirty = 0;
+								
+					// directory stuff...
+					// hook up to parent
+		
+					parent = yaffs_FindOrCreateObjectByNumber(dev,oh->parentObjectId,YAFFS_OBJECT_TYPE_DIRECTORY);
+					if(parent->variantType == YAFFS_OBJECT_TYPE_UNKNOWN)
+					{
+						// Set up as a directory
+						parent->variantType = YAFFS_OBJECT_TYPE_DIRECTORY;
+						INIT_LIST_HEAD(&parent->variant.directoryVariant.children);
+					}
+					else if(parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
+					{
+						// Hoosterman, another problem....
+						// We're trying to use a non-directory as a directory
+						// Todo ... handle
+					}
+					
+					yaffs_AddObjectToDirectory(parent,in);	
+					
+					// Note re hardlinks.
+					// Since we might scan a hardlink before its equivalent object is scanned
+					// we put them all in a list.
+					// After scanning is complete, we should have all the objects, so we run through this
+					// list and fix up all the chains.		
+		
+					switch(in->variantType)
+					{
+						case YAFFS_OBJECT_TYPE_UNKNOWN: 	// Todo got a problem
+							break;
+						case YAFFS_OBJECT_TYPE_FILE:
+							in->variant.fileVariant.fileSize = oh->fileSize;
+							break;
+						case YAFFS_OBJECT_TYPE_HARDLINK:
+							in->variant.hardLinkVariant.equivalentObjectId = oh->equivalentObjectId;
+							(yaffs_Object *)(in->hardLinks.next) = hardList;
+							hardList = in;
+							break;
+						case YAFFS_OBJECT_TYPE_DIRECTORY:	// Do nothing
+							break;
+						case YAFFS_OBJECT_TYPE_SYMLINK: 	// Do nothing
+							in->variant.symLinkVariant.alias = yaffs_CloneString(oh->alias);
+							break;
+					}
+					T((" %d %d header %d \"%s\" type %d\n",blk,c,tags.objectId,oh->name,in->variantType));	
+				}
+			}
+			else
+			{
+				// it's a bad block
+				state = YAFFS_BLOCK_STATE_DEAD;
+			}			
+		}
+		
+		if(state == YAFFS_BLOCK_STATE_UNKNOWN)
+		{
+			// If we got this far, then the block is fully allocated.
+			// ie. Full or Dirty
+			state = (inuse) ? YAFFS_BLOCK_STATE_FULL : YAFFS_BLOCK_STATE_DIRTY;
+	
+		}
+		
+		dev->blockInfo[blk].pageBits = pageBits;
+		dev->blockInfo[blk].pagesInUse = inuse;
+		dev->blockInfo[blk].blockState = state;
+		
+	}
+	
+	// Todo fix up the hard link chains
+	while(hardList)
+	{
+		hl = hardList;
+		hardList = (yaffs_Object *)(hardList->hardLinks.next);
+		
+		in = yaffs_FindObjectByNumber(dev,hl->variant.hardLinkVariant.equivalentObjectId);
+		
+		if(in)
+		{
+			hl->variant.hardLinkVariant.equivalentObject=in;
+			list_add(&hl->hardLinks,&in->hardLinks);
+		}
+		else
+		{
+			//Todo Need to report this better.
+			hl->variant.hardLinkVariant.equivalentObject=NULL;
+			INIT_LIST_HEAD(&hl->hardLinks);
+			
+		}
+		
+	}
+	
+	
+	
+	return YAFFS_OK;
+}
+
+
+////////////////////////// Directory Functions /////////////////////////
+
+
+static void yaffs_AddObjectToDirectory(yaffs_Object *directory, yaffs_Object *obj)
+{
+
+	if(obj->siblings.prev == NULL)
+	{
+		// Not initialised
+		INIT_LIST_HEAD(&obj->siblings);
+		
+	}
+	else if(!list_empty(&obj->siblings))
+	{
+		// If it is holed up somewhere else, un hook it
+		list_del_init(&obj->siblings);
+	}
+	// Now add it
+	list_add(&obj->siblings,&directory->variant.directoryVariant.children);
+	obj->parent = directory;
+}
+
+static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj)
+{
+	list_del_init(&obj->siblings);
+	obj->parent = NULL;
+}
+
+yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory,const char *name)
+{
+	int sum;
+	
+	struct list_head *i;
+	__u8 buffer[YAFFS_BYTES_PER_CHUNK];
+	yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)buffer;
+	
+	yaffs_Object *l;
+	
+	sum = yaffs_CalcNameSum(name);
+	
+	list_for_each(i,&directory->variant.directoryVariant.children)
+	{
+		l = list_entry(i, yaffs_Object,siblings);
+		
+		// Special case for lost-n-found
+		if(l->objectId == YAFFS_OBJECTID_LOSTNFOUND)
+		{
+			if(strcmp(name,YAFFS_LOSTNFOUND_NAME) == 0)
+			{
+				return l;
+			}
+		}
+		else if(l->sum == sum)
+		{
+			// Do a real check
+			yaffs_ReadChunkFromNAND(l->myDev,l->chunkId,buffer,NULL);
+			if(strcmp(name,oh->name) == 0)
+			{
+				return l;
+			}
+			
+			
+		}
+	}
+	
+	return NULL;
+}
+
+
+int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,int (*fn)(yaffs_Object *))
+{
+	struct list_head *i;	
+	yaffs_Object *l;
+	
+	
+	list_for_each(i,&theDir->variant.directoryVariant.children)
+	{
+		l = list_entry(i, yaffs_Object,siblings);
+		if(!fn(l))
+		{
+			return YAFFS_FAIL;
+		}
+	}
+	
+	return YAFFS_OK;
+
+}
+
+
+// GetEquivalentObject dereferences any hard links to get to the
+// actual object.
+
+static yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj)
+{
+	if(obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
+	{
+		// We want the object id of the equivalent object, not this one
+		obj = obj->variant.hardLinkVariant.equivalentObject;
+	}
+	return obj;
+
+}
+
+int yaffs_GetObjectName(yaffs_Object *obj,char *name,int buffSize)
+{
+	memset(name,0,buffSize);
+	
+	if(obj->objectId == YAFFS_OBJECTID_LOSTNFOUND)
+	{
+		strncpy(name,YAFFS_LOSTNFOUND_NAME,buffSize - 1);
+	}
+	else
+	{
+		__u8 buffer[YAFFS_BYTES_PER_CHUNK];
+		yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)buffer;
+
+		memset(buffer,0,YAFFS_BYTES_PER_CHUNK);
+	
+		if(obj->chunkId >= 0)
+		{
+			yaffs_ReadChunkFromNAND(obj->myDev,obj->chunkId,buffer,NULL);
+		}
+		strncpy(name,oh->name,buffSize - 1);
+	}
+	
+	return strlen(name);
+}
+
+int yaffs_GetObjectFileLength(yaffs_Object *obj)
+{
+	
+	// Dereference any hard linking
+	obj = yaffs_GetEquivalentObject(obj);
+	
+	if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
+	{
+		return obj->variant.fileVariant.fileSize;
+	}
+	if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+	{
+		return strlen(obj->variant.symLinkVariant.alias);
+	}
+	else
+	{
+		// Only a directory should drop through to here
+		return YAFFS_BYTES_PER_CHUNK;
+	}	
+}
+
+int yaffs_GetObjectLinkCount(yaffs_Object *obj)
+{
+	int count = 1; // the object itself
+	struct list_head *i;
+	
+	list_for_each(i,&obj->hardLinks)
+	{
+		count++;
+	}
+	return count;
+	
+}
+
+
+int yaffs_GetObjectInode(yaffs_Object *obj)
+{
+	obj = yaffs_GetEquivalentObject(obj);
+	
+	return obj->objectId;
+}
+
+unsigned yaffs_GetObjectType(yaffs_Object *obj)
+{
+	obj = yaffs_GetEquivalentObject(obj);
+	
+	switch(obj->variantType)
+	{
+		case YAFFS_OBJECT_TYPE_FILE:		return DT_REG; break;
+		case YAFFS_OBJECT_TYPE_DIRECTORY:	return DT_DIR; break;
+		case YAFFS_OBJECT_TYPE_SYMLINK:		return DT_LNK; break;
+		case YAFFS_OBJECT_TYPE_HARDLINK:	return DT_REG; break;
+		default: return DT_REG; break;
+	}
+}
+
+char *yaffs_GetSymlinkAlias(yaffs_Object *obj)
+{
+	obj = yaffs_GetEquivalentObject(obj);
+	if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+	{
+		return yaffs_CloneString(obj->variant.symLinkVariant.alias);
+	}
+	else
+	{
+		return yaffs_CloneString("");
+	}
+}
+
+
+int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr)
+{
+	unsigned int valid = attr->ia_valid;
+	
+	if(valid & ATTR_MODE) obj->st_mode = attr->ia_mode;
+	if(valid & ATTR_UID) obj->st_uid = attr->ia_uid;
+	if(valid & ATTR_GID) obj->st_gid = attr->ia_gid;
+	
+	if(valid & ATTR_ATIME) obj->st_atime = attr->ia_atime;
+	if(valid & ATTR_CTIME) obj->st_ctime = attr->ia_ctime;
+	if(valid & ATTR_MTIME) obj->st_mtime = attr->ia_mtime;
+	
+	if(valid & ATTR_SIZE) yaffs_ResizeFile(obj,attr->ia_size);
+	
+	yaffs_UpdateObjectHeader(obj,NULL);
+	
+	return YAFFS_OK;
+	
+}
+int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr)
+{
+	unsigned int valid = 0;
+	
+	attr->ia_mode = obj->st_mode;	valid |= ATTR_MODE;
+	attr->ia_uid = obj->st_uid;		valid |= ATTR_UID;
+	attr->ia_gid = obj->st_gid;		valid |= ATTR_GID;
+	
+	attr->ia_atime = obj->st_atime;	valid |= ATTR_ATIME;
+	attr->ia_ctime = obj->st_ctime;	valid |= ATTR_CTIME;
+	attr->ia_mtime = obj->st_mtime;	valid |= ATTR_MTIME;
+	
+	attr->ia_size = yaffs_GetFileSize(obj); valid |= ATTR_SIZE;
+	
+	attr->ia_valid = valid;
+	
+	return YAFFS_OK;
+	
+}
+
+
+
+int yaffs_DumpObject(yaffs_Object *obj)
+{
+	__u8 buffer[YAFFS_BYTES_PER_CHUNK];
+	char name[256];
+//	yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)buffer;
+
+	memset(buffer,0,YAFFS_BYTES_PER_CHUNK);
+	
+	if(obj->chunkId >= 0)
+	{
+		yaffs_ReadChunkFromNAND(obj->myDev,obj->chunkId,buffer,NULL);
+	}
+	
+	yaffs_GetObjectName(obj,name,256);
+	
+	YPRINTF(("Object %d \"%s\"\n dirty %d valid %d serial %d sum %d chunk %d type %d size %d\n",
+			yaffs_GetObjectInode(obj), name, obj->dirty, obj->valid, obj->serial, 
+			obj->sum, obj->chunkId, yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj)));
+
+#if 0
+	YPRINTF(("Object %d \"%s\"\n dirty %d valid %d serial %d sum %d chunk %d\n",
+			obj->objectId, oh->name, obj->dirty, obj->valid, obj->serial, 
+			obj->sum, obj->chunkId));
+		switch(obj->variantType)
+	{
+		case YAFFS_OBJECT_TYPE_FILE: 
+			YPRINTF((" FILE length %d\n",obj->variant.fileVariant.fileSize));
+			break;
+		case YAFFS_OBJECT_TYPE_DIRECTORY:
+			YPRINTF((" DIRECTORY\n"));
+			break;
+		case YAFFS_OBJECT_TYPE_HARDLINK: //todo
+		case YAFFS_OBJECT_TYPE_SYMLINK:
+		case YAFFS_OBJECT_TYPE_UNKNOWN:
+		default:
+	}
+#endif
+	
+	return YAFFS_OK;
+}
+
+
+///////////////////////// Initialisation code ///////////////////////////
+
+
+
+int yaffs_GutsInitialise(yaffs_Device *dev)
+{
+	unsigned  nChunks,x;
+	int bits;
+
+
+	dev = dev;
+	
+	if(!yaffs_CheckStructures())
+	{
+		return YAFFS_FAIL;
+	}
+
+		
+	// OK now calculate a few things for the device
+	// Calculate chunkGroupBits. 
+	// If there are 64k or less chunks then this is 1
+	// Else it is log2(nChunks) - 16
+	//
+	x = nChunks = YAFFS_CHUNKS_PER_BLOCK * dev->nBlocks;
+	
+	for(bits = 0, x = nChunks; (x & 1) == 0; bits++)
+	{
+		x >>= 1;
+	}
+	
+	if( x != 1)
+	{
+		// Not a power of 2
+		YPRINTF(("nBlocks should be a power of 2 but is %u\n",
+			dev->nBlocks));
+		return YAFFS_FAIL;
+	}
+	
+	if(bits <= 16) 
+	{
+		dev->chunkGroupBits = 0;
+		dev->chunkGroupSize = 1;
+	}
+	else
+	{
+		dev->chunkGroupBits = bits - 16;
+		dev->chunkGroupSize = nChunks/0x10000;
+	}
+	
+	// More device initialisation
+	dev->garbageCollectionRequired  = 0;
+	dev->currentDirtyChecker = 0;
+	
+	yaffs_InitialiseBlocks(dev);
+	
+	yaffs_InitialiseTnodes(dev);
+
+	yaffs_InitialiseObjects(dev);
+	
+	
+	// Initialise the root and lost and found directories
+	dev->lostNFoundDir = dev->rootDir = NULL;
+	dev->rootDir = yaffs_CreateFakeDirectory(dev,YAFFS_OBJECTID_ROOT,YAFFS_ROOT_MODE | S_IFDIR);
+	dev->lostNFoundDir = yaffs_CreateFakeDirectory(dev,YAFFS_OBJECTID_LOSTNFOUND,YAFFS_ROOT_MODE | S_IFDIR);
+	yaffs_AddObjectToDirectory(dev->rootDir,dev->lostNFoundDir);
+		
+	// Now scan the flash.	
+	yaffs_Scan(dev);
+
+	
+	return YAFFS_OK;
+		
+}
+
+void yaffs_Deinitialise(yaffs_Device *dev)
+{
+	yaffs_DeinitialiseBlocks(dev);
+	yaffs_DeinitialiseTnodes(dev);
+	yaffs_DeinitialiseObjects(dev);
+	
+}
+
+int  yaffs_GetNumberOfFreeChunks(yaffs_Device *dev)
+{
+	int nFree = dev->nFreeChunks - (YAFFS_CHUNKS_PER_BLOCK * YAFFS_RESERVED_BLOCKS);
+
+	return (nFree < 0) ? 0 : nFree;	
+	
+}
+
+
+/////////////////// YAFFS test code //////////////////////////////////
+
+#define yaffs_CheckStruct(structure,syze, name) \
+           if(sizeof(structure) != syze) \
+	       { YPRINTF(("%s should be %d but is %d\n",name,syze,sizeof(structure))); \
+	         return YAFFS_FAIL; \
+		   }
+		 
+		 
+static int yaffs_CheckStructures(void)
+{
+	yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags")
+	yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion")
+	yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare")
+	yaffs_CheckStruct(yaffs_Tnode,2* YAFFS_NTNODES_LEVEL0,"yaffs_Tnode")
+	yaffs_CheckStruct(yaffs_ObjectHeader,512,"yaffs_ObjectHeader")
+	
+	
+	return YAFFS_OK;
+}
+
+void yaffs_GutsTest(yaffs_Device *dev)
+{
+	
+	if(yaffs_CheckStructures() != YAFFS_OK)
+	{
+		YPRINTF(("One or more structures malformed-- aborting\n"));
+	}
+	else
+	{
+		YPRINTF(("Structures OK\n"));
+	}
+	
+	yaffs_TnodeTest(dev);
+	yaffs_ObjectTest(dev);	
+}
+
+
diff --git a/yaffs_guts.h b/yaffs_guts.h
new file mode 100644
index 0000000..d1e2973
--- /dev/null
+++ b/yaffs_guts.h
@@ -0,0 +1,431 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yaffs_guts.h: Configuration etc for yaffs_guts
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
+
+#ifndef __YAFFS_GUTS_H__
+#define __YAFFS_GUTS_H__
+
+#include "devextras.h"
+
+
+#define YAFFS_OK	1
+#define YAFFS_FAIL  0
+
+// Y=0x59, A=0x41, S=0x53
+#define YAFFS_MAGIC					0x5941FF53
+
+#define YAFFS_NTNODES_LEVEL0	  	16
+#define YAFFS_TNODES_LEVEL0_BITS	4
+#define YAFFS_TNODES_LEVEL0_MASK	0xf
+
+#define YAFFS_NTNODES_INTERNAL 		(YAFFS_NTNODES_LEVEL0 / 2)
+#define YAFFS_TNODES_INTERNAL_BITS 	(YAFFS_TNODES_LEVEL0_BITS - 1)
+#define YAFFS_TNODES_INTERNAL_MASK	0x7
+#define YAFFS_TNODES_MAX_LEVEL		6
+		
+#define YAFFS_BYTES_PER_CHUNK		512
+#define YAFFS_CHUNK_SIZE_SHIFT		9
+
+#define YAFFS_BYTES_PER_SPARE		16
+
+#define YAFFS_CHUNKS_PER_BLOCK		32
+#define YAFFS_BYTES_PER_BLOCK		(YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK)
+
+#define YAFFS_MAX_CHUNK_ID			0x000FFFFF
+
+#define YAFFS_UNUSED_OBJECT_ID		0x0003FFFF
+
+#define YAFFS_ALLOCATION_NOBJECTS	100
+#define YAFFS_ALLOCATION_NTNODES	100
+#define YAFFS_ALLOCATION_NLINKS		100
+
+#define YAFFS_NOBJECT_BUCKETS		256
+
+
+#define YAFFS_RESERVED_BLOCKS		5
+
+#define YAFFS_OBJECT_SPACE			0x40000
+#define YAFFS_MAX_NAME_LENGTH		255
+
+#define YAFFS_MAX_ALIAS_LENGTH		211
+
+#define YAFFS_OBJECTID_ROOT			1
+#define YAFFS_ROOT_MODE				0666
+#define YAFFS_OBJECTID_LOSTNFOUND	2
+#define YAFFS_LOSTNFOUND_NAME		"lost+found"
+
+// Tags structures in RAM
+// NB This uses bitfield. Bitfields should not stradle a u32 boundary otherwise
+// the structure size will get blown out.
+
+typedef struct
+{
+    unsigned chunkId:20;
+    unsigned serialNumber:2;
+    unsigned byteCount:10;
+    unsigned objectId:18;
+    unsigned ecc:12;
+    unsigned unusedStuff:2;
+} yaffs_Tags;
+
+typedef union
+{
+    yaffs_Tags asTags;
+    __u8       asBytes[8];
+} yaffs_TagsUnion;
+
+
+// Spare structure
+typedef struct
+{
+    __u8  tagByte0;
+    __u8  tagByte1;
+    __u8  tagByte2;
+    __u8  tagByte3;
+    __u8  pageStatus;
+    __u8  blockStatus;
+    __u8  tagByte4;
+    __u8  tagByte5;
+    __u8  ecc1[3];
+    __u8  tagByte6;
+    __u8  tagByte7;
+    __u8  ecc2[3];
+} yaffs_Spare;
+
+// Block data in RAM
+
+typedef enum {
+	YAFFS_BLOCK_STATE_UNKNOWN	= 0,
+	
+	YAFFS_BLOCK_STATE_EMPTY,		// This block is empty
+	
+	YAFFS_BLOCK_STATE_ALLOCATING,	// This block is partially allocated. 
+									// This is the one currently being used for page
+									// allocation. Should never be more than one of these
+							
+
+	YAFFS_BLOCK_STATE_FULL,			// All the pages in this block have been allocated.
+									// At least one page holds valid data.
+							 
+	YAFFS_BLOCK_STATE_DIRTY,		// All pages have been allocated and deleted. 
+									// Erase me, reuse me.
+							
+	YAFFS_BLOCK_STATE_DEAD = 0x99	// This block has failed and is not in use
+
+} yaffs_BlockState;
+
+
+
+
+typedef struct
+{
+	__u32 pageBits;   // bitmap of pages in use
+    __u8  blockState; // One of the above block states
+    __u8  pagesInUse; // number of pages in use
+} yaffs_BlockInfo;
+
+
+//////////////////// Object structure ///////////////////////////
+// This is the object structure as stored on NAND
+
+typedef enum
+{
+	YAFFS_OBJECT_TYPE_UNKNOWN,
+	YAFFS_OBJECT_TYPE_FILE,
+	YAFFS_OBJECT_TYPE_SYMLINK,
+	YAFFS_OBJECT_TYPE_DIRECTORY,
+	YAFFS_OBJECT_TYPE_HARDLINK
+} yaffs_ObjectType;
+
+typedef struct
+{
+	yaffs_ObjectType type;
+
+	// Apply to everything	
+	int   parentObjectId;
+	__u16 sum;	// checksum of name
+	char  name[YAFFS_MAX_NAME_LENGTH + 1];
+
+	// Thes following apply to directories, files, symlinks - not hard links
+	__u32 st_mode;  // protection
+	__u32 st_uid;   // user ID of owner
+	__u32 st_gid;    // group ID of owner 
+	__u32 st_atime; // time of last access
+	__u32 st_mtime; // time of last modification
+	__u32 st_ctime; // time of last change
+	
+	// File size  applies to files only
+	int fileSize; 
+		
+	// Equivalent object id applies to hard links only.
+	int  equivalentObjectId;
+	char alias[YAFFS_MAX_ALIAS_LENGTH + 1];
+	
+	
+} yaffs_ObjectHeader;
+
+
+
+////////////////////  Tnode ///////////////////////////
+
+union yaffs_Tnode_union
+{
+	union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL];
+	__u16 level0[YAFFS_NTNODES_LEVEL0];
+	
+};
+
+typedef union yaffs_Tnode_union yaffs_Tnode;
+
+struct yaffs_TnodeList_struct
+{
+	struct yaffs_TnodeList_struct *next;
+	yaffs_Tnode *tnodes;
+};
+
+typedef struct yaffs_TnodeList_struct yaffs_TnodeList;
+
+
+
+///////////////////  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
+
+
+typedef struct 
+{
+	__u32 fileSize;
+	__u32 topLevel;
+	yaffs_Tnode *top;
+} yaffs_FileStructure;
+
+typedef struct
+{
+	struct list_head children; // list of child links
+} yaffs_DirectoryStructure;
+
+typedef struct
+{
+	char *alias;
+} yaffs_SymLinkStructure;
+
+typedef struct
+{
+	struct yaffs_ObjectStruct *equivalentObject;
+	__u32	equivalentObjectId;
+} yaffs_HardLinkStructure;
+
+typedef union
+{
+	yaffs_FileStructure fileVariant;
+	yaffs_DirectoryStructure directoryVariant;
+	yaffs_SymLinkStructure symLinkVariant;
+	yaffs_HardLinkStructure hardLinkVariant;
+} yaffs_ObjectVariant;
+
+
+struct  yaffs_ObjectStruct
+{
+	__u8 fake:1;			// A fake object has no presence on NAND.
+	__u8 renameAllowed:1;
+	__u8 unlinkAllowed:1;
+	__u8 dirty:1;			// the object needs to be written to flash
+	__u8 valid:1;			// When the file system is being loaded up, this 
+							// object might be created before the data
+							// is available (ie. file data records appear before the header).
+	__u8 serial;			// serial number of chunk in NAND. Store here so we don't have to
+							// read back the old one to update.
+	__u16 sum;				// sum of the name to speed searching
+	
+	struct yaffs_DeviceStruct *myDev; // The device I'm on
+	
+								
+	struct list_head hashLink;	// list of objects in this hash bucket
+							
+
+	struct list_head hardLinks; // all the equivalent hard linked objects
+								// live on this list
+	// directory structure stuff
+	struct yaffs_ObjectStruct  *parent;	//my parent directory
+	struct list_head siblings;	// siblings in a directory
+								// also used for linking up the free list
+		
+	// Where's my data in NAND?
+	int chunkId;		// where it lives
+	
+	__u32 objectId;		// the object id value
+	
+	
+	__u32 st_mode;  	// protection
+	__u32 st_uid;   	// user ID of owner
+	__u32 st_gid;    	// group ID of owner 
+	__u32 st_atime; 	// time of last access
+	__u32 st_mtime; 	// time of last modification
+	__u32 st_ctime; 	// time of last change
+
+	
+	yaffs_ObjectType variantType;
+	
+	yaffs_ObjectVariant variant;
+	
+};
+
+
+
+typedef struct yaffs_ObjectStruct yaffs_Object;
+
+
+struct yaffs_ObjectList_struct
+{
+	yaffs_Object *objects;
+	struct yaffs_ObjectList_struct *next;
+};
+
+typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
+
+typedef struct
+{
+	struct list_head list;
+	__u32 count;
+} yaffs_ObjectBucket;
+
+
+//////////////////// Device ////////////////////////////////
+
+struct yaffs_DeviceStruct
+{
+	// Entry parameters set up way early. Yaffs sets up the rest.
+	__u32 nBlocks;		// Size of whole device in blocks
+	__u32 startBlock;	// Start block we're allowed to use
+	__u32 endBlock;		// End block we're allowed to use
+	__u16 chunkGroupBits; // 0 for devices <= 32MB. else log2(nchunks) - 16
+	__u16 chunkGroupSize; // == 2^^chunkGroupBits
+	
+	
+	void *genericDevice; // Pointer to device context
+						 // On an mtd this holds the mtd pointer.
+	struct semaphore sem;// Semaphore for waiting on erasure.
+	
+	
+	// NAND access functions (Must be set before calling YAFFS)
+	
+	int (*writeChunkToNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_Spare *spare);
+	int (*readChunkFromNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare);
+	int (*eraseBlockInNAND)(struct yaffs_DeviceStruct *dev,int blockInNAND);	
+	int (*initialiseNAND)(struct yaffs_DeviceStruct *dev);
+	
+
+	
+	// Runtime parameters.
+	yaffs_BlockInfo *blockInfo;
+	int   nErasedBlocks;
+	int   allocationBlock;
+	__u32 allocationPage;
+	
+	// Runtime state
+	int   nTnodesCreated;	
+	yaffs_Tnode *freeTnodes;
+	int  nFreeTnodes;
+	yaffs_TnodeList *allocatedTnodeList;
+
+
+	int   nObjectsCreated;
+	yaffs_Object *freeObjects;
+	int   nFreeObjects;
+
+	yaffs_ObjectList *allocatedObjectList;
+
+	yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS];
+
+	int	  nFreeChunks;
+		
+	int   currentDirtyChecker;	// Used to find current dirtiest block
+	
+	int   garbageCollectionRequired;
+	
+	yaffs_Object *rootDir;
+	yaffs_Object *lostNFoundDir;
+	
+	
+};
+
+ typedef struct yaffs_DeviceStruct yaffs_Device;
+
+
+
+//////////// YAFFS Functions //////////////////
+
+int yaffs_GutsInitialise(yaffs_Device *dev);
+void yaffs_Deinitialise(yaffs_Device *dev);
+
+int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev);
+
+
+// Rename
+int yaffs_RenameObject(yaffs_Object *oldDir, const char *oldName, yaffs_Object *newDir, const char *newName);
+
+// generic Object functions
+int yaffs_Unlink(yaffs_Object *dir, const char *name);
+
+// Object access functions.
+int yaffs_GetObjectName(yaffs_Object *obj,char *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);
+
+// Change inode attributes
+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, __u32 offset, int nBytes);
+int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, __u32 offset, int nBytes);
+int yaffs_ResizeFile(yaffs_Object *obj, int newSize);
+
+yaffs_Object *yaffs_MknodFile(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid);
+int yaffs_FlushFile(yaffs_Object *obj);
+
+
+// Directory operations
+yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid);
+yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir,const char *name);
+int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,int (*fn)(yaffs_Object *));
+
+yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev,int number);
+
+// Link operations
+yaffs_Object *yaffs_Link(yaffs_Object *parent, const char *name, yaffs_Object *equivalentObject);
+
+// Symlink operations
+yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const char *name, __u32 mode,  __u32 uid, __u32 gid, const char *alias);
+char *yaffs_GetSymlinkAlias(yaffs_Object *obj);
+
+
+// Special directories
+yaffs_Object *yaffs_Root(yaffs_Device *dev);
+yaffs_Object *yaffs_LostNFound(yaffs_Device *dev);
+
+
+// Debug dump 
+int yaffs_DumpObject(yaffs_Object *obj);
+
+
+void yaffs_GutsTest(yaffs_Device *dev);
+
+
+#endif
diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c
new file mode 100644
index 0000000..3f1e924
--- /dev/null
+++ b/yaffs_mtdif.c
@@ -0,0 +1,104 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yaffs_mtdif.c  NAND mtd wrapper functions.
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
+ #ifdef YAFFS_MTD_ENABLED
+ 
+#include "yportenv.h"
+
+#include "yaffs_mtdif.h"
+
+#include "linux/mtd/mtd.h"
+#include "linux/types.h"
+
+
+int nandmtd_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare)
+{
+	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+	size_t dummy;
+	
+	loff_t addr = ((loff_t)chunkInNAND) * YAFFS_BYTES_PER_CHUNK;
+	
+	
+	__u8 *spareAsBytes = (__u8 *)spare;
+	
+	if(data)
+		mtd->write(mtd,addr,YAFFS_BYTES_PER_CHUNK,&dummy,data);
+	if(spare)
+		mtd->write_oob(mtd,addr,YAFFS_BYTES_PER_SPARE,&dummy,spareAsBytes);
+
+	return YAFFS_OK;
+}
+
+
+int nandmtd_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)
+{
+	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+	size_t dummy;
+	
+	loff_t addr = ((loff_t)chunkInNAND) * YAFFS_BYTES_PER_CHUNK;
+	
+	__u8 *spareAsBytes = (__u8 *)spare;
+	
+	if(data)
+		mtd->read(mtd,addr,YAFFS_BYTES_PER_CHUNK,&dummy,data);
+	if(spare)
+		mtd->read_oob(mtd,addr,YAFFS_BYTES_PER_SPARE,&dummy,spareAsBytes);
+
+	return YAFFS_OK;
+}
+
+
+static void nandmtd_EraseCallback(struct erase_info *ei)
+{
+	yaffs_Device *dev = (yaffs_Device *)ei->priv;	
+	up(&dev->sem);
+}
+
+
+int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+	
+	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+	__u32 addr = ((loff_t) blockNumber) * YAFFS_BYTES_PER_BLOCK;
+	struct erase_info ei;
+	
+	ei.mtd = mtd;
+	ei.addr = addr;
+	ei.len = YAFFS_BYTES_PER_BLOCK;
+	ei.time = 1000;
+	ei.retries = 2;
+	ei.callback = nandmtd_EraseCallback;
+	ei.priv = (u_long)dev;
+	
+	// Todo finish off the ei if required
+	
+	sema_init(&dev->sem,0);
+
+	mtd->erase(mtd,&ei);
+	
+	
+	down(&dev->sem); // Wait for the erasure to complete
+			
+	//Todo, check result of erasure
+	
+	return YAFFS_OK;
+}
+
+int nandmtd_InitialiseNAND(yaffs_Device *dev)
+{
+	return YAFFS_OK;
+}
+
+#endif // YAFFS_MTD_ENABLED
+
diff --git a/yaffs_mtdif.h b/yaffs_mtdif.h
new file mode 100644
index 0000000..6dc2e1b
--- /dev/null
+++ b/yaffs_mtdif.h
@@ -0,0 +1,29 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yaffs_mtdif.h  NAND mtd interface wrappers
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
+
+#ifndef __YAFFS_MTDIF_H__
+#define __YAFFS_MTDIF_H__
+
+#include "yaffs_guts.h"
+
+int nandmtd_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare);
+int nandmtd_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare);
+int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
+int nandmtd_InitialiseNAND(yaffs_Device *dev);
+#endif
+
+
+
+
diff --git a/yaffs_nandemul.h b/yaffs_nandemul.h
new file mode 100644
index 0000000..f233408
--- /dev/null
+++ b/yaffs_nandemul.h
@@ -0,0 +1,34 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ *
+ * Copyright (C) 2002 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_nandemul.h: Interface to emulated NAND functions
+ *
+ */
+ 
+#ifndef __YAFFS_NANDEMUL_H__
+#define __YAFFS_NANDEMUL_H__
+
+#include "yaffs_guts.h" 
+ 
+ 
+/* WriteChunkToNAND and ReadChunkFromNAND are used with two pointers. 
+ * If either of these pointers are null, then that field will not be 
+ * transferred.
+ */
+ 
+int nandemul_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_Spare *spare);
+int nandemul_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare);
+int nandemul_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,int blockInNAND);
+int nandemul_InitialiseNAND(struct yaffs_DeviceStruct *dev);
+
+#endif
+
diff --git a/yaffs_ramem.c b/yaffs_ramem.c
new file mode 100644
index 0000000..7143dff
--- /dev/null
+++ b/yaffs_ramem.c
@@ -0,0 +1,291 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yaffs_ramem.c  NAND emulation on top of a chunk of RAM
+ *
+ * Copyright (C) 2002 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_ramem.c
+ // Since this creates the RAM block at start up it is pretty useless for testing the scanner.
+
+#ifdef YAFFS_RAM_ENABLED
+
+#include "yportenv.h"
+
+#include "yaffs_nandemul.h"
+#include "yaffs_guts.h"
+#include "yaffsinterface.h"
+#include "devextras.h"
+
+
+#define EM_SIZE_IN_MEG 2
+
+#define BLOCK_SIZE (32 * 528)
+#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
+#define FILE_SIZE_IN_BLOCKS (FILE_SIZE_IN_MEG * BLOCKS_PER_MEG)
+#define FILE_SIZE_IN_BYTES (FILE_SIZE_IN_BLOCKS * BLOCK_SIZE)
+
+#define T(x) YPRINTF(x)
+
+#define DEFAULT_SIZE_IN_MB 2
+
+typedef struct 
+{
+	__u8 data[528]; // Data + spare
+	int count[3];   // The programming count for each area of
+			// the page (0..255,256..511,512..527
+	int empty;      // is this empty?
+} nandemul_Page;
+
+typedef struct
+{
+	nandemul_Page page[32]; // The pages in the block
+	__u8 damaged; 		// Is the block damaged?
+	
+} nandemul_Block;
+
+
+
+typedef struct
+{
+	nandemul_Block **block;
+	int nBlocks;
+} nandemul_Device;
+
+static nandemul_Device ned;
+
+int sizeInMB = DEFAULT_SIZE_IN_MB;
+
+
+static void nandemul_ReallyEraseBlock(int blockNumber)
+{
+	int i;
+	
+	nandemul_Block *theBlock = ned.block[blockNumber];
+	
+	for(i = 0; i < 32; i++)
+	{
+		memset(theBlock->page[i].data,0xff,528);
+		theBlock->page[i].count[0] = 0;
+		theBlock->page[i].count[1] = 0;
+		theBlock->page[i].count[2] = 0;
+		theBlock->page[i].empty = 1;
+	}
+
+}
+
+
+int nandemul_CalcNBlocks(void)
+{
+        switch(sizeInMB)
+        {
+        	case 8:
+        	case 16:
+        	case 32:
+        	case 64:
+        	case 128:
+        	case 256:
+        	case 512:
+        		break;
+        	default:
+        		sizeInMB = DEFAULT_SIZE_IN_MB;
+        }
+	return sizeInMB * 64;
+}
+
+
+
+static int  CheckInit(void)
+{
+	static int initialised = 0;
+	
+	int i;
+	int fail = 0;
+	int nBlocks; 
+	int nAllocated = 0;
+	
+	if(initialised) 
+	{
+		return YAFFS_OK;
+	}
+	
+	
+	nBlocks = nandemul_CalcNBlocks();
+	
+	ned.block = YMALLOC(sizeof(nandemul_Block *) * nBlocks);
+	
+	if(!ned.block) return 0;
+	
+	for(i=0; i <nBlocks; i++)
+	{
+		ned.block[i] = NULL;
+	}
+	
+	for(i=0; i <nBlocks && !fail; i++)
+	{
+		if((ned.block[i] = YMALLOC(sizeof(nandemul_Block))) == 0)
+		{
+			fail = 1;
+		}
+		else
+		{
+			nandemul_ReallyEraseBlock(i);
+			ned.block[i]->damaged = 0;
+			nAllocated++;
+		}
+	}
+	
+	if(fail)
+	{
+		for(i = 0; i < nAllocated; i++)
+		{
+			YFREE(ned.block[i]);
+		}
+		YFREE(ned.block);
+		
+		T(("Allocation failed, could only allocate %dMB of %dMB requested.\n",
+		   nAllocated/64,sizeInMB));
+		return 0;
+	}
+	
+	ned.nBlocks = nBlocks;
+	
+	initialised = 1;
+	
+	return 1;
+}
+
+int nandemul_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare)
+{
+	int blk;
+	int pg;
+	int i;
+	
+	__u8 *x;
+	
+	__u8 *spareAsBytes = (__u8 *)spare;
+
+	
+	CheckInit();
+	
+	blk = chunkInNAND/32;
+	pg = chunkInNAND%32;
+	
+	
+	if(data)
+	{
+		x = ned.block[blk]->page[pg].data;
+		
+		for(i = 0; i < 512; i++)
+		{
+			x[i] &=data[i];
+		}
+		
+		ned.block[blk]->page[pg].count[0]++;
+		ned.block[blk]->page[pg].count[1]++;
+		ned.block[blk]->page[pg].empty = 0;
+	}
+	
+	
+	if(spare)
+	{
+		x = &ned.block[blk]->page[pg].data[512];
+			
+		for(i = 0; i < 16; i++)
+		{
+			x[i] &=spareAsBytes[i];
+		}
+		ned.block[blk]->page[pg].count[2]++;
+	}
+
+	return YAFFS_OK;
+}
+
+
+int nandemul_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)
+{
+	int blk;
+	int pg;
+
+	
+	CheckInit();
+	
+	blk = chunkInNAND/32;
+	pg = chunkInNAND%32;
+	
+	
+	if(data)
+	{
+		memcpy(data,ned.block[blk]->page[pg].data,512);
+	}
+	
+	
+	if(spare)
+	{
+		memcpy(spare,&ned.block[blk]->page[pg].data[512],16);
+	}
+
+	return YAFFS_OK;
+}
+
+
+int nandemul_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
+{
+	int blk;
+	int pg;
+	int i;
+
+	
+	CheckInit();
+	
+	blk = chunkInNAND/32;
+	pg = chunkInNAND%32;
+	
+	
+	for(i = 0; i < 528; i++)
+	{
+		if(ned.block[blk]->page[pg].data[i] != 0xFF)
+		{
+			return YAFFS_FAIL;
+		}
+	}
+
+	return YAFFS_OK;
+
+}
+
+int nandemul_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+{
+	
+	CheckInit();
+	
+	if(blockNumber < 0 || blockNumber >= ned.nBlocks)
+	{
+		T(("Attempt to erase non-existant block %d\n",blockNumber));
+	}
+	else if(ned.block[blockNumber]->damaged)
+	{
+		T(("Attempt to erase damaged block %d\n",blockNumber));
+	}
+	else
+	{
+		nandemul_ReallyEraseBlock(blockNumber);
+	}
+	
+	return YAFFS_OK;
+}
+
+int nandemul_InitialiseNAND(yaffs_Device *dev)
+{
+	return YAFFS_OK;
+}
+
+#endif //YAFFS_RAM_ENABLED
+
diff --git a/yaffs_super.c b/yaffs_super.c
new file mode 100644
index 0000000..04dc17e
--- /dev/null
+++ b/yaffs_super.c
@@ -0,0 +1,401 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
+ *
+ * The original JFFS, from which the design for JFFS2 was derived,
+ * was designed and implemented by Axis Communications AB.
+ *
+ * The contents of this file are subject to the Red Hat eCos Public
+ * License Version 1.1 (the "Licence"); you may not use this file
+ * except in compliance with the Licence.  You may obtain a copy of
+ * the Licence at http://www.redhat.com/
+ *
+ * Software distributed under the Licence is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing rights and
+ * limitations under the Licence.
+ *
+ * The Original Code is JFFS2 - Journalling Flash File System, version 2
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License version 2 (the "GPL"), in
+ * which case the provisions of the GPL are applicable instead of the
+ * above.  If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the RHEPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice and
+ * other provisions required by the GPL.  If you do not delete the
+ * provisions above, a recipient may use your version of this file
+ * under either the RHEPL or the GPL.
+ *
+ * $Id: yaffs_super.c,v 1.1 2002-05-20 17:42:08 aleph1 Exp $
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/fs.h>
+#include <linux/jffs2.h>
+#include <linux/pagemap.h>
+#include <linux/mtd/mtd.h>
+#include <linux/interrupt.h>
+#include "nodelist.h"
+
+#ifndef MTD_BLOCK_MAJOR
+#define MTD_BLOCK_MAJOR 31
+#endif
+
+extern void jffs2_read_inode (struct inode *);
+void jffs2_put_super (struct super_block *);
+void jffs2_write_super (struct super_block *);
+static int jffs2_statfs (struct super_block *, struct statfs *);
+int jffs2_remount_fs (struct super_block *, int *, char *);
+extern void jffs2_clear_inode (struct inode *);
+
+static struct super_operations jffs2_super_operations =
+{
+	read_inode:	jffs2_read_inode,
+//	delete_inode:	jffs2_delete_inode,
+	put_super:	jffs2_put_super,
+	write_super:	jffs2_write_super,
+	statfs:		jffs2_statfs,
+	remount_fs:	jffs2_remount_fs,
+	clear_inode:	jffs2_clear_inode
+};
+
+static int jffs2_statfs(struct super_block *sb, struct statfs *buf)
+{
+	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
+	unsigned long avail;
+
+	buf->f_type = JFFS2_SUPER_MAGIC;
+	buf->f_bsize = 1 << PAGE_SHIFT;
+	buf->f_blocks = c->flash_size >> PAGE_SHIFT;
+	buf->f_files = 0;
+	buf->f_ffree = 0;
+	buf->f_namelen = JFFS2_MAX_NAME_LEN;
+
+	spin_lock_bh(&c->erase_completion_lock);
+
+	avail = c->dirty_size + c->free_size;
+	if (avail > c->sector_size * JFFS2_RESERVED_BLOCKS_WRITE)
+		avail -= c->sector_size * JFFS2_RESERVED_BLOCKS_WRITE;
+	else
+		avail = 0;
+
+	buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
+
+#if CONFIG_JFFS2_FS_DEBUG > 0
+	printk(KERN_DEBUG "STATFS:\n");
+	printk(KERN_DEBUG "flash_size: %08x\n", c->flash_size);
+	printk(KERN_DEBUG "used_size: %08x\n", c->used_size);
+	printk(KERN_DEBUG "dirty_size: %08x\n", c->dirty_size);
+	printk(KERN_DEBUG "free_size: %08x\n", c->free_size);
+	printk(KERN_DEBUG "erasing_size: %08x\n", c->erasing_size);
+	printk(KERN_DEBUG "bad_size: %08x\n", c->bad_size);
+	printk(KERN_DEBUG "sector_size: %08x\n", c->sector_size);
+
+	if (c->nextblock) {
+		printk(KERN_DEBUG "nextblock: 0x%08x\n", c->nextblock->offset);
+	} else {
+		printk(KERN_DEBUG "nextblock: NULL\n");
+	}
+	if (c->gcblock) {
+		printk(KERN_DEBUG "gcblock: 0x%08x\n", c->gcblock->offset);
+	} else {
+		printk(KERN_DEBUG "gcblock: NULL\n");
+	}
+	if (list_empty(&c->clean_list)) {
+		printk(KERN_DEBUG "clean_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->clean_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "clean_list: %08x\n", jeb->offset);
+		}
+	}
+	if (list_empty(&c->dirty_list)) {
+		printk(KERN_DEBUG "dirty_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->dirty_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "dirty_list: %08x\n", jeb->offset);
+		}
+	}
+	if (list_empty(&c->erasing_list)) {
+		printk(KERN_DEBUG "erasing_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->erasing_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "erasing_list: %08x\n", jeb->offset);
+		}
+	}
+	if (list_empty(&c->erase_pending_list)) {
+		printk(KERN_DEBUG "erase_pending_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->erase_pending_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "erase_pending_list: %08x\n", jeb->offset);
+		}
+	}
+	if (list_empty(&c->free_list)) {
+		printk(KERN_DEBUG "free_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->free_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "free_list: %08x\n", jeb->offset);
+		}
+	}
+	if (list_empty(&c->bad_list)) {
+		printk(KERN_DEBUG "bad_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->bad_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "bad_list: %08x\n", jeb->offset);
+		}
+	}
+	if (list_empty(&c->bad_used_list)) {
+		printk(KERN_DEBUG "bad_used_list: empty\n");
+	} else {
+		struct list_head *this;
+
+		list_for_each(this, &c->bad_used_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			printk(KERN_DEBUG "bad_used_list: %08x\n", jeb->offset);
+		}
+	}
+#endif /* CONFIG_JFFS2_FS_DEBUG */
+
+	spin_unlock_bh(&c->erase_completion_lock);
+
+
+	return 0;
+}
+
+static struct super_block *jffs2_read_super(struct super_block *sb, void *data, int silent)
+{
+	struct jffs2_sb_info *c;
+	struct inode *root_i;
+	int i;
+
+	D1(printk(KERN_DEBUG "jffs2: read_super for device %s\n", kdevname(sb->s_dev)));
+
+	if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
+		if (!silent)
+			printk(KERN_DEBUG "jffs2: attempt to mount non-MTD device %s\n", kdevname(sb->s_dev));
+		return NULL;
+	}
+
+	c = JFFS2_SB_INFO(sb);
+	memset(c, 0, sizeof(*c));
+	
+	c->mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
+	if (!c->mtd) {
+		D1(printk(KERN_DEBUG "jffs2: MTD device #%u doesn't appear to exist\n", MINOR(sb->s_dev)));
+		return NULL;
+	}
+	c->sector_size = c->mtd->erasesize;
+	c->free_size = c->flash_size = c->mtd->size;
+	c->nr_blocks = c->mtd->size / c->mtd->erasesize;
+	c->blocks = kmalloc(sizeof(struct jffs2_eraseblock) * c->nr_blocks, GFP_KERNEL);
+	if (!c->blocks)
+		goto out_mtd;
+	for (i=0; i<c->nr_blocks; i++) {
+		INIT_LIST_HEAD(&c->blocks[i].list);
+		c->blocks[i].offset = i * c->sector_size;
+		c->blocks[i].free_size = c->sector_size;
+		c->blocks[i].dirty_size = 0;
+		c->blocks[i].used_size = 0;
+		c->blocks[i].first_node = NULL;
+		c->blocks[i].last_node = NULL;
+	}
+		
+	spin_lock_init(&c->nodelist_lock);
+	init_MUTEX(&c->alloc_sem);
+	init_waitqueue_head(&c->erase_wait);
+	spin_lock_init(&c->erase_completion_lock);
+	spin_lock_init(&c->inocache_lock);
+
+	INIT_LIST_HEAD(&c->clean_list);
+	INIT_LIST_HEAD(&c->dirty_list);
+	INIT_LIST_HEAD(&c->erasing_list);
+	INIT_LIST_HEAD(&c->erase_pending_list);
+	INIT_LIST_HEAD(&c->erase_complete_list);
+	INIT_LIST_HEAD(&c->free_list);
+	INIT_LIST_HEAD(&c->bad_list);
+	INIT_LIST_HEAD(&c->bad_used_list);
+	c->highest_ino = 1;
+
+	if (jffs2_build_filesystem(c)) {
+		D1(printk(KERN_DEBUG "build_fs failed\n"));
+		goto out_nodes;
+	}
+	sb->s_op = &jffs2_super_operations;
+
+	D1(printk(KERN_DEBUG "jffs2_read_super(): Getting root inode\n"));
+	root_i = iget(sb, 1);
+	if (is_bad_inode(root_i)) {
+		D1(printk(KERN_WARNING "get root inode failed\n"));
+		goto out_nodes;
+	}
+
+	D1(printk(KERN_DEBUG "jffs2_read_super(): d_alloc_root()\n"));
+	sb->s_root = d_alloc_root(root_i);
+	if (!sb->s_root)
+		goto out_root_i;
+
+#if LINUX_VERSION_CODE >= 0x20403
+	sb->s_maxbytes = 0xFFFFFFFF;
+#endif
+	sb->s_blocksize = PAGE_CACHE_SIZE;
+	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+	sb->s_magic = JFFS2_SUPER_MAGIC;
+	if (!(sb->s_flags & MS_RDONLY))
+		jffs2_start_garbage_collect_thread(c);
+	return sb;
+
+ out_root_i:
+	iput(root_i);
+ out_nodes:
+	jffs2_free_ino_caches(c);
+	jffs2_free_raw_node_refs(c);
+	kfree(c->blocks);
+ out_mtd:
+	put_mtd_device(c->mtd);
+	return NULL;
+}
+
+void jffs2_put_super (struct super_block *sb)
+{
+	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
+
+	D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n"));
+
+	if (!(sb->s_flags & MS_RDONLY))
+		jffs2_stop_garbage_collect_thread(c);
+	jffs2_free_ino_caches(c);
+	jffs2_free_raw_node_refs(c);
+	kfree(c->blocks);
+	if (c->mtd->sync)
+		c->mtd->sync(c->mtd);
+	put_mtd_device(c->mtd);
+	
+	D1(printk(KERN_DEBUG "jffs2_put_super returning\n"));
+}
+
+int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
+{
+	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
+
+	if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
+		return -EROFS;
+
+	/* We stop if it was running, then restart if it needs to.
+	   This also catches the case where it was stopped and this
+	   is just a remount to restart it */
+	if (!(sb->s_flags & MS_RDONLY))
+		jffs2_stop_garbage_collect_thread(c);
+
+	if (!(*flags & MS_RDONLY))
+		jffs2_start_garbage_collect_thread(c);
+	
+	sb->s_flags = (sb->s_flags & ~MS_RDONLY)|(*flags & MS_RDONLY);
+
+	return 0;
+}
+
+void jffs2_write_super (struct super_block *sb)
+{
+	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
+	sb->s_dirt = 0;
+
+	if (sb->s_flags & MS_RDONLY)
+		return;
+
+	jffs2_garbage_collect_trigger(c);
+	jffs2_erase_pending_blocks(c);
+	jffs2_mark_erased_blocks(c);
+}
+
+
+static DECLARE_FSTYPE_DEV(jffs2_fs_type, "jffs2", jffs2_read_super);
+
+static int __init init_jffs2_fs(void)
+{
+	int ret;
+
+	printk(KERN_NOTICE "JFFS2 version 2.1. (C) 2001 Red Hat, Inc., designed by Axis Communications AB.\n");
+
+#ifdef JFFS2_OUT_OF_KERNEL
+	/* sanity checks. Could we do these at compile time? */
+	if (sizeof(struct jffs2_sb_info) > sizeof (((struct super_block *)NULL)->u)) {
+		printk(KERN_ERR "JFFS2 error: struct jffs2_sb_info (%d bytes) doesn't fit in the super_block union (%d bytes)\n", 
+		       sizeof(struct jffs2_sb_info), sizeof (((struct super_block *)NULL)->u));
+		return -EIO;
+	}
+
+	if (sizeof(struct jffs2_inode_info) > sizeof (((struct inode *)NULL)->u)) {
+		printk(KERN_ERR "JFFS2 error: struct jffs2_inode_info (%d bytes) doesn't fit in the inode union (%d bytes)\n", 
+		       sizeof(struct jffs2_inode_info), sizeof (((struct inode *)NULL)->u));
+		return -EIO;
+	}
+#endif
+
+	ret = jffs2_create_slab_caches();
+	if (ret) {
+		printk(KERN_ERR "JFFS2 error: Failed to initialise slab caches\n");
+		return ret;
+	}
+	ret = register_filesystem(&jffs2_fs_type);
+	if (ret) {
+		printk(KERN_ERR "JFFS2 error: Failed to register filesystem\n");
+		jffs2_destroy_slab_caches();
+	}
+	return ret;
+}
+
+static void __exit exit_jffs2_fs(void)
+{
+	jffs2_destroy_slab_caches();
+	unregister_filesystem(&jffs2_fs_type);
+}
+
+module_init(init_jffs2_fs);
+module_exit(exit_jffs2_fs);
+
+MODULE_DESCRIPTION("The Journalling Flash File System, v2");
+MODULE_AUTHOR("Red Hat, Inc.");
+MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for 
+		       // the sake of this tag. It's Free Software.
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
diff --git a/yaffsdev b/yaffsdev
new file mode 100755
index 0000000000000000000000000000000000000000..6e51051b859dcc7fdd205bf6b372f0915281d490
GIT binary patch
literal 93829
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%0DSj=X=uA
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
ST&;vwC%X_h@ifwDo%o;HDSl4?

literal 0
HcmV?d00001

diff --git a/yaffsdev.c b/yaffsdev.c
new file mode 100644
index 0000000..64368f4
--- /dev/null
+++ b/yaffsdev.c
@@ -0,0 +1,303 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yaffsdev.c
+ *
+ * Copyright (C) 2002 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 "yaffsinterface.h"
+#include "yaffs_nandemul.h" 
+#include "yaffs_guts.h"
+#include <stdlib.h>
+
+#include <stdio.h>
+#include <string.h>
+
+ 
+
+
+
+yaffs_Device device;
+
+
+
+
+
+
+
+char *testStr = "this is a test string";
+
+char *testStr2 = "abcdefghijklmnopqrstuvwxyz1234567890";
+
+void TestTimexxx(yaffs_Device *dev)
+{
+	yaffs_Object *f;
+	int x;
+	
+	
+	printf("Start\n");
+	
+
+	f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
+	if(f)
+	{
+		printf("Found\n");
+	}
+	else
+	{
+		f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
+		printf("Created\n");
+	}
+	
+	
+	x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
+		
+}
+
+
+void TestTimeasasas(yaffs_Device *dev)
+{
+	yaffs_Object *f; 
+	int x;
+	int i;
+	int b;
+	char data[200];
+	int written;
+	
+	
+	printf("Start\n");
+	
+
+	f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
+	if(f)
+	{
+		printf("Found\n");
+	}
+	else
+	{
+		f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
+		printf("Created\n");
+	}
+	
+	
+	x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
+	
+	
+	
+	for(i = 0; i < 10000; i+=20)
+	{
+	
+		b++;
+		if(b & 1)
+			written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
+		else
+			written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
+	}
+	
+	
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	printf("Flush\n");
+	
+	yaffs_FlushFile(f);
+
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	yaffs_ReadDataFromFile(f,data,1000,50);
+	data[50] = 0;
+	
+	printf("Read data is \"%s\"\n",data);
+	
+	yaffs_DumpObject(f);
+
+	printf("Resize\n");	
+	yaffs_ResizeFile(f,2000);
+	
+	yaffs_DumpObject(f);
+
+	yaffs_FlushFile(f);
+	
+	
+		
+
+}
+
+void TestTime(yaffs_Device *dev)
+{
+	yaffs_Object *f;
+	yaffs_Object *sl;
+	yaffs_Object *lnf;
+	
+	yaffs_Object *hl1;
+	yaffs_Object *hl2;
+	yaffs_Object *hl3;
+	yaffs_Object *d, *df;
+	
+	int x;
+	int i;
+	int b;
+	char data[200];
+	
+	char * alias;
+	int written;
+	
+	
+	printf("Start\n");
+	
+
+	f = yaffs_FindObjectByName(yaffs_Root(dev),"Name1");
+	if(f)
+	{
+		printf("Found\n");
+	}
+	else
+	{
+		f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
+		printf("Created\n");
+	}
+	
+	
+	x = yaffs_RenameObject(yaffs_Root(dev),"Name1",NULL,"Rename");
+	
+	for(i = 0; i < 100000; i+=20)
+	{
+	
+		b++;
+		if(b & 1)
+			written = yaffs_WriteDataToFile(f,testStr,i,strlen(testStr));
+		else
+			written = yaffs_WriteDataToFile(f,testStr2,i,strlen(testStr2));
+	}
+	
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	printf("Flush\n");
+	
+	yaffs_FlushFile(f);
+	
+	printf("File length is %d\n",yaffs_GetObjectFileLength(f));
+	
+	sl = yaffs_MknodSymLink(yaffs_Root(dev),"sym-link",0,0,0,"/tmp/alias");
+
+
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	printf("\n\nsymlink alias is \"%s\"\n",alias = yaffs_GetSymlinkAlias(sl));
+	
+	free(alias);
+	
+	printf("Unlink symlink %d\n",yaffs_Unlink(yaffs_Root(dev),"sym-link"));
+	
+	
+	yaffs_ReadDataFromFile(f,data,1000,50);
+	data[50] = 0;
+	
+	printf("Read data is \"%s\"\n",data);
+	
+	yaffs_DumpObject(f);
+
+	printf("Resize\n");	
+	yaffs_ResizeFile(f,2000);
+	
+	yaffs_DumpObject(f);
+	
+	lnf = yaffs_FindObjectByName(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME);
+	
+	
+
+	yaffs_FlushFile(f);
+		
+
+	printf("Unlink file: %d\n",yaffs_Unlink(yaffs_Root(dev),"Rename"));
+	
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	// Create a directory and play with it
+	
+
+	printf("Create directory and play with it\n");
+		
+	d = yaffs_MknodDirectory(yaffs_Root(dev),"direct",0,0,0);
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
+	
+	printf("Make file in directory\n");
+	
+	df = yaffs_MknodFile(d,"file-in-directory",0,0,0);
+	yaffs_ApplyToDirectoryChildren(d,yaffs_DumpObject);
+	
+	
+	// Do some stuff with hardlinks
+	//
+	// NB Deleting hardlinked objects can mess up pointers to hardlinks.
+	// The mechanism is as follows:
+	// * If you unlink a file,softlink or directory that has one or more hardlinks,
+	// then the object is renamed to one of the hardlinks and that hardlink is unlinked.
+	// This means that a pointer to a hardlink so deleted will point to an invalid address.
+	// Thus, make sure that pointers to hardlinks are immediately dereferenced.
+
+
+	printf("Hard link tests\n");
+		
+	f = yaffs_MknodFile(yaffs_Root(dev),"Name1",0,0,0);
+	hl1 = yaffs_Link(yaffs_Root(dev),"HardLink 1",f);
+	hl2 = yaffs_Link(yaffs_Root(dev),"HardLink 2",f);
+	hl3 = yaffs_Link(yaffs_Root(dev),"HardLink 3",hl2);
+
+	printf("\n\nHard links created\n");
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	yaffs_Unlink(yaffs_Root(dev),"HardLink 1");
+	printf("\n\nHard link deleted\n");
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	yaffs_Unlink(yaffs_Root(dev),"Name1");
+	printf("\n\nHard linked file deleted\n");
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	yaffs_Unlink(yaffs_Root(dev),"HardLink 2");
+	printf("\n\nHard link 2 deleted\n");
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	yaffs_Unlink(yaffs_Root(dev),"HardLink 3");
+
+	printf("\n\nHard link 3 deleted\n");
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+	
+	// NB We don't allow unlinking or rename of the root or lost+found
+	// We allow setting attributes, but these must not be written to
+	// NAND since they are not real objects.
+	
+	printf("Attempt to rename lost+found - should have failed\n");
+	x = yaffs_RenameObject(yaffs_Root(dev),YAFFS_LOSTNFOUND_NAME,NULL,"Renamed");
+	yaffs_ApplyToDirectoryChildren(yaffs_Root(dev),yaffs_DumpObject);
+
+}
+
+int main(int argc,char *argv[])
+{
+	device.nBlocks = (2 * 1024 * 1024) / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
+	device.startBlock = 1;  // Don't use block 0
+	device.endBlock = device.nBlocks - 1;
+	
+	device.writeChunkToNAND = nandemul_WriteChunkToNAND;
+	device.readChunkFromNAND = nandemul_ReadChunkFromNAND;
+	device.eraseBlockInNAND = nandemul_EraseBlockInNAND;
+	device.initialiseNAND = nandemul_InitialiseNAND;
+	
+	yaffs_GutsInitialise(&device);
+	
+	// yaffs_GutsTest();
+	
+	TestTime(&device);
+	
+	exit(0);
+}
diff --git a/yaffsdev.proj b/yaffsdev.proj
new file mode 100644
index 0000000000000000000000000000000000000000..233551187effaeeb5015185a415ac0c2bbd4a863
GIT binary patch
literal 28672
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

literal 0
HcmV?d00001

diff --git a/yaffsinterface.h b/yaffsinterface.h
new file mode 100644
index 0000000..972a04d
--- /dev/null
+++ b/yaffsinterface.h
@@ -0,0 +1,23 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ * yaffsinterface.h: Interface to the guts of yaffs.
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
+ 
+#ifndef __YAFFSINTERFACE_H__
+#define __YAFFSINTERFACE_H__
+
+
+int yaffs_Initialise(unsigned nBlocks);
+
+#endif
+
diff --git a/yportenv.h b/yportenv.h
new file mode 100644
index 0000000..fc84fc5
--- /dev/null
+++ b/yportenv.h
@@ -0,0 +1,56 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system. 
+ * yportenv.h: Portable services used by yaffs. This is done to allow
+ * simple migration from kernel space into app space for testing.
+ *
+ * Copyright (C) 2002 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.
+ *
+ */
+ 
+#ifndef __PORTENV_H__
+#define __PORTENV_H__
+
+#ifndef __KERNEL__
+
+#include "stdlib.h"
+#include "stdio.h"
+#include "string.h"
+
+#define YPRINTF(x) printf x
+#define YMALLOC(x) malloc(x)
+#define YFREE(x)   free(x)
+
+
+#define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s))
+#define YALERT(s) YINFO(s)
+
+#else
+
+#include "linux/kernel.h"
+#include "linux/mm.h"
+#include "linux/string.h"
+#include "linux/slab.h"
+
+#define YPRINTF(x) printk x
+#define YMALLOC(x) kmalloc(x,GFP_KERNEL)
+#define YFREE(x)   kfree(x)
+
+#endif
+
+
+
+#define YINFO(s) YPRINTF((KERN_DEBUG __FILE__ " %d %s\n",__LINE__,s))
+#define YALERT(s) YINFO(s)
+
+#endif
+
+
+
+
-- 
2.30.2