dark0707
/
px4-firmware
forked from Archive/PX4-Autopilot
1
0
Fork 0
Code Pull Requests Activity
px4-firmware/nuttx/fs/fat/fs_fat32util.c

1857 lines
52 KiB
C
Raw Blame History

/****************************************************************************
* fs/fat/fs_fat32util.c
*
* Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* References:
* Microsoft FAT documentation
* Some good ideas were leveraged from the FAT implementation:
* 'Copyright (C) 2007, ChaN, all right reserved.'
* which has an unrestricted license.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <semaphore.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/kmalloc.h>
#include <nuttx/fs.h>
#include <nuttx/fat.h>
#include "fs_internal.h"
#include "fs_fat32.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: fat_checkfsinfo
*
* Desciption: Read the FAT32 FSINFO sector
*
****************************************************************************/
static int fat_checkfsinfo(struct fat_mountpt_s *fs)
{
/* Make sure that the fsinfo sector is in the cache */
if (fat_fscacheread(fs, fs->fs_fsinfo) == OK)
{
/* Verify that this is, indeed, an FSINFO sector */
if (FSI_GETLEADSIG(fs->fs_buffer) == 0x41615252 &&
FSI_GETSTRUCTSIG(fs->fs_buffer) == 0x61417272 &&
FSI_GETTRAILSIG(fs->fs_buffer) == BOOT_SIGNATURE32)
{
fs->fs_fsinextfree = FSI_GETFREECOUNT(fs->fs_buffer);
fs->fs_fsifreecount = FSI_GETNXTFREE(fs->fs_buffer);
return OK;
}
}
return -ENODEV;
}
/****************************************************************************
* Name: fat_checkbootrecord
*
* Desciption: Read a sector and verify that it is a a FAT boot record.
*
****************************************************************************/
static int fat_checkbootrecord(struct fat_mountpt_s *fs)
{
uint32_t ndatasectors;
uint32_t ntotalfatsects;
uint16_t rootdirsectors = 0;
bool notfat32 = false;
/* Verify the MBR signature at offset 510 in the sector (true even
* if the sector size is greater than 512. All FAT file systems have
* this signature. On a FAT32 volume, the RootEntCount , FatSz16, and
* FatSz32 values should always be zero. The FAT sector size should
* match the reported hardware sector size.
*/
if (MBR_GETSIGNATURE(fs->fs_buffer) != BOOT_SIGNATURE16 ||
MBR_GETBYTESPERSEC(fs->fs_buffer) != fs->fs_hwsectorsize)
{
fdbg("ERROR: Signature: %04x FS sectorsize: %d HW sectorsize: %d\n",
MBR_GETSIGNATURE(fs->fs_buffer), MBR_GETBYTESPERSEC(fs->fs_buffer),
fs->fs_hwsectorsize);
return -EINVAL;
}
/* Verify the FAT32 file system type. The determination of the file
* system type is based on the number of clusters on the volume: FAT12
* volume has <= FAT_MAXCLUST12 (4084) clusters, a FAT16 volume has <=
* FAT_MINCLUST16 (microsfoft says < 65,525) clusters, and any larger
* is FAT32.
*
* Get the number of 32-bit directory entries in root directory (zero
* for FAT32).
*/
fs->fs_rootentcnt = MBR_GETROOTENTCNT(fs->fs_buffer);
if (fs->fs_rootentcnt != 0)
{
notfat32 = true; /* Must be zero for FAT32 */
rootdirsectors = (32 * fs->fs_rootentcnt + fs->fs_hwsectorsize - 1) / fs->fs_hwsectorsize;
}
/* Determine the number of sectors in a FAT. */
fs->fs_nfatsects = MBR_GETFATSZ16(fs->fs_buffer); /* Should be zero */
if (fs->fs_nfatsects)
{
notfat32 = true; /* Must be zero for FAT32 */
}
else
{
fs->fs_nfatsects = MBR_GETFATSZ32(fs->fs_buffer);
}
if (!fs->fs_nfatsects || fs->fs_nfatsects >= fs->fs_hwnsectors)
{
fdbg("ERROR: fs_nfatsects %d fs_hwnsectors: %d\n",
fs->fs_nfatsects, fs->fs_hwnsectors);
return -EINVAL;
}
/* Get the total number of sectors on the volume. */
fs->fs_fattotsec = MBR_GETTOTSEC16(fs->fs_buffer); /* Should be zero */
if (fs->fs_fattotsec)
{
notfat32 = true; /* Must be zero for FAT32 */
}
else
{
fs->fs_fattotsec = MBR_GETTOTSEC32(fs->fs_buffer);
}
if (!fs->fs_fattotsec || fs->fs_fattotsec > fs->fs_hwnsectors)
{
fdbg("ERROR: fs_fattotsec %d fs_hwnsectors: %d\n",
fs->fs_fattotsec, fs->fs_hwnsectors);
return -EINVAL;
}
/* Get the total number of reserved sectors */
fs->fs_fatresvdseccount = MBR_GETRESVDSECCOUNT(fs->fs_buffer);
if (fs->fs_fatresvdseccount > fs->fs_hwnsectors)
{
fdbg("ERROR: fs_fatresvdseccount %d fs_hwnsectors: %d\n",
fs->fs_fatresvdseccount, fs->fs_hwnsectors);
return -EINVAL;
}
/* Get the number of FATs. This is probably two but could have other values */
fs->fs_fatnumfats = MBR_GETNUMFATS(fs->fs_buffer);
ntotalfatsects = fs->fs_fatnumfats * fs->fs_nfatsects;
/* Get the total number of data sectors */
ndatasectors = fs->fs_fattotsec - fs->fs_fatresvdseccount - ntotalfatsects - rootdirsectors;
if (ndatasectors > fs->fs_hwnsectors)
{
fdbg("ERROR: ndatasectors %d fs_hwnsectors: %d\n",
ndatasectors, fs->fs_hwnsectors);
return -EINVAL;
}
/* Get the sectors per cluster */
fs->fs_fatsecperclus = MBR_GETSECPERCLUS(fs->fs_buffer);
/* Calculate the number of clusters */
fs->fs_nclusters = ndatasectors / fs->fs_fatsecperclus;
/* Finally, the test: */
if (fs->fs_nclusters <= FAT_MAXCLUST12)
{
fs->fs_fsinfo = 0;
fs->fs_type = FSTYPE_FAT12;
}
else if (fs->fs_nclusters <= FAT_MAXCLUST16)
{
fs->fs_fsinfo = 0;
fs->fs_type = FSTYPE_FAT16;
}
else if (!notfat32)
{
fs->fs_fsinfo = fs->fs_fatbase + MBR_GETFSINFO(fs->fs_buffer);
fs->fs_type = FSTYPE_FAT32;
}
else
{
fdbg("ERROR: notfat32: %d fs_nclusters: %d\n",
notfat32, fs->fs_nclusters);
return -EINVAL;
}
/* We have what appears to be a valid FAT filesystem! Save a few more things
* from the boot record that we will need later.
*/
fs->fs_fatbase += fs->fs_fatresvdseccount;
if (fs->fs_type == FSTYPE_FAT32)
{
fs->fs_rootbase = MBR_GETROOTCLUS(fs->fs_buffer);
}
else
{
fs->fs_rootbase = fs->fs_fatbase + ntotalfatsects;
}
fs->fs_database = fs->fs_fatbase + ntotalfatsects + fs->fs_rootentcnt / DIRSEC_NDIRS(fs);
fs->fs_fsifreecount = 0xffffffff;
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: fat_getuint16
****************************************************************************/
uint16_t fat_getuint16(uint8_t *ptr)
{
#ifdef CONFIG_ENDIAN_BIG
/* The bytes always have to be swapped if the target is big-endian */
return ((uint16_t)ptr[0] << 8) | ptr[1];
#else
/* Byte-by-byte transfer is still necessary if the address is un-aligned */
return ((uint16_t)ptr[1] << 8) | ptr[0];
#endif
}
/****************************************************************************
* Name: fat_getuint32
****************************************************************************/
uint32_t fat_getuint32(uint8_t *ptr)
{
#ifdef CONFIG_ENDIAN_BIG
/* The bytes always have to be swapped if the target is big-endian */
return ((uint32_t)fat_getuint16(&ptr[0]) << 16) | fat_getuint16(&ptr[2]);
#else
/* Byte-by-byte transfer is still necessary if the address is un-aligned */
return ((uint32_t)fat_getuint16(&ptr[2]) << 16) | fat_getuint16(&ptr[0]);
#endif
}
/****************************************************************************
* Name: fat_putuint16
****************************************************************************/
void fat_putuint16(uint8_t *ptr, uint16_t value16)
{
uint8_t *val = (uint8_t*)&value16;
#ifdef CONFIG_ENDIAN_BIG
/* The bytes always have to be swapped if the target is big-endian */
ptr[0] = val[1];
ptr[1] = val[0];
#else
/* Byte-by-byte transfer is still necessary if the address is un-aligned */
ptr[0] = val[0];
ptr[1] = val[1];
#endif
}
/****************************************************************************
* Name: fat_putuint32
****************************************************************************/
void fat_putuint32(uint8_t *ptr, uint32_t value32)
{
uint16_t *val = (uint16_t*)&value32;
#ifdef CONFIG_ENDIAN_BIG
/* The bytes always have to be swapped if the target is big-endian */
fat_putuint16(&ptr[0], val[2]);
fat_putuint16(&ptr[2], val[0]);
#else
/* Byte-by-byte transfer is still necessary if the address is un-aligned */
fat_putuint16(&ptr[0], val[0]);
fat_putuint16(&ptr[2], val[2]);
#endif
}
/****************************************************************************
* Name: fat_semtake
****************************************************************************/
void fat_semtake(struct fat_mountpt_s *fs)
{
/* Take the semaphore (perhaps waiting) */
while (sem_wait(&fs->fs_sem) != 0)
{
/* The only case that an error should occur here is if
* the wait was awakened by a signal.
*/
ASSERT(*get_errno_ptr() == EINTR);
}
}
/****************************************************************************
* Name: fat_semgive
****************************************************************************/
void fat_semgive(struct fat_mountpt_s *fs)
{
sem_post(&fs->fs_sem);
}
/****************************************************************************
* Name: fat_systime2fattime
*
* Desciption: Get the system time convert to a time and and date suitble
* for writing into the FAT FS.
*
* TIME in LS 16-bits:
* Bits 0:4 = 2 second count (0-29 representing 0-58 seconds)
* Bits 5-10 = minutes (0-59)
* Bits 11-15 = hours (0-23)
* DATE in MS 16-bits
* Bits 0:4 = Day of month (1-31)
* Bits 5:8 = Month of year (1-12)
* Bits 9:15 = Year from 1980 (0-127 representing 1980-2107)
*
****************************************************************************/
uint32_t fat_systime2fattime(void)
{
/* Unless you have a hardware RTC or some other to get accurate time, then
* there is no reason to support FAT time.
*/
#ifdef CONFIG_FS_FATTIME
struct timespec ts;
struct tm tm;
int ret;
/* Get the current time in seconds and nanoseconds */
ret = clock_gettime(CLOCK_REALTIME, &ts);
if (ret == OK)
{
/* Break done the seconds in date and time units */
if (gmtime_r((FAR const time_t *)&ts.tv_sec, &tm) != NULL)
{
/* FAT can only represent dates since 1980. struct tm can
* represent dates since 1900.
*/
if (tm.tm_year >= 80)
{
uint16_t fattime;
uint16_t fatdate;
fattime = (tm.tm_sec >> 1) & 0x001f; /* Bits 0-4: 2 second count (0-29) */
fattime |= (tm.tm_min << 5) & 0x07e0; /* Bits 5-10: minutes (0-59) */
fattime |= (tm.tm_hour << 11) & 0xf800; /* Bits 11-15: hours (0-23) */
fatdate = tm.tm_mday & 0x001f; /* Bits 0-4: Day of month (1-31) */
fatdate |= ((tm.tm_mon+1) << 5) & 0x01e0; /* Bits 5-8: Month of year (1-12) */
fatdate |= ((tm.tm_year-80) << 9) & 0xfe00; /* Bits 9-15: Year from 1980 */
return (uint32_t)fatdate << 16 | (uint32_t)fattime;
}
}
}
#endif
return 0;
}
/****************************************************************************
* Name: fat_fattime2systime
*
* Desciption: Convert FAT data and time to a system time_t
*
* 16-bit FAT time:
* Bits 0:4 = 2 second count (0-29 representing 0-58 seconds)
* Bits 5-10 = minutes (0-59)
* Bits 11-15 = hours (0-23)
* 16-bit FAT date:
* Bits 0:4 = Day of month (1-31)
* Bits 5:8 = Month of year (1-12)
* Bits 9:15 = Year from 1980 (0-127 representing 1980-2107)
*
****************************************************************************/
time_t fat_fattime2systime(uint16_t fattime, uint16_t fatdate)
{
/* Unless you have a hardware RTC or some other to get accurate time, then
* there is no reason to support FAT time.
*/
#ifdef CONFIG_FS_FATTIME
struct tm tm;
unsigned int tmp;
/* Break out the date and time */
tm.tm_sec = (fattime & 0x001f) << 1; /* Bits 0-4: 2 second count (0-29) */
tm.tm_min = (fattime & 0x07e0) >> 5; /* Bits 5-10: minutes (0-59) */
tm.tm_hour = (fattime & 0xf800) >> 11; /* Bits 11-15: hours (0-23) */
tm.tm_mday = (fatdate & 0x001f); /* Bits 0-4: Day of month (1-31) */
tmp = ((fatdate & 0x01e0) >> 5); /* Bits 5-8: Month of year (1-12) */
tm.tm_mon = tmp > 0 ? tmp-1 : 0;
tm.tm_year = ((fatdate & 0xfe00) >> 9) + 80; /* Bits 9-15: Year from 1980 */
/* Then convert the broken out time into seconds since the epoch */
return mktime(&tm);
#else
return 0;
#endif
}
/****************************************************************************
* Name: fat_mount
*
* Desciption: This function is called only when the mountpoint is first
* established. It initializes the mountpoint structure and verifies
* that a valid FAT32 filesystem is provided by the block driver.
*
* The caller should hold the mountpoint semaphore
*
****************************************************************************/
int fat_mount(struct fat_mountpt_s *fs, bool writeable)
{
FAR struct inode *inode;
struct geometry geo;
int ret;
/* Assume that the mount is successful */
fs->fs_mounted = true;
/* Check if there is media available */
inode = fs->fs_blkdriver;
if (!inode || !inode->u.i_bops || !inode->u.i_bops->geometry ||
inode->u.i_bops->geometry(inode, &geo) != OK || !geo.geo_available)
{
ret = -ENODEV;
goto errout;
}
/* Make sure that that the media is write-able (if write access is needed) */
if (writeable && !geo.geo_writeenabled)
{
ret = -EACCES;
goto errout;
}
/* Save the hardware geometry */
fs->fs_hwsectorsize = geo.geo_sectorsize;
fs->fs_hwnsectors = geo.geo_nsectors;
/* Allocate a buffer to hold one hardware sector */
fs->fs_buffer = (uint8_t*)kmalloc(fs->fs_hwsectorsize);
if (!fs->fs_buffer)
{
ret = -ENOMEM;
goto errout;
}
/* Search FAT boot record on the drive. First check at sector zero. This
* could be either the boot record or a partition that refers to the boot
* record.
*
* First read sector zero. This will be the first access to the drive and a
* likely failure point.
*/
fs->fs_fatbase = 0;
ret = fat_hwread(fs, fs->fs_buffer, 0, 1);
if (ret < 0)
{
goto errout_with_buffer;
}
ret = fat_checkbootrecord(fs);
if (ret != OK)
{
/* The contents of sector 0 is not a boot record. It could be a
* partition, however. Assume it is a partition and get the offset
* into the partition table. This table is at offset MBR_TABLE and is
* indexed by 16x the partition number.
*/
int i;
for (i = 0; i < 4; i++)
{
/* Check if the partition exists and, if so, get the bootsector for that
* partition and see if we can find the boot record there.
*/
uint8_t part = PART_GETTYPE(i, fs->fs_buffer);
fvdbg("Partition %d, offset %d, type %d\n", i, PART_ENTRY(i), part);
if (part == 0)
{
fvdbg("No partition %d\n", i);
continue;
}
/* There appears to be a partition, get the sector number of the
* partition (LBA)
*/
fs->fs_fatbase = PART_GETSTARTSECTOR(i, fs->fs_buffer);
/* Read the new candidate boot sector */
ret = fat_hwread(fs, fs->fs_buffer, fs->fs_fatbase, 1);
if (ret < 0)
{
/* Failed to read the sector */
goto errout_with_buffer;
}
/* Check if this is a boot record */
ret = fat_checkbootrecord(fs);
if (ret == OK)
{
/* Break out of the loop if a valid boot record is found */
fvdbg("MBR found in partition %d\n", i);
break;
}
/* Re-read sector 0 so that we can check the next partition */
fvdbg("Partition %d is not an MBR\n", i);
ret = fat_hwread(fs, fs->fs_buffer, 0, 1);
if (ret < 0)
{
goto errout_with_buffer;
}
}
if (i > 3)
{
fdbg("No valid MBR\n");
goto errout_with_buffer;
}
}
/* We have what appears to be a valid FAT filesystem! Now read the
* FSINFO sector (FAT32 only)
*/
if (fs->fs_type == FSTYPE_FAT32)
{
ret = fat_checkfsinfo(fs);
if (ret != OK)
{
goto errout_with_buffer;
}
}
/* We did it! */
fdbg("FAT%d:\n", fs->fs_type == 0 ? 12 : fs->fs_type == 1 ? 16 : 32);
fdbg("\tHW sector size: %d\n", fs->fs_hwsectorsize);
fdbg("\t sectors: %d\n", fs->fs_hwnsectors);
fdbg("\tFAT reserved: %d\n", fs->fs_fatresvdseccount);
fdbg("\t sectors: %d\n", fs->fs_fattotsec);
fdbg("\t start sector: %d\n", fs->fs_fatbase);
fdbg("\t root sector: %d\n", fs->fs_rootbase);
fdbg("\t root entries: %d\n", fs->fs_rootentcnt);
fdbg("\t data sector: %d\n", fs->fs_database);
fdbg("\t FSINFO sector: %d\n", fs->fs_fsinfo);
fdbg("\t Num FATs: %d\n", fs->fs_fatnumfats);
fdbg("\t FAT sectors: %d\n", fs->fs_nfatsects);
fdbg("\t sectors/cluster: %d\n", fs->fs_fatsecperclus);
fdbg("\t max clusters: %d\n", fs->fs_nclusters);
fdbg("\tFSI free count %d\n", fs->fs_fsifreecount);
fdbg("\t next free %d\n", fs->fs_fsinextfree);
return OK;
errout_with_buffer:
kfree(fs->fs_buffer);
fs->fs_buffer = 0;
errout:
fs->fs_mounted = false;
return ret;
}
/****************************************************************************
* Name: fat_checkmount
*
* Desciption: Check if the mountpoint is still valid.
*
* The caller should hold the mountpoint semaphore
*
****************************************************************************/
int fat_checkmount(struct fat_mountpt_s *fs)
{
/* If the fs_mounted flag is false, then we have already handled the loss
* of the mount.
*/
if (fs && fs->fs_mounted)
{
struct fat_file_s *file;
/* We still think the mount is healthy. Check an see if this is
* still the case
*/
if (fs->fs_blkdriver)
{
struct inode *inode = fs->fs_blkdriver;
if (inode && inode->u.i_bops && inode->u.i_bops->geometry)
{
struct geometry geo;
int errcode = inode->u.i_bops->geometry(inode, &geo);
if (errcode == OK && geo.geo_available && !geo.geo_mediachanged)
{
return OK;
}
}
}
/* If we get here, the mount is NOT healthy */
fs->fs_mounted = false;
/* Make sure that this is flagged in every opened file */
for (file = fs->fs_head; file; file = file->ff_next)
{
file->ff_open = false;
}
}
return -ENODEV;
}
/****************************************************************************
* Name: fat_hwread
*
* Desciption: Read the specified sector into the sector buffer
*
****************************************************************************/
int fat_hwread(struct fat_mountpt_s *fs, uint8_t *buffer, off_t sector,
unsigned int nsectors)
{
int ret = -ENODEV;
if (fs && fs->fs_blkdriver )
{
struct inode *inode = fs->fs_blkdriver;
if (inode && inode->u.i_bops && inode->u.i_bops->read)
{
ssize_t nSectorsRead = inode->u.i_bops->read(inode, buffer,
sector, nsectors);
if (nSectorsRead == nsectors)
{
ret = OK;
}
else if (nSectorsRead < 0)
{
ret = nSectorsRead;
}
}
}
return ret;
}
/****************************************************************************
* Name: fat_hwwrite
*
* Desciption: Write the sector buffer to the specified sector
*
****************************************************************************/
int fat_hwwrite(struct fat_mountpt_s *fs, uint8_t *buffer, off_t sector,
unsigned int nsectors)
{
int ret = -ENODEV;
if (fs && fs->fs_blkdriver )
{
struct inode *inode = fs->fs_blkdriver;
if (inode && inode->u.i_bops && inode->u.i_bops->write)
{
ssize_t nSectorsWritten =
inode->u.i_bops->write(inode, buffer, sector, nsectors);
if (nSectorsWritten == nsectors)
{
ret = OK;
}
else if (nSectorsWritten < 0)
{
ret = nSectorsWritten;
}
}
}
return ret;
}
/****************************************************************************
* Name: fat_cluster2sector
*
* Desciption: Convert a cluster number to a start sector number
*
****************************************************************************/
off_t fat_cluster2sector(struct fat_mountpt_s *fs, uint32_t cluster )
{
cluster -= 2;
if (cluster >= fs->fs_nclusters - 2)
{
return -EINVAL;
}
return cluster * fs->fs_fatsecperclus + fs->fs_database;
}
/****************************************************************************
* Name: fat_getcluster
*
* Desciption: Get the next cluster start from the FAT.
*
* Return: <0: error, 0:cluster unassigned, >=0: start sector of cluster
*
****************************************************************************/
off_t fat_getcluster(struct fat_mountpt_s *fs, uint32_t clusterno)
{
/* Verify that the cluster number is within range */
if (clusterno >= 2 && clusterno < fs->fs_nclusters)
{
/* Okay.. Read the next cluster from the FAT. The way we will do
* this depends on the type of FAT filesystm we are dealing with.
*/
switch (fs->fs_type)
{
case FSTYPE_FAT12 :
{
off_t fatsector;
unsigned int fatoffset;
unsigned int cluster;
unsigned int fatindex;
/* FAT12 is more complex because it has 12-bits (1.5 bytes)
* per FAT entry. Get the offset to the first byte:
*/
fatoffset = (clusterno * 3) / 2;
fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
/* Read the sector at this offset */
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
/* Get the first, LS byte of the cluster from the FAT */
fatindex = fatoffset & SEC_NDXMASK(fs);
cluster = fs->fs_buffer[fatindex];
/* With FAT12, the second byte of the cluster number may lie in
* a different sector than the first byte.
*/
fatindex++;
if (fatindex >= fs->fs_hwsectorsize)
{
fatsector++;
fatindex = 0;
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
}
/* Get the second, MS byte of the cluster for 16-bits. The
* does not depend on the endian-ness of the target, but only
* on the fact that the byte stream is little-endian.
*/
cluster |= (unsigned int)fs->fs_buffer[fatindex] << 8;
/* Now, pick out the correct 12 bit cluster start sector value */
if ((clusterno & 1) != 0)
{
/* Odd.. take the MS 12-bits */
cluster >>= 4;
}
else
{
/* Even.. take the LS 12-bits */
cluster &= 0x0fff;
}
return cluster;
}
case FSTYPE_FAT16 :
{
unsigned int fatoffset = 2 * clusterno;
off_t fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
unsigned int fatindex = fatoffset & SEC_NDXMASK(fs);
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
return FAT_GETFAT16(fs->fs_buffer, fatindex);
}
case FSTYPE_FAT32 :
{
unsigned int fatoffset = 4 * clusterno;
off_t fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
unsigned int fatindex = fatoffset & SEC_NDXMASK(fs);
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
return FAT_GETFAT32(fs->fs_buffer, fatindex) & 0x0fffffff;
}
default:
break;
}
}
/* There is no cluster information, or an error occured */
return (off_t)-EINVAL;
}
/****************************************************************************
* Name: fat_putcluster
*
* Desciption: Write a new cluster into the FAT
*
****************************************************************************/
int fat_putcluster(struct fat_mountpt_s *fs, uint32_t clusterno, off_t nextcluster)
{
/* Verify that the cluster number is within range. Zero erases the cluster. */
if (clusterno == 0 || (clusterno >= 2 && clusterno < fs->fs_nclusters))
{
/* Okay.. Write the next cluster into the FAT. The way we will do
* this depends on the type of FAT filesystm we are dealing with.
*/
switch (fs->fs_type)
{
case FSTYPE_FAT12 :
{
off_t fatsector;
unsigned int fatoffset;
unsigned int fatindex;
uint8_t value;
/* FAT12 is more complex because it has 12-bits (1.5 bytes)
* per FAT entry. Get the offset to the first byte:
*/
fatoffset = (clusterno * 3) / 2;
fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
/* Make sure that the sector at this offset is in the cache */
if (fat_fscacheread(fs, fatsector)< 0)
{
/* Read error */
break;
}
/* Get the LS byte first handling the 12-bit alignment within
* the 16-bits
*/
fatindex = fatoffset & SEC_NDXMASK(fs);
if ((clusterno & 1) != 0)
{
/* Save the LS four bits of the next cluster */
value = (fs->fs_buffer[fatindex] & 0x0f) | nextcluster << 4;
}
else
{
/* Save the LS eight bits of the next cluster */
value = (uint8_t)nextcluster;
}
fs->fs_buffer[fatindex] = value;
/* With FAT12, the second byte of the cluster number may lie in
* a different sector than the first byte.
*/
fatindex++;
if (fatindex >= fs->fs_hwsectorsize)
{
/* Read the next sector */
fatsector++;
fatindex = 0;
/* Set the dirty flag to make sure the sector that we
* just modified is written out.
*/
fs->fs_dirty = true;
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
}
/* Output the MS byte first handling the 12-bit alignment within
* the 16-bits
*/
if ((clusterno & 1) != 0)
{
/* Save the MS eight bits of the next cluster */
value = (uint8_t)(nextcluster >> 4);
}
else
{
/* Save the MS four bits of the next cluster */
value = (fs->fs_buffer[fatindex] & 0xf0) | ((nextcluster >> 8) & 0x0f);
}
fs->fs_buffer[fatindex] = value;
}
break;
case FSTYPE_FAT16 :
{
unsigned int fatoffset = 2 * clusterno;
off_t fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
unsigned int fatindex = fatoffset & SEC_NDXMASK(fs);
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
FAT_PUTFAT16(fs->fs_buffer, fatindex, nextcluster & 0xffff);
}
break;
case FSTYPE_FAT32 :
{
unsigned int fatoffset = 4 * clusterno;
off_t fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
unsigned int fatindex = fatoffset & SEC_NDXMASK(fs);
if (fat_fscacheread(fs, fatsector) < 0)
{
/* Read error */
break;
}
FAT_PUTFAT32(fs->fs_buffer, fatindex, nextcluster & 0x0fffffff);
}
break;
default:
return -EINVAL;
}
/* Mark the modified sector as "dirty" and return success */
fs->fs_dirty = true;
return OK;
}
return -EINVAL;
}
/****************************************************************************
* Name: fat_removechain
*
* Desciption: Remove an entire chain of clusters, starting with 'cluster'
*
****************************************************************************/
int fat_removechain(struct fat_mountpt_s *fs, uint32_t cluster)
{
int32_t nextcluster;
int ret;
/* Loop while there are clusters in the chain */
while (cluster >= 2 && cluster < fs->fs_nclusters)
{
/* Get the next cluster after the current one */
nextcluster = fat_getcluster(fs, cluster);
if (nextcluster < 0)
{
/* Error! */
return nextcluster;
}
/* Then nullify current cluster -- removing it from the chain */
ret = fat_putcluster(fs, cluster, 0);
if (ret < 0)
{
return ret;
}
/* Update FSINFINFO data */
if (fs->fs_fsifreecount != 0xffffffff)
{
fs->fs_fsifreecount++;
fs->fs_fsidirty = 1;
}
/* Then set up to remove the next cluster */
cluster = nextcluster;
}
return OK;
}
/****************************************************************************
* Name: fat_extendchain
*
* Desciption: Add a new cluster to the chain following cluster (if cluster
* is non-NULL). if cluster is zero, then a new chain is created.
*
* Return: <0:error, 0: no free cluster, >=2: new cluster number
*
****************************************************************************/
int32_t fat_extendchain(struct fat_mountpt_s *fs, uint32_t cluster)
{
off_t startsector;
uint32_t newcluster;
uint32_t startcluster;
int ret;
/* The special value 0 is used when the new chain should start */
if (cluster == 0)
{
/* The FSINFO NextFree entry should be a good starting point
* in the search for a new cluster
*/
startcluster = fs->fs_fsinextfree;
if (startcluster == 0 || startcluster >= fs->fs_nclusters)
{
/* But it is bad.. we have to start at the beginning */
startcluster = 1;
}
}
else
{
/* We are extending an existing chain. Verify that this
* is a valid cluster by examining its start sector.
*/
startsector = fat_getcluster(fs, cluster);
if (startsector < 0)
{
/* An error occurred, return the error value */
return startsector;
}
else if (startsector < 2)
{
/* Oops.. this cluster does not exist. */
return 0;
}
else if (startsector < fs->fs_nclusters)
{
/* It is already followed by next cluster */
return startsector;
}
/* Okay.. it checks out */
startcluster = cluster;
}
/* Loop until (1) we discover that there are not free clusters
* (return 0), an errors occurs (return -errno), or (3) we find
* the next cluster (return the new cluster number).
*/
newcluster = startcluster;
for (;;)
{
/* Examine the next cluster in the FAT */
newcluster++;
if (newcluster >= fs->fs_nclusters)
{
/* If we hit the end of the available clusters, then
* wrap back to the beginning because we might have
* started at a non-optimal place. But don't continue
* past the start cluster.
*/
newcluster = 2;
if (newcluster > startcluster)
{
/* We are back past the starting cluster, then there
* is no free cluster.
*/
return 0;
}
}
/* We have a candidate cluster. Check if the cluster number is
* mapped to a group of sectors.
*/
startsector = fat_getcluster(fs, newcluster);
if (startsector == 0)
{
/* Found have found a free cluster break out*/
break;
}
else if (startsector < 0)
{
/* Some error occurred, return the error number */
return startsector;
}
/* We wrap all the back to the starting cluster? If so, then
* there are no free clusters.
*/
if (newcluster == startcluster)
{
return 0;
}
}
/* We get here only if we break out with an available cluster
* number in 'newcluster' Now mark that cluster as in-use.
*/
ret = fat_putcluster(fs, newcluster, 0x0fffffff);
if (ret < 0)
{
/* An error occurred */
return ret;
}
/* And link if to the start cluster (if any)*/
if (cluster)
{
/* There is a start cluster -- link it */
ret = fat_putcluster(fs, cluster, newcluster);
if (ret < 0)
{
return ret;
}
}
/* And update the FINSINFO for the next time we have to search */
fs->fs_fsinextfree = newcluster;
if (fs->fs_fsifreecount != 0xffffffff)
{
fs->fs_fsifreecount--;
fs->fs_fsidirty = 1;
}
/* Return then number of the new cluster that was added to the chain */
return newcluster;
}
/****************************************************************************
* Name: fat_nextdirentry
*
* Desciption: Read the next directory entry from the sector in cache,
* reading the next sector(s) in the cluster as necessary. This function
* must return -ENOSPC if if fails because there are no further entries
* available in the directory.
*
****************************************************************************/
int fat_nextdirentry(struct fat_mountpt_s *fs, struct fs_fatdir_s *dir)
{
unsigned int cluster;
unsigned int ndx;
/* Increment the index to the next 32-byte directory entry */
ndx = dir->fd_index + 1;
/* Check if all of the directory entries in this sectory have
* been examined.
*/
if ((ndx & (DIRSEC_NDIRS(fs)-1)) == 0)
{
/* Yes, then we will have to read the next sector */
dir->fd_currsector++;
/* For FAT12/16, the root directory is a group of sectors relative
* to the first sector of the fat volume.
*/
if (!dir->fd_currcluster)
{
/* For FAT12/16, the boot record tells us number of 32-bit directories
* that are contained in the root directory. This should correspond to
* an even number of sectors.
*/
if (ndx >= fs->fs_rootentcnt)
{
/* When we index past this count, we have examined all of the entries in
* the root directory.
*/
return -ENOSPC;
}
}
else
{
/* Not a FAT12/16 root directory, check if we have examined the entire
* cluster comprising the directory.
*
* The current sector within the cluster is the entry number divided
* byte the number of entries per sector
*/
int sector = ndx / DIRSEC_NDIRS(fs);
/* We are finished with the cluster when the last sector of the cluster
* has been examined.
*/
if ((sector & (fs->fs_fatsecperclus-1)) == 0)
{
/* Get next cluster */
cluster = fat_getcluster(fs, dir->fd_currcluster);
/* Check if a valid cluster was obtained. */
if (cluster < 2 || cluster >= fs->fs_nclusters)
{
/* No, we have probably reached the end of the cluster list */
return -ENOSPC;
}
/* Initialize for new cluster */
dir->fd_currcluster = cluster;
dir->fd_currsector = fat_cluster2sector(fs, cluster);
}
}
}
/* Save the new index into dir->fd_currsector */
dir->fd_index = ndx;
return OK;
}
/****************************************************************************
* Name: fat_dirtruncate
*
* Desciption: Truncate an existing file to zero length
*
* Assumptions: The caller holds mountpoint semaphore, fs_buffer holds
* the directory entry, the directory entry sector (fd_sector) is
* currently in the sector cache.
*
****************************************************************************/
int fat_dirtruncate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
{
unsigned int startcluster;
uint32_t writetime;
uint8_t *direntry;
off_t savesector;
int ret;
/* Get start cluster of the file to truncate */
direntry = &fs->fs_buffer[dirinfo->fd_seq.ds_offset];
startcluster =
((uint32_t)DIR_GETFSTCLUSTHI(direntry) << 16) |
DIR_GETFSTCLUSTLO(direntry);
/* Clear the cluster start value in the directory and set the file size
* to zero. This makes the file look empty but also have to dispose of
* all of the clusters in the chain.
*/
DIR_PUTFSTCLUSTHI(direntry, 0);
DIR_PUTFSTCLUSTLO(direntry, 0);
DIR_PUTFILESIZE(direntry, 0);
/* Set the ARCHIVE attribute and update the write time */
DIR_PUTATTRIBUTES(direntry, FATATTR_ARCHIVE);
writetime = fat_systime2fattime();
DIR_PUTWRTTIME(direntry, writetime & 0xffff);
DIR_PUTWRTDATE(direntry, writetime > 16);
/* This sector needs to be written back to disk eventually */
fs->fs_dirty = true;
/* Now remove the entire cluster chain comprising the file */
savesector = fs->fs_currentsector;
ret = fat_removechain(fs, startcluster);
if (ret < 0)
{
return ret;
}
/* Setup FSINFO to resuse this cluster next */
fs->fs_fsinextfree = startcluster - 1;
/* Make sure that the directory is still in the cache */
return fat_fscacheread(fs, savesector);
}
/****************************************************************************
* Name: fat_fscacheflush
*
* Desciption: Flush any dirty sector if fs_buffer as necessary
*
****************************************************************************/
int fat_fscacheflush(struct fat_mountpt_s *fs)
{
int ret;
/* Check if the fs_buffer is dirty. In this case, we will write back the
* contents of fs_buffer.
*/
if (fs->fs_dirty)
{
/* Write the dirty sector */
ret = fat_hwwrite(fs, fs->fs_buffer, fs->fs_currentsector, 1);
if (ret < 0)
{
return ret;
}
/* Does the sector lie in the FAT region? */
if (fs->fs_currentsector >= fs->fs_fatbase &&
fs->fs_currentsector < fs->fs_fatbase + fs->fs_nfatsects)
{
/* Yes, then make the change in the FAT copy as well */
int i;
for (i = fs->fs_fatnumfats; i >= 2; i--)
{
fs->fs_currentsector += fs->fs_nfatsects;
ret = fat_hwwrite(fs, fs->fs_buffer, fs->fs_currentsector, 1);
if (ret < 0)
{
return ret;
}
}
}
/* No longer dirty */
fs->fs_dirty = false;
}
return OK;
}
/****************************************************************************
* Name: fat_fscacheread
*
* Desciption: Read the specified sector into the sector cache, flushing any
* existing dirty sectors as necessary.
*
****************************************************************************/
int fat_fscacheread(struct fat_mountpt_s *fs, off_t sector)
{
int ret;
/* fs->fs_currentsector holds the current sector that is buffered in
* fs->fs_buffer. If the requested sector is the same as this sector, then
* we do nothing. Otherwise, we will have to read the new sector.
*/
if (fs->fs_currentsector != sector)
{
/* We will need to read the new sector. First, flush the cached
* sector if it is dirty.
*/
ret = fat_fscacheflush(fs);
if (ret < 0)
{
return ret;
}
/* Then read the specified sector into the cache */
ret = fat_hwread(fs, fs->fs_buffer, sector, 1);
if (ret < 0)
{
return ret;
}
/* Update the cached sector number */
fs->fs_currentsector = sector;
}
return OK;
}
/****************************************************************************
* Name: fat_ffcacheflush
*
* Desciption: Flush any dirty sectors as necessary
*
****************************************************************************/
int fat_ffcacheflush(struct fat_mountpt_s *fs, struct fat_file_s *ff)
{
int ret;
/* Check if the ff_buffer is dirty. In this case, we will write back the
* contents of ff_buffer.
*/
if (ff->ff_cachesector &&
ff->ff_bflags && (FFBUFF_DIRTY|FFBUFF_VALID) == (FFBUFF_DIRTY|FFBUFF_VALID))
{
/* Write the dirty sector */
ret = fat_hwwrite(fs, ff->ff_buffer, ff->ff_cachesector, 1);
if (ret < 0)
{
return ret;
}
/* No longer dirty, but still valid */
ff->ff_bflags &= ~FFBUFF_DIRTY;
}
return OK;
}
/****************************************************************************
* Name: fat_ffcacheread
*
* Desciption: Read the specified sector into the sector cache, flushing any
* existing dirty sectors as necessary.
*
****************************************************************************/
int fat_ffcacheread(struct fat_mountpt_s *fs, struct fat_file_s *ff, off_t sector)
{
int ret;
/* ff->ff_cachesector holds the current sector that is buffered in
* ff->ff_buffer. If the requested sector is the same as this sector, then
* we do nothing. Otherwise, we will have to read the new sector.
*/
if (ff->ff_cachesector != sector || (ff->ff_bflags & FFBUFF_VALID) == 0)
{
/* We will need to read the new sector. First, flush the cached
* sector if it is dirty.
*/
ret = fat_ffcacheflush(fs, ff);
if (ret < 0)
{
return ret;
}
/* Then read the specified sector into the cache */
ret = fat_hwread(fs, ff->ff_buffer, sector, 1);
if (ret < 0)
{
return ret;
}
/* Update the cached sector number */
ff->ff_cachesector = sector;
ff->ff_bflags |= FFBUFF_VALID;
}
return OK;
}
/****************************************************************************
* Name: fat_ffcacheread
*
* Desciption: Invalidate the current file buffer contents
*
****************************************************************************/
int fat_ffcacheinvalidate(struct fat_mountpt_s *fs, struct fat_file_s *ff)
{
int ret;
/* Is there anything valid in the buffer now? */
if ((ff->ff_bflags & FFBUFF_VALID) != 0)
{
/* We will invalidate the buffered sector */
ret = fat_ffcacheflush(fs, ff);
if (ret < 0)
{
return ret;
}
/* Then discard the current cache contents */
ff->ff_bflags &= ~FFBUFF_VALID;
ff->ff_cachesector = 0;
}
return OK;
}
/****************************************************************************
* Name: fat_updatefsinfo
*
* Desciption: Flush evertyhing buffered for the mountpoint and update
* the FSINFO sector, if appropriate
*
****************************************************************************/
int fat_updatefsinfo(struct fat_mountpt_s *fs)
{
int ret;
/* Flush the fs_buffer if it is dirty */
ret = fat_fscacheflush(fs);
if (ret == OK)
{
/* The FSINFO sector only has to be update for the case of a FAT32 file
* system. Check if the file system type.. If this is a FAT32 file
* system then the fs_fsidirty flag will indicate if the FSINFO sector
* needs to be re-written.
*/
if (fs->fs_type == FSTYPE_FAT32 && fs->fs_fsidirty)
{
/* Create an image of the FSINFO sector in the fs_buffer */
memset(fs->fs_buffer, 0, fs->fs_hwsectorsize);
FSI_PUTLEADSIG(fs->fs_buffer, 0x41615252);
FSI_PUTSTRUCTSIG(fs->fs_buffer, 0x61417272);
FSI_PUTFREECOUNT(fs->fs_buffer, fs->fs_fsifreecount);
FSI_PUTNXTFREE(fs->fs_buffer, fs->fs_fsinextfree);
FSI_PUTTRAILSIG(fs->fs_buffer, BOOT_SIGNATURE32);
/* Then flush this to disk */
fs->fs_currentsector = fs->fs_fsinfo;
fs->fs_dirty = true;
ret = fat_fscacheflush(fs);
/* No longer dirty */
fs->fs_fsidirty = false;
}
}
return ret;
}
/****************************************************************************
* Name: fat_nfreeclusters
*
* Desciption: Get the number of free clusters
*
****************************************************************************/
int fat_nfreeclusters(struct fat_mountpt_s *fs, off_t *pfreeclusters)
{
uint32_t nfreeclusters;
/* If number of the first free cluster is valid, then just return that value. */
if (fs->fs_fsifreecount <= fs->fs_nclusters - 2)
{
*pfreeclusters = fs->fs_fsifreecount;
return OK;
}
/* Otherwise, we will have to count the number of free clusters */
nfreeclusters = 0;
if (fs->fs_type == FSTYPE_FAT12)
{
off_t sector;
/* Examine every cluster in the fat */
for (sector = 2; sector < fs->fs_nclusters; sector++)
{
/* If the cluster is unassigned, then increment the count of free clusters */
if ((uint16_t)fat_getcluster(fs, sector) == 0)
{
nfreeclusters++;
}
}
}
else
{
unsigned int cluster;
off_t fatsector;
unsigned int offset;
int ret;
fatsector = fs->fs_fatbase;
offset = fs->fs_hwsectorsize;
/* Examine each cluster in the fat */
for (cluster = fs->fs_nclusters; cluster > 0; cluster--)
{
/* If we are starting a new sector, then read the new sector in fs_buffer */
if (offset >= fs->fs_hwsectorsize)
{
ret = fat_fscacheread(fs, fatsector++);
if (ret < 0)
{
return ret;
}
/* Reset the offset to the next FAT entry.
* Increment the sector number to read next time around.
*/
offset = 0;
fatsector++;
}
/* FAT16 and FAT32 differ only on the size of each cluster start
* sector number in the FAT.
*/
if (fs->fs_type == FSTYPE_FAT16)
{
if (FAT_GETFAT16(fs->fs_buffer, offset) == 0)
{
nfreeclusters++;
}
offset += 2;
}
else
{
if (FAT_GETFAT32(fs->fs_buffer, offset) == 0)
{
nfreeclusters++;
}
offset += 4;
}
}
}
fs->fs_fsifreecount = nfreeclusters;
if (fs->fs_type == FSTYPE_FAT32)
{
fs->fs_fsidirty = true;
}
*pfreeclusters = nfreeclusters;
return OK;
}
/****************************************************************************
* Name: fat_nfreeclusters
*
* Desciption:
* Given the file position, set the correct current sector to access.
*
****************************************************************************/
int fat_currentsector(struct fat_mountpt_s *fs, struct fat_file_s *ff,
off_t position)
{
int sectoroffset;
if (position <= ff->ff_size )
{
/* sectoroffset is the sector number offset into the current cluster */
sectoroffset = SEC_NSECTORS(fs, position) & CLUS_NDXMASK(fs);
/* The current cluster is the first sector of the cluster plus
* the sector offset
*/
ff->ff_currentsector = fat_cluster2sector(fs, ff->ff_currentcluster)
+ sectoroffset;
/* The remainder is the number of sectors left in the cluster to be
* read/written
*/
ff->ff_sectorsincluster = fs->fs_fatsecperclus - sectoroffset;
fvdbg("position=%d currentsector=%d sectorsincluster=%d\n",
position, ff->ff_currentsector, ff->ff_sectorsincluster);
return OK;
}
/* The position does not lie within the file */
return -ENOSPC;
}
View Git Blame Copy Permalink