Chinaunix首页 | 论坛 | 博客

SparkAndShine旧博客jelline.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

Jelline

  • 博客访问： 1673337
  • 博文数量： 124
  • 博客积分： 4078
  • 博客等级： 中校
  • 技术积分： 3943
  • 用 户 组： 普通用户
  • 注册时间： 2010-07-21 11:28
个人简介

新博客：http://sparkandshine.net/

文章分类

全部博文（124）

推荐博文
相关博文
Contiki学习笔记：Coffee文件系统写入文件cfs_write

分类： 嵌入式

2011-12-24 14:09:41

摘要：

    本文深入源码分析Coffee文件系统写入文件cfs_write技术细节，包括FD_WRITABLE、COFFEE_IO_SEMANTICS、merge_log、write_log_page、find_next_record、create_log、COFFEE_APPEND_ONLY、COFFEE_WRITE。


一、cfs_write

源代码如下：

  1. int cfs_write(int fd, const void *buf, unsigned size)
  2. {
  3.   struct file_desc *fdp;
  4.   struct file *file;

  6.   #if COFFEE_MICRO_LOGS
  7.     int i;
  8.     struct log_param lp;
  9.     cfs_offset_t bytes_left;
  10.     const char dummy[1] =
  11.     {
  12.       0xff
  13.     };
  14.   #endif

  16.   if(!(FD_VALID(fd) && FD_WRITABLE(fd))) //fd有效性判断及检查写权限，详情见1.1
  17.   {
  18.     return - 1;
  19.   }

  21.   fdp = &coffee_fd_set[fd];
  22.   file = fdp->file;


  25.   /***若超过文件末尾写，则扩展文件(当没有设置CFS_COFFEE_IO_FIRM_SIZE时)，见二***/
  26.   #if COFFEE_IO_SEMANTICS
  27.     if(!(fdp->io_flags &CFS_COFFEE_IO_FIRM_SIZE))
  28.     {
  29.     #endif

  31.     while(size + fdp->offset + sizeof(struct file_header) > (file->max_pages *COFFEE_PAGE_SIZE))
  32.     {
  33.       if(merge_log(file->page, 1) < 0)
  34.       {
  35.         return - 1;
  36.       } file = fdp->file;
  37.       PRINTF("Extended the file at page %u\n", (unsigned)file->page);
  38.     }

  40.     #if COFFEE_IO_SEMANTICS
  41.     }
  42.   #endif

  44.   /********写入文件概述，见1.2*************/
  45.   /**************实际写入文件***********************/
  46.   #if COFFEE_MICRO_LOGS
  47.     #if COFFEE_IO_SEMANTICS
  48.       if(!(fdp->io_flags&CFS_COFFEE_IO_FLASH_AWARE) && (FILE_MODIFIED(file) || fdp->offset<file->end))
  49.     #else
  50.       if(FILE_MODIFIED(file) || fdp->offset < file->end)
  51.       {
  52.     #endif
  53.         for(bytes_left = size; bytes_left > 0;)
  54.         {
  55.           lp.offset = fdp->offset;
  56.           lp.buf = buf;
  57.           lp.size = bytes_left;
  58.           i = write_log_page(file, &lp);
  59.           if(i < 0)
  60.           {
  61.             if(size == bytes_left)
  62.             {
  63.               return - 1;
  64.             }
  65.             break;
  66.           }
  67.           else if(i == 0)
  68.           {
  69.             file = fdp->file;
  70.           }
  71.           else
  72.           {
  73.             bytes_left -= i;
  74.             fdp->offset += i;
  75.             buf = (char*)buf + i;

  77.             if(fdp->offset > file->end)
  78.             {
  79.               file->end = fdp->offset;
  80.             }
  81.           }
  82.         }
  83.         if(fdp->offset > file->end)
  84.         {
  85.           COFFEE_WRITE(dummy, 1, absolute_offset(file->page, fdp->offset));
  86.         }
  87.       }
  88.       else
  89.       {
  90.   #endif /* COFFEE_MICRO_LOGS */

  92.       #if COFFEE_APPEND_ONLY
  93.         if(fdp->offset < file->end)
  94.         {
  95.           return - 1;
  96.         }
  97.       #endif

  99.         COFFEE_WRITE(buf, size, absolute_offset(file->page, fdp->offset));
  100.         fdp->offset += size;

  102.   #if COFFEE_MICRO_LOGS
  103.       }
  104.   #endif

  106.     if(fdp->offset > file->end)
  107.     {
  108.       file->end = fdp->offset;
  109.     }

  111.     return size;
  112.   }

