VirtualBox

source: vbox/trunk/src/VBox/Devices/Storage/DrvHostDVD.cpp@ 21205

Last change on this file since 21205 was 19968, checked in by vboxsync, 15 years ago

HostDVD: Add basic support for FreeBSD. Passthrough is working quite well so far.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 26.8 KB
Line 
1/* $Id: DrvHostDVD.cpp 19968 2009-05-24 12:14:19Z vboxsync $ */
2/** @file
3 * DrvHostDVD - Host DVD block driver.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_DRV_HOST_DVD
27#define __STDC_LIMIT_MACROS
28#define __STDC_CONSTANT_MACROS
29#ifdef RT_OS_DARWIN
30# include <mach/mach.h>
31# include <Carbon/Carbon.h>
32# include <IOKit/IOKitLib.h>
33# include <IOKit/IOCFPlugIn.h>
34# include <IOKit/scsi/SCSITaskLib.h>
35# include <IOKit/scsi/SCSICommandOperationCodes.h>
36# include <IOKit/storage/IOStorageDeviceCharacteristics.h>
37# include <mach/mach_error.h>
38# define USE_MEDIA_POLLING
39
40#elif defined(RT_OS_L4)
41/* nothing (yet). */
42
43#elif defined RT_OS_LINUX
44# include <sys/ioctl.h>
45# include <linux/version.h>
46/* All the following crap is apparently not necessary anymore since Linux
47 * version 2.6.29. */
48# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
49/* This is a hack to work around conflicts between these linux kernel headers
50 * and the GLIBC tcpip headers. They have different declarations of the 4
51 * standard byte order functions. */
52# define _LINUX_BYTEORDER_GENERIC_H
53/* This is another hack for not bothering with C++ unfriendly byteswap macros. */
54/* Those macros that are needed are defined in the header below. */
55# include "swab.h"
56# endif
57# include <linux/cdrom.h>
58# include <sys/fcntl.h>
59# include <errno.h>
60# include <limits.h>
61# include <iprt/mem.h>
62# define USE_MEDIA_POLLING
63
64#elif defined(RT_OS_SOLARIS)
65# include <stropts.h>
66# include <fcntl.h>
67# include <ctype.h>
68# include <errno.h>
69# include <pwd.h>
70# include <unistd.h>
71# include <syslog.h>
72# ifdef VBOX_WITH_SUID_WRAPPER
73# include <auth_attr.h>
74# endif
75# include <sys/dkio.h>
76# include <sys/sockio.h>
77# include <sys/scsi/scsi.h>
78# define USE_MEDIA_POLLING
79
80#elif defined(RT_OS_WINDOWS)
81# include <Windows.h>
82# include <winioctl.h>
83# include <ntddscsi.h>
84# undef USE_MEDIA_POLLING
85
86#elif defined(RT_OS_FREEBSD)
87# include <sys/cdefs.h>
88# include <sys/param.h>
89# include <stdio.h>
90# include <cam/cam.h>
91# include <cam/cam_ccb.h>
92# define USE_MEDIA_POLLING
93
94#else
95# error "Unsupported Platform."
96#endif
97
98#include <VBox/pdmdrv.h>
99#include <iprt/assert.h>
100#include <iprt/file.h>
101#include <iprt/string.h>
102#include <iprt/thread.h>
103#include <iprt/critsect.h>
104#include <VBox/scsi.h>
105
106#include "Builtins.h"
107#include "DrvHostBase.h"
108
109
110/* Forward declarations. */
111
112static DECLCALLBACK(int) drvHostDvdDoLock(PDRVHOSTBASE pThis, bool fLock);
113#ifdef VBOX_WITH_SUID_WRAPPER
114static int solarisCheckUserAuth();
115static int solarisEnterRootMode(uid_t *pEffUserID);
116static int solarisExitRootMode(uid_t *pEffUserID);
117#endif
118
119
120/** @copydoc PDMIMOUNT::pfnUnmount */
121static DECLCALLBACK(int) drvHostDvdUnmount(PPDMIMOUNT pInterface, bool fForce)
122{
123 PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
124 RTCritSectEnter(&pThis->CritSect);
125
126 /*
127 * Validate state.
128 */
129 int rc = VINF_SUCCESS;
130 if (!pThis->fLocked || fForce)
131 {
132 /* Unlock drive if necessary. */
133 if (pThis->fLocked)
134 drvHostDvdDoLock(pThis, false);
135
136 /*
137 * Eject the disc.
138 */
139#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
140 uint8_t abCmd[16] =
141 {
142 SCSI_START_STOP_UNIT, 0, 0, 0, 2 /*eject+stop*/, 0,
143 0,0,0,0,0,0,0,0,0,0
144 };
145 rc = DRVHostBaseScsiCmd(pThis, abCmd, 6, PDMBLOCKTXDIR_NONE, NULL, NULL, NULL, 0, 0);
146
147#elif defined(RT_OS_LINUX)
148 rc = ioctl(pThis->FileDevice, CDROMEJECT, 0);
149 if (rc < 0)
150 {
151 if (errno == EBUSY)
152 rc = VERR_PDM_MEDIA_LOCKED;
153 else if (errno == ENOSYS)
154 rc = VERR_NOT_SUPPORTED;
155 else
156 rc = RTErrConvertFromErrno(errno);
157 }
158
159#elif defined(RT_OS_SOLARIS)
160 rc = ioctl(pThis->FileRawDevice, DKIOCEJECT, 0);
161 if (rc < 0)
162 {
163 if (errno == EBUSY)
164 rc = VERR_PDM_MEDIA_LOCKED;
165 else if (errno == ENOSYS || errno == ENOTSUP)
166 rc = VERR_NOT_SUPPORTED;
167 else if (errno == ENODEV)
168 rc = VERR_PDM_MEDIA_NOT_MOUNTED;
169 else
170 rc = RTErrConvertFromErrno(errno);
171 }
172
173#elif defined(RT_OS_WINDOWS)
174 RTFILE FileDevice = pThis->FileDevice;
175 if (FileDevice == NIL_RTFILE) /* obsolete crap */
176 rc = RTFileOpen(&FileDevice, pThis->pszDeviceOpen, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
177 if (RT_SUCCESS(rc))
178 {
179 /* do ioctl */
180 DWORD cbReturned;
181 if (DeviceIoControl((HANDLE)FileDevice, IOCTL_STORAGE_EJECT_MEDIA,
182 NULL, 0,
183 NULL, 0, &cbReturned,
184 NULL))
185 rc = VINF_SUCCESS;
186 else
187 rc = RTErrConvertFromWin32(GetLastError());
188
189 /* clean up handle */
190 if (FileDevice != pThis->FileDevice)
191 RTFileClose(FileDevice);
192 }
193 else
194 AssertMsgFailed(("Failed to open '%s' for ejecting this tray.\n", rc));
195
196
197#else
198 AssertMsgFailed(("Eject is not implemented!\n"));
199 rc = VINF_SUCCESS;
200#endif
201
202 /*
203 * Media is no longer present.
204 */
205 DRVHostBaseMediaNotPresent(pThis); /** @todo This isn't thread safe! */
206 }
207 else
208 {
209 Log(("drvHostDvdUnmount: Locked\n"));
210 rc = VERR_PDM_MEDIA_LOCKED;
211 }
212
213 RTCritSectLeave(&pThis->CritSect);
214 LogFlow(("drvHostDvdUnmount: returns %Rrc\n", rc));
215 return rc;
216}
217
218
219/**
220 * Locks or unlocks the drive.
221 *
222 * @returns VBox status code.
223 * @param pThis The instance data.
224 * @param fLock True if the request is to lock the drive, false if to unlock.
225 */
226static DECLCALLBACK(int) drvHostDvdDoLock(PDRVHOSTBASE pThis, bool fLock)
227{
228#ifdef RT_OS_DARWIN
229 uint8_t abCmd[16] =
230 {
231 SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, fLock, 0,
232 0,0,0,0,0,0,0,0,0,0
233 };
234 int rc = DRVHostBaseScsiCmd(pThis, abCmd, 6, PDMBLOCKTXDIR_NONE, NULL, NULL, NULL, 0, 0);
235
236#elif defined(RT_OS_LINUX)
237 int rc = ioctl(pThis->FileDevice, CDROM_LOCKDOOR, (int)fLock);
238 if (rc < 0)
239 {
240 if (errno == EBUSY)
241 rc = VERR_ACCESS_DENIED;
242 else if (errno == EDRIVE_CANT_DO_THIS)
243 rc = VERR_NOT_SUPPORTED;
244 else
245 rc = RTErrConvertFromErrno(errno);
246 }
247
248#elif defined(RT_OS_SOLARIS)
249 int rc = ioctl(pThis->FileRawDevice, fLock ? DKIOCLOCK : DKIOCUNLOCK, 0);
250 if (rc < 0)
251 {
252 if (errno == EBUSY)
253 rc = VERR_ACCESS_DENIED;
254 else if (errno == ENOTSUP || errno == ENOSYS)
255 rc = VERR_NOT_SUPPORTED;
256 else
257 rc = RTErrConvertFromErrno(errno);
258 }
259
260#elif defined(RT_OS_WINDOWS)
261
262 PREVENT_MEDIA_REMOVAL PreventMediaRemoval = {fLock};
263 DWORD cbReturned;
264 int rc;
265 if (DeviceIoControl((HANDLE)pThis->FileDevice, IOCTL_STORAGE_MEDIA_REMOVAL,
266 &PreventMediaRemoval, sizeof(PreventMediaRemoval),
267 NULL, 0, &cbReturned,
268 NULL))
269 rc = VINF_SUCCESS;
270 else
271 /** @todo figure out the return codes for already locked. */
272 rc = RTErrConvertFromWin32(GetLastError());
273
274#else
275 AssertMsgFailed(("Lock/Unlock is not implemented!\n"));
276 int rc = VINF_SUCCESS;
277
278#endif
279
280 LogFlow(("drvHostDvdDoLock(, fLock=%RTbool): returns %Rrc\n", fLock, rc));
281 return rc;
282}
283
284
285
286#ifdef RT_OS_LINUX
287/**
288 * Get the media size.
289 *
290 * @returns VBox status code.
291 * @param pThis The instance data.
292 * @param pcb Where to store the size.
293 */
294static int drvHostDvdGetMediaSize(PDRVHOSTBASE pThis, uint64_t *pcb)
295{
296 /*
297 * Query the media size.
298 */
299 /* Clear the media-changed-since-last-call-thingy just to be on the safe side. */
300 ioctl(pThis->FileDevice, CDROM_MEDIA_CHANGED, CDSL_CURRENT);
301 return RTFileSeek(pThis->FileDevice, 0, RTFILE_SEEK_END, pcb);
302
303}
304#endif /* RT_OS_LINUX */
305
306
307#ifdef USE_MEDIA_POLLING
308/**
309 * Do media change polling.
310 */
311DECLCALLBACK(int) drvHostDvdPoll(PDRVHOSTBASE pThis)
312{
313 /*
314 * Poll for media change.
315 */
316#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
317#ifdef RT_OS_DARWIN
318 AssertReturn(pThis->ppScsiTaskDI, VERR_INTERNAL_ERROR);
319#endif
320
321 /*
322 * Issue a TEST UNIT READY request.
323 */
324 bool fMediaChanged = false;
325 bool fMediaPresent = false;
326 uint8_t abCmd[16] = { SCSI_TEST_UNIT_READY, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
327 uint8_t abSense[32];
328 int rc2 = DRVHostBaseScsiCmd(pThis, abCmd, 6, PDMBLOCKTXDIR_NONE, NULL, NULL, abSense, sizeof(abSense), 0);
329 if (RT_SUCCESS(rc2))
330 fMediaPresent = true;
331 else if ( rc2 == VERR_UNRESOLVED_ERROR
332 && abSense[2] == 6 /* unit attention */
333 && ( (abSense[12] == 0x29 && abSense[13] < 5 /* reset */)
334 || (abSense[12] == 0x2a && abSense[13] == 0 /* parameters changed */) //???
335 || (abSense[12] == 0x3f && abSense[13] == 0 /* target operating conditions have changed */) //???
336 || (abSense[12] == 0x3f && abSense[13] == 2 /* changed operating definition */) //???
337 || (abSense[12] == 0x3f && abSense[13] == 3 /* inquery parameters changed */)
338 || (abSense[12] == 0x3f && abSense[13] == 5 /* device identifier changed */)
339 )
340 )
341 {
342 fMediaPresent = false;
343 fMediaChanged = true;
344 /** @todo check this media chance stuff on Darwin. */
345 }
346
347#elif defined(RT_OS_LINUX)
348 bool fMediaPresent = ioctl(pThis->FileDevice, CDROM_DRIVE_STATUS, CDSL_CURRENT) == CDS_DISC_OK;
349
350#elif defined(RT_OS_SOLARIS)
351 bool fMediaPresent = false;
352 bool fMediaChanged = false;
353
354 /* Need to pass the previous state and DKIO_NONE for the first time. */
355 static dkio_state s_DeviceState = DKIO_NONE;
356 dkio_state PreviousState = s_DeviceState;
357 int rc2 = ioctl(pThis->FileRawDevice, DKIOCSTATE, &s_DeviceState);
358 if (rc2 == 0)
359 {
360 fMediaPresent = (s_DeviceState == DKIO_INSERTED);
361 if (PreviousState != s_DeviceState)
362 fMediaChanged = true;
363 }
364 else
365 fMediaChanged = true;
366
367#else
368# error "Unsupported platform."
369#endif
370
371 RTCritSectEnter(&pThis->CritSect);
372
373 int rc = VINF_SUCCESS;
374 if (pThis->fMediaPresent != fMediaPresent)
375 {
376 LogFlow(("drvHostDvdPoll: %d -> %d\n", pThis->fMediaPresent, fMediaPresent));
377 pThis->fMediaPresent = false;
378 if (fMediaPresent)
379 rc = DRVHostBaseMediaPresent(pThis);
380 else
381 DRVHostBaseMediaNotPresent(pThis);
382 }
383 else if (fMediaPresent)
384 {
385 /*
386 * Poll for media change.
387 */
388#if defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
389 /* taken care of above. */
390#elif defined(RT_OS_LINUX)
391 bool fMediaChanged = ioctl(pThis->FileDevice, CDROM_MEDIA_CHANGED, CDSL_CURRENT) == 1;
392#else
393# error "Unsupported platform."
394#endif
395 if (fMediaChanged)
396 {
397 LogFlow(("drvHostDVDMediaThread: Media changed!\n"));
398 DRVHostBaseMediaNotPresent(pThis);
399 rc = DRVHostBaseMediaPresent(pThis);
400 }
401 }
402
403 RTCritSectLeave(&pThis->CritSect);
404 return rc;
405}
406#endif /* USE_MEDIA_POLLING */
407
408
409/** @copydoc PDMIBLOCK::pfnSendCmd */
410static int drvHostDvdSendCmd(PPDMIBLOCK pInterface, const uint8_t *pbCmd,
411 PDMBLOCKTXDIR enmTxDir, void *pvBuf, uint32_t *pcbBuf,
412 uint8_t *pabSense, size_t cbSense, uint32_t cTimeoutMillies)
413{
414 PDRVHOSTBASE pThis = PDMIBLOCK_2_DRVHOSTBASE(pInterface);
415 int rc;
416 LogFlow(("%s: cmd[0]=%#04x txdir=%d pcbBuf=%d timeout=%d\n", __FUNCTION__, pbCmd[0], enmTxDir, *pcbBuf, cTimeoutMillies));
417
418#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
419 /*
420 * Pass the request on to the internal scsi command interface.
421 * The command seems to be 12 bytes long, the docs a bit copy&pasty on the command length point...
422 */
423 if (enmTxDir == PDMBLOCKTXDIR_FROM_DEVICE)
424 memset(pvBuf, '\0', *pcbBuf); /* we got read size, but zero it anyway. */
425 rc = DRVHostBaseScsiCmd(pThis, pbCmd, 12, PDMBLOCKTXDIR_FROM_DEVICE, pvBuf, pcbBuf, pabSense, cbSense, cTimeoutMillies);
426 if (rc == VERR_UNRESOLVED_ERROR)
427 /* sense information set */
428 rc = VERR_DEV_IO_ERROR;
429
430#elif defined(RT_OS_L4)
431 /* Not really ported to L4 yet. */
432 rc = VERR_INTERNAL_ERROR;
433
434#elif defined(RT_OS_LINUX)
435 int direction;
436 struct cdrom_generic_command cgc;
437
438 switch (enmTxDir)
439 {
440 case PDMBLOCKTXDIR_NONE:
441 Assert(*pcbBuf == 0);
442 direction = CGC_DATA_NONE;
443 break;
444 case PDMBLOCKTXDIR_FROM_DEVICE:
445 Assert(*pcbBuf != 0);
446 Assert(*pcbBuf <= SCSI_MAX_BUFFER_SIZE);
447 /* Make sure that the buffer is clear for commands reading
448 * data. The actually received data may be shorter than what
449 * we expect, and due to the unreliable feedback about how much
450 * data the ioctl actually transferred, it's impossible to
451 * prevent that. Returning previous buffer contents may cause
452 * security problems inside the guest OS, if users can issue
453 * commands to the CDROM device. */
454 memset(pThis->pbDoubleBuffer, '\0', *pcbBuf);
455 direction = CGC_DATA_READ;
456 break;
457 case PDMBLOCKTXDIR_TO_DEVICE:
458 Assert(*pcbBuf != 0);
459 Assert(*pcbBuf <= SCSI_MAX_BUFFER_SIZE);
460 memcpy(pThis->pbDoubleBuffer, pvBuf, *pcbBuf);
461 direction = CGC_DATA_WRITE;
462 break;
463 default:
464 AssertMsgFailed(("enmTxDir invalid!\n"));
465 direction = CGC_DATA_NONE;
466 }
467 memset(&cgc, '\0', sizeof(cgc));
468 memcpy(cgc.cmd, pbCmd, CDROM_PACKET_SIZE);
469 cgc.buffer = (unsigned char *)pThis->pbDoubleBuffer;
470 cgc.buflen = *pcbBuf;
471 cgc.stat = 0;
472 Assert(cbSense >= sizeof(struct request_sense));
473 cgc.sense = (struct request_sense *)pabSense;
474 cgc.data_direction = direction;
475 cgc.quiet = false;
476 cgc.timeout = cTimeoutMillies;
477 rc = ioctl(pThis->FileDevice, CDROM_SEND_PACKET, &cgc);
478 if (rc < 0)
479 {
480 if (errno == EBUSY)
481 rc = VERR_PDM_MEDIA_LOCKED;
482 else if (errno == ENOSYS)
483 rc = VERR_NOT_SUPPORTED;
484 else
485 {
486 rc = RTErrConvertFromErrno(errno);
487 if (rc == VERR_ACCESS_DENIED && cgc.sense->sense_key == SCSI_SENSE_NONE)
488 cgc.sense->sense_key = SCSI_SENSE_ILLEGAL_REQUEST;
489 Log2(("%s: error status %d, rc=%Rrc\n", __FUNCTION__, cgc.stat, rc));
490 }
491 }
492 switch (enmTxDir)
493 {
494 case PDMBLOCKTXDIR_FROM_DEVICE:
495 memcpy(pvBuf, pThis->pbDoubleBuffer, *pcbBuf);
496 break;
497 default:
498 ;
499 }
500 Log2(("%s: after ioctl: cgc.buflen=%d txlen=%d\n", __FUNCTION__, cgc.buflen, *pcbBuf));
501 /* The value of cgc.buflen does not reliably reflect the actual amount
502 * of data transferred (for packet commands with little data transfer
503 * it's 0). So just assume that everything worked ok. */
504
505#elif defined(RT_OS_SOLARIS)
506 struct uscsi_cmd usc;
507 union scsi_cdb scdb;
508 memset(&usc, 0, sizeof(struct uscsi_cmd));
509 memset(&scdb, 0, sizeof(scdb));
510
511 switch (enmTxDir)
512 {
513 case PDMBLOCKTXDIR_NONE:
514 Assert(*pcbBuf == 0);
515 usc.uscsi_flags = USCSI_READ;
516 /* nothing to do */
517 break;
518
519 case PDMBLOCKTXDIR_FROM_DEVICE:
520 Assert(*pcbBuf != 0);
521 /* Make sure that the buffer is clear for commands reading
522 * data. The actually received data may be shorter than what
523 * we expect, and due to the unreliable feedback about how much
524 * data the ioctl actually transferred, it's impossible to
525 * prevent that. Returning previous buffer contents may cause
526 * security problems inside the guest OS, if users can issue
527 * commands to the CDROM device. */
528 memset(pvBuf, '\0', *pcbBuf);
529 usc.uscsi_flags = USCSI_READ;
530 break;
531 case PDMBLOCKTXDIR_TO_DEVICE:
532 Assert(*pcbBuf != 0);
533 usc.uscsi_flags = USCSI_WRITE;
534 break;
535 default:
536 AssertMsgFailedReturn(("%d\n", enmTxDir), VERR_INTERNAL_ERROR);
537 }
538 usc.uscsi_flags |= USCSI_RQENABLE;
539 usc.uscsi_rqbuf = (char *)pabSense;
540 usc.uscsi_rqlen = cbSense;
541 usc.uscsi_cdb = (caddr_t)&scdb;
542 usc.uscsi_cdblen = 12;
543 memcpy (usc.uscsi_cdb, pbCmd, usc.uscsi_cdblen);
544 usc.uscsi_bufaddr = (caddr_t)pvBuf;
545 usc.uscsi_buflen = *pcbBuf;
546 usc.uscsi_timeout = (cTimeoutMillies + 999) / 1000;
547
548 /* We need root privileges for user-SCSI under Solaris. */
549#ifdef VBOX_WITH_SUID_WRAPPER
550 uid_t effUserID = geteuid();
551 solarisEnterRootMode(&effUserID); /** @todo check return code when this really works. */
552#endif
553 rc = ioctl(pThis->FileRawDevice, USCSICMD, &usc);
554#ifdef VBOX_WITH_SUID_WRAPPER
555 solarisExitRootMode(&effUserID);
556#endif
557 if (rc < 0)
558 {
559 if (errno == EPERM)
560 return VERR_PERMISSION_DENIED;
561 if (usc.uscsi_status)
562 {
563 rc = RTErrConvertFromErrno(errno);
564 Log2(("%s: error status. rc=%Rrc\n", __FUNCTION__, rc));
565 }
566 }
567 Log2(("%s: after ioctl: residual buflen=%d original buflen=%d\n", __FUNCTION__, usc.uscsi_resid, usc.uscsi_buflen));
568
569#elif defined(RT_OS_WINDOWS)
570 int direction;
571 struct _REQ
572 {
573 SCSI_PASS_THROUGH_DIRECT spt;
574 uint8_t aSense[64];
575 } Req;
576 DWORD cbReturned = 0;
577
578 switch (enmTxDir)
579 {
580 case PDMBLOCKTXDIR_NONE:
581 direction = SCSI_IOCTL_DATA_UNSPECIFIED;
582 break;
583 case PDMBLOCKTXDIR_FROM_DEVICE:
584 Assert(*pcbBuf != 0);
585 /* Make sure that the buffer is clear for commands reading
586 * data. The actually received data may be shorter than what
587 * we expect, and due to the unreliable feedback about how much
588 * data the ioctl actually transferred, it's impossible to
589 * prevent that. Returning previous buffer contents may cause
590 * security problems inside the guest OS, if users can issue
591 * commands to the CDROM device. */
592 memset(pvBuf, '\0', *pcbBuf);
593 direction = SCSI_IOCTL_DATA_IN;
594 break;
595 case PDMBLOCKTXDIR_TO_DEVICE:
596 direction = SCSI_IOCTL_DATA_OUT;
597 break;
598 default:
599 AssertMsgFailed(("enmTxDir invalid!\n"));
600 direction = SCSI_IOCTL_DATA_UNSPECIFIED;
601 }
602 memset(&Req, '\0', sizeof(Req));
603 Req.spt.Length = sizeof(Req.spt);
604 Req.spt.CdbLength = 12;
605 memcpy(Req.spt.Cdb, pbCmd, Req.spt.CdbLength);
606 Req.spt.DataBuffer = pvBuf;
607 Req.spt.DataTransferLength = *pcbBuf;
608 Req.spt.DataIn = direction;
609 Req.spt.TimeOutValue = (cTimeoutMillies + 999) / 1000; /* Convert to seconds */
610 Assert(cbSense <= sizeof(Req.aSense));
611 Req.spt.SenseInfoLength = (UCHAR)RT_MIN(sizeof(Req.aSense), cbSense);
612 Req.spt.SenseInfoOffset = RT_OFFSETOF(struct _REQ, aSense);
613 if (DeviceIoControl((HANDLE)pThis->FileDevice, IOCTL_SCSI_PASS_THROUGH_DIRECT,
614 &Req, sizeof(Req), &Req, sizeof(Req), &cbReturned, NULL))
615 {
616 if (cbReturned > RT_OFFSETOF(struct _REQ, aSense))
617 memcpy(pabSense, Req.aSense, cbSense);
618 else
619 memset(pabSense, '\0', cbSense);
620 /* Windows shares the property of not properly reflecting the actually
621 * transferred data size. See above. Assume that everything worked ok.
622 * Except if there are sense information. */
623 rc = (pabSense[2] & 0x0f) == SCSI_SENSE_NONE
624 ? VINF_SUCCESS
625 : VERR_DEV_IO_ERROR;
626 }
627 else
628 rc = RTErrConvertFromWin32(GetLastError());
629 Log2(("%s: scsistatus=%d bytes returned=%d tlength=%d\n", __FUNCTION__, Req.spt.ScsiStatus, cbReturned, Req.spt.DataTransferLength));
630
631#else
632# error "Unsupported platform."
633#endif
634
635 if (pbCmd[0] == SCSI_GET_EVENT_STATUS_NOTIFICATION)
636 {
637 uint8_t *pbBuf = (uint8_t*)pvBuf;
638 Log2(("Event Status Notification class=%#02x supported classes=%#02x\n", pbBuf[2], pbBuf[3]));
639 if (RT_BE2H_U16(*(uint16_t*)pbBuf) >= 6)
640 Log2((" event %#02x %#02x %#02x %#02x\n", pbBuf[4], pbBuf[5], pbBuf[6], pbBuf[7]));
641 }
642
643 LogFlow(("%s: rc=%Rrc\n", __FUNCTION__, rc));
644 return rc;
645}
646
647
648#ifdef VBOX_WITH_SUID_WRAPPER
649/* These functions would have to go into a seperate solaris binary with
650 * the setuid permission set, which would run the user-SCSI ioctl and
651 * return the value. BUT... this might be prohibitively slow.
652 */
653# ifdef RT_OS_SOLARIS
654
655/**
656 * Checks if the current user is authorized using Solaris' role-based access control.
657 * Made as a seperate function with so that it need not be invoked each time we need
658 * to gain root access.
659 *
660 * @returns VBox error code.
661 */
662static int solarisCheckUserAuth()
663{
664 /* Uses Solaris' role-based access control (RBAC).*/
665 struct passwd *pPass = getpwuid(getuid());
666 if (pPass == NULL || chkauthattr("solaris.device.cdrw", pPass->pw_name) == 0)
667 return VERR_PERMISSION_DENIED;
668
669 return VINF_SUCCESS;
670}
671
672
673/**
674 * Setuid wrapper to gain root access.
675 *
676 * @returns VBox error code.
677 * @param pEffUserID Pointer to effective user ID.
678 */
679static int solarisEnterRootMode(uid_t *pEffUserID)
680{
681 /* Increase privilege if required */
682 if (*pEffUserID != 0)
683 {
684 if (seteuid(0) == 0)
685 {
686 *pEffUserID = 0;
687 return VINF_SUCCESS;
688 }
689 return VERR_PERMISSION_DENIED;
690 }
691 return VINF_SUCCESS;
692}
693
694
695/**
696 * Setuid wrapper to relinquish root access.
697 *
698 * @returns VBox error code.
699 * @param pEffUserID Pointer to effective user ID.
700 */
701static int solarisExitRootMode(uid_t *pEffUserID)
702{
703 /* Get back to user mode. */
704 if (*pEffUserID == 0)
705 {
706 uid_t realID = getuid();
707 if (seteuid(realID) == 0)
708 {
709 *pEffUserID = realID;
710 return VINF_SUCCESS;
711 }
712 return VERR_PERMISSION_DENIED;
713 }
714 return VINF_SUCCESS;
715}
716
717# endif /* RT_OS_SOLARIS */
718#endif /* VBOX_WITH_SUID_WRAPPER */
719
720
721/* -=-=-=-=- driver interface -=-=-=-=- */
722
723
724/** @copydoc FNPDMDRVDESTRUCT */
725DECLCALLBACK(void) drvHostDvdDestruct(PPDMDRVINS pDrvIns)
726{
727#ifdef RT_OS_LINUX
728 PDRVHOSTBASE pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTBASE);
729
730 if (pThis->pbDoubleBuffer)
731 {
732 RTMemFree(pThis->pbDoubleBuffer);
733 pThis->pbDoubleBuffer = NULL;
734 }
735#endif
736 return DRVHostBaseDestruct(pDrvIns);
737}
738
739
740/**
741 * Construct a host dvd drive driver instance.
742 *
743 * @returns VBox status.
744 * @param pDrvIns The driver instance data.
745 * If the registration structure is needed, pDrvIns->pDrvReg points to it.
746 * @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
747 * of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
748 * iInstance it's expected to be used a bit in this function.
749 */
750static DECLCALLBACK(int) drvHostDvdConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
751{
752 PDRVHOSTBASE pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTBASE);
753 LogFlow(("drvHostDvdConstruct: iInstance=%d\n", pDrvIns->iInstance));
754
755 /*
756 * Validate configuration.
757 */
758 if (!CFGMR3AreValuesValid(pCfgHandle, "Path\0Interval\0Locked\0BIOSVisible\0AttachFailError\0Passthrough\0"))
759 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
760
761
762 /*
763 * Init instance data.
764 */
765 int rc = DRVHostBaseInitData(pDrvIns, pCfgHandle, PDMBLOCKTYPE_DVD);
766 if (RT_SUCCESS(rc))
767 {
768 /*
769 * Override stuff.
770 */
771#ifdef RT_OS_LINUX
772 pThis->pbDoubleBuffer = (uint8_t *)RTMemAlloc(SCSI_MAX_BUFFER_SIZE);
773 if (!pThis->pbDoubleBuffer)
774 return VERR_NO_MEMORY;
775#endif
776
777#ifndef RT_OS_L4 /* Passthrough is not supported on L4 yet */
778 bool fPassthrough;
779 rc = CFGMR3QueryBool(pCfgHandle, "Passthrough", &fPassthrough);
780 if (RT_SUCCESS(rc) && fPassthrough)
781 {
782 pThis->IBlock.pfnSendCmd = drvHostDvdSendCmd;
783 /* Passthrough requires opening the device in R/W mode. */
784 pThis->fReadOnlyConfig = false;
785# ifdef VBOX_WITH_SUID_WRAPPER /* Solaris setuid for Passthrough mode. */
786 rc = solarisCheckUserAuth();
787 if (RT_FAILURE(rc))
788 {
789 Log(("DVD: solarisCheckUserAuth failed. Permission denied!\n"));
790 return rc;
791 }
792# endif /* VBOX_WITH_SUID_WRAPPER */
793 }
794#endif /* !RT_OS_L4 */
795
796 pThis->IMount.pfnUnmount = drvHostDvdUnmount;
797 pThis->pfnDoLock = drvHostDvdDoLock;
798#ifdef USE_MEDIA_POLLING
799 if (!fPassthrough)
800 pThis->pfnPoll = drvHostDvdPoll;
801 else
802 pThis->pfnPoll = NULL;
803#endif
804#ifdef RT_OS_LINUX
805 pThis->pfnGetMediaSize = drvHostDvdGetMediaSize;
806#endif
807
808 /*
809 * 2nd init part.
810 */
811 rc = DRVHostBaseInitFinish(pThis);
812 }
813 if (RT_FAILURE(rc))
814 {
815 if (!pThis->fAttachFailError)
816 {
817 /* Suppressing the attach failure error must not affect the normal
818 * DRVHostBaseDestruct, so reset this flag below before leaving. */
819 pThis->fKeepInstance = true;
820 rc = VINF_SUCCESS;
821 }
822 DRVHostBaseDestruct(pDrvIns);
823 pThis->fKeepInstance = false;
824 }
825
826 LogFlow(("drvHostDvdConstruct: returns %Rrc\n", rc));
827 return rc;
828}
829
830
831/**
832 * Block driver registration record.
833 */
834const PDMDRVREG g_DrvHostDVD =
835{
836 /* u32Version */
837 PDM_DRVREG_VERSION,
838 /* szDriverName */
839 "HostDVD",
840 /* pszDescription */
841 "Host DVD Block Driver.",
842 /* fFlags */
843 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
844 /* fClass. */
845 PDM_DRVREG_CLASS_BLOCK,
846 /* cMaxInstances */
847 ~0,
848 /* cbInstance */
849 sizeof(DRVHOSTBASE),
850 /* pfnConstruct */
851 drvHostDvdConstruct,
852 /* pfnDestruct */
853 drvHostDvdDestruct,
854 /* pfnIOCtl */
855 NULL,
856 /* pfnPowerOn */
857 NULL,
858 /* pfnReset */
859 NULL,
860 /* pfnSuspend */
861 NULL,
862 /* pfnResume */
863 NULL,
864 /* pfnDetach */
865 NULL
866};
867
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use