VirtualBox

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

Last change on this file since 60404 was 59252, checked in by vboxsync, 8 years ago

pdmifs.h: Move the storage related interfaces (PDMIMEDIA, PDMIMOUNT, PDMISCSICONNECTOR, etc.) into a separate header to reduce the overall size of the header a bit

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use