搜索
bottom↓
回复: 135

FatFs源码剖析

  [复制链接]
(227681267)

出0入0汤圆

发表于 2014-2-19 17:48:16 | 显示全部楼层 |阅读模式
本帖最后由 hexiaolong2009 于 2014-2-19 17:48 编辑

一、介绍:

本文以网上开源文件系统FatFs 0.01为研究对象,剖析FatFs文件系统的核心操作。FatFs目前最新版本已更新到0.10a版本,而我之所以选择0.01版本,是因为这是最早的发布版本,与最新的版本相比,去掉了很多高级应用,且代码量相对较小,宏开关也少了许多,易于阅读和理解,用来研究它的雏形再合适不过了,所以笔者选择0.01版本进行剖析。当大家了解了0.01的核心思想后,再回去看最新的版本,也就容易理解多了。

FatFs历史版本下载:http://elm-chan.org/fsw/ff/00index_e.html    在官网的最下面,能找到所有版本的下载链接。



二、重点:

1. FatFs中有两个重要的缓冲区:win[]和buffer。win[]在FATFS结构体中,buffer在FIL结构体中。

    win[]:系统缓冲区。当操作MBR,DBR,FAT表,根目录区时,使用该缓冲区;

    buffer:文件缓冲区。当对文件的内容进行操作时,如读、写、修改时,才使用该缓冲区。

   

2. 在对文件的f_read和f_write过程中(不考虑f_lseek的情况),只有需要读写的最后一个扇区(内容小于512字节)才会被暂存到buffer中,而前面的扇区内容是直接通过磁盘驱动disk_read/disk_write在用户缓冲区和物理磁盘之间进行交互的。



注意:FatFs 0.01与最新的版本还是不少差异的,如在0.01中,buffer只是个指针,需要用户自己定义文件缓冲区,并将buffer指向该缓冲区。而最新版本中,FIL已经有自己的buf[_MAX_SS]。在0.01中没有f_mount()函数,所以需要手动将全局指针FatFs指向自己定义的变量fs。具体的操作流程可参考官网上的示例代码。



三、关键函数总结:

1. f_open

f_open()

{

    1. 初始化SD卡,初始化FATFS对象;

    2. 查找文件的目录项;

    3. 填充文件结构体FIL。

}



2. f_read

f_read()

{

    1. 从物理磁盘直接读取所需扇区到用户缓冲区,这个过程中未使用buffer缓冲区;

    2. 如果最后一扇区要读取的字节数少于512,则先将最后一扇区读到buffer中,然后再从buffer拷贝需要的字节到用户缓冲区中。

}







3. f_write

f_write()

{

    1. 从用户缓冲区直接写入到物理磁盘,这个过程中未使用buffer缓冲区;

    2. 如果要写入的最后一扇区内容少于512字节,则先从物理磁盘读取最后一扇区的内容到buffer中,然后修改buffer中的相应内容,并设置回写标记,这样下次调用f_close/f_write时,就会将buffer回写到物理磁盘中。

}







4. f_close

关键是调用了f_sync函数。



5. f_sync

f_sync()

{

    1. 将buffer回写到物理磁盘中;

    2. 读取文件对应的目录项到win[]中,更新参数,并回写。

}









5. move_window

move_window专用于操作win[]系统缓冲区。



move_window(B);

调用前:

                     



执行中:





调用后:

                     





四、源码注释

本人在不破坏源码逻辑的前提下,对FatFs 0.01源代码进行了中文注释,个别函数重新修改了排版布局,以方便阅读。结合以上示意图即伪代码,相信大家会很快理解FatFs 0.01的核心思想及架构。
  1. #include <string.h>
  2. #include "ff.h"                        /* FatFs declarations */
  3. #include "diskio.h"                /* Include file for user provided functions */


  4. FATFS *FatFs;                        /* Pointer to the file system object */


  5. /*-------------------------------------------------------------------------
  6.   Module Private Functions
  7. -------------------------------------------------------------------------*/

  8. /*----------------------*/
  9. /* Change Window Offset */

  10. //读取新的扇区内容到临时缓冲区win[],
  11. //如果sector为0,则只需要把win[]的内容写入对应的物理扇区即可
  12. static
  13. BOOL move_window (
  14.         DWORD sector                /* Sector number to make apperance in the FatFs->win */
  15. )                                                /* Move to zero only writes back dirty window */
  16. {
  17.         DWORD wsect;                //wsect用于检索FAT备份表的相应扇区
  18.         FATFS *fs = FatFs;


  19.         wsect = FatFs->winsect;
  20.         /*首先检查目标扇区号是否与win[]对应的扇区号相同,如果相同则不进行任何操作。*/
  21.         if (wsect != sector) {        /* Changed current window */
  22. #ifndef _FS_READONLY
  23.                 BYTE n;

  24.                 //首先检测win[]的内容是否做过修改,如果修改过,则需要先将其写入SD卡中。
  25.                 if (FatFs->dirtyflag) {        /* Write back dirty window if needed */
  26.                         if (disk_write(FatFs->win, wsect, 1) != RES_OK) return FALSE;

  27.                         //清除修改标记
  28.                         FatFs->dirtyflag = 0;
  29.                        
  30.                         /*如果当前操作的是FAT表,那么需要将修改后的FAT表拷贝到对应的FAT备份中*/
  31.                         if (wsect < (FatFs->fatbase + FatFs->sects_fat)) {        /* In FAT area */
  32.                                 for (n = FatFs->n_fats; n >= 2; n--) {        /* Refrect the change to all FAT copies */
  33.                                         wsect += FatFs->sects_fat;
  34.                                         if (disk_write(FatFs->win, wsect, 1) != RES_OK) break;
  35.                                 }
  36.                         }
  37.                 }
  38. #endif

  39.                 //然后再读取新的扇区内容到win[]中
  40.                 if (sector) {
  41.                         if (disk_read(FatFs->win, sector, 1) != RES_OK) return FALSE;
  42.                         FatFs->winsect = sector;        //更新当前缓冲区的扇区号
  43.                 }
  44.         }
  45.         return TRUE;
  46. }







  47. /*--------------------------------------------------------------------------*/
  48. /* Public Funciotns                                                         */
  49. /*--------------------------------------------------------------------------*/


  50. /*----------------------------------------------------------*/
  51. /* Load File System Information and Initialize FatFs Module */
  52. //本函数做三件事:
  53. // 1.初始化SD卡
  54. // 2.检查文件系统类型,FAT16还是FAT32
  55. // 3.填充FatFs对象,即记录物理磁盘的相关参数
  56. FRESULT f_mountdrv ()
  57. {
  58.         BYTE fat;
  59.         DWORD sect, fatend;
  60.         FATFS *fs = FatFs;


  61.         if (!fs) return FR_NOT_ENABLED;

  62.         //首先对文件系统对象清空
  63.         /* Initialize file system object */
  64.         memset(fs, 0, sizeof(FATFS));

  65.         //然后初始化SD卡
  66.         /* Initialize disk drive */
  67.         if (disk_initialize() & STA_NOINIT)        return FR_NOT_READY;

  68.         //接着收搜索DBR系统引导记录,先检查第0扇区是否就是DBR(无MBR的SD卡),如果是则检查文件系统的类型;
  69.         //如果不是则说明第0扇区是MBR,则根据MBR中的信息定位到DBR所在扇区,并检查该文件系统的类型
  70.         /* Search FAT partition */
  71.         fat = check_fs(sect = 0);                /* Check sector 0 as an SFD format */
  72.         if (!fat) {                                                /* Not a FAT boot record, it will be an FDISK format */
  73.                 /* Check a pri-partition listed in top of the partition table */
  74.                 if (fs->win[0x1C2]) {                                        /* Is the partition existing? */
  75.                         sect = LD_DWORD(&(fs->win[0x1C6]));        /* Partition offset in LBA */
  76.                         fat = check_fs(sect);                                /* Check the partition */
  77.                 }
  78.         }
  79.         if (!fat) return FR_NO_FILESYSTEM;        /* No FAT patition */

  80.         //初始化文件系统对象,根据DBR参数信息对Fs成员赋值
  81.         /* Initialize file system object */

  82.         //文件系统类型:FAT16/FAT32
  83.         fs->fs_type = fat;                                                                /* FAT type */

  84.         //单个FAT表所占的扇区数
  85.         fs->sects_fat =                                                                 /* Sectors per FAT */
  86.                 (fat == FS_FAT32) ? LD_DWORD(&(fs->win[0x24])) : LD_WORD(&(fs->win[0x16]));

  87.         //单个簇所占的扇区数
  88.         fs->sects_clust = fs->win[0x0D];                                /* Sectors per cluster */

  89.         //FAT表总数
  90.         fs->n_fats = fs->win[0x10];                                                /* Number of FAT copies */

  91.         //FAT表起始扇区(物理扇区)
  92.         fs->fatbase = sect + LD_WORD(&(fs->win[0x0E]));        /* FAT start sector (physical) */

  93.         //根目录项数
  94.         fs->n_rootdir = LD_WORD(&(fs->win[0x11]));                /* Nmuber of root directory entries */

  95.         //计算根目录起始扇区、数据起始扇区(物理扇区地址)
  96.         fatend = fs->sects_fat * fs->n_fats + fs->fatbase;
  97.         if (fat == FS_FAT32) {
  98.                 fs->dirbase = LD_DWORD(&(fs->win[0x2C]));        /* Directory start cluster */
  99.                 fs->database = fatend;                                                 /* Data start sector (physical) */
  100.         } else {
  101.                 fs->dirbase = fatend;                                                /* Directory start sector (physical) */
  102.                 fs->database = fs->n_rootdir / 16 + fatend;        /* Data start sector (physical) */
  103.         }

  104.         //最大簇号
  105.         fs->max_clust =                                                                 /* Maximum cluster number */
  106.                 (LD_DWORD(&(fs->win[0x20])) - fs->database + sect) / fs->sects_clust + 2;

  107.         return FR_OK;
  108. }





  109. /*-----------------------*/
  110. /* Open or Create a File */

  111. FRESULT f_open (
  112.         FIL *fp,                        /* Pointer to the buffer of new file object to create */
  113.         const char *path,        /* Pointer to the file path */
  114.         BYTE mode                        /* Access mode and file open mode flags */
  115. )
  116. {
  117.         FRESULT res;
  118.         BYTE *dir;
  119.         DIR dirscan;
  120.         char fn[8+3+1];                        //8.3 DOS文件名
  121.         FATFS *fs = FatFs;

  122.         /*首先初始化SD卡,检测文件系统类型,初始化FATFS对象*/
  123.         if ((res = check_mounted()) != FR_OK) return res;
  124.        
  125. #ifndef _FS_READONLY

  126.         //如果磁盘设置为写保护,则返回错误码:FR_WRITE_PROTECTED
  127.         if ((mode & (FA_WRITE|FA_CREATE_ALWAYS)) && (disk_status() & STA_PROTECT))
  128.                 return FR_WRITE_PROTECTED;
  129. #endif

  130.         //根据用户提供的文件路径path,将文件名对应的目录项及其整个扇区读取到win[]中,
  131.         //并填充目录项dirscan、标准格式的文件名fn,以及目录项在win[]中的字节偏移量dir
  132.         res = trace_path(&dirscan, fn, path, &dir);        /* Trace the file path */

  133. #ifndef _FS_READONLY
  134.         /* Create or Open a File */
  135.         if (mode & (FA_CREATE_ALWAYS|FA_OPEN_ALWAYS)) {
  136.                 DWORD dw;

  137.         //如果文件不存在,则强制新建文件
  138.                 if (res != FR_OK) {                /* No file, create new */
  139.                         mode |= FA_CREATE_ALWAYS;
  140.                         if (res != FR_NO_FILE) return res;
  141.                         dir = reserve_direntry(&dirscan);        /* Reserve a directory entry */
  142.                         if (dir == NULL) return FR_DENIED;
  143.                         memcpy(dir, fn, 8+3);                /* Initialize the new entry */
  144.                         *(dir+12) = fn[11];
  145.                         memset(dir+13, 0, 32-13);
  146.                 }
  147.         else {                                /* File already exists */
  148.                         if ((dir == NULL) || (*(dir+11) & (AM_RDO|AM_DIR)))        /* Could not overwrite (R/O or DIR) */
  149.                                 return FR_DENIED;
  150.             
  151.             //如果文件存在,但又以FA_CREATE_ALWAYS方式打开文件,则重写文件
  152.                         if (mode & FA_CREATE_ALWAYS) {        /* Resize it to zero */
  153.                                 dw = fs->winsect;                        /* Remove the cluster chain */
  154.                                 if (!remove_chain(((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26))
  155.                                         || !move_window(dw) )
  156.                                         return FR_RW_ERROR;
  157.                                 ST_WORD(dir+20, 0); ST_WORD(dir+26, 0);        /* cluster = 0 */
  158.                                 ST_DWORD(dir+28, 0);                                        /* size = 0 */
  159.                         }
  160.                 }

  161.                 //如果是强制新建文件操作,则还需更新时间和日期
  162.                 if (mode & FA_CREATE_ALWAYS) {
  163.                         *(dir+11) = AM_ARC;
  164.                         dw = get_fattime();
  165.                         ST_DWORD(dir+14, dw);        /* Created time */
  166.                         ST_DWORD(dir+22, dw);        /* Updated time */
  167.                         fs->dirtyflag = 1;
  168.                 }
  169.         }
  170.         /* Open a File */
  171.         else {
  172. #endif
  173.                 if (res != FR_OK) return res;                /* Trace failed */

  174.                 //如果打开的是一个目录文件,则返回错误码:FR_NO_FILE
  175.                 if ((dir == NULL) || (*(dir+11) & AM_DIR))        /* It is a directory */
  176.                         return FR_NO_FILE;
  177.                
  178. #ifndef _FS_READONLY

  179.                 //如果以FA_WRITE方式打开Read-Only属性的文件,则返回错误码:FR_DENIED
  180.                 if ((mode & FA_WRITE) && (*(dir+11) & AM_RDO)) /* R/O violation */
  181.                         return FR_DENIED;
  182.         }
  183. #endif

  184.         //填充FIL文件结构体参数
  185. #ifdef _FS_READONLY
  186.         fp->flag = mode & (FA_UNBUFFERED|FA_READ);
  187. #else
  188.         fp->flag = mode & (FA_UNBUFFERED|FA_WRITE|FA_READ);
  189.         fp->dir_sect = fs->winsect;                                /* Pointer to the directory entry */
  190.         fp->dir_ptr = dir;
  191. #endif
  192.         fp->org_clust =        ((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26);        /* File start cluster */
  193.         fp->fsize = LD_DWORD(dir+28);                /* File size */
  194.         fp->fptr = 0;                                                /* File ptr */

  195.     //这一步很重要,它将直接导致f_read和f_write操作中的逻辑顺序
  196.         fp->sect_clust = 1;                                        /* Sector counter */
  197.    
  198.         fs->files++;
  199.         return FR_OK;
  200. }



  201. /*-----------*/
  202. /* Read File */
  203. //文件读操作
  204. FRESULT f_read (
  205.         FIL *fp,                 /* Pointer to the file object */
  206.         BYTE *buff,                /* Pointer to data buffer */
  207.         WORD btr,                /* Number of bytes to read */
  208.         WORD *br                /* Pointer to number of bytes read */
  209. )
  210. {
  211.         DWORD clust, sect, ln;
  212.         WORD rcnt;                /*已经读取的字节数*/
  213.         BYTE cc;                /*实际单次要读取的连续最大扇区数*/
  214.         FATFS *fs = FatFs;


  215.         *br = 0;
  216.    
  217.     //错误处理
  218.         if (!fs) return FR_NOT_ENABLED;
  219.         if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_NOT_READY;        /* Check disk ready */
  220.         if (fp->flag & FA__ERROR) return FR_RW_ERROR;        /* Check error flag */
  221.         if (!(fp->flag & FA_READ)) return FR_DENIED;        /* Check access mode */
  222.        
  223.         //检查要读取的字节数是否超出了剩余的文件长度,如果超出了,则只读取剩余字节长度
  224.         ln = fp->fsize - fp->fptr;
  225.         if (btr > ln) btr = ln;                                                        /* Truncate read count by number of bytes left */

  226.     //该循环以簇为单位,每循环一次就读完一个簇的内容
  227.         /* Repeat until all data transferred */
  228.         for ( ;  btr; buff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt)
  229.         {
  230.                        
  231.         //当文件指针与扇区边界对齐时(如:刚打开文件时),执行以下操作;
  232.         //否则(如:调用了f_lseek函数)只将当前buffer中需要的内容直接copy到目标缓冲区,然后进入下一次循环。
  233.                 if ((fp->fptr & 511) == 0)                                         /* On the sector boundary */
  234.                 {                               
  235.             //如果还没有读完当前簇的所有扇区,则将下一个扇区号赋给变量sect。
  236.                         //注意,当第一次读取文件时,由于f_open函数中,已经将sect_clust赋值为1,
  237.                         //所以应该执行else语句
  238.                         if (--(fp->sect_clust))                                 /* Decrement sector counter */
  239.                         {       
  240.                 //一般走到这里就意味着只剩下最后一个扇区需要读取,且要读取的内容小于512字节
  241.                                 sect = fp->curr_sect + 1;                        /* Next sector */
  242.                         }
  243.                         //如果已经读完当前簇的所有扇区,则计算下一个簇的起始位置,
  244.                         //并更新FIL中的当前簇号curr_clust和当前簇剩余扇区数sect_clust
  245.                         else                                                                         /* Next cluster */
  246.                         {       
  247.                 //如果当前文件指针在起始簇内,则将clust设置为起始簇号;
  248.                 //否则,将clust设置为下一簇号
  249.                                 clust = (fp->fptr == 0) ? fp->org_clust : get_cluster(fp->curr_clust);
  250.                                 if ((clust < 2) || (clust >= fs->max_clust)) goto fr_error;
  251.                
  252.                                 fp->curr_clust = clust;                                /* Current cluster */
  253.                                 sect = clust2sect(clust);                        /* Current sector */
  254.                                 fp->sect_clust = fs->sects_clust;        /* Re-initialize the sector counter */
  255.                         }
  256.                        
  257. #ifndef _FS_READONLY

  258.                         //如果buffer中的内容被修改过,则需要先将buffer中的内容回写到物理磁盘中
  259.                         if (fp->flag & FA__DIRTY)                                 /* Flush file I/O buffer if needed */
  260.                         {                               
  261.                                 if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) goto fr_error;
  262.                                 fp->flag &= ~FA__DIRTY;
  263.                         }
  264. #endif

  265.                         //更新当前扇区号
  266.                         fp->curr_sect = sect;                                        /* Update current sector */

  267.                         //计算需要读取部分的剩余扇区数cc(最后一个扇区内容若不满512字节则不计入cc中)
  268.                         cc = btr / 512;                                                       

  269.                         //只要当前扇区不是最后一个扇区,则执行连续的读操作,然后直接进入下一次循环
  270.                         /* When left bytes >= 512 */
  271.             /* Read maximum contiguous sectors */
  272.                         if (cc)                                                                
  273.                         {       
  274.                 //如果cc小于当前簇的剩余扇区数sect_clust,则连续读取cc个扇区;
  275.                 //如果cc大于当前簇的剩余扇区数sect_clust,则只读取当前簇的剩余扇区
  276.                                 if (cc > fp->sect_clust) cc = fp->sect_clust;   

  277.                                 //执行实际的磁盘读操作,读取当前簇的剩余扇区内容到目标缓冲区中
  278.                                 //注意,是直接读到目标接收缓冲区的,而不是到buffer中
  279.                                 if (disk_read(buff, sect, cc) != RES_OK) goto fr_error;

  280.                                 //更新当前簇的剩余扇区数
  281.                                 //该语句实际为:sect_clust = sect_clust - (cc - 1) = sect_clust - cc + 1;
  282.                                 //之所以+1是因为当cc == sect_clust时,sect_clust = sect_clust - sect_clust + 1 = 1;
  283.                                 //所以当下一次循环执行到 if (--(fp->sect_clust)) 时直接进入else语句。
  284.                                 fp->sect_clust -= cc - 1;
  285.                                
  286.                                 //更新当前扇区号,扇区号是基于0索引的,所以这里要-1
  287.                                 fp->curr_sect += cc - 1;

  288.                                 //更新已读的字节数
  289.                                 rcnt = cc * 512;

  290.                 //直接进入下一次循环
  291.                 continue;
  292.                         }

  293.                         if (fp->flag & FA_UNBUFFERED)                        /* Reject unaligned access when unbuffered mode */
  294.                                 return FR_ALIGN_ERROR;

  295.                         //对于文件的最后一个扇区,则先将内容读取到buffer中,然后将需要的内容拷贝到目标缓冲区中,并退出循环
  296.                         if (disk_read(fp->buffer, sect, 1) != RES_OK)        /* Load the sector into file I/O buffer */
  297.                                 goto fr_error;
  298.             
  299.                 }//end if ((fp->fptr & 511) == 0)

  300.                 //计算从buffer中实际要读取的字节数rcnt
  301.                 rcnt = 512 - (fp->fptr & 511);                               
  302.                 if (rcnt > btr) rcnt = btr;

  303.                 //最后将buffer中的指定数据拷贝到目标缓冲区中
  304.                 memcpy(buff, &fp->buffer[fp->fptr & 511], rcnt);    /* Copy fractional bytes from file I/O buffer */

  305.         //一般走到这里就说明已经读完了最后一扇区,下一步将退出循环;
  306.         //如果还没有读完最后一扇,则有可能是在调用f_lseek后第一次调用f_read,那么将进入下一次循环
  307.         }//end for(...)

  308.         return FR_OK;

  309. fr_error:        /* Abort this file due to an unrecoverable error */
  310.         fp->flag |= FA__ERROR;
  311.         return FR_RW_ERROR;
  312. }


  313. FRESULT f_write (
  314.         FIL *fp,                        /* Pointer to the file object */
  315.         const BYTE *buff,        /* Pointer to the data to be written */
  316.         WORD btw,                        /* Number of bytes to write */
  317.         WORD *bw                        /* Pointer to number of bytes written */
  318. )
  319. {
  320.         DWORD clust, sect;
  321.         WORD wcnt;          /*已经写入的字节数*/
  322.         BYTE cc;            /*实际单次要写入的连续最大扇区数*/
  323.         FATFS *fs = FatFs;


  324.         *bw = 0;

  325.     //错误处理
  326.         if (!fs) return FR_NOT_ENABLED;
  327.         if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_NOT_READY;
  328.         if (fp->flag & FA__ERROR) return FR_RW_ERROR;        /* Check error flag */
  329.         if (!(fp->flag & FA_WRITE)) return FR_DENIED;        /* Check access mode */
  330.    
  331.     //保证写入后整个文件大小不得超过4GB
  332.         if (fp->fsize + btw < fp->fsize) btw = 0;                /* File size cannot reach 4GB */

  333.     //该循环以簇为单位,每循环一次就写完一个簇的内容
  334.     /* Repeat until all data transferred */
  335.         for ( ;  btw; buff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt)
  336.         {
  337.         //当文件指针与扇区边界对齐时(如:刚打开文件时),执行以下操作;
  338.         //否则(如:调用了f_lseek函数)只将当前扇区所需要的内容copy到buffer中,然后进入下一次循环。
  339.                 if ((fp->fptr & 511) == 0)                  /* On the sector boundary */
  340.         {               
  341.             //如果还没有写完当前簇的所有扇区,则将下一个扇区号赋给变量sect。
  342.                         //注意,当第一次写文件时,由于f_open函数中,已经将sect_clust赋值为1,
  343.                         //所以应该执行else语句
  344.                         if (--(fp->sect_clust))                 /* Decrement sector counter */
  345.             {               
  346.                 //一般走到这里就意味着只剩下最后一个扇区需要写入,且要写入的内容小于512字节
  347.                                 sect = fp->curr_sect + 1;                        /* Next sector */
  348.                         }
  349.             //如果已经写完当前簇的所有扇区,则计算下一个簇的起始位置,
  350.             //并更新FIL中的当前簇号curr_clust和当前簇剩余扇区数sect_clust
  351.             else                                    /* Next cluster */
  352.             {   
  353.                 //如果当前文件指针在起始簇内,则将当前簇设置为起始簇;
  354.                                 if (fp->fptr == 0)                  /* Top of the file */
  355.                 {               
  356.                                         clust = fp->org_clust;
  357.                     
  358.                     //如果文件不存在,则先创建一个新的簇,并将该簇号设置为当前簇号
  359.                                         if (clust == 0)                                        /* No cluster is created */
  360.                                                 fp->org_clust = clust = create_chain(0);        /* Create a new cluster chain */
  361.                                 }
  362.                 //如果当前文件指针不在起始簇内,则将下一簇号设置为当前簇号
  363.                 else                                /* Middle or end of file */
  364.                 {                           
  365.                                         clust = create_chain(fp->curr_clust);                        /* Trace or streach cluster chain */
  366.                                 }
  367.                                 if ((clust < 2) || (clust >= fs->max_clust)) break;
  368.                
  369.                                 fp->curr_clust = clust;                                /* Current cluster */
  370.                                 sect = clust2sect(clust);                        /* Current sector */
  371.                                 fp->sect_clust = fs->sects_clust;        /* Re-initialize the sector counter */
  372.                         }
  373.             
  374.                         //如果buffer中的内容被修改过,则需要先将buffer中的内容回写到物理磁盘中
  375.                         if (fp->flag & FA__DIRTY)               /* Flush file I/O buffer if needed */
  376.             {               
  377.                                 if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) goto fw_error;
  378.                                 fp->flag &= ~FA__DIRTY;
  379.                         }
  380.             
  381.                         //更新当前扇区号
  382.                         fp->curr_sect = sect;                                        /* Update current sector */

  383.                         //计算需要写入部分的剩余扇区数cc(最后一个扇区内容若不满512字节则不计入cc中)
  384.             cc = btw / 512;                                                       

  385.                         //只要当前扇区不是最后一个扇区,则执行连续的写操作,然后直接进入下一次循环
  386.                         /* When left bytes >= 512 */
  387.             /* Write maximum contiguous sectors */
  388.                         if (cc)                                 
  389.             {                              
  390.                 //如果cc小于当前簇的剩余扇区数sect_clust,则连续写入cc个扇区;
  391.                 //如果cc大于当前簇的剩余扇区数sect_clust,则只将当前簇的剩余扇区写入物理磁盘中
  392.                                 if (cc > fp->sect_clust) cc = fp->sect_clust;
  393.                
  394.                                 //执行实际的磁盘写操作,将源缓冲区中的内容写入到当前簇的剩余扇区中
  395.                                 //注意,是直接从源缓冲区写到物理磁盘中的,没有经过buffer
  396.                                 if (disk_write(buff, sect, cc) != RES_OK) goto fw_error;
  397.                
  398.                                 //更新当前簇的剩余扇区数
  399.                                 //该语句实际为:sect_clust = sect_clust - (cc - 1) = sect_clust - cc + 1;
  400.                                 //之所以+1是因为当cc == sect_clust时,sect_clust = sect_clust - sect_clust + 1 = 1;
  401.                                 //所以当下一次循环执行到 if (--(fp->sect_clust)) 时直接进入else语句。
  402.                                 fp->sect_clust -= cc - 1;
  403.                
  404.                                 //更新当前扇区号,扇区号是基于0索引的,所以这里要-1
  405.                                 fp->curr_sect += cc - 1;
  406.                
  407.                                 //更新已写的字节数
  408.                                 wcnt = cc * 512;

  409.                 //直接进入下一次循环
  410.                 continue;
  411.                         }
  412.             
  413.                         if (fp->flag & FA_UNBUFFERED)                        /* Reject unalighend access when unbuffered mode */
  414.                                 return FR_ALIGN_ERROR;
  415.             
  416.             //如果已经写到最后一个扇区了,则先将SD卡中所对应扇区的原始内容读取到buffer中,然后修改buffer中的内容,再从buffer回写到物理磁盘中
  417.                         if ((fp->fptr < fp->fsize) && (disk_read(fp->buffer, sect, 1) != RES_OK)) /* Fill sector buffer with file data if needed */
  418.                                         goto fw_error;
  419.             
  420.                 }//end if ((fp->fptr & 511) == 0)
  421.         
  422.                 //计算实际要写入的字节数wcnt
  423.                 wcnt = 512 - (fp->fptr & 511);                                /* Copy fractional bytes to file I/O buffer */
  424.                 if (wcnt > btw) wcnt = btw;
  425.         
  426.                 //将源缓冲区中的数据拷贝到buffer中的指定位置
  427.                 memcpy(&fp->buffer[fp->fptr & 511], buff, wcnt);

  428.         //设置buffer回写标记,当调用f_close或执行下一次循环操作时,执行buffer回写操作
  429.                 fp->flag |= FA__DIRTY;
  430.         
  431.         //一般走到这里就说明已经写完了最后一扇区,下一步将退出循环;
  432.         //如果还没有写完最后一扇,则有可能是在调用f_lseek后第一次调用f_write,那么将进入下一次循环
  433.         }//end for(; btw; buff += wcnt,...)

  434.     //如果对原始文件增加了新的内容,则需要更新文件的大小,并设置文件大小更新标记FA__WRITTEN
  435.         if (fp->fptr > fp->fsize) fp->fsize = fp->fptr;        /* Update file size if needed */
  436.         fp->flag |= FA__WRITTEN;                                                /* Set file changed flag */
  437.    
  438.         return FR_OK;

  439. fw_error:        /* Abort this file due to an unrecoverable error */
  440.         fp->flag |= FA__ERROR;
  441.         return FR_RW_ERROR;
  442. }


  443. FRESULT f_sync (
  444.         FIL *fp                /* Pointer to the file object */
  445. )
  446. {
  447.         BYTE *ptr;
  448.         FATFS *fs = FatFs;


  449.         if (!fs) return FR_NOT_ENABLED;
  450.         if ((disk_status() & STA_NOINIT) || !fs->fs_type)
  451.                 return FR_INCORRECT_DISK_CHANGE;

  452.         //检查文件是否增加了新的内容,如果是则需要修改目录项
  453.         /* Has the file been written? */
  454.         if (fp->flag & FA__WRITTEN) {

  455.         //如果buffer的内容被修改了,则需要先将buffer的内容回写到物理磁盘中去
  456.                 /* Write back data buffer if needed */
  457.                 if (fp->flag & FA__DIRTY) {
  458.                         if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) return FR_RW_ERROR;
  459.                         fp->flag &= ~FA__DIRTY;
  460.                 }

  461.         /*************由于更改了文件长度,所以需要修改文件对应的目录项************/

  462.                 //首先读取文件对应的根目录扇区到win[]
  463.                 /* Update the directory entry */
  464.                 if (!move_window(fp->dir_sect)) return FR_RW_ERROR;

  465.                 //然后修改根目录项
  466.                 ptr = fp->dir_ptr;
  467.                 *(ptr+11) |= AM_ARC;                                        /* Set archive bit */
  468.                 ST_DWORD(ptr+28, fp->fsize);                        /* Update file size */
  469.                 ST_WORD(ptr+26, fp->org_clust);                        /* Update start cluster */
  470.                 ST_WORD(ptr+20, fp->org_clust >> 16);
  471.                 ST_DWORD(ptr+22, get_fattime());                /* Updated time */

  472.                 //设置win[]回写标志
  473.                 fs->dirtyflag = 1;

  474.                 //清除文件大小更改标记
  475.                 fp->flag &= ~FA__WRITTEN;
  476.         }

  477.         //将win[]中的根目录信息回写到对应的物理扇区
  478.         if (!move_window(0)) return FR_RW_ERROR;

  479.         return FR_OK;
  480. }
