sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
8bee2e2fe0
nuttx-apps/fsutils/mkfatfs/writefat.c
Xiang Xiao a29d9ea9da fsutils/examples: Include unistd.h explicitly 
to get the prototypes or macros are defined in it

Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
2023-02-05 08:46:59 +02:00

653 lines
18 KiB
C
Raw Blame History

/****************************************************************************
* apps/fsutils/mkfatfs/writefat.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <inttypes.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <debug.h>
#include <unistd.h>
#include <nuttx/fs/fat.h>
#include "fsutils/mkfatfs.h"
#include "fat32.h"
#include "mkfatfs.h"
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: mkfatfs_devwrite
*
* Description:
* Write the content of the dedicate sector buffer beginning to the
* specified sector
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
*
* Return:
* None; caller is responsible for providing valid parameters.
*
****************************************************************************/
static int mkfatfs_devwrite(FAR const struct fat_format_s *fmt,
FAR const struct fat_var_s *var, off_t sector)
{
ssize_t nwritten;
off_t seekpos;
off_t fpos;
int ret;
/* Convert the sector number to a byte offset */
if (sector < 0 || sector >= (off_t)fmt->ff_nsectors)
{
ferr("sector out of range: %ju\n", (intmax_t)sector);
return -ESPIPE;
}
fpos = sector << var->fv_sectshift;
/* Seek to that offset */
seekpos = lseek(var->fv_fd, fpos, SEEK_SET);
if (seekpos == (off_t)-1)
{
ret = -errno;
ferr("ERROR: lseek to %jd failed: %d\n", (intmax_t)fpos, ret);
return ret;
}
else if (seekpos != fpos)
{
ferr("ERROR: lseek failed: %ju vs %ju\n",
(intmax_t)seekpos, (intmax_t)fpos);
return -EINVAL;
}
/* Write the sector to that offset. Partial writes are not expected. */
nwritten = write(var->fv_fd, var->fv_sect, var->fv_sectorsize);
if (nwritten < 0)
{
ret = -errno;
ferr("ERROR: write failed: size=%" PRIu32 " pos=%jd error=%d\n",
var->fv_sectorsize, (intmax_t)fpos, ret);
return ret;
}
else if (nwritten != (ssize_t)var->fv_sectorsize)
{
ferr("ERROR: Partial write: size=%" PRIu32 " written=%zd\n",
var->fv_sectorsize, nwritten);
return -ENODATA;
}
return OK;
}
/****************************************************************************
* Name: mkfatfs_initmbr
*
* Description:
* Initialize the sector image of a masterbood record
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
*
* Return:
* None; caller is responsible for providing valid parameters.
*
****************************************************************************/
static inline void mkfatfs_initmbr(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var)
{
memset(var->fv_sect, 0, var->fv_sectorsize);
/* 3@0: Jump instruction to boot code */
memcpy(&var->fv_sect[MBR_JUMP], var->fv_jump, 3);
/* 8@3: Usually "MSWIN4.1" */
strcpy((FAR char *)&var->fv_sect[MBR_OEMNAME], "NUTTX ");
/* 2@11: Bytes per sector: 512, 1024, 2048, 4096 */
MBR_PUTBYTESPERSEC(var->fv_sect, var->fv_sectorsize);
/* 1@13: Sectors per allocation unit: 2**n, n=0..7 */
MBR_PUTSECPERCLUS(var->fv_sect, (1 << fmt->ff_clustshift));
/* 2@14: Reserved sector count: Usually 32 */
MBR_PUTRESVDSECCOUNT(var->fv_sect, fmt->ff_rsvdseccount);
/* 1@16: Number of FAT data structures: always 2 */
MBR_PUTNUMFATS(var->fv_sect, fmt->ff_nfats);
/* 2@17: FAT12/16: Must be 0 for FAT32 */
MBR_PUTROOTENTCNT(var->fv_sect, fmt->ff_rootdirentries);
/* 2@19: FAT12/16: Must be 0, see MBR_TOTSEC32.
* Handled with 4@32: Total count of sectors on the volume
*/
if (fmt->ff_nsectors >= 65536)
{
MBR_PUTTOTSEC32(var->fv_sect, fmt->ff_nsectors);
}
else
{
MBR_PUTTOTSEC16(var->fv_sect, (uint16_t)fmt->ff_nsectors);
}
/* 1@21: Media code: f0, f8, f9-fa, fc-ff */
MBR_PUTMEDIA(var->fv_sect, FAT_DEFAULT_MEDIA_TYPE); /* Only "hard drive" supported */
/* 2@22: FAT12/16: Must be 0, see MBR32_FATSZ32 -- handled in FAT
* specific logic
*/
/* 2@24: Sectors per track geometry value and 2@26: Number of heads
* geometry value
*/
MBR_PUTSECPERTRK(var->fv_sect, FAT_DEFAULT_SECPERTRK);
MBR_PUTNUMHEADS(var->fv_sect, FAT_DEFAULT_NUMHEADS);
/* 4@28: Count of hidden sectors preceding FAT */
MBR_PUTHIDSEC(var->fv_sect, fmt->ff_hidsec);
/* 4@32: Total count of sectors on the volume -- handled above */
/* Most of the rest of the sector depends on the FAT size */
if (fmt->ff_fattype != 32)
{
/* 2@22: FAT12/16: Must be 0, see MBR32_FATSZ32 */
MBR_PUTFATSZ16(var->fv_sect, (uint16_t)var->fv_nfatsects);
/* The following fields are only valid for FAT12/16 */
/* 1@36: Drive number for MSDOS bootstrap -- left zero */
/* 1@37: Reserved (zero) */
/* 1@38: Extended boot signature: 0x29 if following valid */
MBR_PUTBOOTSIG16(var->fv_sect, EXTBOOT_SIGNATURE);
/* 4@39: Volume serial number */
MBR_PUTVOLID16(var->fv_sect, fmt->ff_volumeid);
/* 11@43: Volume label */
memcpy(&var->fv_sect[MBR16_VOLLAB], fmt->ff_volumelabel, 11);
/* 8@54: "FAT12 ", "FAT16 ", or "FAT " */
if (fmt->ff_fattype == 12)
{
memcpy(&var->fv_sect[MBR16_FILESYSTYPE], "FAT12 ", 8);
}
else /* if (fmt->ff_fattype == 16) */
{
memcpy(&var->fv_sect[MBR16_FILESYSTYPE], "FAT16 ", 8);
}
/* Boot code may be placed in the remainder of the sector */
memcpy(&var->fv_sect[MBR16_BOOTCODE], var->fv_bootcodeblob,
var->fv_bootcodesize);
/* Patch in the correct offset to the boot code */
var->fv_sect[MBR16_BOOTCODE + 3] = var->fv_bootcodepatch;
}
else
{
/* The following fields are only valid for FAT32 */
/* 4@36: Count of sectors occupied by one FAT */
MBR_PUTFATSZ32(var->fv_sect, var->fv_nfatsects);
/* 2@40: 0-3:Active FAT, 7=0 both FATS, 7=1 one FAT -- left zero */
/* 2@42: MSB:Major LSB:Minor revision number (0.0) -- left zero */
/* 4@44: Cluster no. of 1st cluster of root dir */
MBR_PUTROOTCLUS(var->fv_sect, FAT32_DEFAULT_ROOT_CLUSTER);
/* 2@48: Sector number of fsinfo structure. Usually 1. */
MBR_PUTFSINFO(var->fv_sect, FAT_DEFAULT_FSINFO_SECTOR);
/* 2@50: Sector number of boot record. Usually 6 */
MBR_PUTBKBOOTSEC(var->fv_sect, fmt->ff_backupboot);
/* 12@52: Reserved (zero) */
/* 1@64: Drive number for MSDOS bootstrap -- left zero */
/* 1@65: Reserved (zero) */
/* 1@66: Extended boot signature: 0x29 if following valid */
MBR_PUTBOOTSIG32(var->fv_sect, EXTBOOT_SIGNATURE);
/* 4@67: Volume serial number */
MBR_PUTVOLID32(var->fv_sect, fmt->ff_volumeid);
/* 11@71: Volume label */
memcpy(&var->fv_sect[MBR32_VOLLAB], fmt->ff_volumelabel, 11);
/* 8@82: "FAT12 ", "FAT16 ", or "FAT " */
memcpy(&var->fv_sect[MBR32_FILESYSTYPE], "FAT32 ", 8);
/* Boot code may be placed in the remainder of the sector */
memcpy(&var->fv_sect[MBR32_BOOTCODE], var->fv_bootcodeblob,
var->fv_bootcodesize);
/* Patch in the correct offset to the boot code */
var->fv_sect[MBR32_BOOTCODE + 3] = var->fv_bootcodepatch;
}
/* The magic bytes at the end of the MBR are common to FAT12/16/32 */
/* 2@510: Valid MBRs have 0x55aa here */
MBR_PUTSIGNATURE(var->fv_sect, BOOT_SIGNATURE16);
}
/****************************************************************************
* Name: mkfatfs_initfsinfo
*
* Description:
* Initialize the FAT32 FSINFO sector image
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
*
* Return:
* None; caller is responsible for providing valid parameters.
*
****************************************************************************/
static inline void mkfatfs_initfsinfo(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var)
{
UNUSED(fmt);
memset(var->fv_sect, 0, var->fv_sectorsize);
/* 4@0: 0x41615252 = "RRaA" */
FSI_PUTLEADSIG(var->fv_sect, 0x41615252);
/* 480@4: Reserved (zero) */
/* 4@484: 0x61417272 = "rrAa" */
FSI_PUTSTRUCTSIG(var->fv_sect, 0x61417272);
/* 4@488: Last free cluster count on volume */
FSI_PUTFREECOUNT(var->fv_sect, var->fv_nclusters - 1);
/* 4@492: Cluster number of 1st free cluster */
FSI_PUTNXTFREE(var->fv_sect, FAT32_DEFAULT_ROOT_CLUSTER);
/* 12@496: Reserved (zero) */
/* 4@508: 0xaa550000 */
FSI_PUTTRAILSIG(var->fv_sect, BOOT_SIGNATURE32);
}
/****************************************************************************
* Name: mkfatfs_initrootdir
*
* Description:
* Initialize one root directory sector image
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
* sectno - On FAT32, the root directory is a cluster chain.
* This value indicates which sector of the cluster should be
* produced.
*
* Return:
* None; caller is responsible for providing valid parameters.
*
****************************************************************************/
static inline void mkfatfs_initrootdir(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var, int sectno)
{
memset(var->fv_sect, 0, var->fv_sectorsize);
if (sectno == 0)
{
/* It is only necessary to set data in the first sector of the
* directory
*/
if (memcmp(fmt->ff_volumelabel, " ", 11))
{
memcpy(&var->fv_sect[DIR_NAME], fmt->ff_volumelabel, 11);
}
DIR_PUTATTRIBUTES(var->fv_sect, FATATTR_VOLUMEID);
DIR_PUTCRTIME(var->fv_sect, var->fv_createtime & 0xffff);
DIR_PUTWRTTIME(var->fv_sect, var->fv_createtime & 0xffff);
DIR_PUTCRDATE(var->fv_sect, var->fv_createtime >> 16);
DIR_PUTWRTDATE(var->fv_sect, var->fv_createtime >> 16);
}
}
/****************************************************************************
* Name: mkfatfs_writembr
*
* Description:
* Write the master boot record and, for FAT32, the backup boot record and
* the fsinfo sector.
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
*
* Return:
* Zero on success; negated errno on failure
*
****************************************************************************/
static inline int mkfatfs_writembr(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var)
{
int sectno;
int ret;
/* Create an image of the configured master boot record */
mkfatfs_initmbr(fmt, var);
/* Write the master boot record as sector zero */
ret = mkfatfs_devwrite(fmt, var, 0);
/* Write all of the reserved sectors */
memset(var->fv_sect, 0, var->fv_sectorsize);
for (sectno = 1; sectno < fmt->ff_rsvdseccount && ret >= 0; sectno++)
{
ret = mkfatfs_devwrite(fmt, var, sectno);
}
/* Write FAT32-specific sectors */
if (ret >= 0 && fmt->ff_fattype == 32)
{
/* Write the backup master boot record */
if (fmt->ff_backupboot != 0)
{
/* Create another copy of the configured master boot record */
mkfatfs_initmbr(fmt, var);
/* Write it to the backup location */
ret = mkfatfs_devwrite(fmt, var, fmt->ff_backupboot);
}
if (ret >= 0)
{
/* Create an image of the fsinfo sector */
mkfatfs_initfsinfo(fmt, var);
/* Write the fsinfo sector */
ret = mkfatfs_devwrite(fmt, var, FAT_DEFAULT_FSINFO_SECTOR);
}
}
return ret;
}
/****************************************************************************
* Name: mkfatfs_writefat
*
* Description:
* Write the FAT sectors.
*
* NOTE: The FAT FS created by this logic is an older style that includes
* the FAT boot record in the master boot record (MBR) and does not support
* a partition table.
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
*
* Return:
* Zero on success; negated errno on failure
*
****************************************************************************/
static inline int mkfatfs_writefat(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var)
{
off_t offset = fmt->ff_rsvdseccount;
uint8_t fatno;
uint32_t sectno;
int ret;
/* Loop for each FAT copy */
for (fatno = 0; fatno < fmt->ff_nfats; fatno++)
{
/* Loop for each sector in the FAT */
for (sectno = 0; sectno < var->fv_nfatsects; sectno++)
{
memset(var->fv_sect, 0, var->fv_sectorsize);
/* Mark cluster allocations in sector one of each FAT */
if (sectno == 0)
{
memset(var->fv_sect, 0, var->fv_sectorsize);
switch (fmt->ff_fattype)
{
case 12:
/* Mark the first two full FAT entries -- 24 bits,
* 3 bytes total
*/
memset(var->fv_sect, 0xff, 3);
break;
case 16:
/* Mark the first two full FAT entries -- 32 bits,
* 4 bytes total
*/
memset(var->fv_sect, 0xff, 4);
break;
case 32:
default: /* Shouldn't happen */
/* Mark the first two full FAT entries -- 64 bits,
* 8 bytes total
*/
memset(var->fv_sect, 0xff, 8);
/* Cluster 2 is used as the root directory.
* Mark as EOF
*/
var->fv_sect[8] = 0xf8;
memset(&var->fv_sect[9], 0xff, 3);
break;
}
/* Save the media type in the first byte of the FAT */
var->fv_sect[0] = FAT_DEFAULT_MEDIA_TYPE;
}
/* Write the FAT sector */
ret = mkfatfs_devwrite(fmt, var, offset);
if (ret < 0)
{
return ret;
}
offset++;
}
}
return OK;
}
/****************************************************************************
* Name: mkfatfs_writerootdir
*
* Description:
* Write the root directory sectors
*
* Input:
* fmt - User specified format parameters
* var - Other format parameters that are not user specifiable
*
* Return:
* Zero on success; negated errno on failure
*
****************************************************************************/
static inline int mkfatfs_writerootdir(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var)
{
off_t offset = fmt->ff_rsvdseccount + fmt->ff_nfats * var->fv_nfatsects;
int ret;
int i;
/* Write the root directory after the last FAT. This is the root directory
* area for FAT12/16, and the first cluster on FAT32.
*/
for (i = 0; i < var->fv_nrootdirsects; i++)
{
/* Format the next sector of the root directory */
mkfatfs_initrootdir(fmt, var, i);
/* Write the next sector of the root directory */
ret = mkfatfs_devwrite(fmt, var, offset);
if (ret < 0)
{
return ret;
}
offset++;
}
return 0;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: mkfatfs_writefat
*
* Description:
* Write the configured fat filesystem to the block device
*
* Input:
* fmt - Caller specified format parameters
* var - Other format parameters that are not caller specifiable. (Most
* set by mkfatfs_configfatfs()).
*
* Return:
* Zero on success; negated errno on failure
*
****************************************************************************/
int mkfatfs_writefatfs(FAR struct fat_format_s *fmt,
FAR struct fat_var_s *var)
{
int ret;
/* Write the master boot record (also the backup and fsinfo sectors) */
ret = mkfatfs_writembr(fmt, var);
/* Write FATs */
if (ret >= 0)
{
ret = mkfatfs_writefat(fmt, var);
}
/* Write the root directory after the last FAT. */
if (ret >= 0)
{
ret = mkfatfs_writerootdir(fmt, var);
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink