FatFs源码剖析

来源：互联网发布：mac桌面图标怎么隐藏编辑：程序博客网时间：2024/04/30 05:00
一、介绍：
本文以网上开源文件系统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的核心思想及架构。
[cpp] view plain copy
 
#include <string.h>  
#include "ff.h"         /* FatFs declarations */  
#include "diskio.h"     /* Include file for user provided functions */  
  
  
FATFS *FatFs;           /* Pointer to the file system object */  
  
  
/*------------------------------------------------------------------------- 
  Module Private Functions 
-------------------------------------------------------------------------*/  
  
/*----------------------*/  
/* Change Window Offset */  
  
//读取新的扇区内容到临时缓冲区win[]，  
//如果sector为0，则只需要把win[]的内容写入对应的物理扇区即可  
static  
BOOL move_window (  
    DWORD sector        /* Sector number to make apperance in the FatFs->win */  
)                       /* Move to zero only writes back dirty window */  
{  
    DWORD wsect;        //wsect用于检索FAT备份表的相应扇区  
    FATFS *fs = FatFs;  
  
  
    wsect = FatFs->winsect;  
    /*首先检查目标扇区号是否与win[]对应的扇区号相同，如果相同则不进行任何操作。*/  
    if (wsect != sector) {  /* Changed current window */  
#ifndef _FS_READONLY  
        BYTE n;  
  
        //首先检测win[]的内容是否做过修改，如果修改过，则需要先将其写入SD卡中。  
        if (FatFs->dirtyflag) {  /* Write back dirty window if needed */  
            if (disk_write(FatFs->win, wsect, 1) != RES_OK) return FALSE;  
  
            //清除修改标记  
            FatFs->dirtyflag = 0;  
              
            /*如果当前操作的是FAT表，那么需要将修改后的FAT表拷贝到对应的FAT备份中*/  
            if (wsect < (FatFs->fatbase + FatFs->sects_fat)) { /* In FAT area */  
                for (n = FatFs->n_fats; n >= 2; n--) {    /* Refrect the change to all FAT copies */  
                    wsect += FatFs->sects_fat;  
                    if (disk_write(FatFs->win, wsect, 1) != RES_OK) break;  
                }  
            }  
        }  
#endif  
  
        //然后再读取新的扇区内容到win[]中  
        if (sector) {  
            if (disk_read(FatFs->win, sector, 1) != RES_OK) return FALSE;  
            FatFs->winsect = sector; //更新当前缓冲区的扇区号  
        }  
    }  
    return TRUE;  
}  
  
  
  
  
  
  
  
