FatFs源码剖析

hexiaolong2009 · 发表于 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的核心思想及架构。

#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;
}

复制代码

源码下载：
pdf文档：

sunliezhi · 发表于 2014-2-19 18:16:07

顶好

tianming · 发表于 2014-2-19 18:21:45

板凳~~~~

macaroni · 发表于 2014-2-19 18:34:03

地板

RUANJI · 发表于 2014-2-19 18:35:15

不错，收藏了。楼主的帖子都很好啊。

reynold520 · 发表于 2014-2-19 18:48:50

FAT 文件系统 mark

wazhiyi · 发表于 2014-2-19 19:25:34

mark一下，太好了，好人啊

kalo425 · 发表于 2014-2-19 19:33:05

楼主的帖子都写的非常好。清晰透彻···学习了··

Excellence · 发表于 2014-2-19 19:42:35

顶。楼主辛苦。

cmheia · 发表于 2014-2-19 19:48:06

FAT 文件系统 mark 收藏了

philis · 发表于 2014-2-26 22:45:05

直观，详细，谢谢分享啊

yyinfo263 · 发表于 2014-2-26 23:32:48

收藏了写的非常详细谢谢楼主的好文

mypear · 发表于 2014-2-26 23:36:12

mark备用

tcl7281 · 发表于 2014-2-28 21:05:48

顶。楼主辛苦。

bdllllll · 发表于 2014-2-28 21:55:56

楼主辛苦

xranger · 发表于 2014-2-28 22:29:27

多谢分享。确实后面的工程太大，不宜于入门

chenxujiaoyang · 发表于 2014-2-28 22:45:10

深顶v

wyw08 · 发表于 2014-2-28 23:05:54

刚好最近要了解文件系统，顶！

Chash · 发表于 2014-2-28 23:24:04

好东西，谢谢楼主分享！

utopiaprince · 发表于 2014-2-28 23:44:41

好帖，楼主分析的流程很对。

菜包 · 发表于 2014-2-28 23:45:47

分析的真好，图文并茂，谢谢LZ

cxhy · 发表于 2014-3-1 08:00:09

马克一下

sleet1986 · 发表于 2014-3-1 08:28:22

楼主的fatfs是我看过的最好的教程

wenunit · 发表于 2014-3-1 08:47:36

马克一下..........

dengterry · 发表于 2014-3-1 09:38:08

将来要学习的内容，MARK一下

cdlxzlp · 发表于 2014-3-1 10:18:32

有心了这个真的用个心哈哈

Shaw.Embedi · 发表于 2014-3-1 13:02:15

这个真是用心了。

xzf962 · 发表于 2014-3-1 16:59:33

向楼主学习！！

fiddly · 发表于 2014-3-1 19:06:30

FAT文件系统，收藏备用，顶顶！

eehong · 发表于 2014-3-3 22:40:21

Mark Fatfs 开源0.10源码剖析

gardensu · 发表于 2014-3-4 00:59:27

文章很有概括性，流程图画的真漂亮，请问楼主使用什么软件画的？

pipi516 · 发表于 2014-3-4 09:44:57

FAT 文件系统 mark 收藏了

硬邦邦 · 发表于 2014-3-4 09:49:23

谢谢分享，mark

2011micro · 发表于 2014-3-4 10:15:29

牛，需要看看

xiaohu1993 · 发表于 2014-3-4 10:32:02

楼主你好。我想每当一个记事本存了1000个数据之后，如何做到再新建一个记事本再存储数据呢？

yy8047 · 发表于 2014-3-4 10:45:07

谢谢分享！

leicai05 · 发表于 2014-3-4 11:05:34

fatfs详解

hexiaolong2009 · 发表于 2014-3-4 15:55:46

gardensu 发表于 2014-3-4 00:59
文章很有概括性，流程图画的真漂亮，请问楼主使用什么软件画的？

使用VISIO2003画的

hexiaolong2009 · 发表于 2014-3-4 15:57:49

xiaohu1993 发表于 2014-3-4 10:32
楼主你好。我想每当一个记事本存了1000个数据之后，如何做到再新建一个记事本再存储数据呢？ ...

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

xiaoya1945 · 发表于 2014-3-4 16:12:13

好顶赞！收藏级！^_^

xiaohu1993 · 发表于 2014-3-6 08:23:29

楼主，我现在有一个问题。也是用fatfs移植到stm32中，第一天没什么问题。到第二天发现stm32第一次跑程序时，只能新建记事本，不能在记事本中存储数据，也就是sd卡初始化失败了。到第二次再跑程序才能进入while（1），在记事本中存储数据。这事为什么呢？

leon...... · 发表于 2014-3-6 08:34:49

太完美了，学习一下

dexidz · 发表于 2014-3-6 09:26:02

谢谢分享了

prozmx · 发表于 2014-3-6 09:44:56

这个超详细，谢谢了

windrarara · 发表于 2014-3-6 12:20:09

mark一下, 谢谢楼主了

luyiheng · 发表于 2014-3-6 12:32:07

直观，详细，谢谢分享啊

bondxie3 · 发表于 2014-3-6 12:50:28

fatfs剖析，标记！顶

knight_avr · 发表于 2014-3-6 15:51:58