1.1宏FD_VALID和FD_WRITABLE

(1) FD_VALID

    FD_VALID宏用于判断cfs_read函数传进来的fd是否有效，不能小于0(如，-1是get_available_fd函数分配不到fd的返回值)，也不能大于FD的上限(即COFFEE_FD_SET_SIZE)，其对应的file_desc的标志flags不能为空闲(COFFEE_FD_FREE)，源码如下：

  1. #define FD_VALID(fd) ((fd)>= 0 && (fd)<COFFEE_FD_SET_SIZE && coffee_fd_set[(fd)].flags!=COFFEE_FD_FREE)

(2) FD_WRITABLE

    FD_WRITABLE判断该文件是否以CFS_WRITE打开，可见如果想从文件末尾写，则需同时指定CFS_WRITE和CFS_APPEND，源码如下：

  1. #define FD_WRITABLE(fd) (coffee_fd_set[(fd)].flags & CFS_WRITE)

    注：尽管Coffee官方论文[1]声称指定了CFS_APPEND意味着指向CFS_WRITE，从源码分析，显然必须得指定CFS_WRITE才能写入。我觉得把FD_WRITABLE改下，会更符合编程习惯，如下：

  1. #define FD_WRITABLE(fd) (coffee_fd_set[(fd)].flags & CFS_WRITE & CFS_APPEND)

1.2 写入文件概述

