【精华帖整理】写了一段测试nandflash可靠性的代码

本文由 chenrvmldd 在论坛所发，CU技术文章整理，供大家参考学习，转载请注明出处，谢谢。

*说明：测试nandflash的可靠性，有的时候nandflash写进去的内容会变位比如写进去1，可是存储的值变成了0，为了测试这种情况的频率写了下面的测试用例*/
/*nandflash挂载在/home/test目录下，通过不停的往test目录下写两个文件A,B（随便两个文件二进制文件都可以），写进去的文件名和顺序A0，B0，A1，B1，A2，B2....,每写进入一个文件读出来和A或者B比较*/
/*如果一旦发现写满了就删除文件重写继续写，一直持续下去，如果发现读出来的内容和写进入的内容就报错，然后再写一次，如果还错就退出程序*/

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. 
   
7. 
   
8. #include   //for statfs
   
9. #include    //for statfs
   
10. 
    
11. #include
    
12. #include   //for stat
    
13. #include
    
14. #include "errno.h"
    
15. 
    
16. static int nandflash_wrong=0;
    
17. 
    
18. 
    
19. int check_remain_space(void)
    
20. {
    
21.         int stat_flag=0;
    
22.     int i;
    
23.     struct statfs nandflash_stat;
    
24.     long hdisk_remainder_space;
    
25.     char path_name_check[32];
    
26.     struct stat name_buf_check;
    
27.    
    
28.         stat_flag = statfs("/home/test", &nandflash_stat);//获取nandflash的信息
    
29.     if(stat_flag<0)
    
30.     {
    
31.             printf("get nandflash info error!\n");
    
32.             return -1;
    
33.     }
    
34.    
    
35.     hdisk_remainder_space = (float)nandflash_stat.f_bsize * nandflash_stat.f_bfree / 1024;//检测磁盘空间
    
36.     if(hdisk_remainder_space<8*1024)  //至少保留8M的空间
    
37.     {
    
38.       for(i=0;i<200;i++)
    
39.       {
    
40.               sprintf(path_name_check,"/home/test/A%d",i);
    
41.               stat(path_name_check,&name_buf_check);
    
42.         if(errno!=ENOENT)  //文件存在，则删除
    
43.         {
    
44.                  unlink(path_name_check);//不能重名     
    
45.         }
    
46.               sprintf(path_name_check,"/home/test/B%d",i);
    
47.               stat(path_name_check,&name_buf_check);
    
48.         if(errno!=ENOENT)  //文件存在，则删除
    
49.         {
    
50.                 unlink(path_name_check);//不能重名     
    
51.         }
    
52.       }
    
53.       sleep(20); //删除文件并不是立即删除，所以要等待文件删除之后再写,防止写的速度比删除速度快，导致磁盘被写满的情况而出错                   
    
54.       return 1;
    
55.     }
    
56.     return 0;
    
57. }
    
58. 
    
59. int write_read_nandflash(int mark,unsigned int i,int file_size,char *write_buf,char *read_buf)
    
60. {
    
61.         FILE *fp;
    
62.         char path_name[32];
    
63.         unsigned  long buf_count=0;
    
64.         struct stat name_buf;
    
65.        
    
66.         if( mark == 0 )
    
67.         {
    
68.                 sprintf(path_name,"/home/test/A%d",i);//生成不同的文件名A0，A1，A2，A3.......
    
69.     }
    
70.     else
    
71.     {
    
72.             sprintf(path_name,"/home/test/B%d",i);
    
73.                    
    
74.     }
    
75.    
    
76.    
    
77.    stat(path_name,&name_buf);
    
78.    if(errno!=ENOENT)  //文件存在，则删除
    
79.    {
    
80.             unlink(path_name);//不能重名
    
81.             sleep(3);
    
82.    }                
    
83.     if((fp=fopen(path_name,"w"))==NULL)
    
84.     {
    
85.         printf("fopen  failed!\n");
    
86.             return -1;
    
87.     }
    
88. 
    
89.     fwrite(write_buf,file_size,1,fp);
    
90.     fclose(fp);
    
91.    
    
92. //    printf("write file name is:%s\n",path_name);
    
93.     if((fp=fopen(path_name,"r"))==NULL)
    
94.     {
    
95.             printf("fopen  failed!\n");
    
96.             return -1;       
    
97.     }
    
98.     fread(read_buf,file_size,1,fp);
    
99.    
    
100.     for(buf_count=0;buf_count<(file_size-1);buf_count++)//将master/slave文件写到nandflash中的内容读出来比较
     
101.     {
     
102.             if(read_buf[buf_count]!=write_buf[buf_count])
     
103.             {
     
104.                    
     
105.                     system("date");//出错的时候打印的系统时间
     
106.                     printf("file name is %s:\n",path_name);
     
107.                     unlink(path_name);
     
108.                     sleep(3);
     
109.                     if((fp=fopen(path_name,"w"))==NULL)
     
110.             {
     
111.                     printf("fopen  failed!\n");
     
112.                     return -1;
     
113.             }
     
114.                     nandflash_wrong++;
     
115.                     fwrite(write_buf,file_size,1,fp);//出错之后再写一次
     
116.                     fclose(fp);
     
117.                    
     
118.                     if((fp=fopen(path_name,"r"))==NULL)
     
119.             {
     
120.                     printf("fopen  failed!\n");
     
121.                     return -1;       
     
122.             }
     
123.                     fread(read_buf,file_size,1,fp);
     
124.                     for(buf_count=0;buf_count<(file_size-1);buf_count++)
     
125.                     {
     
126.                             if(read_buf[buf_count]!=write_buf[buf_count])
     
127.                             {
     
128.                                     printf("file name is %s:\n",path_name);
     
129.                                     printf("write twice failed!\n");
     
130.                                     fclose(fp);
     
131.                                     return -1;
     
132.                             }
     
133.                     }
     
134.             }
     
135.     }
     
136.     fclose(fp);
     
137.     return 0;
     
138. }
     
