VirtualBox

source: vbox/trunk/src/VBox/Devices/Storage/DrvRawImage.cpp@ 27653

Last change on this file since 27653 was 26173, checked in by vboxsync, 15 years ago

PDM: s/pCfgHandle/pCfg/g - part 2.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.7 KB
Line 
1/* $Id: DrvRawImage.cpp 26173 2010-02-02 21:11:09Z vboxsync $ */
2/** @file
3 * VBox storage devices: Raw image driver
4 */
5
6/*
7 * Copyright (C) 2006-2010 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_RAW_IMAGE
27#include <VBox/pdmdrv.h>
28#include <iprt/assert.h>
29#include <iprt/file.h>
30#include <iprt/string.h>
31#include <iprt/uuid.h>
32
33#include "Builtins.h"
34
35
36/*******************************************************************************
37* Defined Constants And Macros *
38*******************************************************************************/
39/** Converts a pointer to RAWIMAGE::IMedia to a PRDVRAWIMAGE. */
40#define PDMIMEDIA_2_DRVRAWIMAGE(pInterface) ( (PDRVRAWIMAGE)((uintptr_t)pInterface - RT_OFFSETOF(DRVRAWIMAGE, IMedia)) )
41
42/** Converts a pointer to PDMDRVINS::IBase to a PPDMDRVINS. */
43#define PDMIBASE_2_DRVINS(pInterface) ( (PPDMDRVINS)((uintptr_t)pInterface - RT_OFFSETOF(PDMDRVINS, IBase)) )
44
45/** Converts a pointer to PDMDRVINS::IBase to a PVBOXHDD. */
46#define PDMIBASE_2_DRVRAWIMAGE(pInterface) ( PDMINS_2_DATA(PDMIBASE_2_DRVINS(pInterface), PDRVRAWIMAGE) )
47
48
49
50/*******************************************************************************
51* Structures and Typedefs *
52*******************************************************************************/
53/**
54 * Block driver instance data.
55 *
56 * @implements PDMIMEDIA
57 */
58typedef struct DRVRAWIMAGE
59{
60 /** The media interface. */
61 PDMIMEDIA IMedia;
62 /** Pointer to the driver instance. */
63 PPDMDRVINS pDrvIns;
64 /** Pointer to the filename. (Freed by MM) */
65 char *pszFilename;
66 /** File handle of the raw image file. */
67 RTFILE File;
68 /** True if the image is operating in readonly mode. */
69 bool fReadOnly;
70} DRVRAWIMAGE, *PDRVRAWIMAGE;
71
72
73
74/* -=-=-=-=- PDMIMEDIA -=-=-=-=- */
75
76/** @copydoc PDMIMEDIA::pfnGetSize */
77static DECLCALLBACK(uint64_t) drvRawImageGetSize(PPDMIMEDIA pInterface)
78{
79 PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
80 LogFlow(("drvRawImageGetSize: '%s'\n", pThis->pszFilename));
81
82 uint64_t cbFile;
83 int rc = RTFileGetSize(pThis->File, &cbFile);
84 if (RT_SUCCESS(rc))
85 {
86 LogFlow(("drvRawImageGetSize: returns %lld (%s)\n", cbFile, pThis->pszFilename));
87 return cbFile;
88 }
89
90 AssertMsgFailed(("Error querying Raw image file size, rc=%Rrc. (%s)\n", rc, pThis->pszFilename));
91 return 0;
92}
93
94
95/** @copydoc PDMIMEDIA::pfnBiosGetPCHSGeometry */
96static DECLCALLBACK(int) drvRawImageBiosGetPCHSGeometry(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry)
97{
98 return VERR_NOT_IMPLEMENTED;
99}
100
101
102/** @copydoc PDMIMEDIA::pfnBiosSetPCHSGeometry */
103static DECLCALLBACK(int) drvRawImageBiosSetPCHSGeometry(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pPCHSGeometry)
104{
105 return VERR_NOT_IMPLEMENTED;
106}
107
108
109/** @copydoc PDMIMEDIA::pfnBiosGetLCHSGeometry */
110static DECLCALLBACK(int) drvRawImageBiosGetLCHSGeometry(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry)
111{
112 return VERR_NOT_IMPLEMENTED;
113}
114
115
116/** @copydoc PDMIMEDIA::pfnBiosSetLCHSGeometry */
117static DECLCALLBACK(int) drvRawImageBiosSetLCHSGeometry(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry)
118{
119 return VERR_NOT_IMPLEMENTED;
120}
121
122
123/**
124 * Read bits.
125 *
126 * @see PDMIMEDIA::pfnRead for details.
127 */
128static DECLCALLBACK(int) drvRawImageRead(PPDMIMEDIA pInterface, uint64_t off, void *pvBuf, size_t cbRead)
129{
130 PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
131 LogFlow(("drvRawImageRead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n", off, pvBuf, cbRead, pThis->pszFilename));
132
133 Assert(pThis->File);
134 Assert(pvBuf);
135
136 /*
137 * Seek to the position and read.
138 */
139 int rc = RTFileSeek(pThis->File, off, RTFILE_SEEK_BEGIN, NULL);
140 if (RT_SUCCESS(rc))
141 {
142 rc = RTFileRead(pThis->File, pvBuf, cbRead, NULL);
143 if (RT_SUCCESS(rc))
144 {
145 Log2(("drvRawImageRead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n"
146 "%16.*Rhxd\n",
147 off, pvBuf, cbRead, pThis->pszFilename,
148 cbRead, pvBuf));
149 }
150 else
151 AssertMsgFailed(("RTFileRead(%d, %p, %#x) -> %Rrc (off=%#llx '%s')\n",
152 pThis->File, pvBuf, cbRead, rc, off, pThis->pszFilename));
153 }
154 else
155 AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Rrc\n", pThis->File, off, rc));
156 LogFlow(("drvRawImageRead: returns %Rrc\n", rc));
157 return rc;
158}
159
160
161/** @copydoc PDMIMEDIA::pfnWrite */
162static DECLCALLBACK(int) drvRawImageWrite(PPDMIMEDIA pInterface, uint64_t off, const void *pvBuf, size_t cbWrite)
163{
164 PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
165 LogFlow(("drvRawImageWrite: off=%#llx pvBuf=%p cbWrite=%#x (%s)\n", off, pvBuf, cbWrite, pThis->pszFilename));
166
167 Assert(pThis->File);
168 Assert(pvBuf);
169
170 /*
171 * Seek to the position and write.
172 */
173 int rc = RTFileSeek(pThis->File, off, RTFILE_SEEK_BEGIN, NULL);
174 if (RT_SUCCESS(rc))
175 {
176 rc = RTFileWrite(pThis->File, pvBuf, cbWrite, NULL);
177 if (RT_SUCCESS(rc))
178 {
179 Log2(("drvRawImageWrite: off=%#llx pvBuf=%p cbWrite=%#x (%s)\n"
180 "%16.*Rhxd\n",
181 off, pvBuf, cbWrite, pThis->pszFilename,
182 cbWrite, pvBuf));
183 }
184 else
185 AssertMsgFailed(("RTFileWrite(%d, %p, %#x) -> %Rrc (off=%#llx '%s')\n",
186 pThis->File, pvBuf, cbWrite, rc, off, pThis->pszFilename));
187 }
188 else
189 AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Rrc\n", pThis->File, off, rc));
190 LogFlow(("drvRawImageWrite: returns %Rrc\n", rc));
191 return rc;
192}
193
194
195/** @copydoc PDMIMEDIA::pfnFlush */
196static DECLCALLBACK(int) drvRawImageFlush(PPDMIMEDIA pInterface)
197{
198 PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
199 LogFlow(("drvRawImageFlush: (%s)\n", pThis->pszFilename));
200
201 Assert(pThis->File != NIL_RTFILE);
202 int rc = RTFileFlush(pThis->File);
203 LogFlow(("drvRawImageFlush: returns %Rrc\n", rc));
204 return rc;
205}
206
207
208/** @copydoc PDMIMEDIA::pfnGetUuid */
209static DECLCALLBACK(int) drvRawImageGetUuid(PPDMIMEDIA pInterface, PRTUUID pUuid)
210{
211 LogFlow(("drvRawImageGetUuid: returns VERR_NOT_IMPLEMENTED\n"));
212 return VERR_NOT_IMPLEMENTED;
213}
214
215
216/** @copydoc PDMIMEDIA::pfnIsReadOnly */
217static DECLCALLBACK(bool) drvRawImageIsReadOnly(PPDMIMEDIA pInterface)
218{
219 PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
220 return pThis->fReadOnly;
221}
222
223
224/* -=-=-=-=- PDMIBASE -=-=-=-=- */
225
226/**
227 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
228 */
229static DECLCALLBACK(void *) drvRawImageQueryInterface(PPDMIBASE pInterface, const char *pszIID)
230{
231 PPDMDRVINS pDrvIns = PDMIBASE_2_DRVINS(pInterface);
232 PDRVRAWIMAGE pThis = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
233
234 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
235 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIA, &pThis->IMedia);
236 return NULL;
237}
238
239/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
240
241/**
242 * Destruct a driver instance.
243 *
244 * Most VM resources are freed by the VM. This callback is provided so that any non-VM
245 * resources can be freed correctly.
246 *
247 * @param pDrvIns The driver instance data.
248 */
249static DECLCALLBACK(void) drvRawImageDestruct(PPDMDRVINS pDrvIns)
250{
251 PDRVRAWIMAGE pThis = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
252 LogFlow(("drvRawImageDestruct: '%s'\n", pThis->pszFilename));
253 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
254
255 if (pThis->File != NIL_RTFILE)
256 {
257 RTFileClose(pThis->File);
258 pThis->File = NIL_RTFILE;
259 }
260 if (pThis->pszFilename)
261 MMR3HeapFree(pThis->pszFilename);
262}
263
264
265/**
266 * Construct a raw image driver instance.
267 *
268 * @copydoc FNPDMDRVCONSTRUCT
269 */
270static DECLCALLBACK(int) drvRawImageConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
271{
272 PDRVRAWIMAGE pThis = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
273 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
274
275 /*
276 * Init the static parts.
277 */
278 pThis->pDrvIns = pDrvIns;
279 pThis->File = NIL_RTFILE;
280 /* IBase */
281 pDrvIns->IBase.pfnQueryInterface = drvRawImageQueryInterface;
282 /* IMedia */
283 pThis->IMedia.pfnRead = drvRawImageRead;
284 pThis->IMedia.pfnWrite = drvRawImageWrite;
285 pThis->IMedia.pfnFlush = drvRawImageFlush;
286 pThis->IMedia.pfnGetSize = drvRawImageGetSize;
287 pThis->IMedia.pfnGetUuid = drvRawImageGetUuid;
288 pThis->IMedia.pfnIsReadOnly = drvRawImageIsReadOnly;
289 pThis->IMedia.pfnBiosGetPCHSGeometry = drvRawImageBiosGetPCHSGeometry;
290 pThis->IMedia.pfnBiosSetPCHSGeometry = drvRawImageBiosSetPCHSGeometry;
291 pThis->IMedia.pfnBiosGetLCHSGeometry = drvRawImageBiosGetLCHSGeometry;
292 pThis->IMedia.pfnBiosSetLCHSGeometry = drvRawImageBiosSetLCHSGeometry;
293
294 /*
295 * Read the configuration.
296 */
297 if (!CFGMR3AreValuesValid(pCfg, "Path\0"))
298 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
299
300 char *pszName;
301 int rc = CFGMR3QueryStringAlloc(pCfg, "Path", &pszName);
302 if (RT_FAILURE(rc))
303 {
304 AssertMsgFailed(("Configuration error: query for \"Path\" string return %Rrc.\n", rc));
305 return rc;
306 }
307
308 /*
309 * Open the image.
310 */
311 rc = RTFileOpen(&pThis->File, pszName,
312 RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
313 if (RT_SUCCESS(rc))
314 {
315 LogFlow(("drvRawImageConstruct: Raw image '%s' opened successfully.\n", pszName));
316 pThis->pszFilename = pszName;
317 pThis->fReadOnly = false;
318 }
319 else
320 {
321 rc = RTFileOpen(&pThis->File, pszName,
322 RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
323 if (RT_SUCCESS(rc))
324 {
325 LogFlow(("drvRawImageConstruct: Raw image '%s' opened successfully.\n", pszName));
326 pThis->pszFilename = pszName;
327 pThis->fReadOnly = true;
328 }
329 else
330 {
331 AssertMsgFailed(("Could not open Raw image file %s, rc=%Rrc\n", pszName, rc));
332 MMR3HeapFree(pszName);
333 }
334 }
335
336 return rc;
337}
338
339
340/**
341 * Raw image driver registration record.
342 */
343const PDMDRVREG g_DrvRawImage =
344{
345 /* u32Version */
346 PDM_DRVREG_VERSION,
347 /* szName */
348 "RawImage",
349 /* szRCMod */
350 "",
351 /* szR0Mod */
352 "",
353 /* pszDescription */
354 "Raw image access driver.",
355 /* fFlags */
356 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
357 /* fClass. */
358 PDM_DRVREG_CLASS_MEDIA,
359 /* cMaxInstances */
360 ~0,
361 /* cbInstance */
362 sizeof(DRVRAWIMAGE),
363 /* pfnConstruct */
364 drvRawImageConstruct,
365 /* pfnDestruct */
366 drvRawImageDestruct,
367 /* pfnRelocate */
368 NULL,
369 /* pfnIOCtl */
370 NULL,
371 /* pfnPowerOn */
372 NULL,
373 /* pfnReset */
374 NULL,
375 /* pfnSuspend */
376 NULL,
377 /* pfnResume */
378 NULL,
379 /* pfnAttach */
380 NULL,
381 /* pfnDetach */
382 NULL,
383 /* pfnPowerOff */
384 NULL,
385 /* pfnSoftReset */
386 NULL,
387 /* u32EndVersion */
388 PDM_DRVREG_VERSION
389};
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