VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/freebsd/HostHardwareFreeBSD.cpp@ 44528

Last change on this file since 44528 was 44528, checked in by vboxsync, 12 years ago

header (C) fixes

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.9 KB
Line 
1/* $Id: HostHardwareFreeBSD.cpp 44528 2013-02-04 14:27:54Z vboxsync $ */
2/** @file
3 * Classes for handling hardware detection under FreeBSD.
4 */
5
6/*
7 * Copyright (C) 2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#define LOG_GROUP LOG_GROUP_MAIN
19
20/*******************************************************************************
21* Header Files *
22*******************************************************************************/
23
24#include <HostHardwareLinux.h>
25
26#include <VBox/log.h>
27
28#include <iprt/dir.h>
29#include <iprt/env.h>
30#include <iprt/file.h>
31#include <iprt/mem.h>
32#include <iprt/param.h>
33#include <iprt/path.h>
34#include <iprt/thread.h> /* for RTThreadSleep() */
35#include <iprt/string.h>
36
37#ifdef RT_OS_FREEBSD
38# include <sys/param.h>
39# include <sys/types.h>
40# include <sys/stat.h>
41# include <unistd.h>
42# include <sys/ioctl.h>
43# include <fcntl.h>
44# include <cam/cam.h>
45# include <cam/cam_ccb.h>
46# include <cam/scsi/scsi_pass.h>
47#endif /* RT_OS_FREEBSD */
48#include <vector>
49
50/******************************************************************************
51* Typedefs and Defines *
52******************************************************************************/
53
54static int getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
55 bool isDVD, bool *pfSuccess);
56static int getDVDInfoFromCAM(DriveInfoList *pList, bool *pfSuccess);
57
58/** Find the length of a string, ignoring trailing non-ascii or control
59 * characters */
60static size_t strLenStripped(const char *pcsz)
61{
62 size_t cch = 0;
63 for (size_t i = 0; pcsz[i] != '\0'; ++i)
64 if (pcsz[i] > 32 && pcsz[i] < 127)
65 cch = i;
66 return cch + 1;
67}
68
69static void strLenRemoveTrailingWhiteSpace(char *psz, size_t cchStr)
70{
71 while ( (cchStr > 0)
72 && (psz[cchStr -1] == ' '))
73 psz[--cchStr] = '\0';
74}
75
76/**
77 * Initialise the device description for a DVD drive based on
78 * vendor and model name strings.
79 * @param pcszVendor the vendor ID string
80 * @param pcszModel the product ID string
81 * @param pszDesc where to store the description string (optional)
82 * @param cchDesc the size of the buffer in @pszDesc
83 */
84/* static */
85void dvdCreateDeviceString(const char *pcszVendor, const char *pcszModel,
86 char *pszDesc, size_t cchDesc)
87{
88 AssertPtrReturnVoid(pcszVendor);
89 AssertPtrReturnVoid(pcszModel);
90 AssertPtrNullReturnVoid(pszDesc);
91 AssertReturnVoid(!pszDesc || cchDesc > 0);
92 size_t cchVendor = strLenStripped(pcszVendor);
93 size_t cchModel = strLenStripped(pcszModel);
94
95 /* Construct the description string as "Vendor Product" */
96 if (pszDesc)
97 {
98 if (cchVendor > 0)
99 RTStrPrintf(pszDesc, cchDesc, "%.*s %s", cchVendor, pcszVendor,
100 cchModel > 0 ? pcszModel : "(unknown drive model)");
101 else
102 RTStrPrintf(pszDesc, cchDesc, "%s", pcszModel);
103 }
104}
105
106
107int VBoxMainDriveInfo::updateDVDs ()
108{
109 LogFlowThisFunc(("entered\n"));
110 int rc = VINF_SUCCESS;
111 bool fSuccess = false; /* Have we succeeded in finding anything yet? */
112
113 try
114 {
115 mDVDList.clear ();
116 /* Always allow the user to override our auto-detection using an
117 * environment variable. */
118 if (RT_SUCCESS(rc) && !fSuccess)
119 rc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */,
120 &fSuccess);
121 if (RT_SUCCESS(rc) && !fSuccess)
122 rc = getDVDInfoFromCAM(&mDVDList, &fSuccess);
123 }
124 catch(std::bad_alloc &e)
125 {
126 rc = VERR_NO_MEMORY;
127 }
128 LogFlowThisFunc(("rc=%Rrc\n", rc));
129 return rc;
130}
131
132int VBoxMainDriveInfo::updateFloppies ()
133{
134 LogFlowThisFunc(("entered\n"));
135 int rc = VINF_SUCCESS;
136 bool fSuccess = false; /* Have we succeeded in finding anything yet? */
137
138 try
139 {
140 mFloppyList.clear ();
141 /* Always allow the user to override our auto-detection using an
142 * environment variable. */
143 if (RT_SUCCESS(rc) && !fSuccess)
144 rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */,
145 &fSuccess);
146 }
147 catch(std::bad_alloc &e)
148 {
149 rc = VERR_NO_MEMORY;
150 }
151 LogFlowThisFunc(("rc=%Rrc\n", rc));
152 return rc;
153}
154
155/**
156 * Search for available CD/DVD drives using the CAM layer.
157 *
158 * @returns iprt status code
159 * @param pList the list to append the drives found to
160 * @param pfSuccess this will be set to true if we found at least one drive
161 * and to false otherwise. Optional.
162 */
163static int getDVDInfoFromCAM(DriveInfoList *pList, bool *pfSuccess)
164{
165 int rc = VINF_SUCCESS;
166 RTFILE FileXpt;
167
168 rc = RTFileOpen(&FileXpt, "/dev/xpt0", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
169 if (RT_SUCCESS(rc))
170 {
171 union ccb DeviceCCB;
172 struct dev_match_pattern DeviceMatchPattern;
173 struct dev_match_result *paMatches = NULL;
174
175 memset(&DeviceCCB, 0, sizeof(union ccb));
176 memset(&DeviceMatchPattern, 0, sizeof(struct device_match_pattern));
177
178 /* We want to get all devices. */
179 DeviceCCB.ccb_h.func_code = XPT_DEV_MATCH;
180 DeviceCCB.ccb_h.path_id = CAM_XPT_PATH_ID;
181 DeviceCCB.ccb_h.target_id = CAM_TARGET_WILDCARD;
182 DeviceCCB.ccb_h.target_lun = CAM_LUN_WILDCARD;
183
184 /* Setup the pattern */
185 DeviceMatchPattern.type = DEV_MATCH_DEVICE;
186 DeviceMatchPattern.pattern.device_pattern.path_id = CAM_XPT_PATH_ID;
187 DeviceMatchPattern.pattern.device_pattern.target_id = CAM_TARGET_WILDCARD;
188 DeviceMatchPattern.pattern.device_pattern.target_lun = CAM_LUN_WILDCARD;
189 DeviceMatchPattern.pattern.device_pattern.flags = DEV_MATCH_INQUIRY;
190
191#if __FreeBSD_version >= 900000
192# define INQ_PAT data.inq_pat
193#else
194 #define INQ_PAT inq_pat
195#endif
196 DeviceMatchPattern.pattern.device_pattern.INQ_PAT.type = T_CDROM;
197 DeviceMatchPattern.pattern.device_pattern.INQ_PAT.media_type = SIP_MEDIA_REMOVABLE | SIP_MEDIA_FIXED;
198 DeviceMatchPattern.pattern.device_pattern.INQ_PAT.vendor[0] = '*'; /* Matches anything */
199 DeviceMatchPattern.pattern.device_pattern.INQ_PAT.product[0] = '*'; /* Matches anything */
200 DeviceMatchPattern.pattern.device_pattern.INQ_PAT.revision[0] = '*'; /* Matches anything */
201#undef INQ_PAT
202 DeviceCCB.cdm.num_patterns = 1;
203 DeviceCCB.cdm.pattern_buf_len = sizeof(struct dev_match_result);
204 DeviceCCB.cdm.patterns = &DeviceMatchPattern;
205
206 /*
207 * Allocate the buffer holding the matches.
208 * We will allocate for 10 results and call
209 * CAM multiple times if we have more results.
210 */
211 paMatches = (struct dev_match_result *)RTMemAllocZ(10 * sizeof(struct dev_match_result));
212 if (paMatches)
213 {
214 DeviceCCB.cdm.num_matches = 0;
215 DeviceCCB.cdm.match_buf_len = 10 * sizeof(struct dev_match_result);
216 DeviceCCB.cdm.matches = paMatches;
217
218 do
219 {
220 rc = RTFileIoCtl(FileXpt, CAMIOCOMMAND, &DeviceCCB, sizeof(union ccb), NULL);
221 if (RT_FAILURE(rc))
222 {
223 Log(("Error while querying available CD/DVD devices rc=%Rrc\n", rc));
224 break;
225 }
226
227 for (unsigned i = 0; i < DeviceCCB.cdm.num_matches; i++)
228 {
229 if (paMatches[i].type == DEV_MATCH_DEVICE)
230 {
231 /* We have the drive now but need the appropriate device node */
232 struct device_match_result *pDevResult = &paMatches[i].result.device_result;
233 union ccb PeriphCCB;
234 struct dev_match_pattern PeriphMatchPattern;
235 struct dev_match_result aPeriphMatches[2];
236 struct periph_match_result *pPeriphResult = NULL;
237 unsigned iPeriphMatch = 0;
238
239 memset(&PeriphCCB, 0, sizeof(union ccb));
240 memset(&PeriphMatchPattern, 0, sizeof(struct dev_match_pattern));
241 memset(aPeriphMatches, 0, sizeof(aPeriphMatches));
242
243 /* This time we only want the specific nodes for the device. */
244 PeriphCCB.ccb_h.func_code = XPT_DEV_MATCH;
245 PeriphCCB.ccb_h.path_id = paMatches[i].result.device_result.path_id;
246 PeriphCCB.ccb_h.target_id = paMatches[i].result.device_result.target_id;
247 PeriphCCB.ccb_h.target_lun = paMatches[i].result.device_result.target_lun;
248
249 /* Setup the pattern */
250 PeriphMatchPattern.type = DEV_MATCH_PERIPH;
251 PeriphMatchPattern.pattern.periph_pattern.path_id = paMatches[i].result.device_result.path_id;
252 PeriphMatchPattern.pattern.periph_pattern.target_id = paMatches[i].result.device_result.target_id;
253 PeriphMatchPattern.pattern.periph_pattern.target_lun = paMatches[i].result.device_result.target_lun;
254 PeriphMatchPattern.pattern.periph_pattern.flags = PERIPH_MATCH_PATH | PERIPH_MATCH_TARGET | PERIPH_MATCH_LUN;
255 PeriphCCB.cdm.num_patterns = 1;
256 PeriphCCB.cdm.pattern_buf_len = sizeof(struct dev_match_result);
257 PeriphCCB.cdm.patterns = &PeriphMatchPattern;
258 PeriphCCB.cdm.num_matches = 0;
259 PeriphCCB.cdm.match_buf_len = sizeof(aPeriphMatches);
260 PeriphCCB.cdm.matches = aPeriphMatches;
261
262 do
263 {
264 rc = RTFileIoCtl(FileXpt, CAMIOCOMMAND, &PeriphCCB, sizeof(union ccb), NULL);
265 if (RT_FAILURE(rc))
266 {
267 Log(("Error while querying available periph devices rc=%Rrc\n", rc));
268 break;
269 }
270
271 for (iPeriphMatch = 0; iPeriphMatch < PeriphCCB.cdm.num_matches; iPeriphMatch++)
272 {
273 if ( (aPeriphMatches[iPeriphMatch].type == DEV_MATCH_PERIPH)
274 && (!strcmp(aPeriphMatches[iPeriphMatch].result.periph_result.periph_name, "cd")))
275 {
276 pPeriphResult = &aPeriphMatches[iPeriphMatch].result.periph_result;
277 break; /* We found the periph device */
278 }
279 }
280
281 if (iPeriphMatch < PeriphCCB.cdm.num_matches)
282 break;
283
284 } while ( (DeviceCCB.ccb_h.status == CAM_REQ_CMP)
285 && (DeviceCCB.cdm.status == CAM_DEV_MATCH_MORE));
286
287 if (pPeriphResult)
288 {
289 char szPath[RTPATH_MAX];
290 char szDesc[256];
291
292 RTStrPrintf(szPath, sizeof(szPath), "/dev/%s%d",
293 pPeriphResult->periph_name, pPeriphResult->unit_number);
294
295 /* Remove trailing white space. */
296 strLenRemoveTrailingWhiteSpace(pDevResult->inq_data.vendor,
297 sizeof(pDevResult->inq_data.vendor));
298 strLenRemoveTrailingWhiteSpace(pDevResult->inq_data.product,
299 sizeof(pDevResult->inq_data.product));
300
301 dvdCreateDeviceString(pDevResult->inq_data.vendor,
302 pDevResult->inq_data.product,
303 szDesc, sizeof(szDesc));
304
305 pList->push_back(DriveInfo(szPath, "", szDesc));
306 if (pfSuccess)
307 *pfSuccess = true;
308 }
309 }
310 }
311 } while ( (DeviceCCB.ccb_h.status == CAM_REQ_CMP)
312 && (DeviceCCB.cdm.status == CAM_DEV_MATCH_MORE));
313
314 RTMemFree(paMatches);
315 }
316 else
317 rc = VERR_NO_MEMORY;
318
319 RTFileClose(FileXpt);
320 }
321
322 return rc;
323}
324
325/**
326 * Extract the names of drives from an environment variable and add them to a
327 * list if they are valid.
328 * @returns iprt status code
329 * @param pcszVar the name of the environment variable. The variable
330 * value should be a list of device node names, separated
331 * by ':' characters.
332 * @param pList the list to append the drives found to
333 * @param isDVD are we looking for DVD drives or for floppies?
334 * @param pfSuccess this will be set to true if we found at least one drive
335 * and to false otherwise. Optional.
336 */
337static int getDriveInfoFromEnv(const char *pcszVar, DriveInfoList *pList,
338 bool isDVD, bool *pfSuccess)
339{
340 AssertPtrReturn(pcszVar, VERR_INVALID_POINTER);
341 AssertPtrReturn(pList, VERR_INVALID_POINTER);
342 AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
343 LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar,
344 pList, isDVD, pfSuccess));
345 int rc = VINF_SUCCESS;
346 bool success = false;
347 char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
348
349 try
350 {
351 const char *pcszCurrent = pszFreeMe;
352 while (pcszCurrent && *pcszCurrent != '\0')
353 {
354 const char *pcszNext = strchr(pcszCurrent, ':');
355 char szPath[RTPATH_MAX], szReal[RTPATH_MAX];
356 char szDesc[256], szUdi[256];
357 if (pcszNext)
358 RTStrPrintf(szPath, sizeof(szPath), "%.*s",
359 pcszNext - pcszCurrent - 1, pcszCurrent);
360 else
361 RTStrPrintf(szPath, sizeof(szPath), "%s", pcszCurrent);
362 if (RT_SUCCESS(RTPathReal(szPath, szReal, sizeof(szReal))))
363 {
364 szUdi[0] = '\0'; /** @todo r=bird: missing a call to devValidateDevice() here and szUdi wasn't
365 * initialized because of that. Need proper fixing. */
366 pList->push_back(DriveInfo(szReal, szUdi, szDesc));
367 success = true;
368 }
369 pcszCurrent = pcszNext ? pcszNext + 1 : NULL;
370 }
371 if (pfSuccess != NULL)
372 *pfSuccess = success;
373 }
374 catch(std::bad_alloc &e)
375 {
376 rc = VERR_NO_MEMORY;
377 }
378 RTStrFree(pszFreeMe);
379 LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
380 return rc;
381}
382
383#if 0
384int VBoxMainUSBDeviceInfo::UpdateDevices ()
385{
386 LogFlowThisFunc(("entered\n"));
387 int rc = VINF_SUCCESS;
388 bool success = false; /* Have we succeeded in finding anything yet? */
389 try
390 {
391 bool halSuccess = false;
392 mDeviceList.clear();
393#if defined(RT_OS_LINUX)
394#ifdef VBOX_WITH_DBUS
395 if ( RT_SUCCESS(rc)
396 && RT_SUCCESS(RTDBusLoadLib())
397 && (!success || testing()))
398 rc = getUSBDeviceInfoFromHal(&mDeviceList, &halSuccess);
399 /* Try the old API if the new one *succeeded* as only one of them will
400 * pick up devices anyway. */
401 if (RT_SUCCESS(rc) && halSuccess && (!success || testing()))
402 rc = getOldUSBDeviceInfoFromHal(&mDeviceList, &halSuccess);
403 if (!success)
404 success = halSuccess;
405#endif /* VBOX_WITH_DBUS defined */
406#endif /* RT_OS_LINUX */
407 }
408 catch(std::bad_alloc &e)
409 {
410 rc = VERR_NO_MEMORY;
411 }
412 LogFlowThisFunc(("rc=%Rrc\n", rc));
413 return rc;
414}
415
416struct VBoxMainHotplugWaiter::Context
417{
418#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
419 /** The connection to DBus */
420 RTMemAutoPtr <DBusConnection, VBoxHalShutdownPrivate> mConnection;
421 /** Semaphore which is set when a device is hotplugged and reset when
422 * it is read. */
423 volatile bool mTriggered;
424 /** A flag to say that we wish to interrupt the current wait. */
425 volatile bool mInterrupt;
426 /** Constructor */
427 Context() : mTriggered(false), mInterrupt(false) {}
428#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
429};
430
431/* This constructor sets up a private connection to the DBus daemon, connects
432 * to the hal service and installs a filter which sets the mTriggered flag in
433 * the Context structure when a device (not necessarily USB) is added or
434 * removed. */
435VBoxMainHotplugWaiter::VBoxMainHotplugWaiter ()
436{
437#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
438 int rc = VINF_SUCCESS;
439
440 mContext = new Context;
441 if (RT_SUCCESS(RTDBusLoadLib()))
442 {
443 for (unsigned i = 0; RT_SUCCESS(rc) && i < 5 && !mContext->mConnection; ++i)
444 {
445 rc = halInitPrivate (&mContext->mConnection);
446 }
447 if (!mContext->mConnection)
448 rc = VERR_NOT_SUPPORTED;
449 DBusMessage *pMessage;
450 while ( RT_SUCCESS(rc)
451 && (pMessage = dbus_connection_pop_message (mContext->mConnection.get())) != NULL)
452 dbus_message_unref (pMessage); /* empty the message queue. */
453 if ( RT_SUCCESS(rc)
454 && !dbus_connection_add_filter (mContext->mConnection.get(),
455 dbusFilterFunction,
456 (void *) &mContext->mTriggered, NULL))
457 rc = VERR_NO_MEMORY;
458 if (RT_FAILURE(rc))
459 mContext->mConnection.reset();
460 }
461#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
462}
463
464/* Destructor */
465VBoxMainHotplugWaiter::~VBoxMainHotplugWaiter ()
466{
467#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
468 if (!!mContext->mConnection)
469 dbus_connection_remove_filter (mContext->mConnection.get(), dbusFilterFunction,
470 (void *) &mContext->mTriggered);
471 delete mContext;
472#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
473}
474
475/* Currently this is implemented using a timed out wait on our private DBus
476 * connection. Because the connection is private we don't have to worry about
477 * blocking other users. */
478int VBoxMainHotplugWaiter::Wait(RTMSINTERVAL cMillies)
479{
480 int rc = VINF_SUCCESS;
481#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
482 if (!mContext->mConnection)
483 rc = VERR_NOT_SUPPORTED;
484 bool connected = true;
485 mContext->mTriggered = false;
486 mContext->mInterrupt = false;
487 unsigned cRealMillies;
488 if (cMillies != RT_INDEFINITE_WAIT)
489 cRealMillies = cMillies;
490 else
491 cRealMillies = DBUS_POLL_TIMEOUT;
492 while ( RT_SUCCESS(rc) && connected && !mContext->mTriggered
493 && !mContext->mInterrupt)
494 {
495 connected = dbus_connection_read_write_dispatch (mContext->mConnection.get(),
496 cRealMillies);
497 if (mContext->mInterrupt)
498 LogFlowFunc(("wait loop interrupted\n"));
499 if (cMillies != RT_INDEFINITE_WAIT)
500 mContext->mInterrupt = true;
501 }
502 if (!connected)
503 rc = VERR_TRY_AGAIN;
504#else /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
505 rc = VERR_NOT_IMPLEMENTED;
506#endif /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
507 return rc;
508}
509
510/* Set a flag to tell the Wait not to resume next time it times out. */
511void VBoxMainHotplugWaiter::Interrupt()
512{
513#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
514 LogFlowFunc(("\n"));
515 mContext->mInterrupt = true;
516#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
517}
518#endif
519
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette