libs/newlib-cygwin
libs
/
newlib-cygwin
mirror of git://sourceware.org/git/newlib-cygwin.git
4
0
Fork 0
Code Issues Projects Releases Wiki Activity
newlib-cygwin/winsup/cygwin/fhandler/dev_disk.cc

929 lines
26 KiB
C++
Raw Permalink Blame History

/* fhandler/dev_disk.cc: fhandler for the /dev/disk/by-id/... symlinks.
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#include "winsup.h"
#include "path.h"
#include "fhandler.h"
#include "tls_pbuf.h"
#include <storduid.h>
#include <wctype.h>
#include <winioctl.h>
/* Replace invalid characters. Optionally remove leading and trailing
characters. Return remaining string length. */
template <typename char_type, typename func_type>
static int
sanitize_string (char_type *s, char_type leading, char_type trailing,
char_type replace, func_type valid)
{
int first = 0;
if (leading)
while (s[first] == leading)
first++;
int len = -1, i;
for (i = 0; s[first + i]; i++)
{
char_type c = s[first + i];
if (c != trailing)
len = -1;
else if (len < 0)
len = i;
if (!valid (c))
c = replace;
else if (!first)
continue;
s[i] = c;
}
if (len < 0)
len = i;
s[len] = (char_type) 0;
return len;
}
/* Variant for device identify strings. */
static int
sanitize_id_string (char *s)
{
return sanitize_string (s, ' ', ' ', '_', [] (char c) -> bool
{
return (('0' <= c && c <= '9') || c == '.' || c == '-'
|| ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z'));
}
);
}
/* Variant for volume labels. */
static int
sanitize_label_string (WCHAR *s)
{
/* Linux does not skip leading spaces. */
return sanitize_string (s, L'\0', L' ', L'_', [] (WCHAR c) -> bool
{
/* Labels may contain characters not allowed in filenames. Also
replace '#' to avoid that duplicate markers introduce new
duplicates. Linux replaces spaces with \x20 which is not an
option here. */
return !(c == L'/' || c == L'\\' || c == L'#');
}
);
}
/* Fetch storage properties and create the ID string.
returns: 1: success, 0: device ignored, -1: IoControl error. */
static int
storprop_to_id_name (HANDLE devhdl, const UNICODE_STRING *upath,
char *ioctl_buf, char (& name)[NAME_MAX + 1])
{
DWORD bytes_read;
STORAGE_PROPERTY_QUERY descquery =
{ StorageDeviceProperty, PropertyStandardQuery, { 0 } };
if (!DeviceIoControl (devhdl, IOCTL_STORAGE_QUERY_PROPERTY,
&descquery, sizeof (descquery),
ioctl_buf, NT_MAX_PATH,
&bytes_read, nullptr))
{
__seterrno_from_win_error (GetLastError ());
debug_printf ("DeviceIoControl (%S, IOCTL_STORAGE_QUERY_PROPERTY,"
" {StorageDeviceProperty}): %E", upath);
return -1;
}
const STORAGE_DEVICE_DESCRIPTOR *desc =
reinterpret_cast<const STORAGE_DEVICE_DESCRIPTOR *>(ioctl_buf);
int vendor_len = 0, product_len = 0, serial_len = 0;
if (desc->VendorIdOffset)
vendor_len = sanitize_id_string (ioctl_buf + desc->VendorIdOffset);
if (desc->ProductIdOffset)
product_len = sanitize_id_string (ioctl_buf + desc->ProductIdOffset);
if (desc->SerialNumberOffset)
serial_len = sanitize_id_string (ioctl_buf + desc->SerialNumberOffset);
/* Ignore drive if information is empty or too long (should not happen). */
if (!((vendor_len || product_len) && (20/*bustype*/ + vendor_len + 1 +
product_len + 1 + serial_len + 1 + 34/*hash*/ + 1 + 10/*partN*/
< (int) sizeof (name))))
return 0;
/* Translate bus types. */
const char *bus;
switch (desc->BusType)
{
case BusTypeAta: bus = "ata-"; break;
case BusTypeFibre: bus = "fibre-"; break;
case BusTypeNvme: bus = "nvme-"; break;
case BusTypeRAID: bus = "raid-"; break;
case BusTypeSas: bus = "sas-"; break;
case BusTypeSata: bus = "sata-"; break;
case BusTypeScsi: bus = "scsi-"; break;
case BusTypeUsb: bus = "usb-"; break;
case BusTypeVirtual: bus = "virtual-"; break;
default: bus = nullptr; break;
}
/* Create "BUSTYPE-[VENDOR_]PRODUCT[_SERIAL]" string. */
char * cp = name;
if (bus)
cp = stpcpy (cp, bus);
else
cp += __small_sprintf (cp, "bustype%02_y-", desc->BusType);
if (vendor_len)
cp = stpcpy (cp, ioctl_buf + desc->VendorIdOffset);
if (product_len)
{
if (vendor_len)
cp = stpcpy (cp, "_");
cp = stpcpy (cp, ioctl_buf + desc->ProductIdOffset);
}
if (serial_len)
{
cp = stpcpy (cp, "_");
cp = stpcpy (cp, ioctl_buf + desc->SerialNumberOffset);
}
/* Add hash if information is too short (e.g. missing serial number). */
bool add_hash = !(4 <= vendor_len + product_len && 4 <= serial_len);
debug_printf ("%S: bustype: %02_y, add_hash: %d, id: '%s' '%s' '%s' ",
upath, (unsigned) desc->BusType, (int) add_hash,
(vendor_len ? ioctl_buf + desc->VendorIdOffset : ""),
(product_len ? ioctl_buf + desc->ProductIdOffset : ""),
(serial_len ? ioctl_buf + desc->SerialNumberOffset : ""));
if (!add_hash)
return 1;
/* The call below also returns the STORAGE_DEVICE_DESCRIPTOR used above.
MSDN documentation for STORAGE_DEVICE_UNIQUE_IDENTIFIER says:
"The device descriptor contains IDs that are extracted from non-VPD
inquiry data." This may mean that the serial number (part of
SCSI/SAS VPD data) may not always be provided. Therefore a separate
call to retrieve STORAGE_DEVICE_DESCRIPTOR only is done above. */
STORAGE_PROPERTY_QUERY idquery =
{ StorageDeviceUniqueIdProperty, PropertyStandardQuery, { 0 } };
if (!DeviceIoControl (devhdl, IOCTL_STORAGE_QUERY_PROPERTY,
&idquery, sizeof (idquery),
ioctl_buf, NT_MAX_PATH,
&bytes_read, nullptr))
{
__seterrno_from_win_error (GetLastError ());
debug_printf ("DeviceIoControl (%S, IOCTL_STORAGE_QUERY_PROPERTY,"
" {StorageDeviceUniqueIdProperty}): %E", upath);
return -1;
}
/* Utilize the DUID as defined by MSDN to generate a hash. */
const STORAGE_DEVICE_UNIQUE_IDENTIFIER *id =
reinterpret_cast<const STORAGE_DEVICE_UNIQUE_IDENTIFIER *>(ioctl_buf);
debug_printf ("STORAGE_DEVICE_UNIQUE_IDENTIFIER.Size: %u", id->Size);
__int128 hash = 0;
for (ULONG i = 0; i < id->Size; i++)
hash = ioctl_buf[i] + (hash << 6) + (hash << 16) - hash;
__small_sprintf (cp, "_%016_Y%016_X", (unsigned long long) (hash >> 64),
(unsigned long long) hash);
return 1;
}
/* ("HarddiskN", PART_NUM) -> "\\\\?\\Volume{GUID}\\" */
static bool
partition_to_volpath (const UNICODE_STRING *drive_uname, DWORD part_num,
WCHAR (& volpath)[MAX_PATH])
{
WCHAR gpath[MAX_PATH];
__small_swprintf (gpath, L"\\\\?\\GLOBALROOT\\Device\\%S\\Partition%u\\",
drive_uname, part_num);
if (!GetVolumeNameForVolumeMountPointW (gpath, volpath, sizeof(volpath)))
{
debug_printf ("GetVolumeNameForVolumeMountPointW(%W): %E", gpath);
return false;
}
debug_printf ("%W -> %W", gpath, volpath);
return true;
}
/* ("HarddiskN", PART_NUM) -> "x" */
static bool
partition_to_drive(const UNICODE_STRING *drive_uname, DWORD part_num,
WCHAR *w_buf, char *name)
{
WCHAR volpath[MAX_PATH];
if (!partition_to_volpath (drive_uname, part_num, volpath))
return false;
DWORD len;
if (!GetVolumePathNamesForVolumeNameW (volpath, w_buf, NT_MAX_PATH, &len))
{
debug_printf ("GetVolumePathNamesForVolumeNameW(%W): %E", volpath);
return false;
}
debug_printf ("%W -> '%W'%s", volpath, w_buf,
(w_buf[0] && wcschr (w_buf, L'\0')[1] ? ", ..." : ""));
/* Find first "X:\\", skip if not found.
FIXME: Support multiple drive letters. */
WCHAR *p;
for (p = w_buf; ; p = wcschr (p, L'\0') + 1)
{
if (!*p)
return false;
if (L'A' <= p[0] && p[0] <= L'Z' && p[1] == L':' && p[2] == L'\\' && !p[3])
break;
}
name[0] = (p[0] - L'A') + 'a';
name[1] = '\0';
return true;
}
/* ("HarddiskN", PART_NUM) -> "VOLUME_GUID" */
static bool
partition_to_voluuid(const UNICODE_STRING *drive_uname, DWORD part_num,
char *name)
{
WCHAR volpath[MAX_PATH];
if (!partition_to_volpath (drive_uname, part_num, volpath))
return false;
/* Skip if not "\\\\?\\Volume{GUID}...". */
static const WCHAR prefix[] = L"\\\\?\\Volume{";
const size_t prefix_len = sizeof (prefix) / sizeof(WCHAR) - 1, uuid_len = 36;
if (!(!wcsncmp (volpath, prefix, prefix_len)
&& volpath[prefix_len + uuid_len] == L'}'))
return false;
/* Extract GUID. */
volpath[prefix_len + uuid_len] = 0;
__small_sprintf (name, "%W", volpath + prefix_len);
if (!strncmp (name + 9, "0000-0000-00", 12) && !strcmp (name + 32, "0000"))
{
/* MBR "GUID": Use same SERIAL-OFFSET format as in by-partuuid directory.
SERIAL-0000-0000-009a-785634120000 -> SERIAL-123456789a00 */
for (int i = 9, j = 30; i < 19; i += 2, j -= 2)
{
if (j == 22) // name[j + 1] == '-'
j--;
name[i] = name[j];
name[i + 1] = name[j + 1];
}
name[21] = '\0';
}
return true;
}
/* ("HarddiskN", PART_NUM) -> "VOLUME_LABEL" or "VOLUME_SERIAL" */
static bool
partition_to_label_or_uuid(bool uuid, const UNICODE_STRING *drive_uname,
DWORD part_num, char *ioctl_buf, char *name)
{
WCHAR wpath[MAX_PATH];
/* Trailing backslash is required. */
size_t len = __small_swprintf (wpath, L"\\Device\\%S\\Partition%u\\",
drive_uname, part_num);
len *= sizeof (WCHAR);
UNICODE_STRING upath = {(USHORT) len, (USHORT) (len + 1), wpath};
OBJECT_ATTRIBUTES attr;
InitializeObjectAttributes (&attr, &upath, OBJ_CASE_INSENSITIVE, nullptr,
nullptr);
IO_STATUS_BLOCK io;
HANDLE volhdl;
NTSTATUS status = NtOpenFile (&volhdl, READ_CONTROL, &attr, &io,
FILE_SHARE_VALID_FLAGS, 0);
if (!NT_SUCCESS (status))
{
/* Fails with STATUS_UNRECOGNIZED_VOLUME (0xC000014F) if the
partition/filesystem type is unsupported. */
debug_printf ("NtOpenFile(%S), status %y", upath, status);
return false;
}
/* Check for possible 64-bit NTFS serial number first. */
DWORD bytes_read;
const NTFS_VOLUME_DATA_BUFFER *nvdb =
reinterpret_cast<const NTFS_VOLUME_DATA_BUFFER *>(ioctl_buf);
if (uuid && DeviceIoControl (volhdl, FSCTL_GET_NTFS_VOLUME_DATA, nullptr, 0,
ioctl_buf, NT_MAX_PATH, &bytes_read, nullptr))
{
/* Print without any separator as on Linux. */
__small_sprintf (name, "%016X", nvdb->VolumeSerialNumber.QuadPart);
NtClose(volhdl);
return true;
}
/* Get label and 32-bit serial number. */
status = NtQueryVolumeInformationFile (volhdl, &io, ioctl_buf,
NT_MAX_PATH, FileFsVolumeInformation);
NtClose(volhdl);
if (!NT_SUCCESS (status))
{
debug_printf ("NtQueryVolumeInformationFile(%S), status %y", upath,
status);
return false;
}
FILE_FS_VOLUME_INFORMATION *ffvi =
reinterpret_cast<FILE_FS_VOLUME_INFORMATION *>(ioctl_buf);
if (uuid)
/* Print with separator as on Linux. */
__small_sprintf (name, "%04x-%04x", ffvi->VolumeSerialNumber >> 16,
ffvi->VolumeSerialNumber & 0xffff);
else
{
/* Label is not null terminated. */
ffvi->VolumeLabel[ffvi->VolumeLabelLength / sizeof(WCHAR)] = L'\0';
int len = sanitize_label_string (ffvi->VolumeLabel);
if (!len)
return false;
__small_sprintf (name, "%W", ffvi->VolumeLabel);
}
return true;
}
struct by_id_entry
{
char name[NAME_MAX + 1];
u_int8_t drive;
u_int8_t part;
};
static int
by_id_compare_name (const void *a, const void *b)
{
const by_id_entry *ap = reinterpret_cast<const by_id_entry *>(a);
const by_id_entry *bp = reinterpret_cast<const by_id_entry *>(b);
return strcmp (ap->name, bp->name);
}
static int
by_id_compare_name_drive_part (const void *a, const void *b)
{
const by_id_entry *ap = reinterpret_cast<const by_id_entry *>(a);
const by_id_entry *bp = reinterpret_cast<const by_id_entry *>(b);
int cmp = strcmp (ap->name, bp->name);
if (cmp)
return cmp;
cmp = ap->drive - bp->drive;
if (cmp)
return cmp;
return ap->part - bp->part;
}
static by_id_entry *
by_id_realloc (by_id_entry *p, size_t n)
{
void *p2 = realloc (p, n * sizeof (*p));
if (!p2)
free (p);
return reinterpret_cast<by_id_entry *>(p2);
}
static bool
format_partuuid (char *name, const PARTITION_INFORMATION_EX *pix)
{
const GUID *guid;
switch (pix->PartitionStyle)
{
case PARTITION_STYLE_MBR: guid = &pix->Mbr.PartitionId; break;
case PARTITION_STYLE_GPT: guid = &pix->Gpt.PartitionId; break;
default: return false;
}
if (pix->PartitionStyle == PARTITION_STYLE_MBR && !guid->Data2
&& !guid->Data3 && !guid->Data4[6] && !guid->Data4[7])
/* MBR "GUID": SERIAL-0000-0000-00NN-NNNNNNN00000
Byte offset in LE order -----^^^^-^^^^^^^
Print as: SERIAL-OFFSET */
__small_sprintf(name,
"%08_x-%02_x%02_x%02_x%02_x%02_x%02_x",
guid->Data1, guid->Data4[5], guid->Data4[4], guid->Data4[3],
guid->Data4[2], guid->Data4[1], guid->Data4[0]);
else
__small_sprintf(name,
"%08_x-%04_x-%04_x-%02_x%02_x-%02_x%02_x%02_x%02_x%02_x%02_x",
guid->Data1, guid->Data2, guid->Data3,
guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
return true;
}
/* Create sorted name -> drive mapping table. Must be freed by caller. */
static int
get_by_id_table (by_id_entry * &table, fhandler_dev_disk::dev_disk_location loc)
{
table = nullptr;
/* Open \Device object directory. */
wchar_t wpath[MAX_PATH] = L"\\Device";
UNICODE_STRING upath = {14, 16, wpath};
OBJECT_ATTRIBUTES attr;
InitializeObjectAttributes (&attr, &upath, OBJ_CASE_INSENSITIVE, nullptr, nullptr);
HANDLE dirhdl;
NTSTATUS status = NtOpenDirectoryObject (&dirhdl, DIRECTORY_QUERY, &attr);
if (!NT_SUCCESS (status))
{
debug_printf ("NtOpenDirectoryObject, status %y", status);
__seterrno_from_nt_status (status);
return -1;
}
/* Limit disk and partition numbers like fhandler_dev::readdir (). */
const unsigned max_drive_num = 127, max_part_num = 63;
unsigned alloc_size = 0, table_size = 0;
tmp_pathbuf tp;
char *ioctl_buf = tp.c_get ();
char *ioctl_buf2 = (loc == fhandler_dev_disk::disk_by_label
|| loc == fhandler_dev_disk::disk_by_uuid ?
tp.c_get () : nullptr);
WCHAR *w_buf = (loc == fhandler_dev_disk::disk_by_drive ?
tp.w_get () : nullptr);
DIRECTORY_BASIC_INFORMATION *dbi_buf =
reinterpret_cast<DIRECTORY_BASIC_INFORMATION *>(tp.w_get ());
/* Traverse \Device directory ... */
bool errno_set = false;
HANDLE devhdl = nullptr;
BOOLEAN restart = TRUE;
bool last_run = false;
ULONG context = 0;
while (!last_run)
{
if (devhdl)
{
/* Close handle from previous run. */
NtClose(devhdl);
devhdl = nullptr;
}
status = NtQueryDirectoryObject (dirhdl, dbi_buf, 65536, FALSE, restart,
&context, nullptr);
if (!NT_SUCCESS (status))
{
__seterrno_from_nt_status (status);
errno_set = true;
debug_printf ("NtQueryDirectoryObject, status %y", status);
break;
}
if (status != STATUS_MORE_ENTRIES)
last_run = true;
restart = FALSE;
for (const DIRECTORY_BASIC_INFORMATION *dbi = dbi_buf;
dbi->ObjectName.Length > 0;
dbi++)
{
/* ... and check for a "Harddisk[0-9]*" entry. */
if (dbi->ObjectName.Length < 9 * sizeof (WCHAR)
|| wcsncasecmp (dbi->ObjectName.Buffer, L"Harddisk", 8) != 0
|| !iswdigit (dbi->ObjectName.Buffer[8]))
continue;
/* Got it. Now construct the path to the entire disk, which is
"\\Device\\HarddiskX\\Partition0", and open the disk with
minimum permissions. */
unsigned long drive_num = wcstoul (dbi->ObjectName.Buffer + 8,
nullptr, 10);
if (drive_num > max_drive_num)
continue;
wcscpy (wpath, dbi->ObjectName.Buffer);
PWCHAR wpart = wpath + dbi->ObjectName.Length / sizeof (WCHAR);
wcpcpy (wpart, L"\\Partition0");
upath.Length = dbi->ObjectName.Length + 22;
upath.MaximumLength = upath.Length + sizeof (WCHAR);
InitializeObjectAttributes (&attr, &upath, OBJ_CASE_INSENSITIVE,
dirhdl, nullptr);
/* SYNCHRONIZE access is required for IOCTL_STORAGE_QUERY_PROPERTY
for drives behind some drivers (nvmestor.sys). */
IO_STATUS_BLOCK io;
status = NtOpenFile (&devhdl, READ_CONTROL | SYNCHRONIZE, &attr, &io,
FILE_SHARE_VALID_FLAGS, 0);
if (!NT_SUCCESS (status))
{
devhdl = nullptr;
__seterrno_from_nt_status (status);
errno_set = true;
debug_printf ("NtOpenFile(%S), status %y", &upath, status);
continue;
}
/* Add table space for drive, partitions and end marker. */
if (alloc_size <= table_size + max_part_num)
{
alloc_size = table_size + max_part_num + 8;
table = by_id_realloc (table, alloc_size);
if (!table)
{
NtClose (devhdl);
NtClose (dirhdl);
return -1;
}
}
const char *drive_name = "";
if (loc == fhandler_dev_disk::disk_by_id)
{
/* Fetch storage properties and create the ID string. */
int rc = storprop_to_id_name (devhdl, &upath, ioctl_buf,
table[table_size].name);
if (rc <= 0)
{
if (rc < 0)
errno_set = true;
continue;
}
drive_name = table[table_size].name;
table[table_size].drive = drive_num;
table[table_size].part = 0;
table_size++;
}
/* Fetch drive layout info to information of all partitions on disk. */
DWORD bytes_read;
if (!DeviceIoControl (devhdl, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, nullptr, 0,
ioctl_buf, NT_MAX_PATH, &bytes_read, nullptr))
{
__seterrno_from_win_error (GetLastError ());
errno_set = true;
debug_printf ("DeviceIoControl(%S, "
"IOCTL_DISK_GET_DRIVE_LAYOUT_EX): %E", &upath);
continue;
}
/* Loop over partitions. */
const DRIVE_LAYOUT_INFORMATION_EX *dlix =
reinterpret_cast<const DRIVE_LAYOUT_INFORMATION_EX *>(ioctl_buf);
for (DWORD i = 0; i < dlix->PartitionCount; i++)
{
const PARTITION_INFORMATION_EX *pix = &dlix->PartitionEntry[i];
DWORD part_num = pix->PartitionNumber;
/* A partition number of 0 denotes an extended partition or a
filler entry as described in
fhandler_dev_floppy::lock_partition. Just skip. */
if (part_num == 0)
continue;
if (part_num > max_part_num)
break;
char *name = table[table_size].name;
switch (loc)
{
case fhandler_dev_disk::disk_by_drive:
if (!partition_to_drive (&dbi->ObjectName, part_num, w_buf, name))
continue;
break;
case fhandler_dev_disk::disk_by_id:
__small_sprintf (name, "%s-part%u", drive_name, part_num);
break;
case fhandler_dev_disk::disk_by_label:
if (!partition_to_label_or_uuid (false, &dbi->ObjectName,
part_num, ioctl_buf2, name))
continue;
break;
case fhandler_dev_disk::disk_by_partuuid:
if (!format_partuuid (name, pix))
continue;
break;
case fhandler_dev_disk::disk_by_uuid:
if (!partition_to_label_or_uuid (true, &dbi->ObjectName,
part_num, ioctl_buf2, name))
continue;
break;
case fhandler_dev_disk::disk_by_voluuid:
if (!partition_to_voluuid (&dbi->ObjectName, part_num, name))
continue;
break;
default: continue; /* Should not happen. */
}
table[table_size].drive = drive_num;
table[table_size].part = part_num;
table_size++;
}
}
}
if (devhdl)
NtClose(devhdl);
NtClose (dirhdl);
if (!table_size && table)
{
free (table);
table = nullptr;
}
if (!table)
return (errno_set ? -1 : 0);
/* Sort by {name, drive, part} to ensure stable sort order. */
qsort (table, table_size, sizeof (*table), by_id_compare_name_drive_part);
/* Mark duplicate names. */
for (unsigned i = 0; i < table_size; i++)
{
unsigned j = i + 1;
while (j < table_size && !strcmp (table[i].name, table[j].name))
j++;
if (j == i + 1)
continue;
/* Duplicate(s) found, append "#N" to all entries. This never
introduces new duplicates because '#' never occurs in the
original names. */
debug_printf ("mark duplicates %u-%u of '%s'", i, j - 1, table[i].name);
size_t len = strlen (table[i].name);
for (unsigned k = i; k < j; k++)
__small_sprintf (table[k].name + len, "#%u", k - i);
}
debug_printf ("table_size: %d", table_size);
return table_size;
}
const char dev_disk[] = "/dev/disk";
const size_t dev_disk_len = sizeof (dev_disk) - 1;
static const char by_drive[] = "/by-drive";
const size_t by_drive_len = sizeof(by_drive) - 1;
/* Keep this in sync with enum fhandler_dev_disk::dev_disk_location starting
at disk_by_drive. */
static const char * const by_dir_names[] {
"/by-drive", "/by-id", "/by-label",
"/by-partuuid", "/by-uuid", "/by-voluuid"
};
const size_t by_dir_names_size = sizeof(by_dir_names) / sizeof(by_dir_names[0]);
static_assert((size_t) fhandler_dev_disk::disk_by_drive + by_dir_names_size - 1
== (size_t) fhandler_dev_disk::disk_by_voluuid);
fhandler_dev_disk::fhandler_dev_disk ():
fhandler_virtual (),
loc (unknown_loc),
loc_is_link (false),
drive_from_id (-1),
part_from_id (0)
{
}
void
fhandler_dev_disk::init_dev_disk ()
{
if (loc != unknown_loc)
return;
/* Determine location. */
const char *path = get_name ();
size_t dirlen = 0;
loc = invalid_loc; // "/dev/disk/invalid"
if (!path_prefix_p (dev_disk, path, dev_disk_len, false))
; // should not happen
else if (!path[dev_disk_len])
loc = disk_dir; // "/dev/disk"
else
for (size_t i = 0; i < by_dir_names_size; i++)
{
const char *dir = by_dir_names[i];
size_t len = strlen(dir);
if (path_prefix_p (dir, path + dev_disk_len, len, false))
{
loc = (dev_disk_location) (disk_by_drive + i); // "/dev/disk/by-..."
dirlen = dev_disk_len + len;
break;
}
}
loc_is_link = false;
if (dirlen)
{
if (!path[dirlen])
; // "/dev/disk/by-..."
else if (!strchr (path + dirlen + 1, '/'))
loc_is_link = true; // "/dev/disk/by-.../LINK"
else
loc = invalid_loc; // "/dev/disk/by-.../dir/invalid"
}
debug_printf ("%s: loc %d, loc_is_link %d", path, (int) loc, (int) loc_is_link);
/* Done if directory or invalid. */
if (!loc_is_link)
return;
/* Check whether "/dev/disk/by-.../LINK" exists. */
by_id_entry *table;
int table_size = get_by_id_table (table, loc);
if (!table)
{
loc = invalid_loc;
return;
}
by_id_entry key;
strcpy (key.name, path + dirlen + 1);
const void *found = bsearch (&key, table, table_size, sizeof (*table),
by_id_compare_name);
if (found)
{
/* Preserve drive and partition numbers for fillbuf (). */
const by_id_entry *e = reinterpret_cast<const by_id_entry *>(found);
drive_from_id = e->drive;
part_from_id = e->part;
}
else
loc = invalid_loc;
free (table);
}
virtual_ftype_t
fhandler_dev_disk::exists ()
{
debug_printf ("exists (%s)", get_name ());
ensure_inited ();
if (loc == invalid_loc)
return virt_none;
else if (loc_is_link)
return virt_symlink;
else
return virt_directory;
}
int
fhandler_dev_disk::fstat (struct stat *buf)
{
debug_printf ("fstat (%s)", get_name ());
ensure_inited ();
if (loc == invalid_loc)
{
set_errno (ENOENT);
return -1;
}
fhandler_base::fstat (buf);
buf->st_mode = (loc_is_link ? S_IFLNK | S_IWUSR | S_IWGRP | S_IWOTH
: S_IFDIR) | STD_RBITS | STD_XBITS;
buf->st_ino = get_ino ();
return 0;
}
static inline by_id_entry **
dir_id_table (DIR *dir)
{
return reinterpret_cast<by_id_entry **>(&dir->__d_internal);
}
DIR *
fhandler_dev_disk::opendir (int fd)
{
ensure_inited ();
if (loc_is_link)
{
set_errno (ENOTDIR);
return nullptr;
}
by_id_entry *table = nullptr;
if (loc != disk_dir)
{
int table_size = get_by_id_table (table, loc);
if (table_size < 0)
return nullptr; /* errno is set. */
if (table)
{
/* Shrink to required table_size. */
table = by_id_realloc (table, table_size + 1);
if (!table)
return nullptr; /* Should not happen. */
/* Mark end of table for readdir (). */
table[table_size].name[0] = '\0';
}
}
DIR *dir = fhandler_virtual::opendir (fd);
if (!dir)
{
free (table);
return nullptr;
}
dir->__flags = dirent_saw_dot | dirent_saw_dot_dot;
*dir_id_table (dir) = table;
return dir;
}
int
fhandler_dev_disk::closedir (DIR *dir)
{
free (*dir_id_table (dir));
return fhandler_virtual::closedir (dir);
}
int
fhandler_dev_disk::readdir (DIR *dir, dirent *de)
{
int res;
if (dir->__d_position < 2)
{
de->d_name[0] = '.';
de->d_name[1] = (dir->__d_position ? '.' : '\0');
de->d_name[2] = '\0';
de->d_type = DT_DIR;
dir->__d_position++;
res = 0;
}
else if (loc == disk_dir && dir->__d_position < 2 + (int) by_dir_names_size)
{
strcpy (de->d_name, by_dir_names[dir->__d_position - 2] + 1);
de->d_type = DT_DIR;
dir->__d_position++;
res = 0;
}
else if (*dir_id_table (dir))
{
const char *name = (*dir_id_table (dir))[dir->__d_position - 2].name;
if (name[0])
{
strcpy (de->d_name, name);
de->d_type = DT_LNK;
dir->__d_position++;
res = 0;
}
else
res = ENMFILE;
}
else
res = ENMFILE;
syscall_printf ("%d = readdir(%p, %p) (%s)", res, dir, de,
(!res ? de->d_name : ""));
return res;
}
int
fhandler_dev_disk::open (int flags, mode_t mode)
{
ensure_inited ();
int err = 0;
if (!fhandler_virtual::open (flags, mode))
err = -1;
/* else if (loc_is_link) {} */ /* should not happen. */
else if (loc != invalid_loc)
{
if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
err = EEXIST;
else if (flags & O_WRONLY)
err = EISDIR;
else
diropen = true;
}
else
{
if (flags & O_CREAT)
err = EROFS;
else
err = ENOENT;
}
int res;
if (!err)
{
nohandle (true);
set_open_status ();
res = 1;
}
else
{
if (err > 0)
set_errno (err);
res = 0;
}
syscall_printf ("%d = fhandler_dev_disk::open(%y, 0%o)", res, flags, mode);
return res;
}
bool
fhandler_dev_disk::fill_filebuf ()
{
debug_printf ("fill_filebuf (%s)", get_name ());
ensure_inited ();
if (!(loc_is_link && drive_from_id >= 0))
return false;
char buf[32];
int len;
if (drive_from_id + 'a' <= 'z')
len = __small_sprintf (buf, "../../sd%c", drive_from_id + 'a');
else
len = __small_sprintf (buf, "../../sd%c%c",
drive_from_id / ('z' - 'a' + 1) - 1 + 'a',
drive_from_id % ('z' - 'a' + 1) + 'a');
if (part_from_id)
__small_sprintf (buf + len, "%d", part_from_id);
if (filebuf)
cfree (filebuf);
filebuf = cstrdup (buf);
return true;
}
Reference in New Issue View Git Blame Copy Permalink