复制代码


源码下载:
pdf文档:

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
(227679596)

出0入4汤圆

发表于 2014-2-19 18:16:07 | 显示全部楼层
顶好      
(227679258)

出0入0汤圆

发表于 2014-2-19 18:21:45 | 显示全部楼层
板凳~~~~
(227678520)

出0入0汤圆

发表于 2014-2-19 18:34:03 | 显示全部楼层
地板
(227678448)

出0入0汤圆

发表于 2014-2-19 18:35:15 | 显示全部楼层
不错,收藏了。楼主的帖子都很好啊。
(227677633)

出0入0汤圆

发表于 2014-2-19 18:48:50 | 显示全部楼层
FAT 文件系统 mark
(227675429)

出0入0汤圆

发表于 2014-2-19 19:25:34 | 显示全部楼层
mark一下,太好了,好人啊
(227674978)

出0入0汤圆

发表于 2014-2-19 19:33:05 | 显示全部楼层
楼主的 帖子都写的非常好。清晰透彻···学习了··
(227674408)

出0入0汤圆

发表于 2014-2-19 19:42:35 | 显示全部楼层
顶。楼主辛苦。

  
(227674077)

出0入0汤圆

发表于 2014-2-19 19:48:06 | 显示全部楼层
FAT 文件系统 mark 收藏了
(227058658)

