VirtualBox

source: vbox/trunk/src/VBox/Devices/Storage/VSCSI/VSCSILunMmc.cpp@ 44004

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

VSCSI: Added support for media locking/unlocking.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.6 KB
Line 
1/* $Id: VSCSILunMmc.cpp 43693 2012-10-22 09:34:18Z vboxsync $ */
2/** @file
3 * Virtual SCSI driver: MMC LUN implementation (CD/DVD-ROM)
4 */
5
6/*
7 * Copyright (C) 2006-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/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#define LOG_GROUP LOG_GROUP_VSCSI
22#include <VBox/log.h>
23#include <VBox/err.h>
24#include <VBox/types.h>
25#include <VBox/vscsi.h>
26#include <iprt/assert.h>
27#include <iprt/mem.h>
28#include <iprt/string.h>
29
30#include "VSCSIInternal.h"
31
32/**
33 * MMC LUN instance
34 */
35typedef struct VSCSILUNMMC
36{
37 /** Core LUN structure */
38 VSCSILUNINT Core;
39 /** Size of the virtual disk. */
40 uint64_t cSectors;
41 /** Sector size. */
42 uint32_t cbSector;
43 /** Medium locked indicator. */
44 bool fLocked;
45} VSCSILUNMMC, *PVSCSILUNMMC;
46
47
48DECLINLINE(void) mmcLBA2MSF(uint8_t *pbBuf, uint32_t iLBA)
49{
50 iLBA += 150;
51 pbBuf[0] = (iLBA / 75) / 60;
52 pbBuf[1] = (iLBA / 75) % 60;
53 pbBuf[2] = iLBA % 75;
54}
55
56DECLINLINE(uint32_t) mmcMSF2LBA(const uint8_t *pbBuf)
57{
58 return (pbBuf[0] * 60 + pbBuf[1]) * 75 + pbBuf[2];
59}
60
61
62/* Fabricate normal TOC information. */
63static int mmcReadTOCNormal(PVSCSILUNINT pVScsiLun, PVSCSIREQINT pVScsiReq, uint16_t cbMaxTransfer, bool fMSF)
64{
65 PVSCSILUNMMC pVScsiLunMmc = (PVSCSILUNMMC)pVScsiLun;
66 uint8_t aReply[32];
67 uint8_t *pbBuf = aReply;
68 uint8_t *q;
69 uint8_t iStartTrack;
70 uint32_t cbSize;
71
72 iStartTrack = pVScsiReq->pbCDB[6];
73 if (iStartTrack > 1 && iStartTrack != 0xaa)
74 {
75 return vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00);
76 }
77 q = pbBuf + 2;
78 *q++ = 1; /* first session */
79 *q++ = 1; /* last session */
80 if (iStartTrack <= 1)
81 {
82 *q++ = 0; /* reserved */
83 *q++ = 0x14; /* ADR, CONTROL */
84 *q++ = 1; /* track number */
85 *q++ = 0; /* reserved */
86 if (fMSF)
87 {
88 *q++ = 0; /* reserved */
89 mmcLBA2MSF(q, 0);
90 q += 3;
91 }
92 else
93 {
94 /* sector 0 */
95 vscsiH2BEU32(q, 0);
96 q += 4;
97 }
98 }
99 /* lead out track */
100 *q++ = 0; /* reserved */
101 *q++ = 0x14; /* ADR, CONTROL */
102 *q++ = 0xaa; /* track number */
103 *q++ = 0; /* reserved */
104 if (fMSF)
105 {
106 *q++ = 0; /* reserved */
107 mmcLBA2MSF(q, pVScsiLunMmc->cSectors);
108 q += 3;
109 }
110 else
111 {
112 vscsiH2BEU32(q, pVScsiLunMmc->cSectors);
113 q += 4;
114 }
115 cbSize = q - pbBuf;
116 Assert(cbSize <= sizeof(aReply));
117 vscsiH2BEU16(pbBuf, cbSize - 2);
118 if (cbSize < cbMaxTransfer)
119 cbMaxTransfer = cbSize;
120
121 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, cbMaxTransfer);
122
123 return vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
124}
125
126/* Fabricate session information. */
127static int mmcReadTOCMulti(PVSCSILUNINT pVScsiLun, PVSCSIREQINT pVScsiReq, uint16_t cbMaxTransfer, bool fMSF)
128{
129 PVSCSILUNMMC pVScsiLunMmc = (PVSCSILUNMMC)pVScsiLun;
130 uint8_t aReply[32];
131 uint8_t *pbBuf = aReply;
132
133 /* multi session: only a single session defined */
134 memset(pbBuf, 0, 12);
135 pbBuf[1] = 0x0a;
136 pbBuf[2] = 0x01; /* first complete session number */
137 pbBuf[3] = 0x01; /* last complete session number */
138 pbBuf[5] = 0x14; /* ADR, CONTROL */
139 pbBuf[6] = 1; /* first track in last complete session */
140
141 if (fMSF)
142 {
143 pbBuf[8] = 0; /* reserved */
144 mmcLBA2MSF(pbBuf + 8, 0);
145 }
146 else
147 {
148 /* sector 0 */
149 vscsiH2BEU32(pbBuf + 8, 0);
150 }
151
152 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, 12);
153
154 return vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
155}
156
157static int vscsiLunMmcInit(PVSCSILUNINT pVScsiLun)
158{
159 PVSCSILUNMMC pVScsiLunMmc = (PVSCSILUNMMC)pVScsiLun;
160 uint64_t cbDisk = 0;
161 int rc = VINF_SUCCESS;
162
163 pVScsiLunMmc->cbSector = 2048; /* Default to 2K sectors. */
164 rc = vscsiLunMediumGetSize(pVScsiLun, &cbDisk);
165 if (RT_SUCCESS(rc))
166 pVScsiLunMmc->cSectors = cbDisk / pVScsiLunMmc->cbSector;
167
168 return rc;
169}
170
171static int vscsiLunMmcDestroy(PVSCSILUNINT pVScsiLun)
172{
173 PVSCSILUNMMC pVScsiLunMmc = (PVSCSILUNMMC)pVScsiLun;
174
175 return VINF_SUCCESS;
176}
177
178static int vscsiLunMmcReqProcess(PVSCSILUNINT pVScsiLun, PVSCSIREQINT pVScsiReq)
179{
180 PVSCSILUNMMC pVScsiLunMmc = (PVSCSILUNMMC)pVScsiLun;
181 VSCSIIOREQTXDIR enmTxDir = VSCSIIOREQTXDIR_INVALID;
182 uint64_t uLbaStart = 0;
183 uint32_t cSectorTransfer = 0;
184 int rc = VINF_SUCCESS;
185 int rcReq = SCSI_STATUS_OK;
186 unsigned uCmd = pVScsiReq->pbCDB[0];
187
188 /*
189 * GET CONFIGURATION, GET EVENT/STATUS NOTIFICATION, INQUIRY, and REQUEST SENSE commands
190 * operate even when a unit attention condition exists for initiator; every other command
191 * needs to report CHECK CONDITION in that case.
192 */
193 if (!pVScsiLunMmc->Core.fReady && uCmd != SCSI_INQUIRY)
194 {
195 /*
196 * A note on media changes: As long as a medium is not present, the unit remains in
197 * the 'not ready' state. Technically the unit becomes 'ready' soon after a medium
198 * is inserted; however, we internally keep the 'not ready' state until we've had
199 * a chance to report the UNIT ATTENTION status indicating a media change.
200 */
201 if (pVScsiLunMmc->Core.fMediaPresent)
202 {
203 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_UNIT_ATTENTION,
204 SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED, 0x00);
205 pVScsiLunMmc->Core.fReady = true;
206 }
207 else
208 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_NOT_READY,
209 SCSI_ASC_MEDIUM_NOT_PRESENT, 0x00);
210 }
211 else
212 {
213 switch (uCmd)
214 {
215 case SCSI_TEST_UNIT_READY:
216 Assert(!pVScsiLunMmc->Core.fReady); /* Only should get here if LUN isn't ready. */
217 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT, 0x00);
218 break;
219
220 case SCSI_INQUIRY:
221 {
222 SCSIINQUIRYDATA ScsiInquiryReply;
223
224 memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
225
226 ScsiInquiryReply.cbAdditional = 31;
227 ScsiInquiryReply.fRMB = 1; /* Removable. */
228 ScsiInquiryReply.u5PeripheralDeviceType = SCSI_INQUIRY_DATA_PERIPHERAL_DEVICE_TYPE_CD_DVD;
229 ScsiInquiryReply.u3PeripheralQualifier = SCSI_INQUIRY_DATA_PERIPHERAL_QUALIFIER_CONNECTED;
230 ScsiInquiryReply.u3AnsiVersion = 0x05; /* MMC-?? compliant */
231 ScsiInquiryReply.fCmdQue = 1; /* Command queuing supported. */
232 ScsiInquiryReply.fWBus16 = 1;
233 vscsiPadStr(ScsiInquiryReply.achVendorId, "VBOX", 8);
234 vscsiPadStr(ScsiInquiryReply.achProductId, "CD-ROM", 16);
235 vscsiPadStr(ScsiInquiryReply.achProductLevel, "1.0", 4);
236
237 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, (uint8_t *)&ScsiInquiryReply, sizeof(SCSIINQUIRYDATA));
238 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
239 break;
240 }
241 case SCSI_READ_CAPACITY:
242 {
243 uint8_t aReply[8];
244 memset(aReply, 0, sizeof(aReply));
245
246 /*
247 * If sector size exceeds the maximum value that is
248 * able to be stored in 4 bytes return 0xffffffff in this field
249 */
250 if (pVScsiLunMmc->cSectors > UINT32_C(0xffffffff))
251 vscsiH2BEU32(aReply, UINT32_C(0xffffffff));
252 else
253 vscsiH2BEU32(aReply, pVScsiLunMmc->cSectors - 1);
254 vscsiH2BEU32(&aReply[4], pVScsiLunMmc->cbSector);
255 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
256 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
257 break;
258 }
259 case SCSI_MODE_SENSE_6:
260 {
261 uint8_t uModePage = pVScsiReq->pbCDB[2] & 0x3f;
262 uint8_t aReply[24];
263 uint8_t *pu8ReplyPos;
264
265 memset(aReply, 0, sizeof(aReply));
266 aReply[0] = 4; /* Reply length 4. */
267 aReply[1] = 0; /* Default media type. */
268 aReply[2] = RT_BIT(4); /* Caching supported. */
269 aReply[3] = 0; /* Block descriptor length. */
270
271 pu8ReplyPos = aReply + 4;
272
273 if ((uModePage == 0x08) || (uModePage == 0x3f))
274 {
275 memset(pu8ReplyPos, 0, 20);
276 *pu8ReplyPos++ = 0x08; /* Page code. */
277 *pu8ReplyPos++ = 0x12; /* Size of the page. */
278 *pu8ReplyPos++ = 0x4; /* Write cache enabled. */
279 }
280
281 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
282 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
283 break;
284 }
285 case SCSI_MODE_SELECT_6:
286 {
287 /* @todo: implement!! */
288 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
289 break;
290 }
291 case SCSI_READ_6:
292 {
293 enmTxDir = VSCSIIOREQTXDIR_READ;
294 uLbaStart = ((uint64_t) pVScsiReq->pbCDB[3]
295 | (pVScsiReq->pbCDB[2] << 8)
296 | ((pVScsiReq->pbCDB[1] & 0x1f) << 16));
297 cSectorTransfer = pVScsiReq->pbCDB[4];
298 break;
299 }
300 case SCSI_READ_10:
301 {
302 enmTxDir = VSCSIIOREQTXDIR_READ;
303 uLbaStart = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
304 cSectorTransfer = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
305 break;
306 }
307 case SCSI_READ_12:
308 {
309 enmTxDir = VSCSIIOREQTXDIR_READ;
310 uLbaStart = vscsiBE2HU32(&pVScsiReq->pbCDB[2]);
311 cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[6]);
312 break;
313 }
314 case SCSI_READ_16:
315 {
316 enmTxDir = VSCSIIOREQTXDIR_READ;
317 uLbaStart = vscsiBE2HU64(&pVScsiReq->pbCDB[2]);
318 cSectorTransfer = vscsiBE2HU32(&pVScsiReq->pbCDB[10]);
319 break;
320 }
321 case SCSI_READ_BUFFER:
322 {
323 uint8_t uDataMode = pVScsiReq->pbCDB[1] & 0x1f;
324
325 switch (uDataMode)
326 {
327 case 0x00:
328 case 0x01:
329 case 0x02:
330 case 0x03:
331 case 0x0a:
332 break;
333 case 0x0b:
334 {
335 uint8_t aReply[4];
336
337 /* We do not implement an echo buffer. */
338 memset(aReply, 0, sizeof(aReply));
339
340 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
341 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
342 break;
343 }
344 case 0x1a:
345 case 0x1c:
346 break;
347 default:
348 AssertMsgFailed(("Invalid data mode\n"));
349 }
350 break;
351 }
352 case SCSI_VERIFY_10:
353 case SCSI_START_STOP_UNIT:
354 {
355 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
356 break;
357 }
358 case SCSI_LOG_SENSE:
359 {
360 uint16_t cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
361 uint8_t uPageCode = pVScsiReq->pbCDB[2] & 0x3f;
362 uint8_t uSubPageCode = pVScsiReq->pbCDB[3];
363
364 switch (uPageCode)
365 {
366 case 0x00:
367 {
368 if (uSubPageCode == 0)
369 {
370 uint8_t aReply[4];
371
372 aReply[0] = 0;
373 aReply[1] = 0;
374 aReply[2] = 0;
375 aReply[3] = 0;
376
377 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
378 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
379 break;
380 }
381 }
382 default:
383 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00);
384 }
385 break;
386 }
387 case SCSI_SERVICE_ACTION_IN_16:
388 {
389 switch (pVScsiReq->pbCDB[1] & 0x1f)
390 {
391 case SCSI_SVC_ACTION_IN_READ_CAPACITY_16:
392 {
393 uint8_t aReply[32];
394
395 memset(aReply, 0, sizeof(aReply));
396 vscsiH2BEU64(aReply, pVScsiLunMmc->cSectors - 1);
397 vscsiH2BEU32(&aReply[8], pVScsiLunMmc->cbSector);
398 /* Leave the rest 0 */
399 RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
400 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
401 break;
402 }
403 default:
404 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00); /* Don't know if this is correct */
405 }
406 break;
407 }
408 case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL:
409 {
410 pVScsiLunMmc->fLocked = pVScsiReq->pbCDB[4] & 1;
411 vscsiLunMediumSetLock(pVScsiLun, pVScsiLunMmc->fLocked);
412 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
413 break;
414 }
415 case SCSI_READ_TOC_PMA_ATIP:
416 {
417 uint8_t format;
418 uint16_t cbMax;
419 bool fMSF;
420
421 format = pVScsiReq->pbCDB[2] & 0x0f;
422 cbMax = vscsiBE2HU16(&pVScsiReq->pbCDB[7]);
423 fMSF = (pVScsiReq->pbCDB[1] >> 1) & 1;
424 switch (format)
425 {
426 case 0x00:
427 mmcReadTOCNormal(pVScsiLun, pVScsiReq, cbMax, fMSF);
428 break;
429 case 0x01:
430 mmcReadTOCMulti(pVScsiLun, pVScsiReq, cbMax, fMSF);
431 break;
432 default:
433 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0x00);
434 }
435 break;
436 }
437
438 default:
439 //AssertMsgFailed(("Command %#x [%s] not implemented\n", pVScsiReq->pbCDB[0], SCSICmdText(pVScsiReq->pbCDB[0])));
440 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE, 0x00);
441 }
442 }
443
444 if (enmTxDir != VSCSIIOREQTXDIR_INVALID)
445 {
446 LogFlow(("%s: uLbaStart=%llu cSectorTransfer=%u\n",
447 __FUNCTION__, uLbaStart, cSectorTransfer));
448
449 if (RT_UNLIKELY(uLbaStart + cSectorTransfer > pVScsiLunMmc->cSectors))
450 {
451 rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR, 0x00);
452 vscsiDeviceReqComplete(pVScsiLun->pVScsiDevice, pVScsiReq, rcReq, false, VINF_SUCCESS);
453 }
454 else if (!cSectorTransfer)
455 {
456 /* A 0 transfer length is not an error. */
457 rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
458 vscsiDeviceReqComplete(pVScsiLun->pVScsiDevice, pVScsiReq, rcReq, false, VINF_SUCCESS);
459 }
460 else
461 {
462 /* Enqueue new I/O request */
463 rc = vscsiIoReqTransferEnqueue(pVScsiLun, pVScsiReq, enmTxDir,
464 uLbaStart * pVScsiLunMmc->cbSector,
465 cSectorTransfer * pVScsiLunMmc->cbSector);
466 }
467 }
468 else /* Request completed */
469 vscsiDeviceReqComplete(pVScsiLun->pVScsiDevice, pVScsiReq, rcReq, false, VINF_SUCCESS);
470
471 return rc;
472}
473
474VSCSILUNDESC g_VScsiLunTypeMmc =
475{
476 /** enmLunType */
477 VSCSILUNTYPE_MMC,
478 /** pcszDescName */
479 "MMC",
480 /** cbLun */
481 sizeof(VSCSILUNMMC),
482 /** pfnVScsiLunInit */
483 vscsiLunMmcInit,
484 /** pfnVScsiLunDestroy */
485 vscsiLunMmcDestroy,
486 /** pfnVScsiLunReqProcess */
487 vscsiLunMmcReqProcess
488};
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