diff options
Diffstat (limited to 'nuttx/fs/fs_fat32.c')
-rw-r--r-- | nuttx/fs/fs_fat32.c | 2210 |
1 files changed, 0 insertions, 2210 deletions
diff --git a/nuttx/fs/fs_fat32.c b/nuttx/fs/fs_fat32.c deleted file mode 100644 index a54298bce..000000000 --- a/nuttx/fs/fs_fat32.c +++ /dev/null @@ -1,2210 +0,0 @@ -/**************************************************************************** - * fs_fat32.c - * - * Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> - * - * 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 <sys/stat.h> -#include <sys/statfs.h> -#include <stdlib.h> -#include <unistd.h> -#include <string.h> -#include <semaphore.h> -#include <assert.h> -#include <fcntl.h> -#include <errno.h> -#include <debug.h> - -#include <nuttx/fs.h> -#include <nuttx/fat.h> - -#include "fs_internal.h" -#include "fs_fat32.h" - -/**************************************************************************** - * Definitions - ****************************************************************************/ - -/**************************************************************************** - * Private Types - ****************************************************************************/ - -/**************************************************************************** - * Private Function Prototypes - ****************************************************************************/ - -static int fat_open(FAR struct file *filp, const char *relpath, - int oflags, mode_t mode); -static int fat_close(FAR struct file *filp); -static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen); -static ssize_t fat_write(FAR struct file *filp, const char *buffer, - size_t buflen); -static off_t fat_seek(FAR struct file *filp, off_t offset, int whence); -static int fat_ioctl(FAR struct file *filp, int cmd, unsigned long arg); -static int fat_sync(FAR struct file *filp); - -static int fat_opendir(struct inode *mountpt, const char *relpath, - struct internal_dir_s *dir); -static int fat_readdir(struct inode *mountpt, struct internal_dir_s *dir); -static int fat_rewinddir(struct inode *mountpt, struct internal_dir_s *dir); - -static int fat_bind(FAR struct inode *blkdriver, const void *data, - void **handle); -static int fat_unbind(void *handle, FAR struct inode **blkdriver); -static int fat_statfs(struct inode *mountpt, struct statfs *buf); - -static int fat_unlink(struct inode *mountpt, const char *relpath); -static int fat_mkdir(struct inode *mountpt, const char *relpath, - mode_t mode); -static int fat_rmdir(struct inode *mountpt, const char *relpath); -static int fat_rename(struct inode *mountpt, const char *oldrelpath, - const char *newrelpath); -static int fat_stat(struct inode *mountpt, const char *relpath, struct stat *buf); - -/**************************************************************************** - * Private Variables - ****************************************************************************/ - -/**************************************************************************** - * Public Variables - ****************************************************************************/ - -/* See fs_mount.c -- this structure is explicitly externed there. - * We use the old-fashioned kind of initializers so that this will compile - * with any compiler. - */ - -const struct mountpt_operations fat_operations = -{ - fat_open, - fat_close, - fat_read, - fat_write, - fat_seek, - fat_ioctl, - fat_sync, - - fat_opendir, - NULL, - fat_readdir, - fat_rewinddir, - - fat_bind, - fat_unbind, - fat_statfs, - - fat_unlink, - fat_mkdir, - fat_rmdir, - fat_rename, - fat_stat -}; - -/**************************************************************************** - * Private Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: fat_open - ****************************************************************************/ - -static int fat_open(FAR struct file *filp, const char *relpath, - int oflags, mode_t mode) -{ - struct fat_dirinfo_s dirinfo; - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv == NULL && filp->f_inode != NULL); - - /* Get the mountpoint inode reference from the file structure and the - * mountpoint private data from the inode structure - */ - - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Initialize the directory info structure */ - - memset(&dirinfo, 0, sizeof(struct fat_dirinfo_s)); - - /* Locate the directory entry for this path */ - - ret = fat_finddirentry(fs, &dirinfo, relpath); - - /* Three possibililities: (1) a node exists for the relpath and - * dirinfo describes the directory entry of the entity, (2) the - * node does not exist, or (3) some error occurred. - */ - - if (ret == OK) - { - boolean readonly; - - /* The name exists -- but is it a file or a directory? */ - - if (dirinfo.fd_entry == NULL || - (DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_DIRECTORY)) - { - /* It is a directory */ - ret = -EISDIR; - goto errout_with_semaphore; - } - - /* It would be an error if we are asked to create it exclusively */ - - if ((oflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) - { - /* Already exists -- can't create it exclusively */ - ret = -EEXIST; - goto errout_with_semaphore; - } - -#ifdef CONFIG_FILE_MODE -# warning "Missing check for privileges based on inode->i_mode" -#endif - - /* Check if the caller has sufficient privileges to open the file */ - - readonly = ((DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_READONLY) != 0); - if (((oflags & O_WRONLY) != 0) && readonly) - { - ret = -EACCES; - goto errout_with_semaphore; - } - - /* If O_TRUNC is specified and the file is opened for writing, - * then truncate the file. This operation requires that the file is - * writable, but we have already checked that. O_TRUNC without write - * access is ignored. - */ - - if ((oflags & (O_TRUNC|O_WRONLY)) == (O_TRUNC|O_WRONLY)) - { - /* Truncate the file to zero length */ - - ret = fat_dirtruncate(fs, &dirinfo); - if (ret < 0) - { - goto errout_with_semaphore; - } - } - - /* fall through to finish the file open operations */ - - } - else if (ret == -ENOENT) - { - /* The file does not exist. Were we asked to create it? */ - - if ((oflags & O_CREAT) == 0) - { - /* No.. then we fail with -ENOENT */ - ret = -ENOENT; - goto errout_with_semaphore; - } - - /* Yes.. create the file */ - - ret = fat_dircreate(fs, &dirinfo); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Fall through to finish the file open operation */ - } - else - { - /* An error occurred while checking for file existence -- - * such as if an invalid path were provided. - */ - - goto errout_with_semaphore; - } - - /* Create an instance of the file private date to describe the opened - * file. - */ - - ff = (struct fat_file_s *)zalloc(sizeof(struct fat_file_s)); - if (!ff) - { - ret = -ENOMEM; - goto errout_with_semaphore; - } - - /* Create a file buffer to support partial sector accesses */ - - ff->ff_buffer = (ubyte*)malloc(fs->fs_hwsectorsize); - if (!ff->ff_buffer) - { - ret = -ENOMEM; - goto errout_with_struct; - } - - /* Initialize the file private data (only need to initialize non-zero elements) */ - - ff->ff_open = TRUE; - ff->ff_oflags = oflags; - ff->ff_sectorsincluster = 1; - - /* Save information that can be used later to recover the directory entry */ - - ff->ff_dirsector = fs->fs_currentsector; - ff->ff_dirindex = dirinfo.dir.fd_index; - - /* File cluster/size info */ - - ff->ff_startcluster = - ((uint32)DIR_GETFSTCLUSTHI(dirinfo.fd_entry) << 16) | - DIR_GETFSTCLUSTLO(dirinfo.fd_entry); - - ff->ff_size = DIR_GETFILESIZE(dirinfo.fd_entry); - - /* In write/append mode, we need to set the file pointer to the end of the file */ - - if ((oflags & (O_APPEND|O_WRONLY)) == (O_APPEND|O_WRONLY)) - { - ff->ff_position = ff->ff_size; - } - - /* Attach the private date to the struct file instance */ - - filp->f_priv = ff; - - /* Then insert the new instance into the mountpoint structure. - * It needs to be there (1) to handle error conditions that effect - * all files, and (2) to inform the umount logic that we are busy - * (but a simple reference count could have done that). - */ - - ff->ff_next = fs->fs_head; - fs->fs_head = ff->ff_next; - - fat_semgive(fs); - return OK; - - /* Error exits -- goto's are nasty things, but they sure can make error - * handling a lot simpler. - */ - -errout_with_struct: - free(ff); - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_close - ****************************************************************************/ - -static int fat_close(FAR struct file *filp) -{ - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - int ret = OK; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL); - - /* Recover our private data from the struct file instance */ - - ff = filp->f_priv; - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Do not check if the mount is healthy. We must support closing of - * the file even when there is healthy mount. - */ - - /* Synchronize the file buffers and disk content; update times */ - - ret = fat_sync(filp); - - /* Then deallocate the memory structures created when the open method - * was called. - * - * Free the sector buffer that was used to manage partial sector accesses. - */ - - if (ff->ff_buffer) - { - free(ff->ff_buffer); - } - - /* Then free the file structure itself. */ - - free(ff); - filp->f_priv = NULL; - return ret; -} - -/**************************************************************************** - * Name: fat_read - ****************************************************************************/ - -static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen) -{ - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - uint32 cluster; - unsigned int bytesread; - unsigned int readsize; - unsigned int nsectors; - size_t readsector; - size_t bytesleft; - ubyte *userbuffer = (ubyte*)buffer; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL); - - /* Recover our private data from the struct file instance */ - - ff = filp->f_priv; - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Check if the file was opened with read access */ - - if ((ff->ff_oflags & O_RDOK) == 0) - { - ret = -EACCES; - goto errout_with_semaphore; - } - - /* Get the number of bytes left in the file */ - - bytesleft = ff->ff_size - ff->ff_position; - - /* Truncate read count so that it does not exceed the number - * of bytes left in the file. - */ - - if (buflen > bytesleft) - { - buflen = bytesleft; - } - - /* Loop until either (1) all data has been transferred, or (2) an - * error occurs. - */ - - readsize = 0; - readsector = ff->ff_currentsector; - while (buflen > 0) - { - /* Get offset into the sector where we begin the read */ - - int sectorindex = ff->ff_position & SEC_NDXMASK(fs); - bytesread = 0; - - /* Check if the current read stream happens to lie on a - * sector boundary. - */ - - if (sectorindex == 0) - { - /* Try to read another contiguous sector from the cluster */ - - ff->ff_sectorsincluster--; - - /* Are there unread sectors remaining in the cluster? */ - - if (ff->ff_sectorsincluster > 0) - { - /* Yes.. There are more sectors in this cluster to be read - * just increment the current sector number and read. - */ - - readsector = ff->ff_currentsector + 1; - } - else - { - /* No.. Handle the case of the first sector of the file */ - - if (ff->ff_position == 0) - { - /* Get the first cluster of the file */ - - cluster = ff->ff_startcluster; - } - - /* But in the general case, we have to find the next cluster - * in the FAT. - */ - - else - { - cluster = fat_getcluster(fs, ff->ff_currentcluster); - } - - /* Verify the cluster number */ - - if (cluster < 2 || cluster >= fs->fs_nclusters) - { - ret = -EINVAL; /* Not the right error */ - goto errout_with_semaphore; - } - - /* Setup to read the first sector from the new cluster */ - - ff->ff_currentcluster = cluster; - ff->ff_sectorsincluster = fs->fs_fatsecperclus; - readsector = fat_cluster2sector(fs, cluster); - } - } - - /* Check if the user has provided a buffer large enough to - * hold one or more complete sectors. - */ - - nsectors = buflen / fs->fs_hwsectorsize; - if (nsectors > 0) - { - /* Read maximum contiguous sectors directly to the user's - * buffer without using our tiny read buffer. - * - * Limit the number of sectors that we read on this time - * through the loop to the remaining contiguous sectors - * in this cluster - */ - - if (nsectors > ff->ff_sectorsincluster) - { - nsectors = ff->ff_sectorsincluster; - } - - /* We are not sure of the state of the file buffer so - * the safest thing to do is just invalidate it - */ - - (void)fat_ffcacheinvalidate(fs, ff); - - /* Read all of the sectors directory into user memory */ - - ret = fat_hwread(fs, userbuffer, readsector, nsectors); - if (ret < 0) - { - goto errout_with_semaphore; - } - - ff->ff_sectorsincluster -= nsectors - 1; - ff->ff_currentsector = readsector + nsectors - 1; - bytesread = nsectors * fs->fs_hwsectorsize; - } - else - { - /* We are reading a partial sector. First, read the whole sector - * into the file data buffer. This is a caching buffer so if - * it is already there then all is well. - */ - - ret = fat_ffcacheread(fs, ff, readsector); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Copy the partial sector into the user buffer */ - - bytesread = fs->fs_hwsectorsize - sectorindex; - if (bytesread > buflen) - { - bytesread = buflen; - } - - memcpy(userbuffer, &ff->ff_buffer[sectorindex], bytesread); - ff->ff_currentsector = readsector; - } - - /* Set up for the next sector read */ - - userbuffer += bytesread; - ff->ff_position += bytesread; - readsize += bytesread; - buflen -= bytesread; - } - - fat_semgive(fs); - return readsize; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_write - ****************************************************************************/ - -static ssize_t fat_write(FAR struct file *filp, const char *buffer, - size_t buflen) -{ - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - sint32 cluster; - size_t writesector; - unsigned int byteswritten; - unsigned int writesize; - unsigned int nsectors; - ubyte *userbuffer = (ubyte*)buffer; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL); - - /* Recover our private data from the struct file instance */ - - ff = filp->f_priv; - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Check if the file was opened for write access */ - - if ((ff->ff_oflags & O_WROK) == 0) - { - ret = -EACCES; - goto errout_with_semaphore; - } - - /* Check if the file size would exceed the range of size_t */ - - if (ff->ff_size + buflen < ff->ff_size) - { - ret = -EFBIG; - goto errout_with_semaphore; - } - - /* Loop until either (1) all data has been transferred, or (2) an - * error occurs. - */ - - byteswritten = 0; - writesector = ff->ff_currentsector; - while (buflen > 0) - { - /* Get offset into the sector where we begin the read */ - - int sectorindex = ff->ff_position & SEC_NDXMASK(fs); - - /* Check if the current read stream happens to lie on a - * sector boundary. - */ - - if (sectorindex == 0) - { - /* Decrement the number of sectors left in this cluster */ - - ff->ff_sectorsincluster--; - - /* Are there unwritten sectors remaining in this cluster */ - - if (ff->ff_sectorsincluster > 0) - { - /* Yes.. There are more sectors in this cluster to be written. - * just increment the current sector number and write. - */ - - writesector = ff->ff_currentsector + 1; - } - else - { - /* No.. Handle the case of the first sector of the file */ - - if (ff->ff_position == 0) - { - /* Check the first cluster of the file. Zero means that - * the file is empty -- perhaps the file was truncated or - * created when it was opened - */ - - if (ff->ff_startcluster == 0) - { - /* In this case, we have to create a new cluster chain */ - - ff->ff_startcluster = fat_createchain(fs); - } - - /* Start writing at the first cluster of the file */ - - cluster = ff->ff_startcluster; - } - - /* But in the general case, we have to extend the current - * cluster by one (unless lseek was used to move the file - * position back from the end of the file) - */ - - else - { - /* Extend the chain by adding a new cluster after - * the last one - */ - - cluster = fat_extendchain(fs, ff->ff_currentcluster); - } - - /* Verify the cluster number */ - - if (cluster < 0) - { - ret = cluster; - goto errout_with_semaphore; - } - else if (cluster < 2 || cluster >= fs->fs_nclusters) - { - ret = -ENOSPC; - goto errout_with_semaphore; - } - - /* Setup to write the first sector from the new cluster */ - - ff->ff_currentcluster = cluster; - ff->ff_sectorsincluster = fs->fs_fatsecperclus; - writesector = fat_cluster2sector(fs, cluster); - } - } - - /* Check if there is unwritten data in the file buffer */ - - ret = fat_ffcacheflush(fs, ff); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Check if the user has provided a buffer large enough to - * hold one or more complete sectors. - */ - - nsectors = buflen / fs->fs_hwsectorsize; - if (nsectors > 0) - { - /* Write maximum contiguous sectors directly from the user's - * buffer without using our tiny read buffer. - * - * Limit the number of sectors that we write on this time - * through the loop to the remaining contiguous sectors - * in this cluster - */ - - if (nsectors > ff->ff_sectorsincluster) - { - nsectors = ff->ff_sectorsincluster; - } - - /* We are not sure of the state of the file buffer so - * the safest thing to do is just invalidate it - */ - - (void)fat_ffcacheinvalidate(fs, ff); - - /* Write all of the sectors directory from user memory */ - - ret = fat_hwwrite(fs, userbuffer, writesector, nsectors); - if (ret < 0) - { - goto errout_with_semaphore; - } - - ff->ff_sectorsincluster -= nsectors - 1; - ff->ff_currentsector = writesector + nsectors - 1; - writesize = nsectors * fs->fs_hwsectorsize; - ff->ff_bflags |= FFBUFF_MODIFIED; - } - else - { - /* We are write a partial sector. We will first have to - * read the full sector in memory as part of a read-modify-write - * operation. - */ - - if (ff->ff_position < ff->ff_size) - { - ff->ff_currentsector = writesector; - ret = fat_ffcacheread(fs, ff, writesector); - if (ret < 0) - { - goto errout_with_semaphore; - } - } - - /* Copy the partial sector from the user buffer */ - - writesize = fs->fs_hwsectorsize - sectorindex; - if (writesize > buflen) - { - writesize = buflen; - } - - memcpy(&ff->ff_buffer[sectorindex], userbuffer, writesize); - ff->ff_currentsector = writesector; - ff->ff_bflags |= (FFBUFF_DIRTY|FFBUFF_VALID|FFBUFF_MODIFIED); - } - - /* Set up for the next write */ - - userbuffer += writesize; - ff->ff_position += writesize; - byteswritten += writesize; - buflen -= writesize; - } - - /* The transfer has completed without error. Update the file size */ - - if (ff->ff_position > ff->ff_size) - { - ff->ff_size = ff->ff_position; - } - - fat_semgive(fs); - return byteswritten; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_seek - ****************************************************************************/ - -static off_t fat_seek(FAR struct file *filp, off_t offset, int whence) -{ - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - sint32 cluster; - ssize_t position; - unsigned int clustersize; - unsigned int sectoroffset; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL); - - /* Recover our private data from the struct file instance */ - - ff = filp->f_priv; - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Map the offset according to the whence option */ - switch (whence) - { - case SEEK_SET: /* The offset is set to offset bytes. */ - position = offset; - break; - - case SEEK_CUR: /* The offset is set to its current location plus - * offset bytes. */ - - position = offset + ff->ff_position; - break; - - case SEEK_END: /* The offset is set to the size of the file plus - * offset bytes. */ - - position = offset + ff->ff_size; - break; - - default: - return -EINVAL; - } - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Check if there is unwritten data in the file buffer */ - - ret = fat_ffcacheflush(fs, ff); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Attempts to set the position beyound the end of file will - * work if the file is open for write access. - */ - - if (position > ff->ff_size && (ff->ff_oflags & O_WROK) == 0) - { - /* Otherwise, the position is limited to the file size */ - position = ff->ff_size; - } - - /* Set file position to the beginning of the file */ - - ff->ff_position = 0; - ff->ff_sectorsincluster = 1; - - /* Move file position if necessary */ - - if (position) - { - /* Get the start cluster of the file */ - - cluster = ff->ff_startcluster; - if (!cluster) - { - /* Create a new cluster chain if the file does not have one */ - - cluster = fat_createchain(fs); - if (cluster < 0) - { - ret = cluster; - goto errout_with_semaphore; - } - ff->ff_startcluster = cluster; - } - - if (cluster) - { - /* If the file has a cluster chain, follow it to the - * requested position. - */ - - clustersize = fs->fs_fatsecperclus * fs->fs_hwsectorsize; - for (;;) - { - /* Skip over clusters prior to the one containing - * the requested position. - */ - - ff->ff_currentcluster = cluster; - if (position <= clustersize) - { - break; - } - - /* Extend the cluster chain if write in enabled. NOTE: - * this is not consistent with the lseek description: - * "The lseek() function allows the file offset to be - * set beyond the end of the file (but this does not - * change the size of the file). If data is later written - * at this point, subsequent reads of the data in the - * gap (a "hole") return null bytes ('\0') until data - * is actually written into the gap." - */ - - if ((ff->ff_oflags & O_WROK) != 0) - { - /* Extend the cluster chain (fat_extendchain - * will follow the existing chain or add new - * clusters as needed. - */ - - cluster = fat_extendchain(fs, cluster); - } - else - { - /* Other we can only follong the existing chain */ - - cluster = fat_getcluster(fs, cluster); - } - - if (cluster < 0) - { - /* An error occurred getting the cluster */ - - ret = cluster; - goto errout_with_semaphore; - } - - /* Zero means that there is no further clusters available - * in the chain. - */ - - if (cluster == 0) - { - /* At the position to the current locaiton and - * break out. - */ - - position = clustersize; - break; - } - - if (cluster >= fs->fs_nclusters) - { - ret = -ENOSPC; - goto errout_with_semaphore; - } - - /* Otherwise, update the position and continue looking */ - - ff->ff_position += clustersize; - position -= clustersize; - } - - /* We get here after we have found the sector containing - * the requested position. - */ - - sectoroffset = (position - 1) / fs->fs_hwsectorsize; - - /* And get the current sector from the cluster and - * the sectoroffset into the cluster. - */ - - ff->ff_currentsector = - fat_cluster2sector(fs, cluster) + sectoroffset; - - /* Load the sector corresponding to the position */ - - if ((position & SEC_NDXMASK(fs)) != 0) - { - ret = fat_ffcacheread(fs, ff, ff->ff_currentsector); - if (ret < 0) - { - goto errout_with_semaphore; - } - } - - /* Save the number of sectors left in the cluster */ - - ff->ff_sectorsincluster = fs->fs_fatsecperclus - sectoroffset; - - /* And save the new file position */ - - ff->ff_position += position; - } - } - - /* If we extended the size of the file, then mark the file as modified. */ - - if ((ff->ff_oflags & O_WROK) != 0 && ff->ff_position > ff->ff_size) - { - ff->ff_size = ff->ff_position; - ff->ff_bflags |= FFBUFF_MODIFIED; - } - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_ioctl - ****************************************************************************/ - -static int fat_ioctl(FAR struct file *filp, int cmd, unsigned long arg) -{ - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL); - - /* Recover our private data from the struct file instance */ - - ff = filp->f_priv; - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - fat_semgive(fs); - return ret; - } - - /* ioctl calls are just passed through to the contained block driver */ - - fat_semgive(fs); - return -ENOSYS; -} - -/**************************************************************************** - * Name: fat_sync - * - * Description: Synchronize the file state on disk to match internal, in- - * memory state. - * - ****************************************************************************/ - -static int fat_sync(FAR struct file *filp) -{ - struct inode *inode; - struct fat_mountpt_s *fs; - struct fat_file_s *ff; - uint32 wrttime; - ubyte *direntry; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL); - - /* Recover our private data from the struct file instance */ - - ff = filp->f_priv; - inode = filp->f_inode; - fs = inode->i_private; - - DEBUGASSERT(fs != NULL); - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Check if the has been modified in any way */ - if ((ff->ff_bflags & FFBUFF_MODIFIED) != 0) - { - /* Flush any unwritten data in the file buffer */ - - ret = fat_ffcacheflush(fs, ff); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Update the directory entry. First read the directory - * entry into the fs_buffer (preserving the ff_buffer) - */ - - ret = fat_fscacheread(fs, ff->ff_dirsector); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Recover a pointer to the specific directory entry - * in the sector using the saved directory index. - */ - - direntry = &fs->fs_buffer[ff->ff_dirindex * 32]; - - /* Set the archive bit, set the write time, and update - * anything that may have* changed in the directory - * entry: the file size, and the start cluster - */ - - direntry[DIR_ATTRIBUTES] |= FATATTR_ARCHIVE; - - DIR_PUTFILESIZE(direntry, ff->ff_size); - DIR_PUTFSTCLUSTLO(direntry, ff->ff_startcluster); - DIR_PUTFSTCLUSTHI(direntry, ff->ff_startcluster >> 16); - - wrttime = fat_systime2fattime(); - DIR_PUTWRTTIME(direntry, wrttime & 0xffff); - DIR_PUTWRTDATE(direntry, wrttime >> 16); - - /* Clear the modified bit in the flags */ - - ff->ff_bflags &= ~FFBUFF_MODIFIED; - - /* Flush these change to disk and update FSINFO (if - * appropriate. - */ - - fs->fs_dirty = TRUE; - ret = fat_updatefsinfo(fs); - } - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_opendir - * - * Description: Open a directory for read access - * - ****************************************************************************/ - -static int fat_opendir(struct inode *mountpt, const char *relpath, struct internal_dir_s *dir) -{ - struct fat_mountpt_s *fs; - struct fat_dirinfo_s dirinfo; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL); - - /* Recover our private data from the inode instance */ - - fs = mountpt->i_private; - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Find the requested directory */ - - ret = fat_finddirentry(fs, &dirinfo, relpath); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Check if this is the root directory */ - - if (dirinfo.fd_entry == NULL) - { - /* Handle the FAT12/16/32 root directory using the values setup by - * fat_finddirentry() above. - */ - - dir->u.fat.fd_startcluster = dirinfo.dir.fd_startcluster; - dir->u.fat.fd_currcluster = dirinfo.dir.fd_currcluster; - dir->u.fat.fd_currsector = dirinfo.dir.fd_currsector; - dir->u.fat.fd_index = dirinfo.dir.fd_index; - } - - /* This is not the root directory. Verify that it is some kind of directory */ - - else if ((DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_DIRECTORY) == 0) - { - /* The entry is not a directory */ - ret = -ENOTDIR; - goto errout_with_semaphore; - } - else - { - /* The entry is a directory */ - - dir->u.fat.fd_startcluster = - ((uint32)DIR_GETFSTCLUSTHI(dirinfo.fd_entry) << 16) | - DIR_GETFSTCLUSTLO(dirinfo.fd_entry); - dir->u.fat.fd_currcluster = dir->u.fat.fd_startcluster; - dir->u.fat.fd_currsector = fat_cluster2sector(fs, dir->u.fat.fd_currcluster); - dir->u.fat.fd_index = 2; - } - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ERROR; -} - -/**************************************************************************** - * Name: fat_readdir - * - * Description: Read the next directory entry - * - ****************************************************************************/ - -static int fat_readdir(struct inode *mountpt, struct internal_dir_s *dir) -{ - struct fat_mountpt_s *fs; - unsigned int dirindex; - ubyte *direntry; - ubyte ch; - ubyte attribute; - int ret = OK; - - /* Sanity checks */ - - DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL); - - /* Recover our private data from the inode instance */ - - fs = mountpt->i_private; - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Read the next directory entry */ - - dir->fd_dir.d_name[0] = '\0'; - while (dir->u.fat.fd_currsector && dir->fd_dir.d_name[0] == '\0') - { - ret = fat_fscacheread(fs, dir->u.fat.fd_currsector); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Get a reference to the current directory entry */ - - dirindex = (dir->u.fat.fd_index & DIRSEC_NDXMASK(fs)) * 32; - direntry = &fs->fs_buffer[dirindex]; - - /* Has it reached to end of the directory */ - - ch = *direntry; - if (ch == DIR0_ALLEMPTY) - { - /* We signal the end of the directory by returning the - * special error -ENOENT - */ - - ret = -ENOENT; - goto errout_with_semaphore; - } - - /* No, is the current entry a valid entry? */ - - attribute = DIR_GETATTRIBUTES(direntry); - if (ch != DIR0_EMPTY && (attribute & FATATTR_VOLUMEID) == 0) - { - /* Yes.. get the name from the directory info */ - - (void)fat_dirname2path(dir->fd_dir.d_name, direntry); - - /* And the file type */ - - if ((attribute & FATATTR_DIRECTORY) == 0) - { - dir->fd_dir.d_type = DTYPE_FILE; - } - else - { - dir->fd_dir.d_type = DTYPE_DIRECTORY; - } - } - - /* Set up the next directory index */ - - if (fat_nextdirentry(fs, &dir->u.fat) != OK) - { - ret = -ENOENT; - goto errout_with_semaphore; - } - } - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_rewindir - * - * Description: Reset directory read to the first entry - * - ****************************************************************************/ - -static int fat_rewinddir(struct inode *mountpt, struct internal_dir_s *dir) -{ - struct fat_mountpt_s *fs; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL); - - /* Recover our private data from the inode instance */ - - fs = mountpt->i_private; - - /* Make sure that the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Check if this is the root directory */ - - if (fs->fs_type != FSTYPE_FAT32 && - dir->u.fat.fd_startcluster == 0) - { - /* Handle the FAT12/16 root directory */ - - dir->u.fat.fd_currcluster = 0; - dir->u.fat.fd_currsector = fs->fs_rootbase; - dir->u.fat.fd_index = 0; - } - else if (fs->fs_type == FSTYPE_FAT32 && - dir->u.fat.fd_startcluster == fs->fs_rootbase) - { - /* Handle the FAT32 root directory */ - - dir->u.fat.fd_currcluster = dir->u.fat.fd_startcluster; - dir->u.fat.fd_currsector = fat_cluster2sector(fs, fs->fs_rootbase); - dir->u.fat.fd_index = 0; - } - - /* This is not the root directory */ - - else - { - dir->u.fat.fd_currcluster = dir->u.fat.fd_startcluster; - dir->u.fat.fd_currsector = fat_cluster2sector(fs, dir->u.fat.fd_currcluster); - dir->u.fat.fd_index = 2; - } - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ERROR; -} - -/**************************************************************************** - * Name: fat_bind - * - * Description: This implements a portion of the mount operation. This - * function allocates and initializes the mountpoint private data and - * binds the blockdriver inode to the filesystem private data. The final - * binding of the private data (containing the blockdriver) to the - * mountpoint is performed by mount(). - * - ****************************************************************************/ - -static int fat_bind(FAR struct inode *blkdriver, const void *data, - void **handle) -{ - struct fat_mountpt_s *fs; - int ret; - - /* Open the block driver */ - - if (!blkdriver || !blkdriver->u.i_bops) - { - return -ENODEV; - } - - if (blkdriver->u.i_bops->open && - blkdriver->u.i_bops->open(blkdriver) != OK) - { - return -ENODEV; - } - - /* Create an instance of the mountpt state structure */ - - fs = (struct fat_mountpt_s *)zalloc(sizeof(struct fat_mountpt_s)); - if (!fs) - { - return -ENOMEM; - } - - /* Initialize the allocated mountpt state structure. The filesystem is - * responsible for one reference ont the blkdriver inode and does not - * have to addref() here (but does have to release in ubind(). - */ - - fs->fs_blkdriver = blkdriver; /* Save the block driver reference */ - sem_init(&fs->fs_sem, 0, 0); /* Initialize the semaphore that controls access */ - - /* Then get information about the FAT32 filesystem on the devices managed - * by this block driver. - */ - - ret = fat_mount(fs, TRUE); - if (ret != 0) - { - sem_destroy(&fs->fs_sem); - free(fs); - return ret; - } - - *handle = (void*)fs; - fat_semgive(fs); - return OK; -} - -/**************************************************************************** - * Name: fat_unbind - * - * Description: This implements the filesystem portion of the umount - * operation. - * - ****************************************************************************/ - -static int fat_unbind(void *handle, FAR struct inode **blkdriver) -{ - struct fat_mountpt_s *fs = (struct fat_mountpt_s*)handle; - int ret; - - if (!fs) - { - return -EINVAL; - } - - /* Check if there are sill any files opened on the filesystem. */ - - ret = OK; /* Assume success */ - fat_semtake(fs); - if (fs->fs_head) - { - /* We cannot unmount now.. there are open files */ - - ret = -EBUSY; - } - else - { - /* Unmount ... close the block driver */ - - if (fs->fs_blkdriver) - { - struct inode *inode = fs->fs_blkdriver; - if (inode) - { - if (inode->u.i_bops && inode->u.i_bops->close) - { - (void)inode->u.i_bops->close(inode); - } - - /* We hold a reference to the block driver but should - * not but mucking with inodes in this context. So, we will just return - * our contained reference to the block driver inode and let the umount - * logic dispose of it. - */ - - if (blkdriver) - { - *blkdriver = inode; - } - } - } - - /* Release the mountpoint private data */ - - if (fs->fs_buffer) - { - free(fs->fs_buffer); - } - free(fs); - } - - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_statfs - * - * Description: Return filesystem statistics - * - ****************************************************************************/ - -static int fat_statfs(struct inode *mountpt, struct statfs *buf) -{ - struct fat_mountpt_s *fs; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt && mountpt->i_private); - - /* Get the mountpoint private data from the inode structure */ - - fs = mountpt->i_private; - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Fill in the statfs info */ - - memset(buf, 0, sizeof(struct statfs)); - buf->f_type = MSDOS_SUPER_MAGIC; - - /* We will claim that the optimal transfer size is the size of a cluster in bytes */ - - buf->f_bsize = fs->fs_fatsecperclus * fs->fs_hwsectorsize; - - /* Everything else follows in units of clusters */ - - buf->f_blocks = fs->fs_nclusters; /* Total data blocks in the file system */ - ret = fat_nfreeclusters(fs, &buf->f_bfree); /* Free blocks in the file system */ - buf->f_bavail = buf->f_bfree; /* Free blocks avail to non-superuser */ - buf->f_namelen = (8+1+3); /* Maximum length of filenames */ - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_unlink - * - * Description: Remove a file - * - ****************************************************************************/ - -static int fat_unlink(struct inode *mountpt, const char *relpath) -{ - struct fat_mountpt_s *fs; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt && mountpt->i_private); - - /* Get the mountpoint private data from the inode structure */ - - fs = mountpt->i_private; - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret == OK) - { - /* If the file is open, the correct behavior is to remove the file - * name, but to keep the file cluster chain in place until the last - * open reference to the file is closed. - */ - -#warning "Need to defer deleting cluster chain if the file is open" - - /* Remove the file */ - - ret = fat_remove(fs, relpath, FALSE); - } - - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_mkdir - * - * Description: Create a directory - * - ****************************************************************************/ - -static int fat_mkdir(struct inode *mountpt, const char *relpath, mode_t mode) -{ - struct fat_mountpt_s *fs; - struct fat_dirinfo_s dirinfo; - ubyte *direntry; - ubyte *direntry2; - size_t parentsector; - ssize_t dirsector; - sint32 dircluster; - uint32 parentcluster; - uint32 crtime; - unsigned int i; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt && mountpt->i_private); - - /* Get the mountpoint private data from the inode structure */ - - fs = mountpt->i_private; - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Find the directory where the new directory should be created. */ - - ret = fat_finddirentry(fs, &dirinfo, relpath); - - /* If anything exists at this location, then we fail with EEXIST */ - - if (ret == OK) - { - ret = -EEXIST; - goto errout_with_semaphore; - } - - /* What we want to see is for fat_finddirentry to fail with -ENOENT. - * This error means that no failure occurred but that nothing exists - * with this name. - */ - - if (ret != -ENOENT) - { - goto errout_with_semaphore; - } - - /* NOTE: There is no check that dirinfo.fd_name contains the final - * directory name. We could be creating an intermediate directory - * in the full relpath. - */ - - /* Allocate a directory entry for the new directory in this directory */ - - ret = fat_allocatedirentry(fs, &dirinfo); - if (ret != OK) - { - goto errout_with_semaphore; - } - parentsector = fs->fs_currentsector; - - /* Allocate a cluster for new directory */ - - dircluster = fat_createchain(fs); - if (dircluster < 0) - { - ret = dircluster; - goto errout_with_semaphore; - } - else if (dircluster < 2) - { - ret = -ENOSPC; - goto errout_with_semaphore; - } - - dirsector = fat_cluster2sector(fs, dircluster); - if (dirsector < 0) - { - ret = dirsector; - goto errout_with_semaphore; - } - - /* Flush any existing, dirty data in fs_buffer (because we need - * it to create the directory entries. - */ - - ret = fat_fscacheflush(fs); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Get a pointer to the first directory entry in the sector */ - - direntry = fs->fs_buffer; - - /* Now erase the contents of fs_buffer */ - - fs->fs_currentsector = dirsector; - memset(direntry, 0, fs->fs_hwsectorsize); - - /* Now clear all sectors in the new directory cluster (except for the first) */ - - for (i = 1; i < fs->fs_fatsecperclus; i++) - { - ret = fat_hwwrite(fs, direntry, ++dirsector, 1); - if (ret < 0) - { - goto errout_with_semaphore; - } - } - - /* Now create the "." directory entry in the first directory slot */ - - memset(&direntry[DIR_NAME], ' ', 8+3); - direntry[DIR_NAME] = '.'; - DIR_PUTATTRIBUTES(direntry, FATATTR_DIRECTORY); - - crtime = fat_systime2fattime(); - DIR_PUTCRTIME(direntry, crtime & 0xffff); - DIR_PUTWRTTIME(direntry, crtime & 0xffff); - DIR_PUTCRDATE(direntry, crtime >> 16); - DIR_PUTWRTDATE(direntry, crtime >> 16); - - /* Create ".." directory entry in the second directory slot */ - - direntry2 = direntry + 32; - - /* So far, the two entries are nearly the same */ - - memcpy(direntry2, direntry, 32); - direntry2[DIR_NAME+1] = '.'; - - /* Now add the cluster information to both directory entries */ - - DIR_PUTFSTCLUSTHI(direntry, dircluster >> 16); - DIR_PUTFSTCLUSTLO(direntry, dircluster); - - parentcluster = dirinfo.dir.fd_startcluster; - if (fs->fs_type != FSTYPE_FAT32 && parentcluster == fs->fs_rootbase) - { - parentcluster = 0; - } - - DIR_PUTFSTCLUSTHI(direntry2, parentcluster >> 16); - DIR_PUTFSTCLUSTLO(direntry2, parentcluster); - - /* Save the first sector of the directory cluster and re-read - * the parentsector - */ - - fs->fs_dirty = TRUE; - ret = fat_fscacheread(fs, parentsector); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Initialize the new entry directory entry in the parent directory */ - - direntry = dirinfo.fd_entry; - memset(direntry, 0, 32); - - memcpy(direntry, dirinfo.fd_name, 8+3); -#ifdef CONFIG_FLAT_LCNAMES - DIR_PUTNTRES(direntry, dirinfo.fd_ntflags); -#endif - DIR_PUTATTRIBUTES(dirinfo.fd_entry, FATATTR_DIRECTORY); - - /* Same creation time as for . and .. */ - - DIR_PUTCRTIME(dirinfo.fd_entry, crtime & 0xffff); - DIR_PUTWRTTIME(dirinfo.fd_entry, crtime & 0xffff); - DIR_PUTCRDATE(dirinfo.fd_entry, crtime >> 16); - DIR_PUTWRTDATE(dirinfo.fd_entry, crtime >> 16); - - /* Set subdirectory start cluster */ - - DIR_PUTFSTCLUSTLO(dirinfo.fd_entry, dircluster); - DIR_PUTFSTCLUSTHI(dirinfo.fd_entry, dircluster >> 16); - - /* Now update the FAT32 FSINFO sector */ - - fs->fs_dirty = TRUE; - ret = fat_updatefsinfo(fs); - if (ret < 0) - { - goto errout_with_semaphore; - } - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_rmdir - * - * Description: Remove a directory - * - ****************************************************************************/ - -int fat_rmdir(struct inode *mountpt, const char *relpath) -{ - struct fat_mountpt_s *fs; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt && mountpt->i_private); - - /* Get the mountpoint private data from the inode structure */ - - fs = mountpt->i_private; - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret == OK) - { - /* If the directory is open, the correct behavior is to remove the directory - * name, but to keep the directory cluster chain in place until the last - * open reference to the directory is closed. - */ - -#warning "Need to defer deleting cluster chain if the directory is open" - - /* Remove the directory */ - - ret = fat_remove(fs, relpath, TRUE); - } - - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_rename - * - * Description: Rename a file or directory - * - ****************************************************************************/ - -int fat_rename(struct inode *mountpt, const char *oldrelpath, - const char *newrelpath) -{ - struct fat_mountpt_s *fs; - struct fat_dirinfo_s dirinfo; - size_t oldsector; - ubyte *olddirentry; - ubyte *newdirentry; - ubyte dirstate[32-11]; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt && mountpt->i_private); - - /* Get the mountpoint private data from the inode structure */ - - fs = mountpt->i_private; - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Find the directory entry for the oldrelpath */ - - ret = fat_finddirentry(fs, &dirinfo, oldrelpath); - if (ret != OK) - { - /* Some error occurred -- probably -ENOENT */ - - goto errout_with_semaphore; - } - - /* Save the information that will need to recover the - * directory sector and directory entry offset to the - * old directory. - */ - - olddirentry = dirinfo.fd_entry; - - /* One more check: Make sure that the oldrelpath does - * not refer to the root directory. We can't rename the - * root directory. - */ - - if (!olddirentry) - { - ret = -EXDEV; - goto errout_with_semaphore; - } - - oldsector = fs->fs_currentsector; - memcpy(dirstate, &olddirentry[DIR_ATTRIBUTES], 32-11); - - /* No find the directory where we should create the newpath object */ - - ret = fat_finddirentry(fs, &dirinfo, newrelpath); - if (ret == OK) - { - /* It is an error if the object at newrelpath already exists */ - - ret = -EEXIST; - goto errout_with_semaphore; - } - - /* What we expect is -ENOENT mean that the full directory path was - * followed but that the object does not exists in the terminal directory. - */ - - if (ret != -ENOENT) - { - goto errout_with_semaphore; - } - - /* Reserve a directory entry */ - - ret = fat_allocatedirentry(fs, &dirinfo); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Create the new directory entry */ - - newdirentry = dirinfo.fd_entry; - - memcpy(&newdirentry[DIR_ATTRIBUTES], dirstate, 32-11); - memcpy(&newdirentry[DIR_NAME], dirinfo.fd_name, 8+3); -#ifdef CONFIG_FLAT_LCNAMES - DIR_PUTNTRES(newdirentry, dirinfo.fd_ntflags); -#else - DIR_PUTNTRES(newdirentry, 0); -#endif - fs->fs_dirty = TRUE; - - /* Now flush the new directory entry to disk and read the sector - * containing the old directory entry. - */ - - ret = fat_fscacheread(fs, oldsector); - if (ret < 0) - { - goto errout_with_semaphore; - } - - /* Remove the old entry */ - - olddirentry[DIR_NAME] = DIR0_EMPTY; - fs->fs_dirty = TRUE; - - /* Write the old entry to disk and update FSINFO if necessary */ - - ret = fat_updatefsinfo(fs); - if (ret < 0) - { - goto errout_with_semaphore; - } - - fat_semgive(fs); - return OK; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Name: fat_stat - * - * Description: Return information about a file or directory - * - ****************************************************************************/ - -static int fat_stat(struct inode *mountpt, const char *relpath, struct stat *buf) -{ - struct fat_mountpt_s *fs; - struct fat_dirinfo_s dirinfo; - uint16 date; - uint16 date2; - uint16 time; - ubyte attribute; - int ret; - - /* Sanity checks */ - - DEBUGASSERT(mountpt && mountpt->i_private); - - /* Get the mountpoint private data from the inode structure */ - - fs = mountpt->i_private; - - /* Check if the mount is still healthy */ - - fat_semtake(fs); - ret = fat_checkmount(fs); - if (ret != OK) - { - goto errout_with_semaphore; - } - - /* Find the directory entry corresponding to relpath. */ - - ret = fat_finddirentry(fs, &dirinfo, relpath); - - /* If nothing was found, then we fail with EEXIST */ - - if (ret < 0) - { - goto errout_with_semaphore; - } - - memset(buf, 0, sizeof(struct stat)); - if (!dirinfo.fd_entry) - { - /* It's directory name of mount point */ - - buf->st_mode = S_IFDIR|S_IROTH|S_IRGRP|S_IRUSR|S_IWOTH|S_IWGRP|S_IWUSR; - ret = OK; - goto errout_with_semaphore; - } - - /* Get the FAT attribute and map it so some meaningful mode_t values */ - - attribute = DIR_GETATTRIBUTES(dirinfo.fd_entry); - if ((attribute & FATATTR_VOLUMEID) != 0) - { - ret = -ENOENT; - goto errout_with_semaphore; - } - - /* Set the access permissions. The file/directory is always readable - * by everyone but may be writeable by no-one. - */ - - buf->st_mode = S_IROTH|S_IRGRP|S_IRUSR; - if ((attribute & FATATTR_READONLY) == 0) - { - buf->st_mode |= S_IWOTH|S_IWGRP|S_IWUSR; - } - - /* We will report only types file or directory */ - - if ((attribute & FATATTR_DIRECTORY) != 0) - { - buf->st_mode |= S_IFDIR; - } - else - { - buf->st_mode |= S_IFREG; - } - - /* File/directory size, access block size */ - - buf->st_size = DIR_GETFILESIZE(dirinfo.fd_entry); - buf->st_blksize = fs->fs_fatsecperclus * fs->fs_hwsectorsize; - buf->st_blocks = (buf->st_size + buf->st_blksize - 1) / buf->st_blksize; - - /* Times */ - - date = DIR_GETWRTDATE(dirinfo.fd_entry); - time = DIR_GETWRTTIME(dirinfo.fd_entry); - buf->st_mtime = fat_fattime2systime(time, date); - - date2 = DIR_GETLASTACCDATE(dirinfo.fd_entry); - if (date == date2) - { - buf->st_atime = buf->st_mtime; - } - else - { - buf->st_atime = fat_fattime2systime(0, date2); - } - - date = DIR_GETCRDATE(dirinfo.fd_entry); - time = DIR_GETCRTIME(dirinfo.fd_entry); - buf->st_ctime = fat_fattime2systime(time, date); - - ret = OK; - -errout_with_semaphore: - fat_semgive(fs); - return ret; -} - -/**************************************************************************** - * Public Functions - ****************************************************************************/ - |