出0入0汤圆

发表于 2014-2-26 22:45:05 | 显示全部楼层
直观,详细,谢谢分享啊
(227055795)

出0入0汤圆

发表于 2014-2-26 23:32:48 | 显示全部楼层
收藏了 写的非常详细 谢谢楼主的好文
(227055591)

出0入0汤圆

发表于 2014-2-26 23:36:12 | 显示全部楼层
mark备用               
(226891815)

出0入0汤圆

发表于 2014-2-28 21:05:48 | 显示全部楼层

顶。楼主辛苦。
(226888807)

出0入0汤圆

发表于 2014-2-28 21:55:56 | 显示全部楼层
楼主辛苦
(226886796)

出0入0汤圆

发表于 2014-2-28 22:29:27 | 显示全部楼层
多谢分享。确实后面的工程太大,不宜于入门
(226885853)

出0入0汤圆

发表于 2014-2-28 22:45:10 | 显示全部楼层
深顶v               
(226884609)

出0入0汤圆

发表于 2014-2-28 23:05:54 | 显示全部楼层
刚好最近要了解文件系统,顶!
(226883519)

出0入0汤圆

发表于 2014-2-28 23:24:04 | 显示全部楼层
好东西,谢谢楼主分享!
(226882282)

出0入0汤圆