/*--------------------------------------------------------------------------*/  
/* Public Funciotns                                                         */  
/*--------------------------------------------------------------------------*/  
  
  
/*----------------------------------------------------------*/  
/* Load File System Information and Initialize FatFs Module */  
//本函数做三件事:  
// 1.初始化SD卡  
// 2.检查文件系统类型，FAT16还是FAT32  
// 3.填充FatFs对象，即记录物理磁盘的相关参数  
FRESULT f_mountdrv ()  
{  
    BYTE fat;  
    DWORD sect, fatend;  
    FATFS *fs = FatFs;  
  
  
    if (!fs) return FR_NOT_ENABLED;  
  
    //首先对文件系统对象清空  
    /* Initialize file system object */  
    memset(fs, 0, sizeof(FATFS));  
  
    //然后初始化SD卡  
    /* Initialize disk drive */  
    if (disk_initialize() & STA_NOINIT) return FR_NOT_READY;  
  
    //接着收搜索DBR系统引导记录，先检查第0扇区是否就是DBR(无MBR的SD卡)，如果是则检查文件系统的类型；  
    //如果不是则说明第0扇区是MBR，则根据MBR中的信息定位到DBR所在扇区，并检查该文件系统的类型  
    /* Search FAT partition */  
    fat = check_fs(sect = 0);       /* Check sector 0 as an SFD format */  
    if (!fat) {                     /* Not a FAT boot record, it will be an FDISK format */  
        /* Check a pri-partition listed in top of the partition table */  
        if (fs->win[0x1C2]) {                    /* Is the partition existing? */  
            sect = LD_DWORD(&(fs->win[0x1C6]));  /* Partition offset in LBA */  
            fat = check_fs(sect);               /* Check the partition */  
        }  
    }  
    if (!fat) return FR_NO_FILESYSTEM;  /* No FAT patition */  
  
    //初始化文件系统对象，根据DBR参数信息对Fs成员赋值  
    /* Initialize file system object */  
  
    //文件系统类型:FAT16/FAT32  
    fs->fs_type = fat;                               /* FAT type */  
  
    //单个FAT表所占的扇区数  
    fs->sects_fat =                              /* Sectors per FAT */  
        (fat == FS_FAT32) ? LD_DWORD(&(fs->win[0x24])) : LD_WORD(&(fs->win[0x16]));  
  
    //单个簇所占的扇区数  
    fs->sects_clust = fs->win[0x0D];              /* Sectors per cluster */  
  
    //FAT表总数  
    fs->n_fats = fs->win[0x10];                       /* Number of FAT copies */  
  
    //FAT表起始扇区(物理扇区)  
    fs->fatbase = sect + LD_WORD(&(fs->win[0x0E]));   /* FAT start sector (physical) */  
  
    //根目录项数  
    fs->n_rootdir = LD_WORD(&(fs->win[0x11]));        /* Nmuber of root directory entries */  
  
    //计算根目录起始扇区、数据起始扇区(物理扇区地址)  
    fatend = fs->sects_fat * fs->n_fats + fs->fatbase;  
    if (fat == FS_FAT32) {  
        fs->dirbase = LD_DWORD(&(fs->win[0x2C])); /* Directory start cluster */  
        fs->database = fatend;                       /* Data start sector (physical) */  
    } else {  
        fs->dirbase = fatend;                        /* Directory start sector (physical) */  
        fs->database = fs->n_rootdir / 16 + fatend;   /* Data start sector (physical) */  
    }  
  
    //最大簇号  
    fs->max_clust =                              /* Maximum cluster number */  
        (LD_DWORD(&(fs->win[0x20])) - fs->database + sect) / fs->sects_clust + 2;  
  
    return FR_OK;  
}  
  
  
  
  
  
/*-----------------------*/  
/* Open or Create a File */  
  