扩展文件后(必要时，见二)，就实际进入写阶段了，出现了很多预定义的宏，先理清下这些宏的层次关系，而后再详细分析各种情况，简化后源代码如下：

  1. /**************写入文件概述，见1.2***********************/
  2. #if COFFEE_MICRO_LOGS
  3.   #if COFFEE_IO_SEMANTICS
  4.     if(!(fdp->io_flags &CFS_COFFEE_IO_FLASH_AWARE) && (FILE_MODIFIED(file)|| fdp->offset < file->end))
  5.     {
  6.   #else
  7.     if(FILE_MODIFIED(file) || fdp->offset < file->end)
  8.     {
  9.   #endif
  10.       /*************情型1，见三***********/
  11.       for(bytes_left = size; bytes_left > 0;)
  12.       {
  13.       }
  14.     }
  15.     else /*************情型2，见四***********/
  16.     {
  17. #endif

  19. #if COFFEE_MICRO_LOGS
  20.     }
  21. #endif

  23.   /***情型3，见五***/
  24.   if(fdp->offset > file->end)
  25.   {
  26.     file->end = fdp->offset;
  27.   }

    如果借助代码缩进(我用SourceFormat格式化代码，不是很智能，还得手动调)还没看清层次关系，那继续看下图：

图1 宏配置示意图

搞清了宏层次关系，就不难理解写入文件都有哪些情况：

(1)情形1

    配置了COFFEE_MICRO_LOGS且文件要么被修改了(即微日志文件存在)或者文件偏移量小于end(即原始文件还有空间可以写入)，如果Coffee还配置了COFFEE_IO_SEMANTICS，还需要求file_desc的io_flags中CFS_COFFEE_IO_FLASH_AWARE没有设置。

(2)情形2

    配置了COFFEE_MICRO_LOGS，文件要么没有被修改(即微日志文件不存在)且文件偏移量大于等于end，如果Coffee还配置了COFFEE_IO_SEMANTICS，还需要求file_desc的io_flags中CFS_COFFEE_IO_FLASH_AWARE被设置。

    若文件被扩展了(见二)，此时file->end等于偏移量，file的flags中M位为0(即没有微日志文件)，这种情况恰好满足这个条件(CFS_COFFEE_IO_FLASH_AWARE有设置的话)。

(3)情形3

    没有配置COFFEE_MICRO_LOGS，就直接跳到情况三了。事实上，情型1和情型2都需要执行这段代码(也有可能中途就退出了)。

1.3 一个BUG？

    假设系统配置了COFFEE_IO_SEMANTICS且io_flags也设置了CFS_COFFEE_IO_FIRM_SIZE，此时if(!(fdp->io_flags &CFS_COFFEE_IO_FIRM_SIZE))为假，直到跳到#if COFFEE_MICRO_LOGS。倘若系统没有配置COFFEE_MICRO_LOGS，再次跳过，执行以下语句，不论offset与end关系如何，直接返回size。也就是说，在这种最简单的模型下，传给cfs_write的size，原封不动返回。而这种情况是有可能存在的，这难道不是一个BUG？

  1. if(fdp->offset > file->end)
  2. {
  3.    file->end = fdp->offset;
  4. }
  5.   
  6. return size;


二、COFFEE_IO_SEMANTICS与CFS_COFFEE_IO_FIRM_SIZE

    如果没有设置CFS_COFFEE_IO_FIRM_SIZE，当现有的空间不足以数据写入时，则需扩展文件(merge_log函数)，略去参数验证及与本节无关代码如下：

  1. //设置了COFFEE_IO_SEMANTICS
  2. struct file_desc *fdp;
  3. struct file *file;

  5. fdp = &coffee_fd_set[fd];
  6. file = fdp->file;

  8. #if COFFEE_IO_SEMANTICS //见2.1
  9.   if(!(fdp->io_flags&CFS_COFFEE_IO_FIRM_SIZE))//若io_flags没设置CFS_COFFEE_IO_FIRM_SIZE则返回真，见2.1
  10.   {
  11. #endif

  13.   while(size + fdp->offset + sizeof(struct file_header) > (file->max_pages *COFFEE_PAGE_SIZE)) //若待写入的数据超过文件末尾，则合并日志
  14.   {
  15.     if(merge_log(file->page, 1) < 0) //见2.2
  16.     {
  17.       return - 1;
  18.     } 
  19.     file = fdp->file;
  20.     PRINTF("Extended the file at page %u\n", (unsigned)file->page);
  21.   }

  23. #if COFFEE_IO_SEMANTICS
  24.   }
  25. #endif

2.1 COFFEE_IO_SEMANTICS

    如果定义了COFFEE_IO_SEMANTICS，则在file_desc结构体会多一个成员变量io_flags，配置了COFFEE_IO_SEMANTICS可以优化某些存储设备的文件访问(optimize file access on certain storage types)，系统默认没有配置COFFEE_IO_SEMANTICS。系统定义了io_flags两个值，即CFS_COFFEE_IO_FLASH_AWARE和CFS_COFFEE_IO_FIRM_SIZE。设置了CFS_COFFEE_IO_FIRM_SIZE，如果写入文件超过预留的大小，Coffee不会继续扩展文件。当文件有固定大小限制时，设置CFS_COFFEE_IO_FIRM_SIZE可以保护过度写。

    在这里，如果io_flags设置了CFS_COFFEE_IO_FIRM_SIZE，就没必要扩展文件(即使是超过了)。如果连COFFEE_IO_SEMANTICS都没定义，也就是说file压根就没有io_flags，那就更省事了:-)

