FatFs源码剖析(1)

我就是我 2022-11-09 14:26 282阅读 0赞

原文链接：[https://blog.csdn.net/hexiaolong2009/article/details/19495085][https_blog.csdn.net_hexiaolong2009_article_details_19495085]

## 一、介绍： ##

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

0.01版本下载：[FatFs历史版本][FatFs]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]

## 二、重点： ##

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拷贝需要的字节到用户缓冲区中。  
\}  
![在这里插入图片描述][20210315201536843.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
3. f\_write

f\_write()

\{  
1. 从用户缓冲区直接写入到物理磁盘，这个过程中未使用buffer缓冲区；  
2. 如果要写入的最后一扇区内容少于512字节，则先从物理磁盘读取最后一扇区的内容到buffer中，然后修改buffer中的相应内容，并设置回写标记，这样下次调用f\_close/f\_write时，就会将buffer回写到物理磁盘中。

\}  
![在这里插入图片描述][20210315201605763.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
4. f\_close

关键是调用了f\_sync函数。

5.f\_sync

f\_sync()

\{  
1. 将buffer回写到物理磁盘中；  
2. 读取文件对应的目录项到win\[\]中，更新参数，并回写。

\}  
![在这里插入图片描述][20210315201633829.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
6.move\_window

move\_window专用于操作win\[\]系统缓冲区。

move\_window(B);  
调用前：  
![在这里插入图片描述][20210315201724773.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
执行中：  
![在这里插入图片描述][2021031520174742.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
调用后：  
![在这里插入图片描述][20210315201817823.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]

## 四、源码注释 ##

本人在不破坏源码逻辑的前提下，对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;  //定义临时指针fs指向FatFs
     
     
    	wsect = fs->winsect;//找到当前操作的的扇区号FatFs->winsect
    	/*首先检查目标扇区号是否与win[]对应的扇区号相同，如果相同则不进行任何操作，不需要进行读写，直接返回TRUE。*/
    	if (wsect != sector) { 	/* Changed current window */
    #ifndef _FS_READONLY
    		BYTE n;
     
    		//首先检测win[]的内容是否做过修改，如果修改过，则需要先将其写入SD卡中
    		//即： 将修改的内容同步到物理内存中，以便腾出空间重新读取新的扇区内容。
    		if (fs->dirtyflag) { 	/* Write back dirty window if needed */
    			if (disk_write(fs->win, wsect, 1) != RES_OK) return FALSE;
     
    			//清除修改标记
    			fs->dirtyflag = 0;//官网源码是fs->winflag
    			
    			/*如果当前操作的是FAT表，那么需要将修改后的FAT表拷贝到对应的FAT备份中*/
    			if (wsect < (fs->fatbase + fs->sects_fat)) { 	/* In FAT area */
    				for (n = fs->n_fats; n >= 2; n--) { 	/* Refrect the change to all FAT copies */
    					wsect += fs->sects_fat;
    					if (disk_write(fs->win, wsect, 1) != RES_OK) break;
    				}
    			}
    		}
    #endif
     
    		//然后再读取新的扇区内容到win[]中
    		if (sector) { 
    			if (disk_read(fs->win, sector, 1) != RES_OK) return FALSE;
    			fs->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; //disk_initialize()该函数需要用户实现
     
    	//接着搜索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;//check_mounted()如果已经成功挂载过，这里直接返回FR_OK
    	
    #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;//fs->winflag = 1;
     
    		//清除文件大小更改标记
    		fp->flag &= ~FA__WRITTEN;
    	}
     
    	//将win[]中的根目录信息回写到对应的物理扇区
    	if (!move_window(0)) return FR_RW_ERROR;
     
    	return FR_OK;
    }

本文系装载，加了一点点内容，原作者写得非常好  
————————————————  
版权声明：本文为CSDN博主「何小龙」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/hexiaolong2009/article/details/19495085

[https_blog.csdn.net_hexiaolong2009_article_details_19495085]: https://blog.csdn.net/hexiaolong2009/article/details/19495085
[FatFs]: http://elm-chan.org/fsw/ff/archives.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/d045a1cd8ffb49d18fc7c4fc9fa21e12.png
[20210315201536843.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/2cd78ce2f3074a6880e4b1bbbbb1073c.png
[20210315201605763.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/8aa1f802a8764cba8588696d7d2e915e.png
[20210315201633829.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/3cd5a2d65d5745f2af4d5017195b981d.png
[20210315201724773.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/da10fb85bbdd4869ba8599c3d9cc9f81.png
[2021031520174742.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/a4f71daecc3c46a4a61c3387914497bd.png
[20210315201817823.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221023/e1b299927679415d8d8eae345e3ae8f1.png