Chinaunix首页 | 论坛 | 博客

一步一个脚印。。。

首页　| 　博文目录　| 　关于我

yangannie900

  • 博客访问： 118144
  • 博文数量： 27
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 85
  • 用 户 组： 普通用户
  • 注册时间： 2014-08-30 13:49
文章分类

全部博文（27）

文章存档

2017年（3）

2016年（1）

2015年（3）

2014年（20）

我的朋友
最近访客
推荐博文
相关博文
S3C6410使用---13mkyaffs2image

分类： LINUX

2014-08-30 13:53:24

原文地址：S3C6410使用---13mkyaffs2image 作者：wangcong02345

一. mkyaffs2image 是如何生成的
我们往往用 mkyaffs2image把文件系统打包成yaffs.bin格式,然后在u-boot 中用 nand.write.yaffs2 把文件系统烧到nand flash的指定位置上
但是mkyaffs2image是如何编译出来的呢? 其实mkyaffs2image是在yaffs文件系统的utils目录下,
只把其中的chunkSize  spareSize  与 pagesPerBlock几个变量,按照nand_flash中的改一下就可以用

  1. // Adjust these to match your NAND LAYOUT:
  2. //#define chunkSize 8192
  3. //#define spareSize 232
  4. #define chunkSize 4096
  5. //#define spareSize 218
  6. #define spareSize 128
  7. #define pagesPerBlock 128
我这儿只是改了 chunkSize 与 spareSize.但是貌似datasheet上的spareSize=218. 莫非datasheet也可以骗人?



二. mkyaffs2image分析
2. 下面是mkyaffs2image的main, 很简单的一个函数吧
其中, argc必须大于3     
     argv[1] = dir                  //文件系统的path
     argv[2] = image_file      //打包后生成yaffs.bin的路径
  1. int main(int argc, char *argv[])   
  2. {
  3.     struct stat stats;
  4.     stat(argv[1],&stats);  
  5.     if(!S_ISDIR(stats.st_mode))              //保证argv[1]必须是一个目录  
            exit(1);   
  6.     outFile = open(argv[2],O_CREAT | O_TRUNC | O_WRONLY, S_IREAD | S_IWRITE);  //写入到镜像yaffs.bin的fd保存在一个全局变量outFile中
  7.     process_directory(YAFFS_OBJECTID_ROOT,argv[1]);                            //1. 依次读取目录中的文件,写到yaffs.bin中
  8.     pad_image();                                                               //2. 将yaffs.bin扩充到block对齐                       
  9.     close(outFile);
  10. }
2.1 对目录的处理过程
  1. static int process_directory(int parent, const char *path)
  2. {
  3.     DIR *dir;
  4.     char full_name[500];
  5.     struct stat stats;
  6.     int equivalentObj;
  7.     int newObj;
  8.     struct dirent *entry;
  9.     nDirectories++;
  10.     dir = opendir(path);                      //打开目录
  11.     while((entry = readdir(dir)) != NULL)     //遍历目录中的所有文件
  12.     {
  13.         if(strcmp(entry->d_name,".") || strcmp(entry->d_name,".."))         //如果是 . 或者 .. 则直接跳过
  14.             continue;
  15.         snprintf(full_name,sizeof(full_name),"%s/%s",path,entry->d_name);    //构造文件的路径,存于full_name中        
  16.         lstat(full_name,&stats);                                             //获取目录下该文件的stat信息

  18.         if(!S_ISLNK(stats.st_mode) && !S_ISREG(stats.st_mode) && ! S_ISDIR(stats.st_mode) &&
  19.          !S_ISFIFO(stats.st_mode) && !S_ISBLK(stats.st_mode) && ! S_ISCHR(stats.st_mode) &&
  20.          !S_ISSOCK(stats.st_mode))
  21.             continue ;                                                        //不知道这TMD是什么类型的文件则跳过

  23.         newObj = obj_id++;
  24.         n_obj++;                
  25.         if((equivalentObj = find_obj_in_list(stats.st_dev, stats.st_ino)) > 0)
  26.         {
  27.             write_object_header(newObj, YAFFS_OBJECT_TYPE_HARDLINK, &stats, parent, entry->d_name, equivalentObj, NULL);
  28.         }
  29.         else
  30.         {
  31.             add_obj_to_list(stats.st_dev,stats.st_ino,newObj);
  32.             if(S_ISLNK(stats.st_mode))
  33.             {
  34.                 char symname[500];
  35.                 memset(symname,0, sizeof(symname));
  36.                 readlink(full_name,symname,sizeof(symname) -1);
  37.                 write_object_header(newObj, YAFFS_OBJECT_TYPE_SYMLINK, &stats, parent, entry->d_name, -1, symname);

  39.             }
  40.             else if(S_ISREG(stats.st_mode))             //如果是普通文件
  41.             {                        
  42.                 if(write_object_header(newObj, YAFFS_OBJECT_TYPE_FILE, &stats, parent, entry->d_name, -1, NULL) == 0)  //1.先写入文件头
  43.                 {
  44.                     int h;
  45.                     u8 bytes[chunkSize];
  46.                     int n_bytes;
  47.                     int chunk = 0;

  49.                     h = open(full_name,O_RDONLY);                            
  50.                     memset(bytes,0xff,sizeof(bytes));
  51.                     while((n_bytes = read(h,bytes,sizeof(bytes))) > 0)
  52.                     {
  53.                         chunk++;
  54.                         write_chunk(bytes,newObj,chunk,n_bytes);                                            //2.再写入文件内容
  55.                         memset(bytes,0xff,sizeof(bytes));
  56.                     }
  57.                     close(h);
  58.                 }
  59.             }
  60.             else if(S_ISSOCK(stats.st_mode))                                    //如果是socket文件                   
  61.                 write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL);  //只写入文件头                  
  62.             else if(S_ISFIFO(stats.st_mode))                                    //如果是FIFO文件                   
  63.                 write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL); //只写入文件头                   
  64.             else if(S_ISCHR(stats.st_mode))                                     //如果是字符设备文件                  
  65.                 write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL);  //只写入文件头                  
  66.             else if(S_ISBLK(stats.st_mode))                                     //如果是块设备文件                  
  67.                 write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL); //只写入文件头                   
  68.             else if(S_ISDIR(stats.st_mode))                                     //如果是目录文件                   
  69.                 if (write_object_header(newObj, YAFFS_OBJECT_TYPE_DIRECTORY, &stats, parent, entry->d_name, -1, NULL) == 0) //只写入文件头
  70.                     process_directory(newObj,full_name);                       //并把这次的newObj作为parent,继续             
  71.         }    
  72.     }
  73.     closedir(dir);
  74.     return 0;
  75. }
2.1.1
  1. static int write_object_header(int id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
  2. {
  3.     u8 bytes[chunkSize];


  6.     struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes;

  8.     memset(bytes,0xff,sizeof(bytes));

  10.     oh->type = t;

  12.     oh->parent_obj_id = parent;

  14.     if (strlen(name)+1 > sizeof(oh->name))
  15.     {
  16.         errno = ENAMETOOLONG;
  17.         return warn("object name");
  18.     }
  19.     memset(oh->name,0,sizeof(oh->name));
  20.     strcpy(oh->name,name);

  22.     if(t != YAFFS_OBJECT_TYPE_HARDLINK)
  23.     {
  24.         oh->yst_mode = s->st_mode;
  25.         oh->yst_uid = s->st_uid;
  26.         oh->yst_gid = s->st_gid;
  27.         oh->yst_atime = s->st_atime;
  28.         oh->yst_mtime = s->st_mtime;
  29.         oh->yst_ctime = s->st_ctime;
  30.         oh->yst_rdev = s->st_rdev;
  31.     }

  33.     if(t == YAFFS_OBJECT_TYPE_FILE)
  34.     {
  35.         oh->file_size = s->st_size;
  36.     }

  38.     if(t == YAFFS_OBJECT_TYPE_HARDLINK)
  39.     {
  40.         oh->equiv_id = equivalentObj;
  41.     }

  43.     if(t == YAFFS_OBJECT_TYPE_SYMLINK)
  44.     {
  45.         if (strlen(alias)+1 > sizeof(oh->alias))
  46.         {
  47.             errno = ENAMETOOLONG;
  48.             return warn("object alias");
  49.         }
  50.         memset(oh->alias,0,sizeof(oh->alias));
  51.         strcpy(oh->alias,alias);
  52.     }
  53.     return write_chunk(bytes,id,0,0xffff);

  55. }

  1. static int write_chunk(u8 *data, u32 id, u32 chunk_id, u32 n_bytes)
  2. {
  3.     struct yaffs_ext_tags t;
  4.     struct yaffs_packed_tags2 pt;
  5.     char spareData[spareSize];

  7.     if (write(outFile,data,chunkSize) != chunkSize)                //写4K
  8.         fatal("write");

  10.     memset(&t, 0, sizeof(t));

  12.     t.chunk_id = chunk_id;
  13.     t.serial_number = 1;    // **CHECK**
  14.     t.n_bytes = n_bytes;
  15.     t.obj_id = id;
  16.     t.seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
  17.     t.chunk_used = 1;

  19.     nPages++;

  21.     memset(&pt, 0, sizeof(pt));                        //函数将 yaffs_ext_tags转为yaffs_packed_tags2,并生成校验信息,
  22.     yaffs_pack_tags2(&pt,&t,0);                        //但最后一个函数是0,所以只转化保存校验信息
  23.     memset(spareData, 0xff, sizeof(spareData));             
  24.     shuffle_oob(spareData, &pt);

  26.     if (write(outFile,spareData,sizeof(spareData)) != sizeof(spareData))  //写oob
  27.         fatal("write");

  29.     return 0;
  30. }
注:
struct yaffs_packed_tags2 {
    struct yaffs_packed_tags2_tags_only t;     //数据
    struct yaffs_ecc_other ecc;                       //校验信息
};
yaffs_packed_tags2是由数据和校难信息两部分组成的,但是这儿只用了数据不进行校验,所以内核里面也只是读出数据不校验
2.2 扩充yaffs.bin到一个block
  1. static void pad_image(void)
  2. {
  3.     u8 data[chunkSize + spareSize];
  4.     int padPages = (nPages % pagesPerBlock);

  6.     if (padPages)
  7.     {
  8.         memset(data, 0xff, sizeof(data));
  9.         for (padPages = pagesPerBlock-padPages; padPages; padPages--)
  10.         {
  11.             if (write(outFile, data, sizeof(data)) != sizeof(data))
  12.                 fatal("write");
  13.         }
  14.     }
  15. }
d
三. 实验一下
3.1 实验
a.新建目录fs_test,在fs_test新建一文件222.txt, 内空是"bbbcc"
  1. sun@ubuntu:/tmp/mkyaffs/utils/test$ tree
  2. .
  3. └── fs_test
  4.     └── 222.txt

  6. 1 directory, 1 file
  7. sun@ubuntu:/tmp/mkyaffs/utils/test$ cat fs_test/222.txt
  8. bbbccc
b. 利用mkyaffs2image生成yaffs的打包文件fs.yaffs
  1. sun@ubuntu:/tmp/mkyaffs/utils/test$ ../mkyaffs2image fs_test/ fs.yaffs
  2.     main[432]: mkyaffs2image: image building tool for YAFFS2 built Jul 3 2013
  3.     main[464]: Processing directory fs_test/ into image file fs.yaffs
  4.     Object 257, fs_test//222.txt is a
  5.     file,
  6.     1 data chunks written
  7.     pad_image[255]: nPages=2
  8.     main[480]: Operation complete.
  9.     2 objects in 1 directories
  10.     2 NAND pages
  11. sun@ubuntu:/tmp/mkyaffs/utils/test$ ll
  12. total 540
  13. drwxrwxr-x 3 sun sun 4096 Jul 3 16:36 ./
  14. drwxrwxr-x 5 sun sun 4096 Jul 3 15:36 ../
  15. drwxrwxr-x 2 sun sun 4096 Jul 3 15:06 fs_test/
  16. -rw------- 1 sun sun 540672 Jul 3 16:36 fs.yaffs
可以看出fs.yaffs的大小是540672=128×(4096+128)
c. 分析一下fs.yaffs
按page的记录内容,可以分为两种,一个是oh_page另一个是data_page
其中普通文件,需要一个oh_page,如果有内容还需要一个或多个data_page
其它的文件,则只需要一个oh_page就够了.
   oh_page:

data_page:


sizeof(yaffs_obj_hdr)=0x200=512B
28B的信息就是结构体 yaffs_packed_tags2
  1. struct yaffs_packed_tags2_tags_only {
  2.     unsigned seq_number;
  3.     unsigned obj_id;
  4.     unsigned chunk_id;
  5.     unsigned n_bytes;
  6. };
  7. struct yaffs_ecc_other {
  8.     unsigned char col_parity;
  9.     unsigned line_parity;
  10.     unsigned line_parity_prime;
  11. };
  12. struct yaffs_packed_tags2 {
  13.     struct yaffs_packed_tags2_tags_only t;
  14.     struct yaffs_ecc_other ecc;
  15. };
3.2 oh_page与data_page的根本区别
int write_chunk(u8 *data, u32 id, u32 chunk_id, u32 n_bytes);
write_chunk(bytes,id,0,0xffff);                         //写oh_page    chunk_id=0,写入oob
write_chunk(bytes,newObj,chunk,n_bytes);     //写data_page  chunk_id!=0,写入oob

其中 write_chunk的第2个参数id, oh_page与data_page相等的话说明这是同一个文件的头与数据区
其中 write_chunk的第3个参数chunk_id, 区分oh_page与data_page,  oh_page的chunk_id=0


阅读(1311) | 评论(0) | 转发(0) |
0

上一篇：S3C6410使用---15yaffs2中chunk的分配与释放

下一篇：S3C6410使用---11uboot写yaffs2文件系统过程分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6