发表于 2014-2-28 23:44:41 | 显示全部楼层
好帖,楼主分析的流程很对。
(226882216)

出0入0汤圆

发表于 2014-2-28 23:45:47 | 显示全部楼层
分析的真好,图文并茂,谢谢LZ
(226852554)

出0入0汤圆

发表于 2014-3-1 08:00:09 来自手机 | 显示全部楼层
马克一下
(226850861)

出0入0汤圆

发表于 2014-3-1 08:28:22 | 显示全部楼层
楼主的fatfs是我看过的最好的教程
(226849707)

出0入0汤圆

发表于 2014-3-1 08:47:36 | 显示全部楼层
马克一下..........
(226846675)

出0入0汤圆

发表于 2014-3-1 09:38:08 | 显示全部楼层
将来要学习的内容,MARK一下
(226844251)

出0入0汤圆

发表于 2014-3-1 10:18:32 | 显示全部楼层
有心了  这个真的用个心  哈哈
(226834428)

出0入0汤圆

发表于 2014-3-1 13:02:15 | 显示全部楼层
这个真是用心了。
(226820190)

出0入0汤圆

发表于 2014-3-1 16:59:33 | 显示全部楼层
向楼主学习!!
(226812573)

出0入0汤圆

发表于 2014-3-1 19:06:30 | 显示全部楼层
FAT文件系统,收藏备用,顶顶!
(226626942)

