HostHardwareLinux.cpp revision c58f1213e628a545081c70e26c6b67a841cff880
/* $Id$ */
/** @file
* Classes for handling hardware detection under Linux. Please feel free to
* expand these to work for other systems (Solaris!) or to add new ones for
* other systems.
*/
/*
* Copyright (C) 2008-2011 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#define LOG_GROUP LOG_GROUP_MAIN
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include <HostHardwareLinux.h>
#include <vector.h>
#include <VBox/err.h>
#include <VBox/log.h>
#include <iprt/asm.h>
#include <iprt/dir.h>
#include <iprt/env.h>
#include <iprt/file.h>
#include <iprt/mem.h>
#include <iprt/param.h>
#include <iprt/path.h>
#include <iprt/string.h>
#include <iprt/thread.h> /* for RTThreadSleep() */
#include <linux/cdrom.h>
#include <linux/fd.h>
#include <linux/major.h>
#include <scsi/scsi.h>
#include <iprt/linux/sysfs.h>
#ifdef VBOX_USB_WITH_SYSFS
# ifdef VBOX_USB_WITH_INOTIFY
# include <dlfcn.h>
# include <fcntl.h>
# include <poll.h>
# include <signal.h>
# include <unistd.h>
# endif
#endif
#include <vector>
#include <errno.h>
#include <dirent.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
/******************************************************************************
* Global Variables *
******************************************************************************/
#ifdef TESTCASE
static bool testing() { return true; }
static bool fNoProbe = false;
static bool noProbe() { return fNoProbe; }
static void setNoProbe(bool val) { fNoProbe = val; }
#else
static bool testing() { return false; }
static bool noProbe() { return false; }
static void setNoProbe(bool val) { (void)val; }
#endif
/******************************************************************************
* Typedefs and Defines *
******************************************************************************/
static int getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
bool isDVD, bool *pfSuccess);
static int getDriveInfoFromDev(DriveInfoList *pList, bool isDVD,
bool *pfSuccess);
static int getDriveInfoFromSysfs(DriveInfoList *pList, bool isDVD,
bool *pfSuccess);
/** Find the length of a string, ignoring trailing non-ascii or control
* characters */
static size_t strLenStripped(const char *pcsz)
{
size_t cch = 0;
for (size_t i = 0; pcsz[i] != '\0'; ++i)
if (pcsz[i] > 32 && pcsz[i] < 127)
cch = i;
return cch + 1;
}
/**
* Get the name of a floppy drive according to the Linux floppy driver.
* @returns true on success, false if the name was not available (i.e. the
* device was not readable, or the file name wasn't a PC floppy
* device)
* @param pcszNode the path to the device node for the device
* @param Number the Linux floppy driver number for the drive. Required.
* @param pszName where to store the name retrieved
*/
static bool floppyGetName(const char *pcszNode, unsigned Number,
floppy_drive_name pszName)
{
AssertPtrReturn(pcszNode, false);
AssertPtrReturn(pszName, false);
AssertReturn(Number <= 7, false);
RTFILE File;
int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
if (RT_SUCCESS(rc))
{
int rcIoCtl;
rc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
RTFileClose(File);
if (RT_SUCCESS(rc) && rcIoCtl >= 0)
return true;
}
return false;
}
/**
* Create a UDI and a description for a floppy drive based on a number and the
* driver's name for it. We deliberately return an ugly sequence of
* characters as the description rather than an English language string to
* avoid translation issues.
*
* @returns true if we know the device to be valid, false otherwise
* @param pcszName the floppy driver name for the device (optional)
* @param Number the number of the floppy (0 to 3 on FDC 0, 4 to 7 on
* FDC 1)
* @param pszDesc where to store the device description (optional)
* @param cchDesc the size of the buffer in @a pszDesc
* @param pszUdi where to store the device UDI (optional)
* @param cchUdi the size of the buffer in @a pszUdi
*/
static void floppyCreateDeviceStrings(const floppy_drive_name pcszName,
unsigned Number, char *pszDesc,
size_t cchDesc, char *pszUdi,
size_t cchUdi)
{
AssertPtrNullReturnVoid(pcszName);
AssertPtrNullReturnVoid(pszDesc);
AssertReturnVoid(!pszDesc || cchDesc > 0);
AssertPtrNullReturnVoid(pszUdi);
AssertReturnVoid(!pszUdi || cchUdi > 0);
AssertReturnVoid(Number <= 7);
if (pcszName)
{
const char *pcszSize;
switch(pcszName[0])
{
case 'd': case 'q': case 'h':
pcszSize = "5.25\"";
break;
case 'D': case 'H': case 'E': case 'u':
pcszSize = "3.5\"";
break;
default:
pcszSize = "(unknown)";
}
if (pszDesc)
RTStrPrintf(pszDesc, cchDesc, "%s %s K%s", pcszSize, &pcszName[1],
Number > 3 ? ", FDC 2" : "");
}
else
{
if (pszDesc)
RTStrPrintf(pszDesc, cchDesc, "FDD %d%s", (Number & 4) + 1,
Number > 3 ? ", FDC 2" : "");
}
if (pszUdi)
RTStrPrintf(pszUdi, cchUdi,
"/org/freedesktop/Hal/devices/platform_floppy_%u_storage",
Number);
}
/**
* Check whether a device number might correspond to a CD-ROM device according
* to Documentation/devices.txt in the Linux kernel source.
* @returns true if it might, false otherwise
* @param Number the device number (major and minor combination)
*/
static bool isCdromDevNum(dev_t Number)
{
int major = major(Number);
int minor = minor(Number);
if ((major == IDE0_MAJOR) && !(minor & 0x3f))
return true;
if (major == SCSI_CDROM_MAJOR)
return true;
if (major == CDU31A_CDROM_MAJOR)
return true;
if (major == GOLDSTAR_CDROM_MAJOR)
return true;
if (major == OPTICS_CDROM_MAJOR)
return true;
if (major == SANYO_CDROM_MAJOR)
return true;
if (major == MITSUMI_X_CDROM_MAJOR)
return true;
if ((major == IDE1_MAJOR) && !(minor & 0x3f))
return true;
if (major == MITSUMI_CDROM_MAJOR)
return true;
if (major == CDU535_CDROM_MAJOR)
return true;
if (major == MATSUSHITA_CDROM_MAJOR)
return true;
if (major == MATSUSHITA_CDROM2_MAJOR)
return true;
if (major == MATSUSHITA_CDROM3_MAJOR)
return true;
if (major == MATSUSHITA_CDROM4_MAJOR)
return true;
if (major == AZTECH_CDROM_MAJOR)
return true;
if (major == 30 /* CM205_CDROM_MAJOR */) /* no #define for some reason */
return true;
if (major == CM206_CDROM_MAJOR)
return true;
if ((major == IDE3_MAJOR) && !(minor & 0x3f))
return true;
if (major == 46 /* Parallel port ATAPI CD-ROM */) /* no #define */
return true;
if ((major == IDE4_MAJOR) && !(minor & 0x3f))
return true;
if ((major == IDE5_MAJOR) && !(minor & 0x3f))
return true;
if ((major == IDE6_MAJOR) && !(minor & 0x3f))
return true;
if ((major == IDE7_MAJOR) && !(minor & 0x3f))
return true;
if ((major == IDE8_MAJOR) && !(minor & 0x3f))
return true;
if ((major == IDE9_MAJOR) && !(minor & 0x3f))
return true;
if (major == 113 /* VIOCD_MAJOR */)
return true;
return false;
}
/**
* Send an SCSI INQUIRY command to a device and return selected information.
* @returns iprt status code
* @returns VERR_TRY_AGAIN if the query failed but might succeed next time
* @param pcszNode the full path to the device node
* @param pu8Type where to store the SCSI device type on success (optional)
* @param pchVendor where to store the vendor id string on success (optional)
* @param cchVendor the size of the @a pchVendor buffer
* @param pchModel where to store the product id string on success (optional)
* @param cchModel the size of the @a pchModel buffer
* @note check documentation on the SCSI INQUIRY command and the Linux kernel
* SCSI headers included above if you want to understand what is going
* on in this method.
*/
static int cdromDoInquiry(const char *pcszNode, uint8_t *pu8Type,
char *pchVendor, size_t cchVendor, char *pchModel,
size_t cchModel)
{
LogRelFlowFunc(("pcszNode=%s, pu8Type=%p, pchVendor=%p, cchVendor=%llu, pchModel=%p, cchModel=%llu\n",
pcszNode, pu8Type, pchVendor, cchVendor, pchModel,
cchModel));
AssertPtrReturn(pcszNode, VERR_INVALID_POINTER);
AssertPtrNullReturn(pu8Type, VERR_INVALID_POINTER);
AssertPtrNullReturn(pchVendor, VERR_INVALID_POINTER);
AssertPtrNullReturn(pchModel, VERR_INVALID_POINTER);
RTFILE hFile;
int rc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
if (RT_SUCCESS(rc))
{
int rcIoCtl = 0;
unsigned char u8Response[96] = { 0 };
struct cdrom_generic_command CdromCommandReq;
RT_ZERO(CdromCommandReq);
CdromCommandReq.cmd[0] = INQUIRY;
CdromCommandReq.cmd[4] = sizeof(u8Response);
CdromCommandReq.buffer = u8Response;
CdromCommandReq.buflen = sizeof(u8Response);
CdromCommandReq.data_direction = CGC_DATA_READ;
CdromCommandReq.timeout = 5000; /* ms */
rc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
if (RT_SUCCESS(rc) && rcIoCtl < 0)
rc = RTErrConvertFromErrno(-CdromCommandReq.stat);
RTFileClose(hFile);
if (RT_SUCCESS(rc))
{
if (pu8Type)
*pu8Type = u8Response[0] & 0x1f;
if (pchVendor)
RTStrPrintf(pchVendor, cchVendor, "%.8s",
&u8Response[8] /* vendor id string */);
if (pchModel)
RTStrPrintf(pchModel, cchModel, "%.16s",
&u8Response[16] /* product id string */);
LogRelFlowFunc(("returning success: type=%u, vendor=%.8s, product=%.16s\n",
u8Response[0] & 0x1f, &u8Response[8], &u8Response[16]));
return VINF_SUCCESS;
}
}
LogRelFlowFunc(("returning %Rrc\n", rc));
return rc;
}
/**
* Initialise the device strings (description and UDI) for a DVD drive based on
* vendor and model name strings.
* @param pcszVendor the vendor ID string
* @param pcszModel the product ID string
* @param pszDesc where to store the description string (optional)
* @param cchDesc the size of the buffer in @pszDesc
* @param pszUdi where to store the UDI string (optional)
* @param cchUdi the size of the buffer in @pszUdi
*/
/* static */
void dvdCreateDeviceStrings(const char *pcszVendor, const char *pcszModel,
char *pszDesc, size_t cchDesc, char *pszUdi,
size_t cchUdi)
{
AssertPtrReturnVoid(pcszVendor);
AssertPtrReturnVoid(pcszModel);
AssertPtrNullReturnVoid(pszDesc);
AssertReturnVoid(!pszDesc || cchDesc > 0);
AssertPtrNullReturnVoid(pszUdi);
AssertReturnVoid(!pszUdi || cchUdi > 0);
char szCleaned[128];
size_t cchVendor = strLenStripped(pcszVendor);
size_t cchModel = strLenStripped(pcszModel);
/* Create a cleaned version of the model string for the UDI string. */
for (unsigned i = 0; i < sizeof(szCleaned) && pcszModel[i] != '\0'; ++i)
if ( (pcszModel[i] >= '0' && pcszModel[i] <= '9')
|| (pcszModel[i] >= 'A' && pcszModel[i] <= 'z'))
szCleaned[i] = pcszModel[i];
else
szCleaned[i] = '_';
szCleaned[RT_MIN(cchModel, sizeof(szCleaned) - 1)] = '\0';
/* Construct the description string as "Vendor Product" */
if (pszDesc)
{
if (cchVendor > 0)
RTStrPrintf(pszDesc, cchDesc, "%.*s %s", cchVendor, pcszVendor,
cchModel > 0 ? pcszModel : "(unknown drive model)");
else
RTStrPrintf(pszDesc, cchDesc, "%s", pcszModel);
}
/* Construct the UDI string */
if (pszUdi)
{
if (cchModel > 0)
RTStrPrintf(pszUdi, cchUdi,
"/org/freedesktop/Hal/devices/storage_model_%s",
szCleaned);
else
pszUdi[0] = '\0';
}
}
/**
* Check whether a device node points to a valid device and create a UDI and
* a description for it, and store the device number, if it does.
* @returns true if the device is valid, false otherwise
* @param pcszNode the path to the device node
* @param isDVD are we looking for a DVD device (or a floppy device)?
* @param pDevice where to store the device node (optional)
* @param pszDesc where to store the device description (optional)
* @param cchDesc the size of the buffer in @a pszDesc
* @param pszUdi where to store the device UDI (optional)
* @param cchUdi the size of the buffer in @a pszUdi
*/
static bool devValidateDevice(const char *pcszNode, bool isDVD, dev_t *pDevice,
char *pszDesc, size_t cchDesc, char *pszUdi,
size_t cchUdi)
{
AssertPtrReturn(pcszNode, false);
AssertPtrNullReturn(pDevice, false);
AssertPtrNullReturn(pszDesc, false);
AssertReturn(!pszDesc || cchDesc > 0, false);
AssertPtrNullReturn(pszUdi, false);
AssertReturn(!pszUdi || cchUdi > 0, false);
RTFSOBJINFO ObjInfo;
if (RT_FAILURE(RTPathQueryInfo(pcszNode, &ObjInfo, RTFSOBJATTRADD_UNIX)))
return false;
if (!RTFS_IS_DEV_BLOCK(ObjInfo.Attr.fMode))
return false;
if (pDevice)
*pDevice = ObjInfo.Attr.u.Unix.Device;
if (isDVD)
{
char szVendor[128], szModel[128];
uint8_t u8Type;
if (!isCdromDevNum(ObjInfo.Attr.u.Unix.Device))
return false;
if (RT_FAILURE(cdromDoInquiry(pcszNode, &u8Type,
szVendor, sizeof(szVendor),
szModel, sizeof(szModel))))
return false;
if (u8Type != TYPE_ROM)
return false;
dvdCreateDeviceStrings(szVendor, szModel, pszDesc, cchDesc,
pszUdi, cchUdi);
}
else
{
/* Floppies on Linux are legacy devices with hardcoded majors and
* minors */
unsigned Number;
floppy_drive_name szName;
if (major(ObjInfo.Attr.u.Unix.Device) != FLOPPY_MAJOR)
return false;
switch (minor(ObjInfo.Attr.u.Unix.Device))
{
case 0: case 1: case 2: case 3:
Number = minor(ObjInfo.Attr.u.Unix.Device);
break;
case 128: case 129: case 130: case 131:
Number = minor(ObjInfo.Attr.u.Unix.Device) - 128 + 4;
break;
default:
return false;
}
if (!floppyGetName(pcszNode, Number, szName))
return false;
floppyCreateDeviceStrings(szName, Number, pszDesc, cchDesc, pszUdi,
cchUdi);
}
return true;
}
int VBoxMainDriveInfo::updateDVDs ()
{
LogFlowThisFunc(("entered\n"));
int rc = VINF_SUCCESS;
bool success = false; /* Have we succeeded in finding anything yet? */
try
{
mDVDList.clear ();
/* Always allow the user to override our auto-detection using an
* environment variable. */
if (RT_SUCCESS(rc) && (!success || testing()))
rc = getDriveInfoFromEnv ("VBOX_CDROM", &mDVDList, true /* isDVD */,
&success);
setNoProbe(false);
if (RT_SUCCESS(rc) && (!success | testing()))
rc = getDriveInfoFromSysfs(&mDVDList, true /* isDVD */, &success);
if (RT_SUCCESS(rc) && testing())
{
setNoProbe(true);
rc = getDriveInfoFromSysfs(&mDVDList, true /* isDVD */, &success);
}
/* Walk through the /dev subtree if nothing else has helped. */
if (RT_SUCCESS(rc) && (!success | testing()))
rc = getDriveInfoFromDev(&mDVDList, true /* isDVD */, &success);
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
}
LogFlowThisFunc(("rc=%Rrc\n", rc));
return rc;
}
int VBoxMainDriveInfo::updateFloppies ()
{
LogFlowThisFunc(("entered\n"));
int rc = VINF_SUCCESS;
bool success = false; /* Have we succeeded in finding anything yet? */
try
{
mFloppyList.clear ();
if (RT_SUCCESS(rc) && (!success || testing()))
rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList,
false /* isDVD */, &success);
setNoProbe(false);
if ( RT_SUCCESS(rc) && (!success || testing()))
rc = getDriveInfoFromSysfs(&mFloppyList, false /* isDVD */,
&success);
if (RT_SUCCESS(rc) && testing())
{
setNoProbe(true);
rc = getDriveInfoFromSysfs(&mFloppyList, false /* isDVD */, &success);
}
/* Walk through the /dev subtree if nothing else has helped. */
if ( RT_SUCCESS(rc) && (!success || testing()))
rc = getDriveInfoFromDev(&mFloppyList, false /* isDVD */,
&success);
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
}
LogFlowThisFunc(("rc=%Rrc\n", rc));
return rc;
}
/**
* Extract the names of drives from an environment variable and add them to a
* list if they are valid.
* @returns iprt status code
* @param pcszVar the name of the environment variable. The variable
* value should be a list of device node names, separated
* by ':' characters.
* @param pList the list to append the drives found to
* @param isDVD are we looking for DVD drives or for floppies?
* @param pfSuccess this will be set to true if we found at least one drive
* and to false otherwise. Optional.
*/
/* static */
int getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
bool isDVD, bool *pfSuccess)
{
AssertPtrReturn(pcszVar, VERR_INVALID_POINTER);
AssertPtrReturn(pList, VERR_INVALID_POINTER);
AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar,
pList, isDVD, pfSuccess));
int rc = VINF_SUCCESS;
bool success = false;
char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
try
{
const char *pcszCurrent = pszFreeMe;
while (pcszCurrent && *pcszCurrent != '\0')
{
const char *pcszNext = strchr(pcszCurrent, ':');
char szPath[RTPATH_MAX], szReal[RTPATH_MAX];
char szDesc[256], szUdi[256];
if (pcszNext)
RTStrPrintf(szPath, sizeof(szPath), "%.*s",
pcszNext - pcszCurrent - 1, pcszCurrent);
else
RTStrPrintf(szPath, sizeof(szPath), "%s", pcszCurrent);
if ( RT_SUCCESS(RTPathReal(szPath, szReal, sizeof(szReal)))
&& devValidateDevice(szReal, isDVD, NULL, szDesc,
sizeof(szDesc), szUdi, sizeof(szUdi)))
{
pList->push_back(DriveInfo(szReal, szUdi, szDesc));
success = true;
}
pcszCurrent = pcszNext ? pcszNext + 1 : NULL;
}
if (pfSuccess != NULL)
*pfSuccess = success;
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
}
RTStrFree(pszFreeMe);
LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
return rc;
}
class sysfsBlockDev
{
public:
sysfsBlockDev(const char *pcszName, bool wantDVD)
: mpcszName(pcszName), mwantDVD(wantDVD), misConsistent(true),
misValid(false)
{
if (findDeviceNode())
{
if (mwantDVD)
validateAndInitForDVD();
else
validateAndInitForFloppy();
}
}
private:
/** The name of the subdirectory of /sys/block for this device */
const char *mpcszName;
/** Are we looking for a floppy or a DVD device? */
bool mwantDVD;
/** The device node for the device */
char mszNode[RTPATH_MAX];
/** Does the sysfs entry look like we expect it too? This is a canary
* for future sysfs ABI changes. */
bool misConsistent;
/** Is this entry a valid specimen of what we are looking for? */
bool misValid;
/** Human readable drive description string */
char mszDesc[256];
/** Unique identifier for the drive. Should be identical to hal's UDI for
* the device. May not be unique for two identical drives. */
char mszUdi[256];
private:
/* Private methods */
/**
* Fill in the device node member based on the /sys/block subdirectory.
* @returns boolean success value
*/
bool findDeviceNode()
{
dev_t dev = RTLinuxSysFsReadDevNumFile("block/%s/dev", mpcszName);
if (dev == 0)
{
misConsistent = false;
return false;
}
if (RTLinuxFindDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode,
sizeof(mszNode), "%s", mpcszName) < 0)
return false;
return true;
}
/** Check whether the sysfs block entry is valid for a DVD device and
* initialise the string data members for the object. We try to get all
* the information we need from sysfs if possible, to avoid unnecessarily
* poking the device, and if that fails we fall back to an SCSI INQUIRY
* command. */
void validateAndInitForDVD()
{
char szVendor[128], szModel[128];
ssize_t cchVendor, cchModel;
int64_t type = RTLinuxSysFsReadIntFile(10, "block/%s/device/type",
mpcszName);
if (type >= 0 && type != TYPE_ROM)
return;
if (type == TYPE_ROM)
{
cchVendor = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor),
"block/%s/device/vendor",
mpcszName);
if (cchVendor >= 0)
{
cchModel = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel),
"block/%s/device/model",
mpcszName);
if (cchModel >= 0)
{
misValid = true;
dvdCreateDeviceStrings(szVendor, szModel,
mszDesc, sizeof(mszDesc),
mszUdi, sizeof(mszUdi));
return;
}
}
}
if (!noProbe())
probeAndInitForDVD();
}
/** Try to find out whether a device is a DVD drive by sending it an
* SCSI INQUIRY command. If it is, initialise the string and validity
* data members for the object based on the returned data.
*/
void probeAndInitForDVD()
{
AssertReturnVoid(mszNode[0] != '\0');
uint8_t u8Type = 0;
char szVendor[128] = "";
char szModel[128] = "";
int rc = cdromDoInquiry(mszNode, &u8Type, szVendor,
sizeof(szVendor), szModel,
sizeof(szModel));
if (RT_SUCCESS(rc) && (u8Type == TYPE_ROM))
{
misValid = true;
dvdCreateDeviceStrings(szVendor, szModel, mszDesc, sizeof(mszDesc),
mszUdi, sizeof(mszUdi));
}
}
/** Check whether the sysfs block entry is valid for a floppy device and
* initialise the string data members for the object. Since we only
* support floppies using the basic "floppy" driver, we check the driver
* using the entry name and a driver-specific ioctl. */
void validateAndInitForFloppy()
{
bool haveName = false;
floppy_drive_name szName;
char szDriver[8];
if ( mpcszName[0] != 'f'
|| mpcszName[1] != 'd'
|| mpcszName[2] < '0'
|| mpcszName[2] > '7'
|| mpcszName[3] != '\0')
return;
if (!noProbe())
haveName = floppyGetName(mszNode, mpcszName[2] - '0', szName);
if (RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), "block/%s/%s",
mpcszName, "device/driver") >= 0)
{
if (RTStrCmp(szDriver, "floppy"))
return;
}
else if (!haveName)
return;
floppyCreateDeviceStrings(haveName ? szName : NULL,
mpcszName[2] - '0', mszDesc,
sizeof(mszDesc), mszUdi, sizeof(mszUdi));
misValid = true;
}
public:
bool isConsistent()
{
return misConsistent;
}
bool isValid()
{
return misValid;
}
const char *getDesc()
{
return mszDesc;
}
const char *getUdi()
{
return mszUdi;
}
const char *getNode()
{
return mszNode;
}
};
/**
* Helper function to query the sysfs subsystem for information about DVD
* drives attached to the system.
* @returns iprt status code
* @param pList where to add information about the drives detected
* @param isDVD are we looking for DVDs or floppies?
* @param pfSuccess Did we find anything?
*
* @returns IPRT status code
*/
/* static */
int getDriveInfoFromSysfs(DriveInfoList *pList, bool isDVD, bool *pfSuccess)
{
AssertPtrReturn(pList, VERR_INVALID_POINTER);
AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER); /* Valid or Null */
LogFlowFunc (("pList=%p, isDVD=%u, pfSuccess=%p\n",
pList, (unsigned) isDVD, pfSuccess));
PRTDIR pDir = NULL;
int rc;
bool fSuccess = false;
unsigned cFound = 0;
if (!RTPathExists("/sys"))
return VINF_SUCCESS;
rc = RTDirOpen(&pDir, "/sys/block");
/* This might mean that sysfs semantics have changed */
AssertReturn(rc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
fSuccess = true;
if (RT_SUCCESS(rc))
for (;;)
{
RTDIRENTRY entry;
rc = RTDirRead(pDir, &entry, NULL);
Assert(rc != VERR_BUFFER_OVERFLOW); /* Should never happen... */
if (RT_FAILURE(rc)) /* Including overflow and no more files */
break;
if (entry.szName[0] == '.')
continue;
sysfsBlockDev dev(entry.szName, isDVD);
/* This might mean that sysfs semantics have changed */
AssertBreakStmt(dev.isConsistent(), fSuccess = false);
if (!dev.isValid())
continue;
try
{
pList->push_back(DriveInfo(dev.getNode(), dev.getUdi(),
dev.getDesc()));
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
break;
}
++cFound;
}
RTDirClose(pDir);
if (rc == VERR_NO_MORE_FILES)
rc = VINF_SUCCESS;
if (RT_FAILURE(rc))
/* Clean up again */
for (unsigned i = 0; i < cFound; ++i)
pList->pop_back();
if (pfSuccess)
*pfSuccess = fSuccess;
LogFlow (("rc=%Rrc, fSuccess=%u\n", rc, (unsigned) fSuccess));
return rc;
}
/** Structure for holding information about a drive we have found */
struct deviceNodeInfo
{
/** The device number */
dev_t Device;
/** The device node path */
char szPath[RTPATH_MAX];
/** The device description */
char szDesc[256];
/** The device UDI */
char szUdi[256];
};
/** The maximum number of devices we will search for. */
enum { MAX_DEVICE_NODES = 8 };
/** An array of MAX_DEVICE_NODES devices */
typedef struct deviceNodeInfo deviceNodeArray[MAX_DEVICE_NODES];
/**
* Recursive worker function to walk the /dev tree looking for DVD or floppy
* devices.
* @returns true if we have already found MAX_DEVICE_NODES devices, false
* otherwise
* @param pszPath the path to start recursing. The function can modify
* this string at and after the terminating zero
* @param cchPath the size of the buffer (not the string!) in @a pszPath
* @param aDevices where to fill in information about devices that we have
* found
* @param wantDVD are we looking for DVD devices (or floppies)?
*/
static bool devFindDeviceRecursive(char *pszPath, size_t cchPath,
deviceNodeArray aDevices, bool wantDVD)
{
/*
* Check assumptions made by the code below.
*/
size_t const cchBasePath = strlen(pszPath);
AssertReturn(cchBasePath < RTPATH_MAX - 10U, false);
AssertReturn(pszPath[cchBasePath - 1] != '/', false);
PRTDIR pDir;
if (RT_FAILURE(RTDirOpen(&pDir, pszPath)))
return false;
for (;;)
{
RTDIRENTRY Entry;
RTFSOBJINFO ObjInfo;
int rc = RTDirRead(pDir, &Entry, NULL);
if (RT_FAILURE(rc))
break;
if (Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
{
if (RT_FAILURE(RTPathQueryInfo(pszPath, &ObjInfo,
RTFSOBJATTRADD_UNIX)))
continue;
if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
continue;
}
if (Entry.enmType == RTDIRENTRYTYPE_SYMLINK)
continue;
pszPath[cchBasePath] = '\0';
if (RT_FAILURE(RTPathAppend(pszPath, cchPath, Entry.szName)))
break;
/* Do the matching. */
dev_t DevNode;
char szDesc[256], szUdi[256];
if (!devValidateDevice(pszPath, wantDVD, &DevNode, szDesc,
sizeof(szDesc), szUdi, sizeof(szUdi)))
continue;
unsigned i;
for (i = 0; i < MAX_DEVICE_NODES; ++i)
if (!aDevices[i].Device || (aDevices[i].Device == DevNode))
break;
AssertBreak(i < MAX_DEVICE_NODES);
if (aDevices[i].Device)
continue;
aDevices[i].Device = DevNode;
RTStrPrintf(aDevices[i].szPath, sizeof(aDevices[i].szPath),
"%s", pszPath);
AssertCompile(sizeof(aDevices[i].szDesc) == sizeof(szDesc));
strcpy(aDevices[i].szDesc, szDesc);
AssertCompile(sizeof(aDevices[i].szUdi) == sizeof(szUdi));
strcpy(aDevices[i].szUdi, szUdi);
if (i == MAX_DEVICE_NODES - 1)
break;
continue;
/* Recurse into subdirectories. */
if ( (Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
&& !RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
continue;
if (Entry.enmType != RTDIRENTRYTYPE_DIRECTORY)
continue;
if (Entry.szName[0] == '.')
continue;
if (devFindDeviceRecursive(pszPath, cchPath, aDevices, wantDVD))
break;
}
RTDirClose(pDir);
return aDevices[MAX_DEVICE_NODES - 1].Device ? true : false;
}
/**
* Recursively walk through the /dev tree and add any DVD or floppy drives we
* find and can access to our list. (If we can't access them we can't check
* whether or not they are really DVD or floppy drives).
* @note this is rather slow (a couple of seconds) for DVD probing on
* systems with a static /dev tree, as the current code tries to open
* any device node with a major/minor combination that could belong to
* a CD-ROM device, and opening a non-existent device can take a non.
* negligible time on Linux. If it is ever necessary to improve this
* (static /dev trees are no longer very fashionable these days, and
* sysfs looks like it will be with us for a while), we could further
* reduce the number of device nodes we open by checking whether the
* driver is actually loaded in /proc/devices, and by counting the
* of currently attached SCSI CD-ROM devices in /proc/scsi/scsi (yes,
* there is a race, but it is probably not important for us).
* @returns iprt status code
* @param pList the list to append the drives found to
* @param isDVD are we looking for DVD drives or for floppies?
* @param pfSuccess this will be set to true if we found at least one drive
* and to false otherwise. Optional.
*/
/* static */
int getDriveInfoFromDev(DriveInfoList *pList, bool isDVD, bool *pfSuccess)
{
AssertPtrReturn(pList, VERR_INVALID_POINTER);
AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
LogFlowFunc(("pList=%p, isDVD=%d, pfSuccess=%p\n", pList, isDVD,
pfSuccess));
int rc = VINF_SUCCESS;
bool success = false;
char szPath[RTPATH_MAX] = "/dev";
deviceNodeArray aDevices;
RT_ZERO(aDevices);
devFindDeviceRecursive(szPath, sizeof(szPath), aDevices, isDVD);
try
{
for (unsigned i = 0; i < MAX_DEVICE_NODES; ++i)
{
if (aDevices[i].Device)
{
pList->push_back(DriveInfo(aDevices[i].szPath,
aDevices[i].szUdi, aDevices[i].szDesc));
success = true;
}
}
if (pfSuccess != NULL)
*pfSuccess = success;
}
catch(std::bad_alloc &e)
{
rc = VERR_NO_MEMORY;
}
LogFlowFunc (("rc=%Rrc, success=%d\n", rc, success));
return rc;
}
/** Helper for readFilePathsFromDir(). Adds a path to the vector if it is not
* NULL and not a dotfile (".", "..", ".*"). */
static int maybeAddPathToVector(const char *pcszPath, const char *pcszEntry,
VECTOR_PTR(char *) *pvecpchDevs)
{
char *pszPath;
if (!pcszPath)
return 0;
if (pcszEntry[0] == '.')
return 0;
pszPath = RTStrDup(pcszPath);
if (!pszPath)
return ENOMEM;
if (RT_FAILURE(VEC_PUSH_BACK_PTR(pvecpchDevs, char *, pszPath)))
return ENOMEM;
return 0;
}
/** Helper for readFilePaths(). Adds the entries from the open directory
* @a pDir to the vector @a pvecpchDevs using either the full path or the
* realpath() and skipping hidden files and files on which realpath() fails. */
static int readFilePathsFromDir(const char *pcszPath, DIR *pDir,
VECTOR_PTR(char *) *pvecpchDevs, int withRealPath)
{
struct dirent entry, *pResult;
int err;
for (err = readdir_r(pDir, &entry, &pResult); pResult;
err = readdir_r(pDir, &entry, &pResult))
{
/* We (implicitly) require that PATH_MAX be defined */
char szPath[PATH_MAX + 1], szRealPath[PATH_MAX + 1], *pszPath;
if (snprintf(szPath, sizeof(szPath), "%s/%s", pcszPath,
entry.d_name) < 0)
return errno;
if (withRealPath)
pszPath = realpath(szPath, szRealPath);
else
pszPath = szPath;
if ((err = maybeAddPathToVector(pszPath, entry.d_name, pvecpchDevs)))
return err;
}
return err;
}
/**
* Helper for walkDirectory to dump the names of a directory's entries into a
* vector of char pointers.
*
* @returns zero on success or (positive) posix error value.
* @param pcszPath the path to dump.
* @param pvecpchDevs an empty vector of char pointers - must be cleaned up
* by the caller even on failure.
* @param withRealPath whether to canonicalise the filename with realpath
*/
static int readFilePaths(const char *pcszPath, VECTOR_PTR(char *) *pvecpchDevs,
int withRealPath)
{
DIR *pDir;
int err;
AssertPtrReturn(pvecpchDevs, EINVAL);
AssertReturn(VEC_SIZE_PTR(pvecpchDevs) == 0, EINVAL);
AssertPtrReturn(pcszPath, EINVAL);
pDir = opendir(pcszPath);
if (!pDir)
return RTErrConvertFromErrno(errno);
err = readFilePathsFromDir(pcszPath, pDir, pvecpchDevs, withRealPath);
if (closedir(pDir) < 0 && !err)
err = errno;
return RTErrConvertFromErrno(err);
}
class hotplugNullImpl : public VBoxMainHotplugWaiterImpl
{
public:
hotplugNullImpl(const char *) {}
virtual ~hotplugNullImpl (void) {}
/** @copydoc VBoxMainHotplugWaiter::Wait */
virtual int Wait (RTMSINTERVAL)
{
return VERR_NOT_SUPPORTED;
}
/** @copydoc VBoxMainHotplugWaiter::Interrupt */
virtual void Interrupt (void) {}
virtual int getStatus(void)
{
return VERR_NOT_SUPPORTED;
}
};
#ifdef VBOX_USB_WITH_SYSFS
# ifdef VBOX_USB_WITH_INOTIFY
/** Class wrapper around an inotify watch (or a group of them to be precise).
*/
typedef struct inotifyWatch
{
/** Pointer to the inotify_add_watch() glibc function/Linux API */
int (*inotify_add_watch)(int, const char *, uint32_t);
/** The native handle of the inotify fd. */
int mhInotify;
} inotifyWatch;
/** The flags we pass to inotify - modify, create, delete, change permissions
*/
#define IN_FLAGS 0x306
static int iwAddWatch(inotifyWatch *pSelf, const char *pcszPath)
{
errno = 0;
if ( pSelf->inotify_add_watch(pSelf->mhInotify, pcszPath, IN_FLAGS) >= 0
|| (errno == EACCES))
return VINF_SUCCESS;
/* Other errors listed in the manpage can be treated as fatal */
return RTErrConvertFromErrno(errno);
}
/** Object initialisation */
static int iwInit(inotifyWatch *pSelf)
{
int (*inotify_init)(void);
int fd, flags;
int rc = VINF_SUCCESS;
AssertPtr(pSelf);
pSelf->mhInotify = -1;
errno = 0;
*(void **)(&inotify_init) = dlsym(RTLD_DEFAULT, "inotify_init");
if (!inotify_init)
return VERR_LDR_IMPORTED_SYMBOL_NOT_FOUND;
*(void **)(&pSelf->inotify_add_watch)
= dlsym(RTLD_DEFAULT, "inotify_add_watch");
if (!pSelf->inotify_add_watch)
return VERR_LDR_IMPORTED_SYMBOL_NOT_FOUND;
fd = inotify_init();
if (fd < 0)
{
Assert(errno > 0);
return RTErrConvertFromErrno(errno);
}
Assert(errno == 0);
flags = fcntl(fd, F_GETFL, NULL);
if ( flags < 0
|| fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0
|| fcntl(fd, F_SETFD, FD_CLOEXEC) < 0 /* race here */)
{
Assert(errno > 0);
rc = RTErrConvertFromErrno(errno);
}
if (RT_FAILURE(rc))
close(fd);
else
{
Assert(errno == 0);
pSelf->mhInotify = fd;
}
return rc;
}
static void iwTerm(inotifyWatch *pSelf)
{
AssertPtrReturnVoid(pSelf);
if (pSelf->mhInotify != -1)
{
close(pSelf->mhInotify);
pSelf->mhInotify = -1;
}
}
static int iwGetFD(inotifyWatch *pSelf)
{
AssertPtrReturn(pSelf, -1);
return pSelf->mhInotify;
}
# define SYSFS_WAKEUP_STRING "Wake up!"
class hotplugInotifyImpl : public VBoxMainHotplugWaiterImpl
{
/** Pipe used to interrupt wait(), the read end. */
int mhWakeupPipeR;
/** Pipe used to interrupt wait(), the write end. */
int mhWakeupPipeW;
/** The inotify watch set */
inotifyWatch mWatches;
/** Flag to mark that the Wait() method is currently being called, and to
* ensure that it isn't called multiple times in parallel. */
volatile uint32_t mfWaiting;
/** The root of the USB devices tree. */
const char *mpcszDevicesRoot;
/** iprt result code from object initialisation. Should be AssertReturn-ed
* on at the start of all methods. I went this way because I didn't want
* to deal with exceptions. */
int mStatus;
/** ID values associates with the wakeup pipe and the FAM socket for polling
*/
enum
{
RPIPE_ID = 0,
INOTIFY_ID,
MAX_POLLID
};
/** Clean up any resources in use, gracefully skipping over any which have
* not yet been allocated or already cleaned up. Intended to be called
* from the destructor or after a failed initialisation. */
void term(void);
int drainInotify();
/** Read the wakeup string from the wakeup pipe */
int drainWakeupPipe(void);
public:
hotplugInotifyImpl(const char *pcszDevicesRoot);
virtual ~hotplugInotifyImpl(void)
{
term();
#ifdef DEBUG
/** The first call to term should mark all resources as freed, so this
* should be a semantic no-op. */
term();
#endif
}
/** Is inotify available and working on this system? If so we expect that
* this implementation will be usable. */
/** @todo test the "inotify in glibc but not in the kernel" case. */
static bool Available(void)
{
int (*inotify_init)(void);
*(void **)(&inotify_init) = dlsym(RTLD_DEFAULT, "inotify_init");
if (!inotify_init)
return false;
int fd = inotify_init();
if (fd == -1)
return false;
close(fd);
return true;
}
virtual int getStatus(void)
{
return mStatus;
}
/** @copydoc VBoxMainHotplugWaiter::Wait */
virtual int Wait(RTMSINTERVAL);
/** @copydoc VBoxMainHotplugWaiter::Interrupt */
virtual void Interrupt(void);
};
/** Simplified version of RTPipeCreate */
static int pipeCreateSimple(int *phPipeRead, int *phPipeWrite)
{
AssertPtrReturn(phPipeRead, VERR_INVALID_POINTER);
AssertPtrReturn(phPipeWrite, VERR_INVALID_POINTER);
/*
* Create the pipe and set the close-on-exec flag.
*/
int aFds[2] = {-1, -1};
if (pipe(aFds))
return RTErrConvertFromErrno(errno);
if ( fcntl(aFds[0], F_SETFD, FD_CLOEXEC) < 0
|| fcntl(aFds[1], F_SETFD, FD_CLOEXEC) < 0)
{
int rc = RTErrConvertFromErrno(errno);
close(aFds[0]);
close(aFds[1]);
return rc;
}
*phPipeRead = aFds[0];
*phPipeWrite = aFds[1];
/*
* Before we leave, make sure to shut up SIGPIPE.
*/
signal(SIGPIPE, SIG_IGN);
return VINF_SUCCESS;
}
hotplugInotifyImpl::hotplugInotifyImpl(const char *pcszDevicesRoot) :
mhWakeupPipeR(-1), mhWakeupPipeW(-1), mfWaiting(0),
mpcszDevicesRoot(pcszDevicesRoot), mStatus(VERR_WRONG_ORDER)
{
# ifdef DEBUG
/* Excercise the code path (term() on a not-fully-initialised object) as
* well as we can. On an uninitialised object this method is a semantic
* no-op. */
mWatches.mhInotify = -1; /* term will access this variable */
term();
/* For now this probing method should only be used if nothing else is
* available */
# endif
int rc;
do {
if (RT_FAILURE(rc = iwInit(&mWatches)))
break;
if (RT_FAILURE(rc = iwAddWatch(&mWatches, mpcszDevicesRoot)))
break;
if (RT_FAILURE(rc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW)))
break;
} while(0);
mStatus = rc;
if (RT_FAILURE(rc))
term();
}
void hotplugInotifyImpl::term(void)
{
/** This would probably be a pending segfault, so die cleanly */
AssertRelease(!mfWaiting);
if (mhWakeupPipeR != -1)
{
close(mhWakeupPipeR);
mhWakeupPipeR = -1;
}
if (mhWakeupPipeW != -1)
{
close(mhWakeupPipeW);
mhWakeupPipeW = -1;
}
iwTerm(&mWatches);
}
int hotplugInotifyImpl::drainInotify()
{
char chBuf[RTPATH_MAX + 256]; /* Should always be big enough */
ssize_t cchRead;
AssertRCReturn(mStatus, VERR_WRONG_ORDER);
errno = 0;
do {
cchRead = read(iwGetFD(&mWatches), chBuf, sizeof(chBuf));
} while (cchRead > 0);
if (cchRead == 0)
return VINF_SUCCESS;
if (cchRead < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
return VINF_SUCCESS;
Assert(errno > 0);
return RTErrConvertFromErrno(errno);
}
int hotplugInotifyImpl::drainWakeupPipe(void)
{
char szBuf[sizeof(SYSFS_WAKEUP_STRING)];
ssize_t cbRead;
AssertRCReturn(mStatus, VERR_WRONG_ORDER);
cbRead = read(mhWakeupPipeR, szBuf, sizeof(szBuf));
Assert(cbRead > 0);
NOREF(cbRead);
return VINF_SUCCESS;
}
int hotplugInotifyImpl::Wait(RTMSINTERVAL aMillies)
{
int rc;
char **ppszEntry;
VECTOR_PTR(char *) vecpchDevs;
AssertRCReturn(mStatus, VERR_WRONG_ORDER);
bool fEntered = ASMAtomicCmpXchgU32(&mfWaiting, 1, 0);
AssertReturn(fEntered, VERR_WRONG_ORDER);
VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
do {
struct pollfd pollFD[MAX_POLLID];
rc = readFilePaths(mpcszDevicesRoot, &vecpchDevs, false);
if (RT_SUCCESS(rc))
VEC_FOR_EACH(&vecpchDevs, char *, ppszEntry)
if (RT_FAILURE(rc = iwAddWatch(&mWatches, *ppszEntry)))
break;
if (RT_FAILURE(rc))
break;
pollFD[RPIPE_ID].fd = mhWakeupPipeR;
pollFD[RPIPE_ID].events = POLLIN;
pollFD[INOTIFY_ID].fd = iwGetFD(&mWatches);
pollFD[INOTIFY_ID].events = POLLIN | POLLERR | POLLHUP;
errno = 0;
int cPolled = poll(pollFD, RT_ELEMENTS(pollFD), aMillies);
if (cPolled < 0)
{
Assert(errno > 0);
rc = RTErrConvertFromErrno(errno);
}
else if (pollFD[RPIPE_ID].revents)
{
rc = drainWakeupPipe();
if (RT_SUCCESS(rc))
rc = VERR_INTERRUPTED;
break;
}
else if (!(pollFD[INOTIFY_ID].revents))
{
AssertBreakStmt(cPolled == 0, rc = VERR_INTERNAL_ERROR);
rc = VERR_TIMEOUT;
}
Assert(errno == 0 || (RT_FAILURE(rc) && rc != VERR_TIMEOUT));
if (RT_FAILURE(rc))
break;
AssertBreakStmt(cPolled == 1, rc = VERR_INTERNAL_ERROR);
if (RT_FAILURE(rc = drainInotify()))
break;
} while (false);
mfWaiting = 0;
VEC_CLEANUP_PTR(&vecpchDevs);
return rc;
}
void hotplugInotifyImpl::Interrupt(void)
{
AssertRCReturnVoid(mStatus);
ssize_t cbWritten = write(mhWakeupPipeW, SYSFS_WAKEUP_STRING,
sizeof(SYSFS_WAKEUP_STRING));
if (cbWritten > 0)
fsync(mhWakeupPipeW);
}
# endif /* VBOX_USB_WITH_INOTIFY */
#endif /* VBOX_USB_WTH_SYSFS */
VBoxMainHotplugWaiter::VBoxMainHotplugWaiter(const char *pcszDevicesRoot)
{
try
{
#ifdef VBOX_USB_WITH_SYSFS
# ifdef VBOX_USB_WITH_INOTIFY
if (hotplugInotifyImpl::Available())
{
mImpl = new hotplugInotifyImpl(pcszDevicesRoot);
return;
}
# endif /* VBOX_USB_WITH_INOTIFY */
#endif /* VBOX_USB_WITH_SYSFS */
mImpl = new hotplugNullImpl(pcszDevicesRoot);
}
catch(std::bad_alloc &e)
{ }
}