9a1b726bae
This change reflects that the geometry isn't related to the largest allocatable unit on the platform. Calls to read and write block devices are also affected and have been updated.
487 lines
13 KiB
C
487 lines
13 KiB
C
/****************************************************************************
|
|
* drivers/loop/losetup.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 <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mount.h>
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <debug.h>
|
|
#include <errno.h>
|
|
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/fs/fs.h>
|
|
#include <nuttx/fs/loop.h>
|
|
#include <nuttx/semaphore.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
#define loop_semgive(d) nxsem_post(&(d)->sem) /* To match loop_semtake */
|
|
#define MAX_OPENCNT (255) /* Limit of uint8_t */
|
|
|
|
/****************************************************************************
|
|
* Private Types
|
|
****************************************************************************/
|
|
|
|
struct loop_struct_s
|
|
{
|
|
sem_t sem; /* For safe read-modify-write operations */
|
|
uint32_t nsectors; /* Number of sectors on device */
|
|
off_t offset; /* Offset (in bytes) to the first sector */
|
|
uint16_t sectsize; /* The size of one sector */
|
|
uint8_t opencnt; /* Count of open references to the loop device */
|
|
bool writeenabled; /* true: can write to device */
|
|
struct file devfile; /* File struct of char device/file */
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
static int loop_semtake(FAR struct loop_struct_s *dev);
|
|
static int loop_open(FAR struct inode *inode);
|
|
static int loop_close(FAR struct inode *inode);
|
|
static ssize_t loop_read(FAR struct inode *inode, FAR unsigned char *buffer,
|
|
blkcnt_t start_sector, unsigned int nsectors);
|
|
static ssize_t loop_write(FAR struct inode *inode,
|
|
FAR const unsigned char *buffer,
|
|
blkcnt_t start_sector, unsigned int nsectors);
|
|
static int loop_geometry(FAR struct inode *inode,
|
|
FAR struct geometry *geometry);
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static const struct block_operations g_bops =
|
|
{
|
|
loop_open, /* open */
|
|
loop_close, /* close */
|
|
loop_read, /* read */
|
|
loop_write, /* write */
|
|
loop_geometry, /* geometry */
|
|
NULL /* ioctl */
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
, NULL /* unlink */
|
|
#endif
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: loop_semtake
|
|
****************************************************************************/
|
|
|
|
static int loop_semtake(FAR struct loop_struct_s *dev)
|
|
{
|
|
return nxsem_wait(&dev->sem);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: loop_open
|
|
*
|
|
* Description: Open the block device
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int loop_open(FAR struct inode *inode)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
int ret;
|
|
|
|
DEBUGASSERT(inode && inode->i_private);
|
|
dev = (FAR struct loop_struct_s *)inode->i_private;
|
|
|
|
/* Make sure we have exclusive access to the state structure */
|
|
|
|
ret = loop_semtake(dev);
|
|
if (ret == OK)
|
|
{
|
|
if (dev->opencnt == MAX_OPENCNT)
|
|
{
|
|
ret = -EMFILE;
|
|
}
|
|
else
|
|
{
|
|
/* Increment the open count */
|
|
|
|
dev->opencnt++;
|
|
}
|
|
|
|
loop_semgive(dev);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: loop_close
|
|
*
|
|
* Description: close the block device
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int loop_close(FAR struct inode *inode)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
int ret;
|
|
|
|
DEBUGASSERT(inode && inode->i_private);
|
|
dev = (FAR struct loop_struct_s *)inode->i_private;
|
|
|
|
/* Make sure we have exclusive access to the state structure */
|
|
|
|
ret = loop_semtake(dev);
|
|
if (ret == OK)
|
|
{
|
|
if (dev->opencnt == 0)
|
|
{
|
|
ret = -EIO;
|
|
}
|
|
else
|
|
{
|
|
/* Decrement the open count */
|
|
|
|
dev->opencnt--;
|
|
}
|
|
|
|
loop_semgive(dev);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: loop_read
|
|
*
|
|
* Description: Read the specified number of sectors
|
|
*
|
|
****************************************************************************/
|
|
|
|
static ssize_t loop_read(FAR struct inode *inode, FAR unsigned char *buffer,
|
|
blkcnt_t start_sector, unsigned int nsectors)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
ssize_t nbytesread;
|
|
off_t offset;
|
|
off_t ret;
|
|
|
|
DEBUGASSERT(inode && inode->i_private);
|
|
dev = (FAR struct loop_struct_s *)inode->i_private;
|
|
|
|
if (start_sector + nsectors > dev->nsectors)
|
|
{
|
|
ferr("ERROR: Read past end of file\n");
|
|
return -EIO;
|
|
}
|
|
|
|
/* Calculate the offset to read the sectors and seek to the position */
|
|
|
|
offset = start_sector * dev->sectsize + dev->offset;
|
|
ret = file_seek(&dev->devfile, offset, SEEK_SET);
|
|
if (ret < 0)
|
|
{
|
|
ferr("ERROR: Seek failed for offset=%d: %d\n", (int)offset, (int)ret);
|
|
return -EIO;
|
|
}
|
|
|
|
/* Then read the requested number of sectors from that position */
|
|
|
|
do
|
|
{
|
|
nbytesread = file_read(&dev->devfile, buffer,
|
|
nsectors * dev->sectsize);
|
|
if (nbytesread < 0 && nbytesread != -EINTR)
|
|
{
|
|
ferr("ERROR: Read failed: %zd\n", nbytesread);
|
|
return (int)nbytesread;
|
|
}
|
|
}
|
|
while (nbytesread < 0);
|
|
|
|
/* Return the number of sectors read */
|
|
|
|
return nbytesread / dev->sectsize;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: loop_write
|
|
*
|
|
* Description: Write the specified number of sectors
|
|
*
|
|
****************************************************************************/
|
|
|
|
static ssize_t loop_write(FAR struct inode *inode,
|
|
FAR const unsigned char *buffer,
|
|
blkcnt_t start_sector, unsigned int nsectors)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
ssize_t nbyteswritten;
|
|
off_t offset;
|
|
off_t ret;
|
|
|
|
DEBUGASSERT(inode && inode->i_private);
|
|
dev = (FAR struct loop_struct_s *)inode->i_private;
|
|
|
|
/* Calculate the offset to write the sectors and seek to the position */
|
|
|
|
offset = start_sector * dev->sectsize + dev->offset;
|
|
ret = file_seek(&dev->devfile, offset, SEEK_SET);
|
|
if (ret < 0)
|
|
{
|
|
ferr("ERROR: Seek failed for offset=%d: %d\n", (int)offset, (int)ret);
|
|
}
|
|
|
|
/* Then write the requested number of sectors to that position */
|
|
|
|
do
|
|
{
|
|
nbyteswritten = file_write(&dev->devfile, buffer,
|
|
nsectors * dev->sectsize);
|
|
if (nbyteswritten < 0 && nbyteswritten != -EINTR)
|
|
{
|
|
ferr("ERROR: nx_write failed: %zd\n", nbyteswritten);
|
|
return nbyteswritten;
|
|
}
|
|
}
|
|
while (nbyteswritten < 0);
|
|
|
|
/* Return the number of sectors written */
|
|
|
|
return nbyteswritten / dev->sectsize;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: loop_geometry
|
|
*
|
|
* Description: Return device geometry
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int loop_geometry(FAR struct inode *inode,
|
|
FAR struct geometry *geometry)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
|
|
DEBUGASSERT(inode);
|
|
if (geometry)
|
|
{
|
|
dev = (FAR struct loop_struct_s *)inode->i_private;
|
|
geometry->geo_available = true;
|
|
geometry->geo_mediachanged = false;
|
|
geometry->geo_writeenabled = dev->writeenabled;
|
|
geometry->geo_nsectors = dev->nsectors;
|
|
geometry->geo_sectorsize = dev->sectsize;
|
|
return OK;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: losetup
|
|
*
|
|
* Description:
|
|
* Setup the loop device so that it exports the file referenced by
|
|
* 'filename' as a block device.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int losetup(FAR const char *devname, FAR const char *filename,
|
|
uint16_t sectsize, off_t offset, bool readonly)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
struct stat sb;
|
|
int ret;
|
|
|
|
/* Sanity check */
|
|
|
|
#ifdef CONFIG_DEBUG_FEATURES
|
|
if (devname == NULL || filename == NULL || sectsize == 0)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
#endif
|
|
|
|
/* Get the size of the file */
|
|
|
|
ret = nx_stat(filename, &sb, 1);
|
|
if (ret < 0)
|
|
{
|
|
ferr("ERROR: Failed to stat %s: %d\n", filename, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Check if the file system is big enough for one block */
|
|
|
|
if (sb.st_size - offset < sectsize)
|
|
{
|
|
ferr("ERROR: File is too small for blocksize\n");
|
|
return -ERANGE;
|
|
}
|
|
|
|
/* Allocate a loop device structure */
|
|
|
|
dev = (FAR struct loop_struct_s *)
|
|
kmm_zalloc(sizeof(struct loop_struct_s));
|
|
if (dev == NULL)
|
|
{
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Initialize the loop device structure. */
|
|
|
|
nxsem_init(&dev->sem, 0, 1);
|
|
dev->nsectors = (sb.st_size - offset) / sectsize;
|
|
dev->sectsize = sectsize;
|
|
dev->offset = offset;
|
|
|
|
/* Open the file. */
|
|
|
|
/* First try to open the device R/W access (unless we are asked
|
|
* to open it readonly).
|
|
*/
|
|
|
|
ret = -ENOSYS;
|
|
if (!readonly)
|
|
{
|
|
ret = file_open(&dev->devfile, filename, O_RDWR);
|
|
}
|
|
|
|
if (ret >= 0)
|
|
{
|
|
dev->writeenabled = true; /* Success */
|
|
}
|
|
else
|
|
{
|
|
/* If that fails, then try to open the device read-only */
|
|
|
|
ret = file_open(&dev->devfile, filename, O_RDONLY);
|
|
if (ret < 0)
|
|
{
|
|
ferr("ERROR: Failed to open %s: %d\n", filename, ret);
|
|
goto errout_with_dev;
|
|
}
|
|
}
|
|
|
|
/* Inode private data will be reference to the loop device structure */
|
|
|
|
ret = register_blockdriver(devname, &g_bops, 0, dev);
|
|
if (ret < 0)
|
|
{
|
|
ferr("ERROR: register_blockdriver failed: %d\n", -ret);
|
|
goto errout_with_file;
|
|
}
|
|
|
|
return OK;
|
|
|
|
errout_with_file:
|
|
file_close(&dev->devfile);
|
|
|
|
errout_with_dev:
|
|
kmm_free(dev);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: loteardown
|
|
*
|
|
* Description:
|
|
* Undo the setup performed by losetup
|
|
*
|
|
****************************************************************************/
|
|
|
|
int loteardown(FAR const char *devname)
|
|
{
|
|
FAR struct loop_struct_s *dev;
|
|
FAR struct inode *inode;
|
|
int ret;
|
|
|
|
/* Sanity check */
|
|
|
|
#ifdef CONFIG_DEBUG_FEATURES
|
|
if (devname == NULL)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
#endif
|
|
|
|
/* Open the block driver associated with devname so that we can get the
|
|
* inode reference.
|
|
*/
|
|
|
|
ret = open_blockdriver(devname, MS_RDONLY, &inode);
|
|
if (ret < 0)
|
|
{
|
|
ferr("ERROR: Failed to open %s: %d\n", devname, -ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Inode private data is a reference to the loop device structure */
|
|
|
|
dev = (FAR struct loop_struct_s *)inode->i_private;
|
|
close_blockdriver(inode);
|
|
|
|
DEBUGASSERT(dev != NULL);
|
|
|
|
/* Are there still open references to the device */
|
|
|
|
if (dev->opencnt > 0)
|
|
{
|
|
return -EBUSY;
|
|
}
|
|
|
|
/* Otherwise, unregister the block device */
|
|
|
|
ret = unregister_blockdriver(devname);
|
|
|
|
/* Release the device structure */
|
|
|
|
if (dev->devfile.f_inode != NULL)
|
|
{
|
|
file_close(&dev->devfile);
|
|
}
|
|
|
|
kmm_free(dev);
|
|
return ret;
|
|
}
|