出0入0汤圆

发表于 2014-3-3 22:40:21 | 显示全部楼层
Mark Fatfs 开源0.10源码剖析
(226618596)

出0入0汤圆

发表于 2014-3-4 00:59:27 | 显示全部楼层
文章很有概括性,流程图画的真漂亮,请问楼主使用什么软件画的?
(226587066)

出0入0汤圆

发表于 2014-3-4 09:44:57 | 显示全部楼层

FAT 文件系统 mark 收藏了
(226586800)

出0入10汤圆

发表于 2014-3-4 09:49:23 | 显示全部楼层
谢谢分享,mark
(226585234)

出0入0汤圆

发表于 2014-3-4 10:15:29 | 显示全部楼层
牛,需要看看
(226584241)

出0入0汤圆

发表于 2014-3-4 10:32:02 | 显示全部楼层
楼主你好。我想每当一个记事本存了1000个数据之后,如何做到再新建一个记事本再存储数据呢?
(226583456)

出0入0汤圆

发表于 2014-3-4 10:45:07 | 显示全部楼层
谢谢分享!
(226582229)

出0入0汤圆

发表于 2014-3-4 11:05:34 | 显示全部楼层
fatfs详解
(226564817)

出0入0汤圆

 楼主| 发表于 2014-3-4 15:55:46 | 显示全部楼层
