int ntfsMountAll (ntfs_md **mounts, u32 flags)
{
const INTERFACE_ID *discs = ntfsGetDiscInterfaces();
const INTERFACE_ID *disc = NULL;
ntfs_md mount_points[NTFS_MAX_MOUNTS];
sec_t *partitions = NULL;
int mount_count = 0;
int partition_count = 0;
char name[128];
int i, j, k;
// Initialise ntfs-3g
ntfsInit();
// Find and mount all NTFS partitions on all known devices
for (i = 0; discs[i].name != NULL && discs[i].interface != NULL; i++) {
disc = &discs[i];
partition_count = ntfsFindPartitions(disc->interface, &partitions);
if (partition_count > 0 && partitions) {
for (j = 0, k = 0; j < partition_count; j++) {
// Find the next unused mount name
do {
sprintf(name, "%s%i", NTFS_MOUNT_PREFIX, k++);
if (k >= NTFS_MAX_MOUNTS) {
ntfs_free(partitions);
errno = EADDRNOTAVAIL;
return -1;
}
} while (ntfsGetDevice(name, false));
// Mount the partition
if (mount_count < NTFS_MAX_MOUNTS) {
if (ntfsMount(name, disc->interface, partitions[j], CACHE_DEFAULT_PAGE_SIZE, CACHE_DEFAULT_PAGE_COUNT, flags)) {
strcpy(mount_points[mount_count].name, name);
mount_points[mount_count].interface = disc->interface;
mount_points[mount_count].startSector = partitions[j];
mount_count++;
}
}
}
ntfs_free(partitions);
}
}
// Return the mounts (if any)
if (mount_count > 0 && mounts) {
*mounts = (ntfs_md*)ntfs_alloc(sizeof(ntfs_md) * mount_count);
if (*mounts) {
memcpy(*mounts, &mount_points, sizeof(ntfs_md) * mount_count);
return mount_count;
}
}
return 0;
}
ntfs_vd *ntfsGetVolume (const char *path)
{
// Get the volume descriptor from the paths associated devoptab (if found)
const devoptab_t *devoptab_ntfs = ntfsGetDevOpTab();
const devoptab_t *devoptab = ntfsGetDevice(path, true);
if (devoptab && devoptab_ntfs && (devoptab->open_r == devoptab_ntfs->open_r))
return (ntfs_vd*)devoptab->deviceData;
return NULL;
}
bool ntfsMount (const char *name, const DISC_INTERFACE *interface, sec_t startSector, u32 cachePageCount, u32 cachePageSize, u32 flags)
{
ntfs_vd *vd = NULL;
gekko_fd *fd = NULL;
// Sanity check
if (!name || !interface) {
errno = EINVAL;
return -1;
}
// Initialise ntfs-3g
ntfsInit();
// Check that the requested mount name is free
if (ntfsGetDevice(name, false)) {
errno = EADDRINUSE;
return false;
}
// Check that we can at least read from this device
if (!(interface->features & FEATURE_MEDIUM_CANREAD)) {
errno = EPERM;
return false;
}
// Allocate the volume descriptor
vd = (ntfs_vd*)ntfs_alloc(sizeof(ntfs_vd));
if (!vd) {
errno = ENOMEM;
return false;
}
// Setup the volume descriptor
vd->id = interface->ioType;
vd->flags = 0;
vd->uid = 0;
vd->gid = 0;
vd->fmask = 0;
vd->dmask = 0;
vd->atime = ((flags & NTFS_UPDATE_ACCESS_TIMES) ? ATIME_ENABLED : ATIME_DISABLED);
vd->showHiddenFiles = (flags & NTFS_SHOW_HIDDEN_FILES);
vd->showSystemFiles = (flags & NTFS_SHOW_SYSTEM_FILES);
// Allocate the device driver descriptor
fd = (gekko_fd*)ntfs_alloc(sizeof(gekko_fd));
if (!fd) {
ntfs_free(vd);
errno = ENOMEM;
return false;
}
// Setup the device driver descriptor
fd->interface = interface;
fd->startSector = startSector;
fd->sectorSize = 0;
fd->sectorCount = 0;
fd->cachePageCount = cachePageCount;
fd->cachePageSize = cachePageSize;
// Allocate the device driver
vd->dev = ntfs_device_alloc(name, 0, &ntfs_device_gekko_io_ops, fd);
if (!vd->dev) {
ntfs_free(fd);
ntfs_free(vd);
return false;
}
// Build the mount flags
if (flags & NTFS_READ_ONLY)
vd->flags |= MS_RDONLY;
else
{
if (!(interface->features & FEATURE_MEDIUM_CANWRITE))
vd->flags |= MS_RDONLY;
if ((interface->features & FEATURE_MEDIUM_CANREAD) && (interface->features & FEATURE_MEDIUM_CANWRITE))
vd->flags |= MS_EXCLUSIVE;
}
if (flags & NTFS_RECOVER)
vd->flags |= MS_RECOVER;
if (flags & NTFS_IGNORE_HIBERFILE)
vd->flags |= MS_IGNORE_HIBERFILE;
if (vd->flags & MS_RDONLY)
ntfs_log_debug("Mounting \"%s\" as read-only\n", name);
// Mount the device
vd->vol = ntfs_device_mount(vd->dev, vd->flags);
if (!vd->vol) {
switch(ntfs_volume_error(errno)) {
case NTFS_VOLUME_NOT_NTFS:
errno = EINVALPART;
break;
case NTFS_VOLUME_CORRUPT:
errno = EINVALPART;
break;
case NTFS_VOLUME_HIBERNATED:
errno = EHIBERNATED;
break;
case NTFS_VOLUME_UNCLEAN_UNMOUNT:
errno = EDIRTY;
break;
default:
errno = EINVAL;
break;
}
ntfs_device_free(vd->dev);
ntfs_free(vd);
return false;
}
// Initialise the volume descriptor
if (ntfsInitVolume(vd)) {
ntfs_umount(vd->vol, true);
ntfs_free(vd);
return false;
}
// Add the device to the devoptab table
if (ntfsAddDevice(name, vd)) {
ntfsDeinitVolume(vd);
ntfs_umount(vd->vol, true);
ntfs_free(vd);
return false;
}
return true;
}
ntfs_vd *ntfsMount (const char *name, struct _NTFS_VOLUME *interface, sec_t startSector, u32 cachePageCount, u32 cachePageSize, u32 flags)
{
ntfs_vd *vd = NULL;
struct _uefi_fd *fd = NULL;
const devoptab_t *mnt;
//Print(L"ntfsMount %a\n", name);
//CpuBreakpoint();
// Sanity check
if (!name || !interface) {
//Print(L"ntfsMount EINVAL\n");
errno = EINVAL;
return false;
}
// Initialise ntfs-3g
ntfsInit();
mnt = ntfsGetDevice(name, false);
// Check that the requested mount name is free
if (mnt) {
//Print(L"ntfsMount EADDRINUSE\n");
errno = 99; //EADDRINUSE;
return (ntfs_vd*) mnt->deviceData; // previous mnt data!
}
// Allocate the volume descriptor
vd = (ntfs_vd*)ntfs_alloc(sizeof(ntfs_vd));
if (!vd) {
//Print(L"ntfsMount ENOMEM\n");
errno = ENOMEM;
return false;
}
else {
//Print(L"ntfsMount ntfs_vd!\n");
}
// Setup the volume descriptor
//Print(L"vd.id! [%x]\n", vd);
vd->id = 0;//interface->ioType;
//Print(L"vd.flags!\n");
vd->flags = 0;
vd->uid = 0;
vd->gid = 0;
vd->fmask = 0;
vd->dmask = 0;
vd->atime = ((flags & NTFS_UPDATE_ACCESS_TIMES) ? ATIME_ENABLED : ATIME_DISABLED);
vd->showHiddenFiles = (flags & NTFS_SHOW_HIDDEN_FILES);
vd->showSystemFiles = (flags & NTFS_SHOW_SYSTEM_FILES);
//Print(L"invoking ntfs_alloc!\n");
// Allocate the device driver descriptor
fd = (struct _uefi_fd *)ntfs_alloc(sizeof(struct _uefi_fd));
if (!fd) {
//Print(L"ntfsMount ENOMEM(2)\n");
ntfs_free(vd);
errno = ENOMEM;
return false;
}
else
{
//Print(L"ntfs_alloc uefi_fd\n");
}
// Setup the device driver descriptor
fd->interface = interface;
fd->startSector = startSector;
fd->sectorSize = 0x200;
fd->sectorCount = 0x200;
fd->cachePageCount = cachePageCount;
fd->cachePageSize = cachePageSize;
// Allocate the device driver
vd->dev = ntfs_device_alloc(name, 0, &ntfs_device_uefi_io_ops, fd);
if (!vd->dev) {
//Print(L"ntfsMount ntfs_device_alloc failed\n");
ntfs_free(fd);
ntfs_free(vd);
return false;
}
//Print(L"ntfs_device_alloc success\n");
// Build the mount flags
if (flags & NTFS_READ_ONLY)
vd->flags |= NTFS_MNT_RDONLY;
if (flags & NTFS_RECOVER)
vd->flags |= NTFS_MNT_RECOVER;
if (flags & NTFS_IGNORE_HIBERFILE)
vd->flags |= NTFS_MNT_IGNORE_HIBERFILE;
if (vd->flags & NTFS_MNT_RDONLY)
ntfs_log_debug("Mounting \"%s\" as read-only\n", name);
// Mount the device
//Print(L"Invoking ntfs_device_mount\n");
vd->vol = ntfs_device_mount(vd->dev, vd->flags);
if (!vd->vol) {
switch(ntfs_volume_error(errno)) {
case NTFS_VOLUME_NOT_NTFS: errno = EINVALPART; break;
case NTFS_VOLUME_CORRUPT: errno = EINVALPART; break;
case NTFS_VOLUME_HIBERNATED: errno = EHIBERNATED; break;
case NTFS_VOLUME_UNCLEAN_UNMOUNT: errno = EDIRTY; break;
default: errno = EINVAL; break;
}
ntfs_device_free(vd->dev);
ntfs_free(vd);
//Print(L"ntfsMount ntfs_device_mount FAILED (%x)\n", errno);
return NULL;
}
if (flags & NTFS_IGNORE_CASE)
ntfs_set_ignore_case(vd->vol);
// Initialise the volume descriptor
if (ntfsInitVolume(vd)) {
ntfs_umount(vd->vol, true);
ntfs_free(vd);
//Print(L"ntfsMount ntfsInitVolume failed\n");
return NULL;
}
// Add the device to the devoptab table
if (ntfsAddDevice(name, vd)) {
//Print(L"ntfsMount ntfsAddDevice failed\n");
ntfsDeinitVolume(vd);
ntfs_umount(vd->vol, true);
ntfs_free(vd);
return NULL;
}
//Print(L"ntfsMount done.\n");
return vd;
}