LZ辛苦了！！

lxh413458727 · 发表于 2014-3-6 16:23:36

图文解析，very good. 3Q!

pchf005 · 发表于 2014-3-6 16:55:48

sgweilong · 发表于 2014-3-11 15:22:35

好文，mark！

Mac_Alex · 发表于 2014-3-11 16:18:14

谢谢分享！最近在学习这个，先Mark。

wildcat7261 · 发表于 2014-3-11 17:07:26

学习了

liuruoshui · 发表于 2014-3-11 17:39:44

好资料！

Mac_Alex · 发表于 2014-3-12 16:51:02

最近在学习这个，谢谢分享！

Baldwin · 发表于 2014-3-12 16:56:24

您好，您的画图软件用的什么啊

yixinyiyi · 发表于 2014-3-12 18:29:48

MARK,学习

234918154 · 发表于 2014-3-13 15:51:52

楼主好人啊！

MR_ZJY · 发表于 2014-5-25 08:35:33

mark..

wangdanzhoudan · 发表于 2014-6-24 19:27:06

多谢楼主分享，赞一个！

广轻电气091 · 发表于 2014-6-25 11:20:59

谢谢楼主分享，太好了

LCRPN · 发表于 2014-6-25 16:10:40

是楼主原创的吗？
这个必须有空过来好好学习。

SMC · 发表于 2014-6-25 21:30:41

fat文件 mark

mbass51 · 发表于 2014-6-26 09:41:33

好長細的筆記

imjacob · 发表于 2014-6-26 14:22:04

好文章，光看那几个图就知道是好文

wangbao619 · 发表于 2014-6-26 14:41:50

留个名，看一下。

xi_liang · 发表于 2014-6-27 06:58:31

很好的帖子，别的不说，这图画得牛B

hexiaolong2009 · 发表于 2014-6-27 09:36:13

xi_liang 发表于 2014-6-27 06:58
很好的帖子，别的不说，这图画得牛B

过奖了，你们这些前辈才算真正的大牛！
你的开发板现在卖的咋样了？

xjtyOnly51 · 发表于 2014-6-27 10:19:16

thanks a lot

liyang121316 · 发表于 2014-7-16 08:10:20

顶，楼主真不错！

hdmsfhfg · 发表于 2014-7-19 16:05:32

必须顶起

zhaojianjiang · 发表于 2014-7-19 19:27:28

mark一下，太好了，好人啊

依韵 · 发表于 2014-7-21 11:54:47

顶起学习

MyDSO · 发表于 2014-7-21 12:25:52

正在找这个东西，收下。
楼主辛苦了。

电子小罗 · 发表于 2014-7-21 12:53:34

LZ辛苦辛苦

Hearthbeats · 发表于 2014-7-22 09:59:54

正在学习fatfs 楼主辛苦了

xukai871105 · 发表于 2014-7-30 14:04:56

这个资料真的是太好了！

机器人天空 · 发表于 2014-7-30 14:14:03

好东西，赶紧收藏

kaomantou · 发表于 2014-7-30 14:49:25

mark一下下

myxiaonia · 发表于 2014-10-12 22:52:13

xi_liang 发表于 2014-6-27 06:58
很好的帖子，别的不说，这图画得牛B

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

chengsong · 发表于 2014-10-12 22:56:33

好资料要收藏！

重庆酱油仔 · 发表于 2014-10-13 08:53:59

mark,FatFs源码;

RainKing · 发表于 2014-10-13 08:56:51

楼主花了大力气啊.............

love0679 · 发表于 2014-10-13 09:03:48

楼主写的太详细了~好好学习一下~3Q3Q

hyghyg1234 · 发表于 2014-10-13 09:07:26

非常好。

cjt5132 · 发表于 2014-10-17 15:22:06

好详细啊，不错

hamipeter · 发表于 2014-10-17 17:09:49

支持一下！！！！！

liangerfan · 发表于 2014-10-17 17:13:12

已加入收藏夹，谢谢分享

k_er_tlwei · 发表于 2014-10-17 17:20:22

顶LZ,好好学习下

Joezhu · 发表于 2014-10-17 18:56:59

赞一个

飞剑 · 发表于 2014-10-18 10:49:14

收藏了。

聆听风声 · 发表于 2014-10-19 02:15:28

学习了！！

cjt5132 · 发表于 2014-10-27 13:51:00

不错不错。。。

dz46316740 · 发表于 2014-10-27 14:34:48

不错，用过这个文件系统

liangerfan · 发表于 2014-10-30 10:39:54

标记，看高手写的代码各种规范，结构逻辑清晰，好好学习

dmzy · 发表于 2014-11-6 15:31:10

MARK

Puppey · 发表于 2014-11-13 20:33:06

好文章，顶上去！

yinzhongxing · 发表于 2014-11-14 16:47:08

要做这方面的东西正好学习了

KDTeam · 发表于 2014-11-15 19:31:22

mark 谢谢分享

Yan_xp · 发表于 2014-11-16 09:10:50

太谢谢楼主了！我也是喜欢在m3 mcu使用freertos，正需要使用fs！

FatFs源码剖析

本帖子中包含更多资源

阿莫论坛20周年了！感谢大家的支持与爱护！！