gardensu 发表于 2014-3-4 00:59
文章很有概括性,流程图画的真漂亮,请问楼主使用什么软件画的?

使用VISIO2003画的
(226564694)

出0入0汤圆

 楼主| 发表于 2014-3-4 15:57:49 | 显示全部楼层
xiaohu1993 发表于 2014-3-4 10:32
楼主你好。我想每当一个记事本存了1000个数据之后,如何做到再新建一个记事本再存储数据呢? ...

每当一个记事本写满了1000个字节时,就调用一次f_close,然后用f_open新建一个文本文件,接着重复之前的步骤。
(226563830)

出0入0汤圆

发表于 2014-3-4 16:12:13 | 显示全部楼层
好顶赞!收藏级!^_^
(226419154)

出0入0汤圆

发表于 2014-3-6 08:23:29 | 显示全部楼层
楼主,我现在有一个问题。也是用fatfs移植到stm32中,第一天没什么问题。到第二天发现stm32第一次跑程序时,只能新建记事本,不能在记事本中存储数据,也就是sd卡初始化失败了。到第二次再跑程序才能进入while(1),在记事本中存储数据。这事为什么呢?
(226418474)

出0入0汤圆

发表于 2014-3-6 08:34:49 | 显示全部楼层
太完美了,学习一下
(226415401)

出0入0汤圆

发表于 2014-3-6 09:26:02 | 显示全部楼层
谢谢分享了
(226414267)

出0入0汤圆

发表于 2014-3-6 09:44:56 | 显示全部楼层
这个超详细,谢谢了
(226404954)

出0入0汤圆

发表于 2014-3-6 12:20:09 | 显示全部楼层
mark一下, 谢谢楼主了
(226404236)

出0入0汤圆

发表于 2014-3-6 12:32:07 | 显示全部楼层
直观,详细,谢谢分享啊
(226403135)

出0入0汤圆

发表于 2014-3-6 12:50:28 | 显示全部楼层
fatfs剖析,标记!顶
(226392245)

出0入0汤圆

发表于 2014-3-6 15:51:58 | 显示全部楼层
LZ辛苦了!!
(226390347)

出0入0汤圆

发表于 2014-3-6 16:23:36 | 显示全部楼层
图文解析,very good. 3Q!
(226388415)

出0入0汤圆

发表于 2014-3-6 16:55:48 | 显示全部楼层
(225962008)

出0入0汤圆

发表于 2014-3-11 15:22:35 | 显示全部楼层
好文,mark!
(225958669)

出0入0汤圆

发表于 2014-3-11 16:18:14 | 显示全部楼层
谢谢分享!最近在学习这个,先Mark。
(225955717)

出0入0汤圆

发表于 2014-3-11 17:07:26 | 显示全部楼层
学习了                  
(225953779)

出0入16汤圆

发表于 2014-3-11 17:39:44 | 显示全部楼层
好资料!
(225870301)

出0入0汤圆

发表于 2014-3-12 16:51:02 | 显示全部楼层
最近在学习这个,谢谢分享!
(225869979)

出0入0汤圆

发表于 2014-3-12 16:56:24 | 显示全部楼层
您好,您的画图软件用的什么啊
(225864375)

出0入0汤圆

发表于 2014-3-12 18:29:48 | 显示全部楼层
MARK,学习
(225787451)

出0入0汤圆

发表于 2014-3-13 15:51:52 | 显示全部楼层
楼主好人啊!
(219506430)

出0入0汤圆

发表于 2014-5-25 08:35:33 | 显示全部楼层
mark..
(216875337)

出0入0汤圆

发表于 2014-6-24 19:27:06 | 显示全部楼层
多谢楼主分享,赞一个!
(216818104)

出0入0汤圆