FRESULT f_open (  
    FIL *fp,            /* Pointer to the buffer of new file object to create */  
    const char *path,   /* Pointer to the file path */  
    BYTE mode           /* Access mode and file open mode flags */  
)  
{  
    FRESULT res;  
    BYTE *dir;  
    DIR dirscan;  
    char fn[8+3+1];         //8.3 DOS文件名  
    FATFS *fs = FatFs;  
  
    /*首先初始化SD卡，检测文件系统类型，初始化FATFS对象*/  
    if ((res = check_mounted()) != FR_OK) return res;  
      
#ifndef _FS_READONLY  
  
    //如果磁盘设置为写保护，则返回错误码:FR_WRITE_PROTECTED  
    if ((mode & (FA_WRITE|FA_CREATE_ALWAYS)) && (disk_status() & STA_PROTECT))  
        return FR_WRITE_PROTECTED;  
#endif  
  
    //根据用户提供的文件路径path，将文件名对应的目录项及其整个扇区读取到win[]中，  
    //并填充目录项dirscan、标准格式的文件名fn，以及目录项在win[]中的字节偏移量dir  
    res = trace_path(&dirscan, fn, path, &dir); /* Trace the file path */  
  
#ifndef _FS_READONLY  
    /* Create or Open a File */  
    if (mode & (FA_CREATE_ALWAYS|FA_OPEN_ALWAYS)) {  
        DWORD dw;  
  
        //如果文件不存在，则强制新建文件  
        if (res != FR_OK) {     /* No file, create new */  
            mode |= FA_CREATE_ALWAYS;  
            if (res != FR_NO_FILE) return res;  
            dir = reserve_direntry(&dirscan);   /* Reserve a directory entry */  
            if (dir == NULL) return FR_DENIED;  
            memcpy(dir, fn, 8+3);       /* Initialize the new entry */  
            *(dir+12) = fn[11];  
            memset(dir+13, 0, 32-13);  
        }   
        else {              /* File already exists */  
            if ((dir == NULL) || (*(dir+11) & (AM_RDO|AM_DIR))) /* Could not overwrite (R/O or DIR) */  
                return FR_DENIED;  
              
            //如果文件存在，但又以FA_CREATE_ALWAYS方式打开文件，则重写文件  
            if (mode & FA_CREATE_ALWAYS) {  /* Resize it to zero */  
                dw = fs->winsect;            /* Remove the cluster chain */  
                if (!remove_chain(((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26))  
                    || !move_window(dw) )  
                    return FR_RW_ERROR;  
                ST_WORD(dir+20, 0); ST_WORD(dir+26, 0); /* cluster = 0 */  
                ST_DWORD(dir+28, 0);                    /* size = 0 */  
            }  
        }  
  
        //如果是强制新建文件操作，则还需更新时间和日期  
        if (mode & FA_CREATE_ALWAYS) {  
            *(dir+11) = AM_ARC;  
            dw = get_fattime();  
            ST_DWORD(dir+14, dw);   /* Created time */  
            ST_DWORD(dir+22, dw);   /* Updated time */  
            fs->dirtyflag = 1;  
        }  
    }  
    /* Open a File */  
    else {  
#endif  
        if (res != FR_OK) return res;       /* Trace failed */  
  
        //如果打开的是一个目录文件，则返回错误码:FR_NO_FILE  
        if ((dir == NULL) || (*(dir+11) & AM_DIR))  /* It is a directory */  
            return FR_NO_FILE;  
          
#ifndef _FS_READONLY  
  
        //如果以FA_WRITE方式打开Read-Only属性的文件，则返回错误码:FR_DENIED  
        if ((mode & FA_WRITE) && (*(dir+11) & AM_RDO)) /* R/O violation */  
            return FR_DENIED;  
    }  
#endif  
  
    //填充FIL文件结构体参数  
#ifdef _FS_READONLY  
    fp->flag = mode & (FA_UNBUFFERED|FA_READ);  
#else  
    fp->flag = mode & (FA_UNBUFFERED|FA_WRITE|FA_READ);  
    fp->dir_sect = fs->winsect;               /* Pointer to the directory entry */  
    fp->dir_ptr = dir;  
#endif  
    fp->org_clust =  ((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26); /* File start cluster */  
    fp->fsize = LD_DWORD(dir+28);        /* File size */  
    fp->fptr = 0;                        /* File ptr */  
  
    //这一步很重要，它将直接导致f_read和f_write操作中的逻辑顺序  
    fp->sect_clust = 1;                  /* Sector counter */  
      
    fs->files++;  
    return FR_OK;  
}  
  
  
  
/*-----------*/  
/* Read File */  
//文件读操作  
FRESULT f_read (  
    FIL *fp,        /* Pointer to the file object */  
    BYTE *buff,     /* Pointer to data buffer */  
    WORD btr,       /* Number of bytes to read */  
    WORD *br        /* Pointer to number of bytes read */  
)  
{  
    DWORD clust, sect, ln;  
    WORD rcnt;      /*已经读取的字节数*/  
    BYTE cc;        /*实际单次要读取的连续最大扇区数*/  
    FATFS *fs = FatFs;  
  
  
    *br = 0;  
      
    //错误处理  
    if (!fs) return FR_NOT_ENABLED;  
    if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_NOT_READY;   /* Check disk ready */  
    if (fp->flag & FA__ERROR) return FR_RW_ERROR;    /* Check error flag */  
    if (!(fp->flag & FA_READ)) return FR_DENIED; /* Check access mode */  
      
    //检查要读取的字节数是否超出了剩余的文件长度，如果超出了，则只读取剩余字节长度  
    ln = fp->fsize - fp->fptr;  
    if (btr > ln) btr = ln;                          /* Truncate read count by number of bytes left */  
  
    //该循环以簇为单位，每循环一次就读完一个簇的内容  
    /* Repeat until all data transferred */  
    for ( ;  btr; buff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt)   
    {  
              
        //当文件指针与扇区边界对齐时(如:刚打开文件时)，执行以下操作；  
        //否则(如:调用了f_lseek函数)只将当前buffer中需要的内容直接copy到目标缓冲区，然后进入下一次循环。  
        if ((fp->fptr & 511) == 0)                   /* On the sector boundary */  
        {                 
            //如果还没有读完当前簇的所有扇区，则将下一个扇区号赋给变量sect。  
            //注意，当第一次读取文件时，由于f_open函数中，已经将sect_clust赋值为1，  
            //所以应该执行else语句  
            if (--(fp->sect_clust))              /* Decrement sector counter */  
            {     
                //一般走到这里就意味着只剩下最后一个扇区需要读取，且要读取的内容小于512字节  
                sect = fp->curr_sect + 1;            /* Next sector */  
            }   
            //如果已经读完当前簇的所有扇区，则计算下一个簇的起始位置，  
            //并更新FIL中的当前簇号curr_clust和当前簇剩余扇区数sect_clust  
            else                                    /* Next cluster */  
            {     
                //如果当前文件指针在起始簇内，则将clust设置为起始簇号；  
                //否则，将clust设置为下一簇号  
                clust = (fp->fptr == 0) ? fp->org_clust : get_cluster(fp->curr_clust);  
                if ((clust < 2) || (clust >= fs->max_clust)) goto fr_error;  
                  
                fp->curr_clust = clust;              /* Current cluster */  
                sect = clust2sect(clust);           /* Current sector */  
                fp->sect_clust = fs->sects_clust; /* Re-initialize the sector counter */  
            }  
              
#ifndef _FS_READONLY  
  
            //如果buffer中的内容被修改过，则需要先将buffer中的内容回写到物理磁盘中  
            if (fp->flag & FA__DIRTY)                /* Flush file I/O buffer if needed */  
            {                 
                if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) goto fr_error;  
                fp->flag &= ~FA__DIRTY;  
            }  
#endif  
  
            //更新当前扇区号  
            fp->curr_sect = sect;                    /* Update current sector */  
  
            //计算需要读取部分的剩余扇区数cc(最后一个扇区内容若不满512字节则不计入cc中)  
            cc = btr / 512;                           
  
            //只要当前扇区不是最后一个扇区，则执行连续的读操作，然后直接进入下一次循环  
            /* When left bytes >= 512 */  
            /* Read maximum contiguous sectors */  
            if (cc)                                   
            {     
                //如果cc小于当前簇的剩余扇区数sect_clust，则连续读取cc个扇区；  
                //如果cc大于当前簇的剩余扇区数sect_clust，则只读取当前簇的剩余扇区  
                if (cc > fp->sect_clust) cc = fp->sect_clust;     
  
                //执行实际的磁盘读操作，读取当前簇的剩余扇区内容到目标缓冲区中  
                //注意，是直接读到目标接收缓冲区的，而不是到buffer中  
                if (disk_read(buff, sect, cc) != RES_OK) goto fr_error;  
  
                //更新当前簇的剩余扇区数  
                //该语句实际为:sect_clust = sect_clust - (cc - 1) = sect_clust - cc + 1;  
                //之所以+1是因为当cc == sect_clust时，sect_clust = sect_clust - sect_clust + 1 = 1；  
                //所以当下一次循环执行到 if (--(fp->sect_clust)) 时直接进入else语句。  
                fp->sect_clust -= cc - 1;  
                  
                //更新当前扇区号，扇区号是基于0索引的，所以这里要-1  
                fp->curr_sect += cc - 1;  
  
                //更新已读的字节数  
                rcnt = cc * 512;   
  
                //直接进入下一次循环  
                continue;  
            }  
  
            if (fp->flag & FA_UNBUFFERED)            /* Reject unaligned access when unbuffered mode */  
                return FR_ALIGN_ERROR;  
  
            //对于文件的最后一个扇区，则先将内容读取到buffer中，然后将需要的内容拷贝到目标缓冲区中，并退出循环  
            if (disk_read(fp->buffer, sect, 1) != RES_OK)    /* Load the sector into file I/O buffer */  
                goto fr_error;  
              
        }//end if ((fp->fptr & 511) == 0)  
  
        //计算从buffer中实际要读取的字节数rcnt  
        rcnt = 512 - (fp->fptr & 511);                 
        if (rcnt > btr) rcnt = btr;  
  
        //最后将buffer中的指定数据拷贝到目标缓冲区中  
        memcpy(buff, &fp->buffer[fp->fptr & 511], rcnt);    /* Copy fractional bytes from file I/O buffer */  
  
        //一般走到这里就说明已经读完了最后一扇区，下一步将退出循环;  
        //如果还没有读完最后一扇，则有可能是在调用f_lseek后第一次调用f_read，那么将进入下一次循环  
    }//end for(...)  
  
    return FR_OK;  
  
fr_error:   /* Abort this file due to an unrecoverable error */  
    fp->flag |= FA__ERROR;  
    return FR_RW_ERROR;  
}  
  
  
FRESULT f_write (  
    FIL *fp,            /* Pointer to the file object */  
    const BYTE *buff,   /* Pointer to the data to be written */  
    WORD btw,           /* Number of bytes to write */  
    WORD *bw            /* Pointer to number of bytes written */  
)  
{  
    DWORD clust, sect;  
    WORD wcnt;          /*已经写入的字节数*/  
    BYTE cc;            /*实际单次要写入的连续最大扇区数*/  
    FATFS *fs = FatFs;  
  
  
    *bw = 0;  
  
    //错误处理  
    if (!fs) return FR_NOT_ENABLED;  
    if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_NOT_READY;  
    if (fp->flag & FA__ERROR) return FR_RW_ERROR;    /* Check error flag */  
    if (!(fp->flag & FA_WRITE)) return FR_DENIED;    /* Check access mode */  
      
    //保证写入后整个文件大小不得超过4GB  
    if (fp->fsize + btw < fp->fsize) btw = 0;      /* File size cannot reach 4GB */  
  
    //该循环以簇为单位，每循环一次就写完一个簇的内容  
    /* Repeat until all data transferred */  
    for ( ;  btw; buff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt)   
    {  
        //当文件指针与扇区边界对齐时(如:刚打开文件时)，执行以下操作；  
        //否则(如:调用了f_lseek函数)只将当前扇区所需要的内容copy到buffer中，然后进入下一次循环。  
        if ((fp->fptr & 511) == 0)                  /* On the sector boundary */  
        {                 
            //如果还没有写完当前簇的所有扇区，则将下一个扇区号赋给变量sect。  
            //注意，当第一次写文件时，由于f_open函数中，已经将sect_clust赋值为1，  
            //所以应该执行else语句  
            if (--(fp->sect_clust))                 /* Decrement sector counter */  
            {                 
                //一般走到这里就意味着只剩下最后一个扇区需要写入，且要写入的内容小于512字节  
                sect = fp->curr_sect + 1;            /* Next sector */  
            }   
            //如果已经写完当前簇的所有扇区，则计算下一个簇的起始位置，  
            //并更新FIL中的当前簇号curr_clust和当前簇剩余扇区数sect_clust  
            else                                    /* Next cluster */  
            {     
                //如果当前文件指针在起始簇内，则将当前簇设置为起始簇；  
                if (fp->fptr == 0)                  /* Top of the file */  
                {                 
                    clust = fp->org_clust;  
                      
                    //如果文件不存在，则先创建一个新的簇，并将该簇号设置为当前簇号  
                    if (clust == 0)                 /* No cluster is created */  
                        fp->org_clust = clust = create_chain(0); /* Create a new cluster chain */  
                }   
                //如果当前文件指针不在起始簇内，则将下一簇号设置为当前簇号  
                else                                /* Middle or end of file */  
                {                             
                    clust = create_chain(fp->curr_clust);            /* Trace or streach cluster chain */  
                }  
                if ((clust < 2) || (clust >= fs->max_clust)) break;  
                  
                fp->curr_clust = clust;              /* Current cluster */  
                sect = clust2sect(clust);           /* Current sector */  
                fp->sect_clust = fs->sects_clust; /* Re-initialize the sector counter */  
            }  
              
            //如果buffer中的内容被修改过，则需要先将buffer中的内容回写到物理磁盘中  
            if (fp->flag & FA__DIRTY)               /* Flush file I/O buffer if needed */  
            {                 
                if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) goto fw_error;  
                fp->flag &= ~FA__DIRTY;  
            }  
              
            //更新当前扇区号  
            fp->curr_sect = sect;                    /* Update current sector */  
  
            //计算需要写入部分的剩余扇区数cc(最后一个扇区内容若不满512字节则不计入cc中)  
            cc = btw / 512;                           
  
            //只要当前扇区不是最后一个扇区，则执行连续的写操作，然后直接进入下一次循环  
            /* When left bytes >= 512 */  
            /* Write maximum contiguous sectors */  
            if (cc)                                   
            {                                
                //如果cc小于当前簇的剩余扇区数sect_clust，则连续写入cc个扇区；  
                //如果cc大于当前簇的剩余扇区数sect_clust，则只将当前簇的剩余扇区写入物理磁盘中  
                if (cc > fp->sect_clust) cc = fp->sect_clust;  
                  
                //执行实际的磁盘写操作，将源缓冲区中的内容写入到当前簇的剩余扇区中  
                //注意，是直接从源缓冲区写到物理磁盘中的，没有经过buffer  
                if (disk_write(buff, sect, cc) != RES_OK) goto fw_error;  
                  
                //更新当前簇的剩余扇区数  
                //该语句实际为:sect_clust = sect_clust - (cc - 1) = sect_clust - cc + 1;  
                //之所以+1是因为当cc == sect_clust时，sect_clust = sect_clust - sect_clust + 1 = 1；  
                //所以当下一次循环执行到 if (--(fp->sect_clust)) 时直接进入else语句。  
                fp->sect_clust -= cc - 1;  
                  
                //更新当前扇区号，扇区号是基于0索引的，所以这里要-1  
                fp->curr_sect += cc - 1;  
                  
                //更新已写的字节数  
                wcnt = cc * 512;   
  
                //直接进入下一次循环  
                continue;  
            }  
              
            if (fp->flag & FA_UNBUFFERED)            /* Reject unalighend access when unbuffered mode */  
                return FR_ALIGN_ERROR;  
              
            //如果已经写到最后一个扇区了，则先将SD卡中所对应扇区的原始内容读取到buffer中，然后修改buffer中的内容，再从buffer回写到物理磁盘中  
            if ((fp->fptr < fp->fsize) && (disk_read(fp->buffer, sect, 1) != RES_OK)) /* Fill sector buffer with file data if needed */  
                    goto fw_error;  
              
        }//end if ((fp->fptr & 511) == 0)   
          
        //计算实际要写入的字节数wcnt  
        wcnt = 512 - (fp->fptr & 511);               /* Copy fractional bytes to file I/O buffer */  
        if (wcnt > btw) wcnt = btw;  
          
        //将源缓冲区中的数据拷贝到buffer中的指定位置  
        memcpy(&fp->buffer[fp->fptr & 511], buff, wcnt);  
  
        //设置buffer回写标记，当调用f_close或执行下一次循环操作时，执行buffer回写操作  
        fp->flag |= FA__DIRTY;  
          
        //一般走到这里就说明已经写完了最后一扇区，下一步将退出循环;  
        //如果还没有写完最后一扇，则有可能是在调用f_lseek后第一次调用f_write，那么将进入下一次循环  
    }//end for(; btw; buff += wcnt,...)  
  
    //如果对原始文件增加了新的内容，则需要更新文件的大小，并设置文件大小更新标记FA__WRITTEN  
    if (fp->fptr > fp->fsize) fp->fsize = fp->fptr;  /* Update file size if needed */  
    fp->flag |= FA__WRITTEN;                     /* Set file changed flag */  
      
    return FR_OK;  
  
fw_error:   /* Abort this file due to an unrecoverable error */  
    fp->flag |= FA__ERROR;  
    return FR_RW_ERROR;  
}  
  
  
FRESULT f_sync (  
    FIL *fp     /* Pointer to the file object */  
)  
{  
    BYTE *ptr;  
    FATFS *fs = FatFs;  
  
  
    if (!fs) return FR_NOT_ENABLED;  
    if ((disk_status() & STA_NOINIT) || !fs->fs_type)  
        return FR_INCORRECT_DISK_CHANGE;  
  
    //检查文件是否增加了新的内容，如果是则需要修改目录项  
    /* Has the file been written? */  
    if (fp->flag & FA__WRITTEN) {  
  
        //如果buffer的内容被修改了，则需要先将buffer的内容回写到物理磁盘中去  
        /* Write back data buffer if needed */  
        if (fp->flag & FA__DIRTY) {  
            if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) return FR_RW_ERROR;  
            fp->flag &= ~FA__DIRTY;  
        }  
  
    /*************由于更改了文件长度，所以需要修改文件对应的目录项************/  
  
        //首先读取文件对应的根目录扇区到win[]  
        /* Update the directory entry */  
        if (!move_window(fp->dir_sect)) return FR_RW_ERROR;  
  
        //然后修改根目录项  
        ptr = fp->dir_ptr;  
        *(ptr+11) |= AM_ARC;                    /* Set archive bit */  
        ST_DWORD(ptr+28, fp->fsize);         /* Update file size */  
        ST_WORD(ptr+26, fp->org_clust);          /* Update start cluster */  
        ST_WORD(ptr+20, fp->org_clust >> 16);  
        ST_DWORD(ptr+22, get_fattime());        /* Updated time */  
  
        //设置win[]回写标志  
        fs->dirtyflag = 1;  
  
        //清除文件大小更改标记  
        fp->flag &= ~FA__WRITTEN;  
    }  
  
    //将win[]中的根目录信息回写到对应的物理扇区  
    if (!move_window(0)) return FR_RW_ERROR;  
  
    return FR_OK;  
}  
0 0