2.2 merge_log

    merge_log用于合并日志，即当文件剩余空间不足以写入size字节时，需要扩展，具体做法是：将原始文件和微日志文件(如果有的话)拷贝到新文件。源代码如下：

  1. //merge_log(file->page, 1)
  2. static int merge_log(coffee_page_t file_page, int extend)
  3. {
  4.   struct file_header hdr, hdr2;
  5.   int fd, n;
  6.   cfs_offset_t offset;
  7.   coffee_page_t max_pages;
  8.   struct file *new_file;
  9.   int i;

  11.   read_header(&hdr, file_page);

  13.   fd = cfs_open(hdr.name, CFS_READ); //以只读方式找开文件
  14.   if(fd < 0)
  15.   {
  16.     return - 1;
  17.   }

  19.   /***创建新的文件***/
  20.   max_pages = hdr.max_pages << extend;
  21.   new_file = reserve(hdr.name, max_pages, 1, 0); //创建新文件的主体函数
  22.   if(new_file == NULL)
  23.   {
  24.     cfs_close(fd);
  25.     return - 1;
  26.   }

  28.   offset = 0;
  29.   
  30.   /***将原文件的数据内容拷贝到新文件new_file***/
  31.   do
  32.   {
  33.     char buf[hdr.log_record_size == 0 ? COFFEE_PAGE_SIZE : hdr.log_record_size]; //数组表达式不是常量，编译出错

  35.     n = cfs_read(fd, buf, sizeof(buf));
  36.     if(n < 0)
  37.     {
  38.       remove_by_page(new_file->page, !REMOVE_LOG, !CLOSE_FDS, ALLOW_GC);
  39.       cfs_close(fd);
  40.       return - 1;
  41.     }
  42.     else if(n > 0)
  43.     {
  44.       COFFEE_WRITE(buf, n, absolute_offset(new_file->page, offset));
  45.       offset += n;
  46.     }
  47.   }while(n != 0);

  49.   /***利用原来那个file_desc***/
  50.   for(i = 0; i < COFFEE_FD_SET_SIZE; i++)
  51.   {
  52.     if(coffee_fd_set[i].flags != COFFEE_FD_FREE && coffee_fd_set[i].file->page == file_page)
  53.     {
  54.       coffee_fd_set[i].file = new_file;
  55.       new_file->references++;
  56.     }
  57.   }

  59.   /***删除原文件***/
  60.   if(remove_by_page(file_page, REMOVE_LOG, !CLOSE_FDS, !ALLOW_GC) < 0) //删除原始文件和微日志文件、不关闭FD、不进行垃圾回收
  61.   {
  62.     remove_by_page(new_file->page, !REMOVE_LOG, !CLOSE_FDS, !ALLOW_GC);
  63.     cfs_close(fd);
  64.     return - 1;
  65.   }

  67.   /***将原来file_header的log_record_size和log_records拷贝到新的file_header***/
  68.   read_header(&hdr2, new_file->page);
  69.   hdr2.log_record_size = hdr.log_record_size;
  70.   hdr2.log_records = hdr.log_records;
  71.   write_header(&hdr2, new_file->page);

  73.   /***设置新文件new_file的flags、end***/
  74.   new_file->flags &= ~COFFEE_FILE_MODIFIED;
  75.   new_file->end = offset;

  77.   cfs_close(fd);

  79.   return 0;
  80. }

    reserve是创建新文件的主体函数，首先进行参数验证，接着查看物理FLASH是否有连续pages空闲页，若有，则返回该文件即将占有页的第一页。否则，调用Coffee垃圾回收，再次查看物理FLASH是否有连续pages空闲页，如果还没有就返回NULL。创建成功后，加载文件(load_file)，如果缓存失败也是返回NULL。详情见博文《Contiki学习笔记：Coffee文件系统创建文件》。


