From 5db1cd009e8dc6ff01fabdeb8cddf65d609bfe2f Mon Sep 17 00:00:00 2001 From: Christian Franke Date: Sat, 4 Nov 2023 16:49:28 +0100 Subject: [PATCH] Cygwin: Add /dev/disk/by-id symlinks The new directory '/dev/disk/by-id' provides symlinks for each disk and its partitions: 'BUSTYPE-[VENDOR_]PRODUCT_SERIAL[-partN]' -> '../../sdX[N]'. This is based on strings provided by STORAGE_DEVICE_DESCRIPTOR. If this information is too short, a 128-bit hash of the STORAGE_DEVICE_UNIQUE_IDENTIFIER raw data is added. Administrator privileges are not required. Signed-off-by: Christian Franke --- winsup/cygwin/Makefile.am | 1 + winsup/cygwin/devices.in | 4 + winsup/cygwin/dtable.cc | 3 + winsup/cygwin/fhandler/dev_disk.cc | 646 ++++++++++++++++++++++++ winsup/cygwin/local_includes/devices.h | 6 +- winsup/cygwin/local_includes/fhandler.h | 47 ++ winsup/cygwin/mount.cc | 10 + 7 files changed, 716 insertions(+), 1 deletion(-) create mode 100644 winsup/cygwin/fhandler/dev_disk.cc diff --git a/winsup/cygwin/Makefile.am b/winsup/cygwin/Makefile.am index 64b252a22..376c79fc3 100644 --- a/winsup/cygwin/Makefile.am +++ b/winsup/cygwin/Makefile.am @@ -84,6 +84,7 @@ FHANDLER_FILES= \ fhandler/console.cc \ fhandler/cygdrive.cc \ fhandler/dev.cc \ + fhandler/dev_disk.cc \ fhandler/dev_fd.cc \ fhandler/disk_file.cc \ fhandler/dsp.cc \ diff --git a/winsup/cygwin/devices.in b/winsup/cygwin/devices.in index 2545dd85e..48d3843fe 100644 --- a/winsup/cygwin/devices.in +++ b/winsup/cygwin/devices.in @@ -115,6 +115,9 @@ const _device dev_cygdrive_storage = const _device dev_fs_storage = {"", {FH_FS}, "", exists}; +const _device dev_dev_disk_storage = + {"", {FH_DEV_DISK}, "", exists}; + const _device dev_proc_storage = {"", {FH_PROC}, "", exists}; @@ -173,6 +176,7 @@ const _device dev_error_storage = the POSIX namespace. */ %% "/dev", BRACK(FH_DEV), "", exists, S_IFDIR +"/dev/disk", BRACK(FH_DEV_DISK), "", exists, S_IFDIR "/dev/tty", BRACK(FH_TTY), "/dev/tty", exists, S_IFCHR "/dev/pty%(0-127)d", BRACK(FHDEV(DEV_PTYS_MAJOR, {$1})), "/dev/pty{$1}", exists_pty, S_IFCHR, =ptys_dev ":ptym%(0-127)d", BRACK(FHDEV(DEV_PTYM_MAJOR, {$1})), "/dev/ptym{$1}", exists_internal, S_IFCHR, =ptym_dev diff --git a/winsup/cygwin/dtable.cc b/winsup/cygwin/dtable.cc index 21d525389..9508f3e0b 100644 --- a/winsup/cygwin/dtable.cc +++ b/winsup/cygwin/dtable.cc @@ -585,6 +585,9 @@ fh_alloc (path_conv& pc) case FH_DEV: fh = cnew (fhandler_dev); break; + case FH_DEV_DISK: + fh = cnew (fhandler_dev_disk); + break; case FH_DEV_FD: fh = cnew (fhandler_dev_fd); break; diff --git a/winsup/cygwin/fhandler/dev_disk.cc b/winsup/cygwin/fhandler/dev_disk.cc new file mode 100644 index 000000000..2cbe5434e --- /dev/null +++ b/winsup/cygwin/fhandler/dev_disk.cc @@ -0,0 +1,646 @@ +/* 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 +#include +#include + +/* Replace non-printing and unexpected characters, remove trailing spaces, + return remaining string length. */ +static int +sanitize_id_string (char *s) +{ + int lastspace = -1, i; + for (i = 0; s[i]; i++) + { + char c = s[i]; + if (c != ' ') + lastspace = -1; + else if (lastspace < 0) + lastspace = i; + if (('0' <= c && c <= '9') || c == '.' || c == '-' + || ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z')) + continue; + s[i] = '_'; + } + if (lastspace >= 0) + s[(i = lastspace)] = '\0'; + return i; +} + +/* 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(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(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; +} + +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(a); + const by_id_entry *bp = reinterpret_cast(b); + return strcmp (ap->name, bp->name); +} + +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(p2); +} + +/* Create sorted name -> drive mapping table. Must be freed by caller. */ +static int +get_by_id_table (by_id_entry * &table) +{ + 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 (); + DIRECTORY_BASIC_INFORMATION *dbi_buf = + reinterpret_cast(tp.w_get ()); + + /* Traverse \Device directory ... */ + bool errno_set = false; + HANDLE devhdl = INVALID_HANDLE_VALUE; + BOOLEAN restart = TRUE; + bool last_run = false; + ULONG context = 0; + while (!last_run) + { + if (devhdl != INVALID_HANDLE_VALUE) + { + /* Close handle from previous run. */ + NtClose(devhdl); + devhdl = INVALID_HANDLE_VALUE; + } + + 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 = INVALID_HANDLE_VALUE; + __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; + } + } + + /* 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; + } + int drive_index = table_size++; + size_t drive_len = strlen(table[drive_index].name); + table[drive_index].drive = drive_num; + table[drive_index].part = 0; + + /* Fetch drive layout info to get size of all partitions on disk. */ + DWORD part_cnt = 0; + PARTITION_INFORMATION_EX *pix = nullptr; + PARTITION_INFORMATION *pi = nullptr; + DWORD bytes_read; + if (DeviceIoControl (devhdl, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, nullptr, 0, + ioctl_buf, NT_MAX_PATH, &bytes_read, nullptr)) + { + DRIVE_LAYOUT_INFORMATION_EX *pdlix = + reinterpret_cast(ioctl_buf); + part_cnt = pdlix->PartitionCount; + pix = pdlix->PartitionEntry; + } + else if (DeviceIoControl (devhdl, IOCTL_DISK_GET_DRIVE_LAYOUT, nullptr, + 0, ioctl_buf, NT_MAX_PATH, &bytes_read, + nullptr)) + { + DRIVE_LAYOUT_INFORMATION *pdli = + reinterpret_cast(ioctl_buf); + part_cnt = pdli->PartitionCount; + pi = pdli->PartitionEntry; + } + else + debug_printf ("DeviceIoControl(%S, " + "IOCTL_DISK_GET_DRIVE_LAYOUT{_EX}): %E", &upath); + + /* Loop over partitions. */ + if (pix || pi) + for (DWORD i = 0; i < part_cnt; i++) + { + DWORD part_num; + if (pix) + { + part_num = pix->PartitionNumber; + ++pix; + } + else + { + part_num = pi->PartitionNumber; + ++pi; + } + /* 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; + table[table_size] = table[drive_index]; + __small_sprintf(table[table_size].name + drive_len, "-part%u", + part_num); + table[table_size].part = part_num; + table_size++; + } + } + } + if (devhdl != INVALID_HANDLE_VALUE) + NtClose(devhdl); + NtClose (dirhdl); + + if (!table_size && table) + { + free (table); + table = nullptr; + } + if (!table) + return (errno_set ? -1 : 0); + + /* Sort by name and remove duplicates. */ + qsort (table, table_size, sizeof (*table), by_id_compare_name); + 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, remove all entries with this name. */ + debug_printf ("removing duplicates %d-%d: '%s'", i, j - 1, table[i].name); + if (j < table_size) + memmove (table + i, table + j, (table_size - j) * sizeof (*table)); + table_size -= j - i; + 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; + +fhandler_dev_disk::fhandler_dev_disk (): + fhandler_virtual (), + loc (unknown_loc), + drive_from_id (-1), + part_from_id (0) +{ +} + +void +fhandler_dev_disk::init_dev_disk () +{ + if (loc != unknown_loc) + return; + + static const char by_id[] = "/by-id"; + const size_t by_id_len = sizeof(by_id) - 1; + + /* Determine location. */ + const char *path = get_name (); + if (!path_prefix_p (dev_disk, path, dev_disk_len, false)) + loc = invalid_loc; // should not happen + else if (!path[dev_disk_len]) + loc = disk_dir; // "/dev/disk" + else if (!path_prefix_p (by_id, path + dev_disk_len, by_id_len, false)) + loc = invalid_loc; // "/dev/disk/invalid" + else if (!path[dev_disk_len + by_id_len]) + loc = by_id_dir; // "/dev/disk/by-id" + else if (strchr (path + dev_disk_len + by_id_len + 1, '/')) + loc = invalid_loc; // "/dev/disk/by-id/dir/invalid" + else + loc = by_id_link; // possible "/dev/disk/by-id/LINK" + debug_printf ("'%s': loc %d", path, (int)loc); + + /* Done if "/dev/disk", "/dev/disk/by_id" or invalid. */ + if (loc != by_id_link) + return; + + /* Check whether "/dev/disk/by_id/LINK" exists. */ + by_id_entry *table; + int table_size = get_by_id_table (table); + if (!table) + { + loc = invalid_loc; + return; + } + + by_id_entry key; + strcpy (key.name, path + dev_disk_len + by_id_len + 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(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 (); + switch (loc) + { + case disk_dir: + case by_id_dir: + return virt_directory; + case by_id_link: + return virt_symlink; + default: + return virt_none; + } +} + +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 == by_id_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(&dir->__d_internal); +} + +DIR * +fhandler_dev_disk::opendir (int fd) +{ + ensure_inited (); + if (!(loc == disk_dir || loc == by_id_dir)) + { + set_errno (ENOTDIR); + return nullptr; + } + + by_id_entry *table = nullptr; + if (loc == by_id_dir) + { + int table_size = get_by_id_table (table); + 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) + { + strcpy (de->d_name, "by-id"); + de->d_type = DT_DIR; + dir->__d_position++; + res = 0; + } + else if (loc == by_id_dir && *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 == disk_dir || loc == by_id_dir) + { + if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) + err = EEXIST; + else if (flags & O_WRONLY) + err = EISDIR; + else + diropen = true; + } + /* else if (loc == by_id_link) { } */ /* should not happen */ + else /* (loc == invalid_loc) */ + { + 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 == by_id_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; +} diff --git a/winsup/cygwin/local_includes/devices.h b/winsup/cygwin/local_includes/devices.h index 10035263d..1e035f9d6 100644 --- a/winsup/cygwin/local_includes/devices.h +++ b/winsup/cygwin/local_includes/devices.h @@ -71,6 +71,7 @@ enum fh_devices FH_DEV = FHDEV (DEV_VIRTFS_MAJOR, 193), FH_CYGDRIVE= FHDEV (DEV_VIRTFS_MAJOR, 192), FH_DEV_FD = FHDEV (DEV_VIRTFS_MAJOR, 191), + FH_DEV_DISK= FHDEV (DEV_VIRTFS_MAJOR, 190), FH_SIGNALFD= FHDEV (DEV_VIRTFS_MAJOR, 13), FH_TIMERFD = FHDEV (DEV_VIRTFS_MAJOR, 14), @@ -415,6 +416,8 @@ extern const _device dev_piper_storage; #define piper_dev ((device *) &dev_piper_storage) extern const _device dev_pipew_storage; #define pipew_dev ((device *) &dev_pipew_storage) +extern const _device dev_dev_disk_storage; +#define dev_disk_dev ((device *) &dev_dev_disk_storage) extern const _device dev_proc_storage; #define proc_dev ((device *) &dev_proc_storage) extern const _device dev_dev_storage; @@ -439,7 +442,8 @@ extern const _device dev_fs_storage; #define isprocsys_dev(devn) (devn == FH_PROCSYS) #define isvirtual_dev(devn) \ - (isproc_dev (devn) || devn == FH_CYGDRIVE || devn == FH_NETDRIVE || devn == FH_DEV_FD) + (isproc_dev (devn) || devn == FH_CYGDRIVE || devn == FH_NETDRIVE \ + || devn == FH_DEV_FD || devn == FH_DEV_DISK) #define iscons_dev(n) \ ((device::major ((dev_t) (n)) == DEV_CONS_MAJOR) \ diff --git a/winsup/cygwin/local_includes/fhandler.h b/winsup/cygwin/local_includes/fhandler.h index 212c22344..cd61aadf8 100644 --- a/winsup/cygwin/local_includes/fhandler.h +++ b/winsup/cygwin/local_includes/fhandler.h @@ -40,6 +40,8 @@ details. */ extern const char *windows_device_names[]; extern struct __cygwin_perfile *perfile_table; #define __fmode (*(user_data->fmode_ptr)) +extern const char dev_disk[]; +extern const size_t dev_disk_len; extern const char proc[]; extern const size_t proc_len; extern const char procsys[]; @@ -3190,6 +3192,50 @@ class fhandler_procnet: public fhandler_proc } }; +class fhandler_dev_disk: public fhandler_virtual +{ + enum dev_disk_location { + unknown_loc, invalid_loc, disk_dir, by_id_dir, by_id_link + }; + dev_disk_location loc; + + void init_dev_disk (); + void ensure_inited () + { + if (loc == unknown_loc) + init_dev_disk (); + } + + int drive_from_id; + int part_from_id; + + public: + fhandler_dev_disk (); + fhandler_dev_disk (void *) {} + virtual_ftype_t exists(); + DIR *opendir (int fd); + int closedir (DIR *); + int readdir (DIR *, dirent *); + int open (int flags, mode_t mode = 0); + int fstat (struct stat *buf); + bool fill_filebuf (); + + void copy_from (fhandler_base *x) + { + pc.free_strings (); + *this = *reinterpret_cast (x); + _copy_from_reset_helper (); + } + + fhandler_dev_disk *clone (cygheap_types malloc_type = HEAP_FHANDLER) + { + void *ptr = (void *) ccalloc (malloc_type, 1, sizeof (fhandler_dev_disk)); + fhandler_dev_disk *fh = new (ptr) fhandler_dev_disk (ptr); + fh->copy_from (this); + return fh; + } +}; + class fhandler_dev_fd: public fhandler_virtual { public: @@ -3416,6 +3462,7 @@ typedef union char __dev_raw[sizeof (fhandler_dev_raw)]; char __dev_tape[sizeof (fhandler_dev_tape)]; char __dev_zero[sizeof (fhandler_dev_zero)]; + char __dev_disk[sizeof (fhandler_dev_disk)]; char __dev_fd[sizeof (fhandler_dev_fd)]; char __disk_file[sizeof (fhandler_disk_file)]; char __fifo[sizeof (fhandler_fifo)]; diff --git a/winsup/cygwin/mount.cc b/winsup/cygwin/mount.cc index 36ab042a7..13ace6250 100644 --- a/winsup/cygwin/mount.cc +++ b/winsup/cygwin/mount.cc @@ -35,6 +35,9 @@ details. */ (path[mount_table->cygdrive_len + 1] == '/' || \ !path[mount_table->cygdrive_len + 1])) +#define isdev_disk(path) \ + (path_prefix_p (dev_disk, (path), dev_disk_len, false)) + #define isproc(path) \ (path_prefix_p (proc, (path), proc_len, false)) @@ -685,6 +688,13 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev, /* Go through chroot check */ goto out; } + if (isdev_disk (src_path)) + { + dev = *dev_disk_dev; + *flags = 0; + strcpy (dst, src_path); + goto out; + } if (isproc (src_path)) { dev = *proc_dev; -- 2.42.0