139. 
     
140. int main(void)
     
141. {
     
142.         int A_size,B_size;
     
143.         A_size=B_size=0;       
     
144.        
     
145.         int A_fd,B_fd;
     
146.        
     
147.         char *A_buf_read=NULL;
     
148.         char *B_buf_read=NULL;
     
149.         char *A_buf_write=NULL;
     
150.         char *B_buf_write=NULL;
     
151.        
     
152.         unsigned int  iteation=0;
     
153. 
     
154.     int ret;
     
155.    
     
156.     A_fd=0;
     
157.     A_fd=open("/home/A",O_RDONLY);
     
158.         if(A_fd<0)
     
159.         {
     
160.                 printf("open A faild!\n");
     
161.                 return -1;
     
162.         }
     
163.         A_size=lseek(A_fd,0,SEEK_END);
     
164.         lseek(A_fd,0,SEEK_SET);
     
165.         A_buf_write=(char *)malloc(A_size);
     
166.        
     
167.         if(NULL == A_buf_write)
     
168.         {
     
169.                 printf("A_buf_write malloc failed!\n");
     
170.                 close(A_fd);
     
171.                 return -1;
     
172.         }
     
173.        
     
174.         A_buf_read=(char *)malloc(A_size);
     
175.         if(NULL == A_buf_read)
     
176.         {
     
177.                 printf("A_buf_read malloc failed!\n");
     
178.                 close(A_fd);
     
179.                 return -1;
     
180.         }
     
181.         if(read(A_fd,A_buf_write,A_size)<0)
     
182.         {
     
183.                 close(A_fd);
     
184.                 printf("read A file failed\n");
     
185.         }
     
186.        
     
187.         close(A_fd);
     
188.         B_fd=0;
     
189.     B_fd=open("/home/B",O_RDONLY);
     
190.         if(B_fd<0)
     
191.         {
     
192.                 printf("open B faild!\n");
     
193.                 return -1;
     
194.         }
     
195.         B_size=lseek(B_fd,0,SEEK_END);
     
196.         lseek(B_fd,0,SEEK_SET);
     
197.         B_buf_write=(char *)malloc(B_size);
     
198.        
     
199.         if(NULL == B_buf_write)
     
200.         {
     
201.                 printf("B_buf_write malloc failed!\n");
     
202.                 close(B_fd);
     
203.                 return -1;
     
204.         }
     
205.        
     
206.         B_buf_read=(char *)malloc(B_size);
     
207.         if(NULL == B_buf_read)
     
208.         {
     
209.                 printf("B_buf_read malloc failed!\n");
     
210.                 close(B_fd);
     
211.                 return -1;
     
212.         }
     
213.         if(read(B_fd,B_buf_write,B_size)<0)
     
214.         {
     
215.                 printf("read B file failed\n");
     
216.                 close(B_fd);
     
217.         }
     
218.     close(B_fd);
     
219.    
     
220.     system("date");//测试开始，开始读写nandflash
     
221.     while(1)
     
222.     {
     
223.            
     
224.             if((ret=check_remain_space())<0)//检测磁盘空间，小于8M,要删除文件重新从A0，B0，A1，B1，A2，B2。。。。写
     
225.             {
     
226.                     printf("check space wrong\n");
     
227.                     return -1;
     
228.             }
     
229.             else if(ret==1)
     
230.             {
     
231.                     iteation=0;
     
232.             }
     
233.            
     
234.             if(write_read_nandflash(0,iteation,A_size,A_buf_write,A_buf_read)<0)//write A to nand and read it to compare
     
235.             {
     
236.                     printf("write_read nand flash wrong\n");
     
237.                     return -1;
     
238.             }
     
239.             if(write_read_nandflash(1,iteation,B_size,B_buf_write,B_buf_read)<0)//write B
     
240.             {
     
241.                     printf("write_read nand flash wrong\n");
     
242.                     return -1;
     
243.             }
     
244.             iteation++;
     
245.     }
     
246.    
     
247.     return 0;
     
248. }