HostHardwareLinux.cpp revision bf94a12e434bda567d373eb5076cbf96aad6e987
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Classes for handling hardware detection under Linux. Please feel free to
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * expand these to work for other systems (Solaris!) or to add new ones for
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * other systems.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Copyright (C) 2008-2010 Oracle Corporation
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * available from http://www.virtualbox.org. This file is free software;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * you can redistribute it and/or modify it under the terms of the GNU
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * General Public License (GPL) as published by the Free Software
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync/*******************************************************************************
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync* Header Files *
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync*******************************************************************************/
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/******************************************************************************
044af0d1e6474076366759db86f101778c5f20ccvboxsync* Global Variables *
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync******************************************************************************/
2d8870843ff566fee9bd3a6a5942414254106479vboxsyncstatic bool testing() { return true; }
2d8870843ff566fee9bd3a6a5942414254106479vboxsyncstatic bool fNoProbe = false;
2d8870843ff566fee9bd3a6a5942414254106479vboxsyncstatic void setNoProbe(bool val) { fNoProbe = val; }
2d8870843ff566fee9bd3a6a5942414254106479vboxsyncstatic bool testing() { return false; }
2d8870843ff566fee9bd3a6a5942414254106479vboxsyncstatic bool noProbe() { return false; }
044af0d1e6474076366759db86f101778c5f20ccvboxsync/******************************************************************************
044af0d1e6474076366759db86f101778c5f20ccvboxsync* Typedefs and Defines *
044af0d1e6474076366759db86f101778c5f20ccvboxsync******************************************************************************/
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic int getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic int getDriveInfoFromDev(DriveInfoList *pList, bool isDVD,
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic int getDriveInfoFromSysfs(DriveInfoList *pList, bool isDVD,
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic int getUSBDeviceInfoFromSysfs(USBDeviceInfoList *pList, bool *pfSuccess);
044af0d1e6474076366759db86f101778c5f20ccvboxsync/** Function object to be invoked on filenames from a directory. */
044af0d1e6474076366759db86f101778c5f20ccvboxsynctypedef struct pathHandler
044af0d1e6474076366759db86f101778c5f20ccvboxsync /** Called on each element of the sysfs directory. Can e.g. store
044af0d1e6474076366759db86f101778c5f20ccvboxsync * interesting entries in a list. */
044af0d1e6474076366759db86f101778c5f20ccvboxsync bool (*handle)(pathHandler *pHandle, const char *pcszNode);
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic bool phDoHandle(pathHandler *pHandler, const char *pcszNode)
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic int walkDirectory(const char *pcszPath, pathHandler *pHandler,
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsyncstatic int getDeviceInfoFromSysfs(const char *pcszPath, pathHandler *pHandler);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#endif /* VBOX_USB_WITH_SYSFS */
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync/** Find the length of a string, ignoring trailing non-ascii or control
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync * characters */
044af0d1e6474076366759db86f101778c5f20ccvboxsync * Get the name of a floppy drive according to the Linux floppy driver.
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @returns true on success, false if the name was not available (i.e. the
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * device was not readible, or the file name wasn't a PC floppy
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param pcszNode the path to the device node for the device
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param Number the Linux floppy driver number for the drive. Required.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param pszName where to store the name retreived
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsyncstatic bool floppyGetName(const char *pcszNode, unsigned Number,
7d80dfbe5d66fc4c6de6fe109ce96a081496dcd4vboxsync int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync rc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
a1df400bbe9d64aad400442e56eb637019300a5evboxsync return true;
a1df400bbe9d64aad400442e56eb637019300a5evboxsync return false;
a1df400bbe9d64aad400442e56eb637019300a5evboxsync * Create a UDI and a description for a floppy drive based on a number and the
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync * driver's name for it. We deliberately return an ugly sequence of
a1df400bbe9d64aad400442e56eb637019300a5evboxsync * characters as the description rather than an English language string to
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync * avoid translation issues.
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync * @returns true if we know the device to be valid, false otherwise
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param pcszName the floppy driver name for the device (optional)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param Number the number of the floppy (0 to 3 on FDC 0, 4 to 7 on
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param pszDesc where to store the device description (optional)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param cchDesc the size of the buffer in @a pszDesc
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param pszUdi where to store the device UDI (optional)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param cchUdi the size of the buffer in @a pszUdi
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsyncstatic void floppyCreateDeviceStrings(const floppy_drive_name pcszName,
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync const char *pcszSize;
7d80dfbe5d66fc4c6de6fe109ce96a081496dcd4vboxsync RTStrPrintf(pszDesc, cchDesc, "%s %s K%s", pcszSize, &pcszName[1],
7d80dfbe5d66fc4c6de6fe109ce96a081496dcd4vboxsync RTStrPrintf(pszDesc, cchDesc, "FDD %d%s", (Number & 4) + 1,
7d80dfbe5d66fc4c6de6fe109ce96a081496dcd4vboxsync "/org/freedesktop/Hal/devices/platform_floppy_%u_storage",
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Check whether a device number might correspond to a CD-ROM device according
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * to Documentation/devices.txt in the Linux kernel source.
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @returns true if it might, false otherwise
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param Number the device number (major and minor combination)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync if (major == 30 /* CM205_CDROM_MAJOR */) /* no #define for some reason */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync if (major == 46 /* Parallel port ATAPI CD-ROM */) /* no #define */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return true;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return false;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * Send an SCSI INQUIRY command to a device and return selected information.
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @returns iprt status code
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @returns VERR_TRY_AGAIN if the query failed but might succeed next time
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pcszNode the full path to the device node
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pu8Type where to store the SCSI device type on success (optional)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pchVendor where to store the vendor id string on success (optional)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param cchVendor the size of the @a pchVendor buffer
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pchModel where to store the product id string on success (optional)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param cchModel the size of the @a pchModel buffer
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @note check documentation on the SCSI INQUIRY command and the Linux kernel
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * SCSI headers included above if you want to understand what is going
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * on in this method.
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsyncstatic int cdromDoInquiry(const char *pcszNode, uint8_t *pu8Type,
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync LogRelFlowFunc(("pcszNode=%s, pu8Type=%p, pchVendor=%p, cchVendor=%llu, pchModel=%p, cchModel=%llu\n",
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync AssertPtrNullReturn(pu8Type, VERR_INVALID_POINTER);
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync AssertPtrNullReturn(pchVendor, VERR_INVALID_POINTER);
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync AssertPtrNullReturn(pchModel, VERR_INVALID_POINTER);
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync int rc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync rc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync LogRelFlowFunc(("returning success: type=%u, vendor=%.8s, product=%.16s\n",
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync u8Response[0] & 0x1f, &u8Response[8], &u8Response[16]));
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * Initialise the device strings (description and UDI) for a DVD drive based on
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * vendor and model name strings.
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pcszVendor the vendor ID string
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pcszModel the product ID string
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pszDesc where to store the description string (optional)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param cchDesc the size of the buffer in @pszDesc
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param pszUdi where to store the UDI string (optional)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @param cchUdi the size of the buffer in @pszUdi
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync/* static */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsyncvoid dvdCreateDeviceStrings(const char *pcszVendor, const char *pcszModel,
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync /* Create a cleaned version of the model string for the UDI string. */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync for (unsigned i = 0; pcszModel[i] != '\0' && i < sizeof(szCleaned); ++i)
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync szCleaned[RT_MIN(cchModel, sizeof(szCleaned) - 1)] = '\0';
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync /* Construct the description string as "Vendor Product" */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync RTStrPrintf(pszDesc, cchDesc, "%.*s %s", cchVendor, pcszVendor,
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync cchModel > 0 ? pcszModel : "(unknown drive model)");
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync /* Construct the UDI string */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * Check whether a device node points to a valid device and create a UDI and
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * a description for it, and store the device number, if it does.
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync * @returns true if the device is valid, false otherwise
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param pcszNode the path to the device node
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param isDVD are we looking for a DVD device (or a floppy device)?
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param pDevice where to store the device node (optional)
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param pszDesc where to store the device description (optional)
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param cchDesc the size of the buffer in @a pszDesc
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param pszUdi where to store the device UDI (optional)
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync * @param cchUdi the size of the buffer in @a pszUdi
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsyncstatic bool devValidateDevice(const char *pcszNode, bool isDVD, dev_t *pDevice,
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync if (RT_FAILURE(RTPathQueryInfo(pcszNode, &ObjInfo, RTFSOBJATTRADD_UNIX)))
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync return false;
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync return false;
9af7167fa39f1f139899c989da973e59b9cccc3fvboxsync return false;
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync return false;
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync return false;
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync dvdCreateDeviceStrings(szVendor, szModel, pszDesc, cchDesc,
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync /* Floppies on Linux are legacy devices with hardcoded majors and
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync * minors */
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync if (major(ObjInfo.Attr.u.Unix.Device) != FLOPPY_MAJOR)
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync return false;
daa94352f51be2329ac8660f70396e03a7cb983bvboxsync Number = minor(ObjInfo.Attr.u.Unix.Device) - 128 + 4;
d6f8b76ab3b2ec0c270c96f9db6e2568fc41b5fevboxsync return false;
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return false;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync floppyCreateDeviceStrings(szName, Number, pszDesc, cchDesc, pszUdi,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync return true;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync bool success = false; /* Have we succeeded in finding anything yet? */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* Always allow the user to override our auto-detection using an
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * environment variable. */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync rc = getDriveInfoFromEnv ("VBOX_CDROM", &mDVDList, true /* isDVD */,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync rc = getDriveInfoFromSysfs(&mDVDList, true /* isDVD */, &success);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync rc = getDriveInfoFromSysfs(&mDVDList, true /* isDVD */, &success);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* Walk through the /dev subtree if nothing else has helped. */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync rc = getDriveInfoFromDev(&mDVDList, true /* isDVD */, &success);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync bool success = false; /* Have we succeeded in finding anything yet? */
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList,
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync rc = getDriveInfoFromSysfs(&mFloppyList, false /* isDVD */,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync rc = getDriveInfoFromSysfs(&mFloppyList, false /* isDVD */, &success);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* Walk through the /dev subtree if nothing else has helped. */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync rc = getDriveInfoFromDev(&mFloppyList, false /* isDVD */,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * Extract the names of drives from an environment variable and add them to a
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * list if they are valid.
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync * @returns iprt status code
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync * @param pcszVar the name of the environment variable. The variable
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * value should be a list of device node names, separated
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * by ':' characters.
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @param pList the list to append the drives found to
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @param isDVD are we looking for DVD drives or for floppies?
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @param pfSuccess this will be set to true if we found at least one drive
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * and to false otherwise. Optional.
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync/* static */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsyncint getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync bool success = false;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync RTStrPrintf(szPath, sizeof(szPath), "%s", pcszCurrent);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync if ( RT_SUCCESS(RTPathReal(szPath, szReal, sizeof(szReal)))
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync pList->push_back(DriveInfo(szReal, szUdi, szDesc));
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync : mpcszName(pcszName), mwantDVD(wantDVD), misConsistent(true),
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The name of the subdirectory of /sys/block for this device */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Are we looking for a floppy or a DVD device? */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The device node for the device */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Does the sysfs entry look like we expect it too? This is a canary
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * for future sysfs ABI changes. */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Is this entry a valid specimen of what we are looking for? */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Human readible drive description string */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Unique identifier for the drive. Should be identical to hal's UDI for
9939c713bffcfc4305d99d994552aa2ad9bce097vboxsync * the device. May not be unique for two identical drives. */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* Private methods */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * Fill in the device node member based on the /sys/block subdirectory.
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @returns boolean success value
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync dev_t dev = RTLinuxSysFsReadDevNumFile("block/%s/dev", mpcszName);
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync return false;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync if (RTLinuxFindDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode,
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync return false;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync return true;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Check whether the sysfs block entry is valid for a DVD device and
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * initialise the string data members for the object. We try to get all
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * the information we need from sysfs if possible, to avoid unnecessarily
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * poking the device, and if that fails we fall back to an SCSI INQUIRY
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * command. */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync int64_t type = RTLinuxSysFsReadIntFile(10, "block/%s/device/type",
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync cchVendor = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor),
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync cchModel = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel),
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** Try to find out whether a device is a DVD drive by sending it an
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * SCSI INQUIRY command. If it is, initialise the string and validity
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * data members for the object based on the returned data.
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync int rc = cdromDoInquiry(mszNode, &u8Type, szVendor,
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync dvdCreateDeviceStrings(szVendor, szModel, mszDesc, sizeof(mszDesc),
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync /** Check whether the sysfs block entry is valid for a floppy device and
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync * initialise the string data members for the object. Since we only
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync * support floppies using the basic "floppy" driver, we check the driver
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync * using the entry name and a driver-specific ioctl. */
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync bool haveName = false;
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync haveName = floppyGetName(mszNode, mpcszName[2] - '0', szName);
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync if (RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), "block/%s/%s",
9b19ad593b379ebfcc8273f85b90763b14b1da63vboxsync floppyCreateDeviceStrings(haveName ? szName : NULL,
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync const char *getDesc()
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync const char *getUdi()
044af0d1e6474076366759db86f101778c5f20ccvboxsync const char *getNode()
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * Helper function to query the sysfs subsystem for information about DVD
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * drives attached to the system.
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @returns iprt status code
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @param pList where to add information about the drives detected
2d8870843ff566fee9bd3a6a5942414254106479vboxsync * @param isDVD are we looking for DVDs or floppies?
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @param pfSuccess Did we find anything?
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * @returns IPRT status code
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync/* static */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsyncint getDriveInfoFromSysfs(DriveInfoList *pList, bool isDVD, bool *pfSuccess)
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER); /* Valid or Null */
2d8870843ff566fee9bd3a6a5942414254106479vboxsync LogFlowFunc (("pList=%p, isDVD=%u, pfSuccess=%p\n",
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync bool fSuccess = false;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync unsigned cFound = 0;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* This might mean that sysfs semantics have changed */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync AssertReturn(rc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
9d020a0622f95aec3aabaff436a495e88dbbd71avboxsync Assert(rc != VERR_BUFFER_OVERFLOW); /* Should never happen... */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync if (RT_FAILURE(rc)) /* Including overflow and no more files */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* This might mean that sysfs semantics have changed */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync AssertBreakStmt(dev.isConsistent(), fSuccess = false);
9d020a0622f95aec3aabaff436a495e88dbbd71avboxsync pList->push_back(DriveInfo(dev.getNode(), dev.getUdi(),
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* Clean up again */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync for (unsigned i = 0; i < cFound; ++i)
9d020a0622f95aec3aabaff436a495e88dbbd71avboxsync LogFlow (("rc=%Rrc, fSuccess=%u\n", rc, (unsigned) fSuccess));
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync/** Structure for holding information about a drive we have found */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The device number */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The device node path */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The device description */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The device UDI */
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync/** The maximum number of devices we will search for. */
044af0d1e6474076366759db86f101778c5f20ccvboxsync/** An array of MAX_DEVICE_NODES devices */
044af0d1e6474076366759db86f101778c5f20ccvboxsynctypedef struct deviceNodeInfo deviceNodeArray[MAX_DEVICE_NODES];
044af0d1e6474076366759db86f101778c5f20ccvboxsync * Recursive worker function to walk the /dev tree looking for DVD or floppy
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @returns true if we have already found MAX_DEVICE_NODES devices, false
044af0d1e6474076366759db86f101778c5f20ccvboxsync * otherwise
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param pszPath the path to start recursing. The function can modify
044af0d1e6474076366759db86f101778c5f20ccvboxsync * this string at and after the terminating zero
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param cchPath the size of the buffer (not the string!) in @a pszPath
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param aDevices where to fill in information about devices that we have
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param wantDVD are we looking for DVD devices (or floppies)?
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic bool devFindDeviceRecursive(char *pszPath, size_t cchPath,
5eda82e218d35ae0691febd531e1bfc0324cc4a6vboxsync * Check assumptions made by the code below.
5eda82e218d35ae0691febd531e1bfc0324cc4a6vboxsync AssertReturn(cchBasePath < RTPATH_MAX - 10U, false);
5eda82e218d35ae0691febd531e1bfc0324cc4a6vboxsync AssertReturn(pszPath[cchBasePath - 1] != '/', false);
5eda82e218d35ae0691febd531e1bfc0324cc4a6vboxsync return false;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync if (RT_FAILURE(RTPathAppend(pszPath, cchPath, Entry.szName)))
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /* Do the matching. */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync if (!devValidateDevice(pszPath, wantDVD, &DevNode, szDesc,
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync unsigned i;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync for (i = 0; i < MAX_DEVICE_NODES; ++i)
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync if (!aDevices[i].Device || (aDevices[i].Device == DevNode))
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync RTStrPrintf(aDevices[i].szPath, sizeof(aDevices[i].szPath),
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync AssertCompile(sizeof(aDevices[i].szDesc) == sizeof(szDesc));
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync AssertCompile(sizeof(aDevices[i].szUdi) == sizeof(szUdi));
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /* Recurse into subdirectories. */
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync if (devFindDeviceRecursive(pszPath, cchPath, aDevices, wantDVD))
b7a07b07543924f45c1fffd2f90de582038b8ba6vboxsync return aDevices[MAX_DEVICE_NODES - 1].Device ? true : false;
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * Recursively walk through the /dev tree and add any DVD or floppy drives we
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * find and can access to our list. (If we can't access them we can't check
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * whether or not they are really DVD or floppy drives).
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * @note this is rather slow (a couple of seconds) for DVD probing on
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * systems with a static /dev tree, as the current code tries to open
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * any device node with a major/minor combination that could belong to
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * a CD-ROM device, and opening a non-existent device can take a non.
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * negligeable time on Linux. If it is ever necessary to improve this
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync * (static /dev trees are no longer very fashionable these days, and
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * sysfs looks like it will be with us for a while), we could further
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * reduce the number of device nodes we open by checking whether the
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * driver is actually loaded in /proc/devices, and by counting the
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * of currently attached SCSI CD-ROM devices in /proc/scsi/scsi (yes,
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * there is a race, but it is probably not important for us).
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * @returns iprt status code
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * @param pList the list to append the drives found to
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * @param isDVD are we looking for DVD drives or for floppies?
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * @param pfSuccess this will be set to true if we found at least one drive
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * and to false otherwise. Optional.
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync/* static */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsyncint getDriveInfoFromDev(DriveInfoList *pList, bool isDVD, bool *pfSuccess)
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync LogFlowFunc(("pList=%p, isDVD=%d, pfSuccess=%p\n", pList, isDVD,
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync bool success = false;
e9525bea57dc13d82fd3392913aebb33d2cb79e3vboxsync devFindDeviceRecursive(szPath, sizeof(szPath), aDevices, isDVD);
e9525bea57dc13d82fd3392913aebb33d2cb79e3vboxsync for (unsigned i = 0; i < MAX_DEVICE_NODES; ++i)
e9525bea57dc13d82fd3392913aebb33d2cb79e3vboxsync LogFlowFunc (("rc=%Rrc, success=%d\n", rc, success));
e9525bea57dc13d82fd3392913aebb33d2cb79e3vboxsyncint USBDevInfoUpdateDevices (VBoxMainUSBDeviceInfo *pSelf)
e9525bea57dc13d82fd3392913aebb33d2cb79e3vboxsync bool success = false; /* Have we succeeded in finding anything yet? */
d90eec53c9dcaa0f3d1054e8734ed46875b9093avboxsync rc = getUSBDeviceInfoFromSysfs(&pSelf->mDeviceList, &success);
d90eec53c9dcaa0f3d1054e8734ed46875b9093avboxsync#else /* !VBOX_USB_WITH_SYSFS */
d90eec53c9dcaa0f3d1054e8734ed46875b9093avboxsync#endif /* !VBOX_USB_WITH_SYSFS */
d90eec53c9dcaa0f3d1054e8734ed46875b9093avboxsyncclass hotplugNullImpl : public VBoxMainHotplugWaiterImpl
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync virtual ~hotplugNullImpl (void) {}
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** @copydoc VBoxMainHotplugWaiter::Wait */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** @copydoc VBoxMainHotplugWaiter::Interrupt */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync virtual void Interrupt (void) {}
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync virtual int getStatus(void)
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync/** Class wrapper around an inotify watch (or a group of them to be precise).
a1df400bbe9d64aad400442e56eb637019300a5evboxsync * Inherits from pathHandler so that it can be passed to walkDirectory() to
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * easily add all files from a directory. */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsynctypedef struct inotifyWatch
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync /** The pathHandler we inherit from - this must be the first structure
044af0d1e6474076366759db86f101778c5f20ccvboxsync * member */
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync /** Pointer to the inotify_add_watch() glibc function/Linux API */
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync int (*inotify_add_watch)(int, const char *, uint32_t);
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync /** The native handle of the inotify fd. */
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync/** The flags we pass to inotify - modify, create, delete, change permissions
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsyncstatic bool iwHandle(pathHandler *pParent, const char *pcszPath)
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync if ( pSelf->inotify_add_watch(pSelf->mhInotify, pcszPath, IN_FLAGS) >= 0
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync return true;
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync /* Other errors listed in the manpage can be treated as fatal */
bbb4c0bfd5ea55e99591d8811771257a437053eevboxsync return false;
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync/** Object initialisation */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync int (*inotify_init)(void);
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync *(void **)(&inotify_init) = dlsym(RTLD_DEFAULT, "inotify_init");
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsyncclass hotplugInotifyImpl : public VBoxMainHotplugWaiterImpl
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** Pipe used to interrupt wait(), the read end. */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** Pipe used to interrupt wait(), the write end. */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** The inotify watch set */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** Flag to mark that the Wait() method is currently being called, and to
a1df400bbe9d64aad400442e56eb637019300a5evboxsync * ensure that it isn't called multiple times in parallel. */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** iprt result code from object initialisation. Should be AssertReturn-ed
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * on at the start of all methods. I went this way because I didn't want
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * to deal with exceptions. */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** ID values associates with the wakeup pipe and the FAM socket for polling
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** Clean up any resources in use, gracefully skipping over any which have
a1df400bbe9d64aad400442e56eb637019300a5evboxsync * not yet been allocated or already cleaned up. Intended to be called
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync * from the destructor or after a failed initialisation. */
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync void term(void);
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync /** Read the wakeup string from the wakeup pipe */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /** The first call to term should mark all resources as freed, so this
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync * should be a semantic no-op. */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /** Are sysfs and inotify available on this system? If so we expect that
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * this implementation will be usable. */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync static bool Available(void)
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync virtual int getStatus(void)
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /** @copydoc VBoxMainHotplugWaiter::Wait */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /** @copydoc VBoxMainHotplugWaiter::Interrupt */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync virtual void Interrupt(void);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync/** Simplified version of RTPipeCreate */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsyncstatic int pipeCreateSimple(int *phPipeRead, int *phPipeWrite)
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync AssertPtrReturn(phPipeWrite, VERR_INVALID_POINTER);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * Create the pipe and set the close-on-exec flag if requested.
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * Before we leave, make sure to shut up SIGPIPE.
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync mhWakeupPipeR(-1), mhWakeupPipeW(-1), mfWaiting(0),
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /* Excercise the code path (term() on a not-fully-initialised object) as
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * well as we can. On an uninitialised object this method is a sematic
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * no-op. */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /* For now this probing method should only be used if nothing else is
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * available */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync phDoHandle(&mWatches.mParent, SYSFS_USB_DEVICE_PATH);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync if (RT_FAILURE(rc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW)))
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync } while(0);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /** This would probably be a pending segfault, so die cleanly */
2d8870843ff566fee9bd3a6a5942414254106479vboxsync char chBuf[RTPATH_MAX + 256]; /* Should always be big enough */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync cchRead = read(iwGetFD(&mWatches), chBuf, sizeof(chBuf));
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync } while (cchRead > 0);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync if (cchRead < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync cbRead = read(mhWakeupPipeR, szBuf, sizeof(szBuf));
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync bool fEntered = ASMAtomicCmpXchgU32(&mfWaiting, 1, 0);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync if (RT_FAILURE(rc = walkDirectory(SYSFS_USB_DEVICE_PATH, &mWatches.mParent,
2d8870843ff566fee9bd3a6a5942414254106479vboxsync pollFD[INOTIFY_ID].events = POLLIN | POLLERR | POLLHUP;
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync int cPolled = poll(pollFD, RT_ELEMENTS(pollFD), aMillies);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync AssertBreakStmt(cPolled == 0, rc = VERR_INTERNAL_ERROR);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync Assert(errno == 0 || (RT_FAILURE(rc) && rc != VERR_TIMEOUT));
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync AssertBreakStmt(cPolled == 1, rc = VERR_INTERNAL_ERROR);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync } while (false);
a1df400bbe9d64aad400442e56eb637019300a5evboxsync ssize_t cbWritten = write(mhWakeupPipeW, SYSFS_WAKEUP_STRING,
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync# endif /* VBOX_USB_WITH_INOTIFY */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync#endif /* VBOX_USB_WTH_SYSFS */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync# endif /* VBOX_USB_WITH_INOTIFY */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync#endif /* VBOX_USB_WITH_SYSFS */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * Helper function to walk a directory, calling a function object on its files
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @returns iprt status code
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @param pcszPath Directory to walk.
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @param pHandler Handler object which will be invoked on each file
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @param useRealPath Whether to resolve the filename to its real path
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * before calling the handler. In this case the target
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * must exist.
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @returns IPRT status code
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync/* static */
a1df400bbe9d64aad400442e56eb637019300a5evboxsyncint walkDirectory(const char *pcszPath, pathHandler *pHandler, bool useRealPath)
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync LogFlowFunc (("pcszPath=%s, pHandler=%p\n", pcszPath, pHandler));
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync Assert(rc != VERR_BUFFER_OVERFLOW); /* Should never happen... */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /* We break on "no more files" as well as on "real" errors */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync if (RTStrPrintf(szPath, sizeof(szPath), "%s/%s", pcszPath,
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync rc = RTPathReal(szPath, szAbsPath, sizeof(szAbsPath));
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync break; /* The file can vanish if a device is unplugged. */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * Helper function to walk a sysfs directory for extracting information about
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @returns iprt status code
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @param pcszPath Sysfs directory to walk. Must exist.
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @param pHandler Handler object which will be invoked on each directory
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * @returns IPRT status code
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync/* static */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsyncint getDeviceInfoFromSysfs(const char *pcszPath, pathHandler *pHandler)
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync/** Deduce the bus that a USB device is plugged into from the device node
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * number. See drivers/usb/core/hub.c:usb_new_device as of Linux 2.6.20. */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync/** Deduce the device number of a USB device on the bus from the device node
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * number. See drivers/usb/core/hub.c:usb_new_device as of Linux 2.6.20. */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * Tell whether a file in /sys/bus/usb/devices is a device rather than an
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync * interface. To be used with getDeviceInfoFromSysfs().
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync /** The pathHandler object we inherit from - must come first */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsyncstatic bool mudHandle(pathHandler *pParent, const char *pcszNode)
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return true;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync dev_t devnum = RTLinuxSysFsReadDevNumFile("%s/dev", pcszNode);
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /* Sanity test of our static helpers */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync Assert(usbBusFromDevNum(makedev(USBDEVICE_MAJOR, 517)) == 5);
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync Assert(usbDeviceFromDevNum(makedev(USBDEVICE_MAJOR, 517)) == 6);
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync cchDevPath = RTLinuxFindDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync "/dev/bus/usb/%.3d/%.3d",
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return true;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync if (USBDeviceInfoList_push_back(pSelf->mList, &info))
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return true;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return false;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsyncstatic void mudInit(matchUSBDevice *pSelf, USBDeviceInfoList *pList)
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync * Tell whether a file in /sys/bus/usb/devices is an interface rather than a
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync * device. To be used with getDeviceInfoFromSysfs().
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /** The pathHandler class we inherit from - must be the first member. */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync/** The logic for testing whether a sysfs address corresponds to an
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync * interface of a device. Both must be referenced by their canonical
4dcf37df51439573b55cc16f53590c7b68cb1051vboxsync * sysfs paths. This is not tested, as the test requires file-system
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync * interaction. */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsyncstatic bool muiIsAnInterfaceOf(const char *pcszIface, const char *pcszDev)
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /* If this passes, pcszIface is at least cchDev long */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return false;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /* If this passes, pcszIface is longer than cchDev */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return false;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /* In sysfs an interface is an immediate subdirectory of the device */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return false;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /* And it always has a colon in its name */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return false;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync /* And hopefully we have now elimitated everything else */
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return true;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsyncstatic bool muiHandle(pathHandler *pParent, const char *pcszNode)
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync matchUSBInterface *pSelf = (matchUSBInterface *)pParent;
560a1042a968cf73161ac78555eddc8d16e8bebdvboxsync if (!muiIsAnInterfaceOf(pcszNode, pSelf->mInfo->mSysfsPath))
560a1042a968cf73161ac78555eddc8d16e8bebdvboxsync return true;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync if (USBInterfaceList_push_back(&pSelf->mInfo->mInterfaces, &pcszDup))
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return true;
feffb6492a600891a421e4c1bf0a2bcd2213568dvboxsync return false;
26645f447bb6a819f33492c84e03e364092ec600vboxsync/** This constructor is currently used to unit test the class logic in
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * debug builds. Since no access is made to anything outside the class,
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * this shouldn't cause any slowdown worth mentioning. */
590bfe12ce22cd3716448fbb9f4dc51664bfe5e2vboxsyncstatic void muiInit(matchUSBInterface *pSelf, USBDeviceInfo *pInfo)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync Assert(muiIsAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0",
bool *pfSuccess)
if (pfSuccess)
return rc;