三、写入文件情形1

    配置了COFFEE_MICRO_LOGS且文件要么被修改了(即微日志文件存在)或者文件偏移量小于end(即原始文件还有空间可以写入)，如果Coffee还配置了COFFEE_IO_SEMANTICS，还需要求file_desc的io_flags中CFS_COFFEE_IO_FLASH_AWARE没有设置。略去参数验证及与本节无关代码如下：

  1. struct file_desc *fdp;
  2. struct file *file;

  4. #if COFFEE_MICRO_LOGS
  5.   int i;
  6.   struct log_param lp;
  7.   cfs_offset_t bytes_left;
  8.   const char dummy[1] =
  9.   {
  10.     0xff
  11.   };
  12. #endif

  14. fdp = &coffee_fd_set[fd];
  15. file = fdp->file;

  17. {
  18.   for(bytes_left = size; bytes_left > 0;)
  19.   {
  20.     /***初始化lp结构体***/
  21.     lp.offset = fdp->offset;
  22.     lp.buf = buf;
  23.     lp.size = bytes_left;

  25.     i = write_log_page(file, &lp); //见3.1
  26.     if(i < 0)
  27.     {
  28.       if(size == bytes_left)
  29.       {
  30.         return - 1;
  31.       }
  32.       break;
  33.     }
  34.     else if(i == 0)
  35.     {
  36.       file = fdp->file;
  37.     }
  38.     else
  39.     {
  40.       bytes_left -= i;
  41.       fdp->offset += i;
  42.       buf = (char*)buf + i;

  44.       if(fdp->offset > file->end)
  45.       {
  46.         file->end = fdp->offset;
  47.       }
  48.     }
  49.   }
  50.   if(fdp->offset > file->end)
  51.   {
  52.     COFFEE_WRITE(dummy, 1, absolute_offset(file->page, fdp->offset)); //向文件offset处写入字节"0xFF"
  53.   }
  54. }

  56. /*******************************/
  57. if(fdp->offset > file->end)
  58. {
  59.   file->end = fdp->offset;
  60. }

  62. return size;

3.1 write_log_page

write_log_page将内容写入日志，源代码如下：

  1. #if COFFEE_MICRO_LOGS
  2.   static int write_log_page(struct file *file, struct log_param *lp)
  3.   {
  4.     struct file_header hdr;
  5.     uint16_t region;
  6.     coffee_page_t log_page;
  7.     int16_t log_record;
  8.     uint16_t log_record_size;
  9.     uint16_t log_records;
  10.     cfs_offset_t offset;
  11.     struct log_param lp_out;

  13.     read_header(&hdr, file->page);

  15.     adjust_log_config(&hdr, &log_record_size, &log_records);
  16.     region = modify_log_buffer(log_record_size, &lp->offset, &lp->size);

  18.     log_page = 0;
  19.     if(HDR_MODIFIED(hdr))
  20.     //判断微日志文件是否存在
  21.     {
  22.       /* A log structure has already been created. */
  23.       log_page = hdr.log_page;
  24.       log_record = find_next_record(file, log_page, log_records); //见3.2
  25.       if(log_record >= log_records)
  26.       {
  27.         /* The log is full; merge the log. */
  28.         PRINTF("Coffee: Merging the file %s with its log\n", hdr.name);
  29.         return merge_log(file->page, 0);
  30.       }
  31.     }
  32.     else
  33.     {
  34.       /***创建微日志文件，见3.3***/
  35.       log_page = create_log(file, &hdr);
  36.       if(log_page == INVALID_PAGE)
  37.       {
  38.         return - 1;
  39.       }
  40.       PRINTF("Coffee: Created a log structure for file %s at page %u\n", hdr.name,(unsigned)log_page);
  41.       hdr.log_page = log_page;
  42.       log_record = 0;
  43.     }

  45.     {
  46.       char copy_buf[log_record_size];

  48.       lp_out.offset = offset = region * log_record_size;
  49.       lp_out.buf = copy_buf;
  50.       lp_out.size = log_record_size;

  52.       if((lp->offset>0 || lp->size != log_record_size) && read_log_page(&hdr,log_record, &lp_out) < 0)
  53.       {
  54.         COFFEE_READ(copy_buf, sizeof(copy_buf), absolute_offset(file->page, offset));
  55.       }

  57.       memcpy(&copy_buf[lp->offset], lp->buf, lp->size);

  59.       /*
  60.        * Write the region number in the region index table.
  61.        * The region number is incremented to avoid values of zero.
  62.        */
  63.       offset = absolute_offset(log_page, 0);
  64.       ++region;
  65.       COFFEE_WRITE(&region, sizeof(region), offset + log_record * sizeof(region));

  67.       offset += log_records * sizeof(region);
  68.       COFFEE_WRITE(copy_buf, sizeof(copy_buf), offset + log_record * log_record_size);
  69.       file->record_count = + 1;
  70.     }

  72.     return lp->size;
  73.   }
  74. #endif