发表于 2014-6-25 11:20:59 | 显示全部楼层
谢谢楼主分享,太好了
(216800723)

出0入0汤圆

发表于 2014-6-25 16:10:40 | 显示全部楼层
是楼主原创的吗?
这个必须有空过来好好学习。
(216781522)

出0入0汤圆

发表于 2014-6-25 21:30:41 | 显示全部楼层
fat文件 mark
(216737670)

出0入0汤圆

发表于 2014-6-26 09:41:33 | 显示全部楼层
好長細的筆記
(216720839)

出0入0汤圆

发表于 2014-6-26 14:22:04 | 显示全部楼层
好文章,光看那几个图就知道是好文
(216719653)

出0入0汤圆

发表于 2014-6-26 14:41:50 | 显示全部楼层
留个名,看一下。
(216661052)

出0入0汤圆

发表于 2014-6-27 06:58:31 | 显示全部楼层
很好的帖子,别的不说,这图画得牛B
(216651590)

出0入0汤圆

 楼主| 发表于 2014-6-27 09:36:13 | 显示全部楼层
xi_liang 发表于 2014-6-27 06:58
很好的帖子,别的不说,这图画得牛B

过奖了,你们这些前辈才算真正的大牛!
你的开发板现在卖的咋样了?
(216649007)

出0入0汤圆

发表于 2014-6-27 10:19:16 | 显示全部楼层
thanks a lot
(215015143)

出0入0汤圆

发表于 2014-7-16 08:10:20 | 显示全部楼层
顶,楼主真不错!
(214727431)

出0入0汤圆

发表于 2014-7-19 16:05:32 | 显示全部楼层
必须顶起
(214715315)

出0入0汤圆

发表于 2014-7-19 19:27:28 | 显示全部楼层

mark一下,太好了,好人啊
(214569676)

出0入0汤圆

发表于 2014-7-21 11:54:47 | 显示全部楼层
顶起学习
(214567811)

出0入0汤圆

发表于 2014-7-21 12:25:52 | 显示全部楼层
正在找这个东西,收下。
楼主辛苦了。
(214566149)

出0入0汤圆

发表于 2014-7-21 12:53:34 | 显示全部楼层
LZ辛苦辛苦
(214490169)

出0入0汤圆

发表于 2014-7-22 09:59:54 | 显示全部楼层
正在学习fatfs 楼主辛苦了
(213784267)

出0入0汤圆

发表于 2014-7-30 14:04:56 | 显示全部楼层
这个资料真的是太好了!
(213783720)

出0入0汤圆

发表于 2014-7-30 14:14:03 | 显示全部楼层
好东西,赶紧收藏
(213781598)

出0入0汤圆

发表于 2014-7-30 14:49:25 | 显示全部楼层
mark一下下
(207359030)

出0入0汤圆

发表于 2014-10-12 22:52:13 | 显示全部楼层
xi_liang 发表于 2014-6-27 06:58
很好的帖子,别的不说,这图画得牛B

这位兄弟visio用的确实熟练啊,我试用了下很不顺手啊,可能是不熟悉的缘故
(207358770)

出0入0汤圆

发表于 2014-10-12 22:56:33 | 显示全部楼层
好资料要收藏!
(207322924)

出0入0汤圆

发表于 2014-10-13 08:53:59 | 显示全部楼层
mark,FatFs源码;
(207322752)

出0入0汤圆

发表于 2014-10-13 08:56:51 | 显示全部楼层
楼主花了大力气啊.............
(207322335)

出0入0汤圆

发表于 2014-10-13 09:03:48 | 显示全部楼层
楼主写的太详细了~好好学习一下~3Q3Q
(207322117)

出0入0汤圆

发表于 2014-10-13 09:07:26 | 显示全部楼层
非常好。
(206954037)

出0入0汤圆

发表于 2014-10-17 15:22:06 | 显示全部楼层
好详细啊,不错
(206947574)

出0入0汤圆

发表于 2014-10-17 17:09:49 来自手机 | 显示全部楼层
支持一下!!!!!
(206947371)

出0入0汤圆

发表于 2014-10-17 17:13:12 | 显示全部楼层
已加入收藏夹,谢谢分享
(206946941)

出0入0汤圆

发表于 2014-10-17 17:20:22 | 显示全部楼层
顶LZ,好好学习下
(206941144)

出0入0汤圆

发表于 2014-10-17 18:56:59 | 显示全部楼层
赞一个   
(206884009)

出0入0汤圆

发表于 2014-10-18 10:49:14 | 显示全部楼层
收藏了。
(206828435)

出0入0汤圆

发表于 2014-10-19 02:15:28 | 显示全部楼层
学习了!!
(206095503)

出0入0汤圆

发表于 2014-10-27 13:51:00 | 显示全部楼层
不错不错。。。
(206092875)

出0入0汤圆

发表于 2014-10-27 14:34:48 来自手机 | 显示全部楼层
不错,用过这个文件系统
(205847769)

出0入0汤圆

发表于 2014-10-30 10:39:54 | 显示全部楼层
标记,看高手写的代码各种规范,结构逻辑清晰,好好学习
(205225493)

出0入0汤圆

发表于 2014-11-6 15:31:10 | 显示全部楼层
MARK               
(204602577)

出0入0汤圆

发表于 2014-11-13 20:33:06 | 显示全部楼层
好文章,顶上去!
(204529735)

出0入0汤圆

发表于 2014-11-14 16:47:08 | 显示全部楼层
要做这方面的东西正好学习了
(204433481)

出0入0汤圆

发表于 2014-11-15 19:31:22 | 显示全部楼层
mark 谢谢分享
(204384313)

出0入0汤圆

发表于 2014-11-16 09:10:50 | 显示全部楼层
太谢谢楼主了!我也是喜欢在m3 mcu使用freertos,正需要使用fs!
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子论坛 ( 公安交互式论坛备案:44190002001997 粤ICP备09047143号 )

GMT+8, 2021-5-8 22:36

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表