/**
* ntfs_device_unix_io_open - Open a device and lock it exclusively
* @dev:
* @flags:
*
* Description...
*
* Returns:
*/
static int ntfs_device_unix_io_open(struct ntfs_device *dev, int flags)
{
struct flock flk;
struct stat sbuf;
int err;
if (NDevOpen(dev)) {
errno = EBUSY;
return -1;
}
if (stat(dev->d_name, &sbuf)) {
ntfs_log_perror("Failed to access '%s'", dev->d_name);
return -1;
}
if (S_ISBLK(sbuf.st_mode))
NDevSetBlock(dev);
dev->d_private = ntfs_malloc(sizeof(int));
if (!dev->d_private)
return -1;
/*
* Open file for exclusive access if mounting r/w.
* Fuseblk takes care about block devices.
*/
if (!NDevBlock(dev) && (flags & O_RDWR) == O_RDWR)
flags |= O_EXCL;
*(int*)dev->d_private = open(dev->d_name, flags);
if (*(int*)dev->d_private == -1) {
err = errno;
goto err_out;
}
if ((flags & O_RDWR) != O_RDWR)
NDevSetReadOnly(dev);
memset(&flk, 0, sizeof(flk));
if (NDevReadOnly(dev))
flk.l_type = F_RDLCK;
else
flk.l_type = F_WRLCK;
flk.l_whence = SEEK_SET;
flk.l_start = flk.l_len = 0LL;
if (fcntl(DEV_FD(dev), F_SETLK, &flk)) {
err = errno;
ntfs_log_perror("Failed to %s lock '%s'", NDevReadOnly(dev) ?
"read" : "write", dev->d_name);
if (close(DEV_FD(dev)))
ntfs_log_perror("Failed to close '%s'", dev->d_name);
goto err_out;
}
NDevSetOpen(dev);
return 0;
err_out:
free(dev->d_private);
dev->d_private = NULL;
errno = err;
return -1;
}
/**
* ntfs_device_unix_io_open - Open a device and lock it exclusively
* @dev:
* @flags:
*
* Description...
*
* Returns:
*/
static int ntfs_device_unix_io_open(struct ntfs_device *dev, int flags)
{
struct flock flk;
struct stat sbuf;
int err;
if (NDevOpen(dev)) {
errno = EBUSY;
return -1;
}
if (!(dev->d_private = ntfs_malloc(sizeof(int))))
return -1;
*(int*)dev->d_private = open(dev->d_name, flags);
if (*(int*)dev->d_private == -1) {
err = errno;
goto err_out;
}
/* Setup our read-only flag. */
if ((flags & O_RDWR) != O_RDWR)
NDevSetReadOnly(dev);
/* Acquire exclusive (mandatory) lock on the whole device. */
memset(&flk, 0, sizeof(flk));
if (NDevReadOnly(dev))
flk.l_type = F_RDLCK;
else
flk.l_type = F_WRLCK;
flk.l_whence = SEEK_SET;
flk.l_start = flk.l_len = 0LL;
if (fcntl(DEV_FD(dev), F_SETLK, &flk)) {
err = errno;
ntfs_log_debug("ntfs_device_unix_io_open: Could not lock %s "
"for %s\n", dev->d_name, NDevReadOnly(dev) ?
"reading" : "writing");
if (close(DEV_FD(dev)))
ntfs_log_perror("ntfs_device_unix_io_open: Warning: "
"Could not close %s", dev->d_name);
goto err_out;
}
/* Determine if device is a block device or not, ignoring errors. */
if (!fstat(DEV_FD(dev), &sbuf) && S_ISBLK(sbuf.st_mode))
NDevSetBlock(dev);
/* Set our open flag. */
NDevSetOpen(dev);
return 0;
err_out:
free(dev->d_private);
dev->d_private = NULL;
errno = err;
return -1;
}
static int ntfs_device_uefi_io_open(struct ntfs_device *dev, int flags)
{
NTFS_BOOT_SECTOR *boot;
EFI_DISK_IO_PROTOCOL *DiskIo;
NTFS_VOLUME *Volume;
struct _uefi_fd *fd = DEV_FD(dev);
Volume = fd->interface;
ntfs_log_trace("dev %p, flags %i\n", dev, flags);
// Get the device driver descriptor
if (!fd) {
errno = EBADF;
return -1;
}
// Get the device interface
DiskIo = Volume->DiskIo;
if (!DiskIo) {
errno = ENODEV;
return -1;
}
// Start the device interface and ensure that it is inserted
//if (!interface->startup()) {
// ntfs_log_perror("device failed to start\n");
// errno = EIO;
// return -1;
// }
//if (!interface->isInserted()) {
// ntfs_log_perror("device media is not inserted\n");
// errno = EIO;
// return -1;
//}
// Check that the device isn't already open (used by another volume?)
if (NDevOpen(dev)) {
//AsciiPrint("ntfs_device_uefi_io_open...BUSY\n\r");
ntfs_log_perror("device is busy (already open)\n");
errno = EBUSY;
return -1;
}
// Check that there is a valid NTFS boot sector at the start of the device
boot = (NTFS_BOOT_SECTOR *) ntfs_alloc(MAX_SECTOR_SIZE);
if(boot == NULL) {
//AsciiPrint("ntfs_device_uefi_io_open...ENOMEM\n\r");
errno = ENOMEM;
return -1;
}
if (DiskIo->ReadDisk(DiskIo, Volume->MediaId, 0, sizeof(NTFS_BOOT_SECTOR), boot) != EFI_SUCCESS) {
//AsciiPrint("DiskIo ptr %x\n\r", DiskIo);
//AsciiPrint("interface ptr %x\n\r", fd->interface);
//AsciiPrint("DiskIo->ReadDisk(%x,%x,%x)\n\r", fd->interface->MediaId, fd->startSector * fd->sectorSize, sizeof(NTFS_BOOT_SECTOR));
//AsciiPrint("Sector size: %x\n\r", fd->sectorSize);
//AsciiPrint("ntfs_device_uefi_io_open...read failure boot sector\n\r");
ntfs_log_perror("read failure @ sector %x\n", fd->startSector);
errno = EIO;
ntfs_free(boot);
return -1;
}
if (!ntfs_boot_sector_is_ntfs(boot)) {
//AsciiPrint("ntfs_device_uefi_io_open...EINVALIDPART\n\r");
errno = EINVALPART;
ntfs_free(boot);
return -1;
}
// Parse the boot sector
fd->hiddenSectors = le32_to_cpu(boot->bpb.hidden_sectors);
fd->sectorSize = le16_to_cpu(boot->bpb.bytes_per_sector);
fd->sectorCount = sle64_to_cpu(boot->number_of_sectors);
fd->pos = 0;
fd->len = (fd->sectorCount * fd->sectorSize);
fd->ino = le64_to_cpu(boot->volume_serial_number);
// Free memory for boot sector
ntfs_free(boot);
// Mark the device as read-only (if required)
if (flags & O_RDONLY) {
NDevSetReadOnly(dev);
}
// cache disabled!
fd->cache = NULL;
//_NTFS_cache_constructor(fd->cachePageCount, fd->cachePageSize, interface, fd->startSector + fd->sectorCount, fd->sectorSize);
// Mark the device as open
NDevSetBlock(dev);
NDevSetOpen(dev);
//AsciiPrint("ntfs_device_uefi_io_open...success\n\r");
return 0;
}