3.2 find_next_record

find_next_record源代码如下：

  1. //log_record = find_next_record(file, log_page, log_records);
  2. #if COFFEE_MICRO_LOGS
  3.   static int find_next_record(struct file *file, coffee_page_t log_page, int log_records)
  4.   {
  5.     int log_record, preferred_batch_size;

  7.     if(file->record_count >= 0)
  8.     {
  9.       return file->record_count;
  10.     }

  12.     preferred_batch_size = log_records > COFFEE_LOG_TABLE_LIMIT ? COFFEE_LOG_TABLE_LIMIT: log_records;
  13.     {
  14.       /* The next log record is unknown at this point; search for it. */
  15.       uint16_t indices[preferred_batch_size];
  16.       uint16_t processed;
  17.       uint16_t batch_size;

  19.       log_record = log_records;
  20.       for(processed = 0; processed < log_records; processed += batch_size)
  21.       {
  22.         batch_size = log_records - processed >= preferred_batch_size ? preferred_batch_size: log_records - processed;

  24.         COFFEE_READ(&indices, batch_size *sizeof(indices[0]), absolute_offset(log_page, processed *sizeof(indices[0])));
  25.         for(log_record = 0; log_record < batch_size; log_record++)
  26.         {
  27.           if(indices[log_record] == 0)
  28.           {
  29.             log_record += processed;
  30.             break;
  31.           }
  32.         }
  33.       }
  34.     }

  36.     return log_record;
  37.   }
  38. #endif

3.3 创建微日志文件create_log

    create_log首先调整日志记录大小和日志记录数量，reserve创建并加载微日志文件，若成功，对file_header及file相关成员变量进行一些设置，返回微日志文件的第一页，否则返回INVALID_PAGE。创建成功后的文件总体示意图如下：

图3 创建微日志文件示意图

创建微日志文件create_log源代码如下：

  1. //log_page = create_log(file, &hdr);
  2. #if COFFEE_MICRO_LOGS
  3.   static coffee_page_t create_log(struct file *file, struct file_header *hdr)
  4.   {
  5.     uint16_t log_record_size, log_records;
  6.     cfs_offset_t size;
  7.     struct file *log_file;

  9.     adjust_log_config(hdr, &log_record_size, &log_records); //调整微日志配置

  11.     /************创建微日志文件***************/
  12.     size = log_records *(sizeof(uint16_t) + log_record_size); //Log index size+log data size
  13.     log_file = reserve(hdr->name, page_count(size), 1, HDR_FLAG_LOG);
  14.     if (log_file == NULL)
  15.     {
  16.       return INVALID_PAGE;
  17.     }

  19.     hdr->flags |= HDR_FLAG_MODIFIED; //将file_header的flags中M位置1，表示文件已修改，微日志文件存在
  20.     hdr->log_page = log_file->page; //将file_header的log_page指向微日志文件的第一页
  21.     write_header(hdr, file->page); //写入file_header

  23.     file->flags |= COFFEE_FILE_MODIFIED; //file_header的flag中M位为1(即物理文件被修改，日志存在)，则file->flags设为COFFEE_FILE_MODIFIED
  24.     return log_file->page;
  25.   }
  26. #endif

   adjust_log_config调整日志记录大小和日志记录数量，即如果log_record_size及log_records为0，则设成默认值，详情参见博文《Contiki学习笔记：Coffee文件系统读取文件cfs_read》。

    reserve是创建微日志文件的主体函数，首先进行参数验证，接着查看物理FLASH是否有连续pages空闲页，若有，则返回该文件即将占有页的第一页。否则，调用Coffee垃圾回收，再次查看物理FLASH是否有连续pages空闲页，如果还没有就返回NULL。并加载文件load_file，若成功，返回file指针，否则返回NULL。详情参见博文《Contiki学习笔记：Coffee文件系统创建文件》三。


四、写入文件情形2

    配置了COFFEE_MICRO_LOGS，文件要么没有被修改(即微日志文件不存在)且文件偏移量大于等于end，如果Coffee还配置了COFFEE_IO_SEMANTICS，还需要求file_desc的io_flags中CFS_COFFEE_IO_FLASH_AWARE被设置。

    若文件被扩展了(见二)，此时file->end等于偏移量，file的flags中M位为0(即没有微日志文件)，这种情况恰好满足这个条件(CFS_COFFEE_IO_FLASH_AWARE有设置的话)。

    当系统配置了COFFEE_APPEND_ONLY，即只允许文件末尾写入，确保偏移量在文件末尾之后，就直接写入。略去参数验证及与本节无关代码如下：

  1. struct file_desc *fdp;
  2. struct file *file;
  1. #if COFFEE_MICRO_LOGS
  2.   int i;
  3.   struct log_param lp;
  4.   cfs_offset_t bytes_left;
  5.   const char dummy[1] =
  6.   {
  7.     0xff
  8.   };
  9. #endif

  2. fdp = &coffee_fd_set[fd];
  3. file = fdp->file;

  5. #if COFFEE_APPEND_ONLY //见4.1
  6.   if(fdp->offset < file->end)
  7.   {
  8.     return - 1;
  9.   }
  10. #endif

  12. COFFEE_WRITE(buf, size, absolute_offset(file->page, fdp->offset)); //此时offset >= end，见4.2
  13. fdp->offset += size;

  /***************************/
  1. if(fdp->offset > file->end)
  2. {
  3.   file->end = fdp->offset;
  4. }
  5. return size;

4.1 COFFEE_APPEND_ONLY

    COFFEE_APPEND_ONLY用于指定文件写入只能从文件末尾写，系统默认是没有设置的，若设置了，可以节省代码空间( save some code space)。值得注意的是，COFFEE_APPEND_ONLY和COFFEE_MICRO_LOGS不能同时为1，否则编译错误，源码如下：

  1. #if COFFEE_MICRO_LOGS && COFFEE_APPEND_ONLY
  2.   #error "Cannot have COFFEE_APPEND_ONLY set when COFFEE_MICRO_LOGS is set."
  3. #endif

4.2 COFFEE_WRITE

    COFFEE_WRITE宏直接定位到硬件相关的读函数，移植Coffee文件的时候需要映射过去(在cfs-coffee-arch.h)，源码如下：

  1. #define COFFEE_WRITE(buf, size, offset) stm32_flash_write(COFFEE_START + offset, buf, size)

    COFFEE_WRITE与stm32_flash_write映射关系如下图，在原有的offset加上COFFEE_START，就得到了从FLASH_START处的偏移量，即实际物理FLASH位置。

图 COFFEE_WRITE与stm32_flash_write映射关系

我觉得好奇怪，既然已经超过了文件末尾，那应该是从file->end写入，否则会产生文件空洞。


五、写入文件情形3

    没有配置COFFEE_MICRO_LOGS，就直接跳到情型3了，事实上，情型1和情型2都需要执行这段代码，

略去参数验证及与本节无关代码如下：

   

  1. struct file_desc *fdp;
  2. struct file *file;

  4. fdp = &coffee_fd_set[fd];
  5. file = fdp->file;

  7. if(fdp->offset > file->end)
  8. {
  9.   file->end = fdp->offset;
  10. }
  11. return size;


更多Contiki学习笔记可通过博文《Contiki学习笔记：目录》索引访问。


本文图片1~2源文件如下：

 COFFEE_WRITE与stm32_flash_write映射关系.rar   

 创建微日志示意图.rar   


参考资料：

[1] Tsiftes Nicolas,Dunkels Adam,He Zhitao.Enabling large-scale storage in sensor networks with the coffee file system[J].International Conference on Information Processing in Sensor Networks.2009,349-360

[2]

[3] Contiki源代码

阅读(2717) | 评论(0) | 转发(1) |
0

上一篇：Contiki学习笔记：Coffee文件系统删除文件cfs_remove

下一篇：Contiki学习笔记：Coffee文件系统flags标志位

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

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

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

16024965号-6