yaffs Added some more tests to timothy_tests.
[yaffs2.git] / direct / basic-test / yaffs_fileem2k.c
1 /*
2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
3  *
4  * Copyright (C) 2002-2010 Aleph One Ltd.
5  *   for Toby Churchill Ltd and Brightstar Engineering
6  *
7  * Created by Charles Manning <charles@aleph1.co.uk>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 /*
15  * This provides a YAFFS nand emulation on a file for emulating 2kB pages.
16  * This is only intended as test code to test persistence etc.
17  */
18
19 const char *yaffs_flashif2_c_version = "$Id: yaffs_fileem2k.c,v 1.24 2010-02-18 01:18:04 charles Exp $";
20
21
22 #include "yportenv.h"
23 #include "yaffs_trace.h"
24
25 #include "yaffs_flashif2.h"
26 #include "yaffs_guts.h"
27 #include "yaffs_fileem2k.h"
28 #include "yaffs_packedtags2.h"
29 #include "yaffs_tagsvalidity.h"
30
31
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <unistd.h> 
36
37
38
39 #define REPORT_ERROR 0
40
41 typedef struct 
42 {
43         u8 data[PAGE_SIZE]; // Data + spare
44 } yflash_Page;
45
46 typedef struct
47 {
48         yflash_Page page[PAGES_PER_BLOCK]; // The pages in the block
49         
50 } yflash_Block;
51
52
53
54 #define MAX_HANDLES 20
55 #define BLOCKS_PER_HANDLE (32*8)
56
57 typedef struct
58 {
59         int handle[MAX_HANDLES];
60         int nBlocks;
61 } yflash_Device;
62
63 static yflash_Device filedisk;
64
65 int yaffs_test_partial_write = 0;
66
67 extern int random_seed;
68 extern int simulate_power_failure;
69 static int remaining_ops;
70 static int nops_so_far;
71
72 int ops_multiplier;
73
74
75 static void yflash2_MaybePowerFail(unsigned int nand_chunk, int failPoint)
76 {
77
78    nops_so_far++;
79    
80    
81    remaining_ops--;
82    if(simulate_power_failure &&
83       remaining_ops < 1){
84        printf("Simulated power failure after %d operations\n",nops_so_far);
85        printf("  power failed on nand_chunk %d, at fail point %d\n",
86                         nand_chunk, failPoint);
87         exit(0);
88   }
89 }
90
91
92
93
94
95 static u8 localBuffer[PAGE_SIZE];
96
97 static char *NToName(char *buf,int n)
98 {
99         sprintf(buf,"emfile-2k-%d",n);
100         return buf;
101 }
102
103 static char dummyBuffer[BLOCK_SIZE];
104
105 static int GetBlockFileHandle(int n)
106 {
107         int h;
108         int requiredSize;
109         
110         char name[40];
111         NToName(name,n);
112         int fSize;
113         int i;
114         
115         h =  open(name, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
116         if(h >= 0){
117                 fSize = lseek(h,0,SEEK_END);
118                 requiredSize = BLOCKS_PER_HANDLE * BLOCK_SIZE;
119                 if(fSize < requiredSize){
120                    for(i = 0; i < BLOCKS_PER_HANDLE; i++)
121                         if(write(h,dummyBuffer,BLOCK_SIZE) != BLOCK_SIZE)
122                                 return -1;
123                         
124                 }
125         }
126         
127         return h;
128
129 }
130
131 static int  CheckInit(void)
132 {
133         static int initialised = 0;
134         int i;
135
136         int blk;
137
138         
139         if(initialised) 
140         {
141                 return YAFFS_OK;
142         }
143
144         initialised = 1;
145         
146
147         srand(random_seed);
148         remaining_ops = (rand() % 1000) * 5;
149         memset(dummyBuffer,0xff,sizeof(dummyBuffer));
150
151         
152         
153         filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
154
155         for(i = 0; i <  MAX_HANDLES; i++)
156                 filedisk.handle[i] = -1;
157         
158         for(i = 0,blk = 0; blk < filedisk.nBlocks; blk+=BLOCKS_PER_HANDLE,i++)
159                 filedisk.handle[i] = GetBlockFileHandle(i);
160         
161         
162         return 1;
163 }
164
165
166 int yflash2_GetNumberOfBlocks(void)
167 {
168         CheckInit();
169         
170         return filedisk.nBlocks;
171 }
172
173 int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags)
174 {
175         int written;
176         int pos;
177         int h;
178         int i;
179         int nRead;
180         int error;
181         
182         yaffs_trace(YAFFS_TRACE_MTD, "write chunk %d data %p tags %p",nand_chunk, data, tags);
183
184         CheckInit();
185         
186         
187         if(dev->param.inband_tags){
188                 
189                 struct yaffs_packed_tags2_tags_only * pt2tp;
190                 pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk];
191                 yaffs_pack_tags2_tags_only(pt2tp,tags);
192                 
193                 pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
194                 h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
195                                                         
196                 lseek(h,pos,SEEK_SET);
197                 written = write(h,data,dev->param.total_bytes_per_chunk);
198
199                 
200                 if(yaffs_test_partial_write){
201                         close(h);
202                         exit(1);
203                 }
204                 
205                 if(written != dev->param.total_bytes_per_chunk) return YAFFS_FAIL;
206
207
208         }
209         
210         else {
211                 /* First do a write of a partial page */
212                 int n_partials;
213                 int bpos;
214
215                 if(data)
216                 {
217                         pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
218                         h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
219                 
220                         
221                         memcpy(localBuffer,data, dev->data_bytes_per_chunk);
222                         
223                         n_partials = rand()%20;
224                         
225                         for(i = 0; i < n_partials; i++){
226                                 bpos = rand() % dev->data_bytes_per_chunk;
227                                 
228                                 localBuffer[bpos] |= (1 << (rand() & 7));
229                         }
230                   
231                         if(REPORT_ERROR && memcmp(localBuffer,data,dev->data_bytes_per_chunk))
232                                 printf("nand simulator: data does not match\n");
233                         
234                         lseek(h,pos,SEEK_SET);
235                         written = write(h,localBuffer,dev->data_bytes_per_chunk);
236                 
237                         if(yaffs_test_partial_write){
238                                 close(h);
239                                 exit(1);
240                         }
241
242
243                         if(written != dev->data_bytes_per_chunk) return YAFFS_FAIL;
244                 }
245                 // yflash2_MaybePowerFail(nand_chunk,1);
246         
247                 if(tags)
248                 {
249                         pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
250                         h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
251                 
252                         lseek(h,pos,SEEK_SET);
253
254                         if( 0 && dev->param.is_yaffs2)
255                         {
256                         
257                                 written = write(h,tags,sizeof(struct yaffs_ext_tags));
258                                 if(written != sizeof(struct yaffs_ext_tags)) return YAFFS_FAIL;
259                         }
260                         else
261                         {
262                                 struct yaffs_packed_tags2 pt;
263                                 yaffs_pack_tags2(&pt,tags, !dev->param.no_tags_ecc);
264                                 u8 * ptab = (u8 *)&pt;
265
266                                 nRead = read(h,localBuffer,sizeof(pt));
267                                 for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){
268                                         if(localBuffer[i] != 0xFF){
269                                                 printf("nand simulation: chunk %d oob byte %d was %0x2\n",
270                                                         nand_chunk,i,localBuffer[i]);
271                                                         error = 1;
272                                         }
273                                 }
274                 
275                                 for(i = 0; i < sizeof(pt); i++)
276                                 localBuffer[i] &= ptab[i];
277                                 
278                                 n_partials = rand()% sizeof(pt);
279                         
280                                 for(i = 0; i < n_partials; i++){
281                                         bpos = rand() % sizeof(pt);
282                                 
283                                         localBuffer[bpos] |= (1 << (rand() & 7));
284                                 }                       
285                          
286                                 if(REPORT_ERROR && memcmp(localBuffer,&pt,sizeof(pt)))
287                                         printf("nand sim: tags corruption\n");
288                                 
289                                 lseek(h,pos,SEEK_SET);
290                         
291                                 written = write(h,localBuffer,sizeof(pt));
292                                 if(written != sizeof(pt)) return YAFFS_FAIL;
293                         }
294                 }
295                 
296                 //yflash2_MaybePowerFail(nand_chunk,2);
297                 
298                 /* Next do the whole write */
299                 if(data)
300                 {
301                         pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
302                         h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
303                 
304                         
305                         memset(localBuffer,0xFF, PAGE_SIZE);            
306                         for(i = 0; i < dev->data_bytes_per_chunk; i++){
307                                 localBuffer[i] &= data[i];
308                         }
309                   
310                         if(REPORT_ERROR && memcmp(localBuffer,data,dev->data_bytes_per_chunk))
311                                 printf("nand simulator: data does not match\n");
312                         
313                         lseek(h,pos,SEEK_SET);
314                         written = write(h,localBuffer,dev->data_bytes_per_chunk);
315                 
316                         if(yaffs_test_partial_write){
317                                 close(h);
318                                 exit(1);
319                         }
320
321
322                         if(written != dev->data_bytes_per_chunk) return YAFFS_FAIL;
323                 }
324         
325                 if(tags)
326                 {
327                         pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
328                         h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
329                 
330                         lseek(h,pos,SEEK_SET);
331
332                         if( 0 && dev->param.is_yaffs2)
333                         {
334                         
335                                 written = write(h,tags,sizeof(struct yaffs_ext_tags));
336                                 if(written != sizeof(struct yaffs_ext_tags)) return YAFFS_FAIL;
337                         }
338                         else
339                         {
340                                 struct yaffs_packed_tags2 pt;
341                                 yaffs_pack_tags2(&pt,tags,!dev->param.no_tags_ecc);
342                                 u8 * ptab = (u8 *)&pt;
343
344                                 nRead = read(h,localBuffer,sizeof(pt));
345                                 for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){
346                                         if(localBuffer[i] != 0xFF){
347                                                 printf("nand simulation: chunk %d oob byte %d was %0x2\n",
348                                                         nand_chunk,i,localBuffer[i]);
349                                                         error = 1;
350                                         }
351                                 }
352                 
353                                 for(i = 0; i < sizeof(pt); i++)
354                                 localBuffer[i] &= ptab[i];
355                          
356                                 if(REPORT_ERROR && memcmp(localBuffer,&pt,sizeof(pt)))
357                                         printf("nand sim: tags corruption\n");
358                                 
359                                 lseek(h,pos,SEEK_SET);
360                         
361                                 written = write(h,localBuffer,sizeof(pt));
362                                 if(written != sizeof(pt)) return YAFFS_FAIL;
363                         }
364                 }
365                 
366                 yflash2_MaybePowerFail(nand_chunk,3);
367         
368         }
369         return YAFFS_OK;        
370
371 }
372
373 int yaffs_check_all_ff(const u8 *ptr, int n)
374 {
375         while(n)
376         {
377                 n--;
378                 if(*ptr!=0xFF) return 0;
379                 ptr++;
380         }
381         return 1;
382 }
383
384
385 static int fail300 = 1;
386 static int fail320 = 1;
387
388 static int failRead10 = 2;
389
390 int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags)
391 {
392         int nread;
393         int pos;
394         int h;
395         int localData = 0;
396         int retval = YAFFS_OK;
397         int nRead;
398         
399         yaffs_trace(YAFFS_TRACE_MTD,"read chunk %d data %p tags %p",nand_chunk, data, tags);
400         
401         CheckInit();
402         
403         
404         
405         
406         if(dev->param.inband_tags){
407                 /* Got to suck the tags out of the data area */
408                 if(!data) {
409                         localData=1;
410                         data = yaffs_get_temp_buffer(dev,__LINE__);
411                 }
412
413                 
414                 struct yaffs_packed_tags2_tags_only * pt2tp;
415                 pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk];
416
417                 
418                 pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
419                 h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
420                 
421                 lseek(h,pos,SEEK_SET);
422
423                 nRead = read(h, data,dev->param.total_bytes_per_chunk);
424
425                 yaffs_unpack_tags2_tags_only(tags,pt2tp);
426                 
427                 if(nread != dev->param.total_bytes_per_chunk)
428                         retval = YAFFS_FAIL;
429                         
430                 if(localData)
431                         yaffs_release_temp_buffer(dev,data,__LINE__);
432
433
434
435         }
436         
437         else {
438         
439                 if(data)
440                 {
441
442                         pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
443                         h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];              
444                         lseek(h,pos,SEEK_SET);
445                         nread = read(h,data,dev->data_bytes_per_chunk);
446                 
447                 
448                         if(nread != dev->data_bytes_per_chunk) 
449                                 retval = YAFFS_FAIL;
450                 }
451         
452                 if(tags)
453                 {
454                         pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
455                         h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];              
456                         lseek(h,pos,SEEK_SET);
457
458                         if(0 && dev->param.is_yaffs2)
459                         {
460                                 nread= read(h,tags,sizeof(struct yaffs_ext_tags));
461                                 if(nread != sizeof(struct yaffs_ext_tags))
462                                          retval =  YAFFS_FAIL;
463                                 if(yaffs_check_all_ff((u8 *)tags,sizeof(struct yaffs_ext_tags)))
464                                 {
465                                         yaffs_init_tags(tags);
466                                 }
467                                 else
468                                 {
469                                         tags->chunk_used = 1;
470                                 }
471                         }
472                         else
473                         {
474                                 struct yaffs_packed_tags2 pt;
475                                 nread= read(h,&pt,sizeof(pt));
476                                 yaffs_unpack_tags2(tags,&pt, !dev->param.no_tags_ecc);
477 #ifdef SIMULATE_FAILURES
478                                 if((nand_chunk >> 6) == 100) {
479                                         if(fail300 && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR){
480                                                 tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
481                                                 fail300 = 0;
482                                         }
483                                 }
484                                 
485                                 if((nand_chunk >> 6) == 110) {
486                                         if(fail320 && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR){
487                                                 tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
488                                                 fail320 = 0;
489                                         }
490                                 }
491 #endif
492                                 if(failRead10>0 && nand_chunk == 10){
493                                         failRead10--;
494                                         nread = 0;
495                                 }
496                         
497                                 if(nread != sizeof(pt))
498                                         retval = YAFFS_FAIL;
499                         }
500                 }
501         }
502         
503
504
505         return retval;  
506
507 }
508
509
510 int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
511 {
512         int written;
513         int h;
514         
515         struct yaffs_packed_tags2 pt;
516
517         CheckInit();
518         
519         memset(&pt,0,sizeof(pt));
520         h = filedisk.handle[(block_no / ( BLOCKS_PER_HANDLE))];
521         lseek(h,((block_no % BLOCKS_PER_HANDLE) * dev->param.chunks_per_block) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
522         written = write(h,&pt,sizeof(pt));
523                 
524         if(written != sizeof(pt)) return YAFFS_FAIL;
525         
526         
527         return YAFFS_OK;
528         
529 }
530
531 int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
532 {
533
534         int i;
535         int h;
536                 
537         CheckInit();
538         
539         //printf("erase block %d\n",blockNumber);
540         
541         if(blockNumber == 320)
542                 fail320 = 1;
543         
544         if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
545         {
546                 yaffs_trace(YAFFS_TRACE_ALWAYS,"Attempt to erase non-existant block %d",blockNumber);
547                 return YAFFS_FAIL;
548         }
549         else
550         {
551         
552                 u8 pg[PAGE_SIZE];
553                 int syz = PAGE_SIZE;
554                 int pos;
555                 
556                 memset(pg,0xff,syz);
557                 
558
559                 h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))];
560                 lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->param.chunks_per_block) * PAGE_SIZE,SEEK_SET);                
561                 for(i = 0; i < dev->param.chunks_per_block; i++)
562                 {
563                         write(h,pg,PAGE_SIZE);
564                 }
565                 pos = lseek(h, 0,SEEK_CUR);
566                 
567                 return YAFFS_OK;
568         }
569         
570 }
571
572 int yflash2_InitialiseNAND(struct yaffs_dev *dev)
573 {
574         CheckInit();
575         
576         return YAFFS_OK;
577 }
578
579
580
581
582 int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number)
583 {
584         struct yaffs_ext_tags tags;
585         int chunkNo;
586
587         *seq_number = 0;
588         
589         chunkNo = block_no * dev->param.chunks_per_block;
590         
591         yflash2_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
592         if(tags.block_bad)
593         {
594                 *state = YAFFS_BLOCK_STATE_DEAD;
595         }
596         else if(!tags.chunk_used)
597         {
598                 *state = YAFFS_BLOCK_STATE_EMPTY;
599         }
600         else if(tags.chunk_used)
601         {
602                 *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
603                 *seq_number = tags.seq_number;
604         }
605         return YAFFS_OK;
606 }
607