vd-plugin.h@ 35638

Last change on this file since 35638 was 33567, checked in by vboxsync, 14 years ago
VD: Move the generic virtual disk framework + backends to src/VBox/Storage and rename the files to get rid of the HDD part because it supports floppy and DVD images too
Property svn:eol-style set to `native`
File size: 25.6 KB

Line
1	/** @file
2	* Internal hard disk format support API for VBoxHDD.
3	*/
4
5	/*
6	* Copyright (C) 2006-2010 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*/
25
26	#ifndef __VBoxHDD_Plugin_h__
27	#define __VBoxHDD_Plugin_h__
28
29	#include <VBox/vd.h>
30
31
32	/** @name VBox HDD backend write flags
33	* @{
34	*/
35	/** Do not allocate a new block on this write. This is just an advisory
36	* flag. The backend may still decide in some circumstances that it wants
37	* to ignore this flag (which may cause extra dynamic image expansion). */
38	#define VD_WRITE_NO_ALLOC RT_BIT(1)
39	/** @}*/
40
41
42	/**
43	* Image format backend interface used by VBox HDD Container implementation.
44	*/
45	typedef struct VBOXHDDBACKEND
46	{
47	/**
48	* The name of the backend (constant string).
49	*/
50	const char *pszBackendName;
51
52	/**
53	* The size of the structure.
54	*/
55	uint32_t cbSize;
56
57	/**
58	* The capabilities of the backend.
59	*/
60	uint64_t uBackendCaps;
61
62	/**
63	* Pointer to a NULL-terminated array, containing the supported
64	* file extensions. Note that some backends do not work on files, so this
65	* pointer may just contain NULL.
66	*/
67	PCVDFILEEXTENSION paFileExtensions;
68
69	/**
70	* Pointer to an array of structs describing each supported config key.
71	* Terminated by a NULL config key. Note that some backends do not support
72	* the configuration interface, so this pointer may just contain NULL.
73	* Mandatory if the backend sets VD_CAP_CONFIG.
74	*/
75	PCVDCONFIGINFO paConfigInfo;
76
77	/**
78	* Handle of loaded plugin library, NIL_RTLDRMOD for static backends.
79	*/
80	RTLDRMOD hPlugin;
81
82	/**
83	* Check if a file is valid for the backend.
84	*
85	* @returns VBox status code.
86	* @param pszFilename Name of the image file.
87	* @param pVDIfsDisk Pointer to the per-disk VD interface list.
88	* @param pVDIfsImage Pointer to the per-image VD interface list.
89	* @param penmType Returns the supported device type on success.
90	*/
91	DECLR3CALLBACKMEMBER(int, pfnCheckIfValid, (const char *pszFilename, PVDINTERFACE pVDIfsDisk,
92	PVDINTERFACE pVDIfsImage, VDTYPE *penmType));
93
94	/**
95	* Open a disk image.
96	*
97	* @returns VBox status code.
98	* @param pszFilename Name of the image file to open. Guaranteed to be available and
99	* unchanged during the lifetime of this image.
100	* @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
101	* @param pVDIfsDisk Pointer to the per-disk VD interface list.
102	* @param pVDIfsImage Pointer to the per-image VD interface list.
103	* @param enmType Requested type of the image.
104	* @param ppBackendData Opaque state data for this image.
105	*/
106	DECLR3CALLBACKMEMBER(int, pfnOpen, (const char *pszFilename, unsigned uOpenFlags,
107	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
108	VDTYPE enmType, void **ppBackendData));
109
110	/**
111	* Create a disk image.
112	*
113	* @returns VBox status code.
114	* @param pszFilename Name of the image file to create. Guaranteed to be available and
115	* unchanged during the lifetime of this image.
116	* @param cbSize Image size in bytes.
117	* @param uImageFlags Flags specifying special image features.
118	* @param pszComment Pointer to image comment. NULL is ok.
119	* @param pPCHSGeometry Physical drive geometry CHS <= (16383,16,255).
120	* @param pLCHSGeometry Logical drive geometry CHS <= (1024,255,63).
121	* @param pUuid New UUID of the image. Not NULL.
122	* @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
123	* @param uPercentStart Starting value for progress percentage.
124	* @param uPercentSpan Span for varying progress percentage.
125	* @param pVDIfsDisk Pointer to the per-disk VD interface list.
126	* @param pVDIfsImage Pointer to the per-image VD interface list.
127	* @param pVDIfsOperation Pointer to the per-operation VD interface list.
128	* @param ppBackendData Opaque state data for this image.
129	*/
130	DECLR3CALLBACKMEMBER(int, pfnCreate, (const char *pszFilename, uint64_t cbSize,
131	unsigned uImageFlags, const char *pszComment,
132	PCVDGEOMETRY pPCHSGeometry,
133	PCVDGEOMETRY pLCHSGeometry,
134	PCRTUUID pUuid, unsigned uOpenFlags,
135	unsigned uPercentStart, unsigned uPercentSpan,
136	PVDINTERFACE pVDIfsDisk,
137	PVDINTERFACE pVDIfsImage,
138	PVDINTERFACE pVDIfsOperation,
139	void **ppBackendData));
140
141	/**
142	* Rename a disk image. Only needs to work as long as the operating
143	* system's rename file functionality is usable. If an attempt is made to
144	* rename an image to a location on another disk/filesystem, this function
145	* may just fail with an appropriate error code (not changing the opened
146	* image data at all). Also works only on images which actually refer to
147	* regular files. May be NULL.
148	*
149	* @returns VBox status code.
150	* @param pBackendData Opaque state data for this image.
151	* @param pszFilename New name of the image file. Guaranteed to be available and
152	* unchanged during the lifetime of this image.
153	*/
154	DECLR3CALLBACKMEMBER(int, pfnRename, (void pBackendData, const char pszFilename));
155
156	/**
157	* Close a disk image.
158	*
159	* @returns VBox status code.
160	* @param pBackendData Opaque state data for this image.
161	* @param fDelete If true, delete the image from the host disk.
162	*/
163	DECLR3CALLBACKMEMBER(int, pfnClose, (void *pBackendData, bool fDelete));
164
165	/**
166	* Read data from a disk image. The area read never crosses a block
167	* boundary.
168	*
169	* @returns VBox status code.
170	* @returns VERR_VD_BLOCK_FREE if this image contains no data for this block.
171	* @param pBackendData Opaque state data for this image.
172	* @param uOffset Offset to start reading from.
173	* @param pvBuf Where to store the read bits.
174	* @param cbRead Number of bytes to read.
175	* @param pcbActuallyRead Pointer to returned number of bytes read.
176	*/
177	DECLR3CALLBACKMEMBER(int, pfnRead, (void pBackendData, uint64_t uOffset, void pvBuf,
178	size_t cbRead, size_t *pcbActuallyRead));
179
180	/**
181	* Write data to a disk image. The area written never crosses a block
182	* boundary.
183	*
184	* @returns VBox status code.
185	* @returns VERR_VD_BLOCK_FREE if this image contains no data for this block and
186	* this is not a full-block write. The write must be repeated with
187	* the correct amount of prefix/postfix data read from the images below
188	* in the image stack. This might not be the most convenient interface,
189	* but it works with arbitrary block sizes, especially when the image
190	* stack uses different block sizes.
191	* @param pBackendData Opaque state data for this image.
192	* @param uOffset Offset to start writing to.
193	* @param pvBuf Where to retrieve the written bits.
194	* @param cbWrite Number of bytes to write.
195	* @param pcbWriteProcess Pointer to returned number of bytes that could
196	* be processed. In case the function returned
197	* VERR_VD_BLOCK_FREE this is the number of bytes
198	* that could be written in a full block write,
199	* when prefixed/postfixed by the appropriate
200	* amount of (previously read) padding data.
201	* @param pcbPreRead Pointer to the returned amount of data that must
202	* be prefixed to perform a full block write.
203	* @param pcbPostRead Pointer to the returned amount of data that must
204	* be postfixed to perform a full block write.
205	* @param fWrite Flags which affect write behavior. Combination
206	* of the VD_WRITE_* flags.
207	*/
208	DECLR3CALLBACKMEMBER(int, pfnWrite, (void *pBackendData, uint64_t uOffset,
209	const void *pvBuf, size_t cbWrite,
210	size_t pcbWriteProcess, size_t pcbPreRead,
211	size_t *pcbPostRead, unsigned fWrite));
212
213	/**
214	* Flush data to disk.
215	*
216	* @returns VBox status code.
217	* @param pBackendData Opaque state data for this image.
218	*/
219	DECLR3CALLBACKMEMBER(int, pfnFlush, (void *pBackendData));
220
221	/**
222	* Get the version of a disk image.
223	*
224	* @returns version of disk image.
225	* @param pBackendData Opaque state data for this image.
226	*/
227	DECLR3CALLBACKMEMBER(unsigned, pfnGetVersion, (void *pBackendData));
228
229	/**
230	* Get the capacity of a disk image.
231	*
232	* @returns size of disk image in bytes.
233	* @param pBackendData Opaque state data for this image.
234	*/
235	DECLR3CALLBACKMEMBER(uint64_t, pfnGetSize, (void *pBackendData));
236
237	/**
238	* Get the file size of a disk image.
239	*
240	* @returns size of disk image in bytes.
241	* @param pBackendData Opaque state data for this image.
242	*/
243	DECLR3CALLBACKMEMBER(uint64_t, pfnGetFileSize, (void *pBackendData));
244
245	/**
246	* Get virtual disk PCHS geometry stored in a disk image.
247	*
248	* @returns VBox status code.
249	* @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the image.
250	* @param pBackendData Opaque state data for this image.
251	* @param pPCHSGeometry Where to store the geometry. Not NULL.
252	*/
253	DECLR3CALLBACKMEMBER(int, pfnGetPCHSGeometry, (void *pBackendData, PVDGEOMETRY pPCHSGeometry));
254
255	/**
256	* Set virtual disk PCHS geometry stored in a disk image.
257	* Only called if geometry is different than before.
258	*
259	* @returns VBox status code.
260	* @param pBackendData Opaque state data for this image.
261	* @param pPCHSGeometry Where to load the geometry from. Not NULL.
262	*/
263	DECLR3CALLBACKMEMBER(int, pfnSetPCHSGeometry, (void *pBackendData, PCVDGEOMETRY pPCHSGeometry));
264
265	/**
266	* Get virtual disk LCHS geometry stored in a disk image.
267	*
268	* @returns VBox status code.
269	* @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the image.
270	* @param pBackendData Opaque state data for this image.
271	* @param pLCHSGeometry Where to store the geometry. Not NULL.
272	*/
273	DECLR3CALLBACKMEMBER(int, pfnGetLCHSGeometry, (void *pBackendData, PVDGEOMETRY pLCHSGeometry));
274
275	/**
276	* Set virtual disk LCHS geometry stored in a disk image.
277	* Only called if geometry is different than before.
278	*
279	* @returns VBox status code.
280	* @param pBackendData Opaque state data for this image.
281	* @param pLCHSGeometry Where to load the geometry from. Not NULL.
282	*/
283	DECLR3CALLBACKMEMBER(int, pfnSetLCHSGeometry, (void *pBackendData, PCVDGEOMETRY pLCHSGeometry));
284
285	/**
286	* Get the image flags of a disk image.
287	*
288	* @returns image flags of disk image.
289	* @param pBackendData Opaque state data for this image.
290	*/
291	DECLR3CALLBACKMEMBER(unsigned, pfnGetImageFlags, (void *pBackendData));
292
293	/**
294	* Get the open flags of a disk image.
295	*
296	* @returns open flags of disk image.
297	* @param pBackendData Opaque state data for this image.
298	*/
299	DECLR3CALLBACKMEMBER(unsigned, pfnGetOpenFlags, (void *pBackendData));
300
301	/**
302	* Set the open flags of a disk image. May cause the image to be locked
303	* in a different mode or be reopened (which can fail).
304	*
305	* @returns VBox status code.
306	* @param pBackendData Opaque state data for this image.
307	* @param uOpenFlags New open flags for this image.
308	*/
309	DECLR3CALLBACKMEMBER(int, pfnSetOpenFlags, (void *pBackendData, unsigned uOpenFlags));
310
311	/**
312	* Get comment of a disk image.
313	*
314	* @returns VBox status code.
315	* @param pBackendData Opaque state data for this image.
316	* @param pszComment Where to store the comment.
317	* @param cbComment Size of the comment buffer.
318	*/
319	DECLR3CALLBACKMEMBER(int, pfnGetComment, (void pBackendData, char pszComment, size_t cbComment));
320
321	/**
322	* Set comment of a disk image.
323	*
324	* @returns VBox status code.
325	* @param pBackendData Opaque state data for this image.
326	* @param pszComment Where to get the comment from. NULL resets comment.
327	* The comment is silently truncated if the image format
328	* limit is exceeded.
329	*/
330	DECLR3CALLBACKMEMBER(int, pfnSetComment, (void pBackendData, const char pszComment));
331
332	/**
333	* Get UUID of a disk image.
334	*
335	* @returns VBox status code.
336	* @param pBackendData Opaque state data for this image.
337	* @param pUuid Where to store the image UUID.
338	*/
339	DECLR3CALLBACKMEMBER(int, pfnGetUuid, (void *pBackendData, PRTUUID pUuid));
340
341	/**
342	* Set UUID of a disk image.
343	*
344	* @returns VBox status code.
345	* @param pBackendData Opaque state data for this image.
346	* @param pUuid Where to get the image UUID from.
347	*/
348	DECLR3CALLBACKMEMBER(int, pfnSetUuid, (void *pBackendData, PCRTUUID pUuid));
349
350	/**
351	* Get last modification UUID of a disk image.
352	*
353	* @returns VBox status code.
354	* @param pBackendData Opaque state data for this image.
355	* @param pUuid Where to store the image modification UUID.
356	*/
357	DECLR3CALLBACKMEMBER(int, pfnGetModificationUuid, (void *pBackendData, PRTUUID pUuid));
358
359	/**
360	* Set last modification UUID of a disk image.
361	*
362	* @returns VBox status code.
363	* @param pBackendData Opaque state data for this image.
364	* @param pUuid Where to get the image modification UUID from.
365	*/
366	DECLR3CALLBACKMEMBER(int, pfnSetModificationUuid, (void *pBackendData, PCRTUUID pUuid));
367
368	/**
369	* Get parent UUID of a disk image.
370	*
371	* @returns VBox status code.
372	* @param pBackendData Opaque state data for this image.
373	* @param pUuid Where to store the parent image UUID.
374	*/
375	DECLR3CALLBACKMEMBER(int, pfnGetParentUuid, (void *pBackendData, PRTUUID pUuid));
376
377	/**
378	* Set parent UUID of a disk image.
379	*
380	* @returns VBox status code.
381	* @param pBackendData Opaque state data for this image.
382	* @param pUuid Where to get the parent image UUID from.
383	*/
384	DECLR3CALLBACKMEMBER(int, pfnSetParentUuid, (void *pBackendData, PCRTUUID pUuid));
385
386	/**
387	* Get parent modification UUID of a disk image.
388	*
389	* @returns VBox status code.
390	* @param pBackendData Opaque state data for this image.
391	* @param pUuid Where to store the parent image modification UUID.
392	*/
393	DECLR3CALLBACKMEMBER(int, pfnGetParentModificationUuid, (void *pBackendData, PRTUUID pUuid));
394
395	/**
396	* Set parent modification UUID of a disk image.
397	*
398	* @returns VBox status code.
399	* @param pBackendData Opaque state data for this image.
400	* @param pUuid Where to get the parent image modification UUID from.
401	*/
402	DECLR3CALLBACKMEMBER(int, pfnSetParentModificationUuid, (void *pBackendData, PCRTUUID pUuid));
403
404	/**
405	* Dump information about a disk image.
406	*
407	* @param pBackendData Opaque state data for this image.
408	*/
409	DECLR3CALLBACKMEMBER(void, pfnDump, (void *pBackendData));
410
411	/**
412	* Get a time stamp of a disk image. May be NULL.
413	*
414	* @returns VBox status code.
415	* @param pBackendData Opaque state data for this image.
416	* @param pTimeStamp Where to store the time stamp.
417	*/
418	DECLR3CALLBACKMEMBER(int, pfnGetTimeStamp, (void *pBackendData, PRTTIMESPEC pTimeStamp));
419
420	/**
421	* Get the parent time stamp of a disk image. May be NULL.
422	*
423	* @returns VBox status code.
424	* @param pBackendData Opaque state data for this image.
425	* @param pTimeStamp Where to store the time stamp.
426	*/
427	DECLR3CALLBACKMEMBER(int, pfnGetParentTimeStamp, (void *pBackendData, PRTTIMESPEC pTimeStamp));
428
429	/**
430	* Set the parent time stamp of a disk image. May be NULL.
431	*
432	* @returns VBox status code.
433	* @param pBackendData Opaque state data for this image.
434	* @param pTimeStamp Where to get the time stamp from.
435	*/
436	DECLR3CALLBACKMEMBER(int, pfnSetParentTimeStamp, (void *pBackendData, PCRTTIMESPEC pTimeStamp));
437
438	/**
439	* Get the relative path to parent image. May be NULL.
440	*
441	* @returns VBox status code.
442	* @param pBackendData Opaque state data for this image.
443	* @param pszParentFilename Where to store the path.
444	*/
445	DECLR3CALLBACKMEMBER(int, pfnGetParentFilename, (void pBackendData, char *ppszParentFilename));
446
447	/**
448	* Set the relative path to parent image. May be NULL.
449	*
450	* @returns VBox status code.
451	* @param pBackendData Opaque state data for this image.
452	* @param pszParentFilename Where to get the path from.
453	*/
454	DECLR3CALLBACKMEMBER(int, pfnSetParentFilename, (void pBackendData, const char pszParentFilename));
455
456	/**
457	* Return whether asynchronous I/O operations are supported for this image.
458	*
459	* @returns true if asynchronous I/O is supported
460	* false otherwise.
461	* @param pBackendData Opaque state data for this image.
462	*/
463	DECLR3CALLBACKMEMBER(bool, pfnIsAsyncIOSupported, (void *pBackendData));
464
465	/**
466	* Start an asynchronous read request.
467	*
468	* @returns VBox status code.
469	* @param pBackendData Opaque state data for this image.
470	* @param uOffset The offset of the virtual disk to read from.
471	* @param cbRead How many bytes to read.
472	* @param pIoCtx I/O context associated with this request.
473	* @param pcbActuallyRead Pointer to returned number of bytes read.
474	*/
475	DECLR3CALLBACKMEMBER(int, pfnAsyncRead, (void *pBackendData, uint64_t uOffset, size_t cbRead,
476	PVDIOCTX pIoCtx, size_t *pcbActuallyRead));
477
478	/**
479	* Start an asynchronous write request.
480	*
481	* @returns VBox status code.
482	* @param pBackendData Opaque state data for this image.
483	* @param uOffset The offset of the virtual disk to write to.
484	* @param cbWrite How many bytes to write.
485	* @param pIoCtx I/O context associated with this request.
486	* @param pcbWriteProcess Pointer to returned number of bytes that could
487	* be processed. In case the function returned
488	* VERR_VD_BLOCK_FREE this is the number of bytes
489	* that could be written in a full block write,
490	* when prefixed/postfixed by the appropriate
491	* amount of (previously read) padding data.
492	* @param pcbPreRead Pointer to the returned amount of data that must
493	* be prefixed to perform a full block write.
494	* @param pcbPostRead Pointer to the returned amount of data that must
495	* be postfixed to perform a full block write.
496	* @param fWrite Flags which affect write behavior. Combination
497	* of the VD_WRITE_* flags.
498	*/
499	DECLR3CALLBACKMEMBER(int, pfnAsyncWrite, (void *pBackendData, uint64_t uOffset, size_t cbWrite,
500	PVDIOCTX pIoCtx,
501	size_t pcbWriteProcess, size_t pcbPreRead,
502	size_t *pcbPostRead, unsigned fWrite));
503
504	/**
505	* Flush data to disk.
506	*
507	* @returns VBox status code.
508	* @param pBackendData Opaque state data for this image.
509	* @param pIoCtx I/O context associated with this request.
510	*/
511	DECLR3CALLBACKMEMBER(int, pfnAsyncFlush, (void *pBackendData, PVDIOCTX pIoCtx));
512
513	/** Returns a human readable hard disk location string given a
514	* set of hard disk configuration keys. The returned string is an
515	* equivalent of the full file path for image-based hard disks.
516	* Mandatory for backends with no VD_CAP_FILE and NULL otherwise. */
517	DECLR3CALLBACKMEMBER(int, pfnComposeLocation, (PVDINTERFACE pConfig, char **pszLocation));
518
519	/** Returns a human readable hard disk name string given a
520	* set of hard disk configuration keys. The returned string is an
521	* equivalent of the file name part in the full file path for
522	* image-based hard disks. Mandatory for backends with no
523	* VD_CAP_FILE and NULL otherwise. */
524	DECLR3CALLBACKMEMBER(int, pfnComposeName, (PVDINTERFACE pConfig, char **pszName));
525
526	/**
527	* Compact the image. The pointer may be NULL, indicating that this
528	* isn't supported yet (for file-based images) or not necessary.
529	*
530	* @returns VBox status code.
531	* @returns VERR_NOT_SUPPORTED if this image cannot be compacted yet.
532	* @param pBackendData Opaque state data for this image.
533	* @param uPercentStart Starting value for progress percentage.
534	* @param uPercentSpan Span for varying progress percentage.
535	* @param pVDIfsDisk Pointer to the per-disk VD interface list.
536	* @param pVDIfsImage Pointer to the per-image VD interface list.
537	* @param pVDIfsOperation Pointer to the per-operation VD interface list.
538	*/
539	DECLR3CALLBACKMEMBER(int, pfnCompact, (void *pBackendData,
540	unsigned uPercentStart, unsigned uPercentSpan,
541	PVDINTERFACE pVDIfsDisk,
542	PVDINTERFACE pVDIfsImage,
543	PVDINTERFACE pVDIfsOperation));
544
545	/**
546	* Resize the image. The pointer may be NULL, indicating that this
547	* isn't supported yet (for file-based images) or not necessary.
548	*
549	* @returns VBox status code.
550	* @returns VERR_NOT_SUPPORTED if this image cannot be compacted yet.
551	* @param pBackendData Opaque state data for this image.
552	* @param cbSize New size of the image.
553	* @param pPCHSGeometry Pointer to the new physical disk geometry <= (16383,16,63). Not NULL.
554	* @param pLCHSGeometry Pointer to the new logical disk geometry <= (x,255,63). Not NULL.
555	* @param uPercentStart Starting value for progress percentage.
556	* @param uPercentSpan Span for varying progress percentage.
557	* @param pVDIfsDisk Pointer to the per-disk VD interface list.
558	* @param pVDIfsImage Pointer to the per-image VD interface list.
559	* @param pVDIfsOperation Pointer to the per-operation VD interface list.
560	*/
561	DECLR3CALLBACKMEMBER(int, pfnResize, (void *pBackendData,
562	uint64_t cbSize,
563	PCVDGEOMETRY pPCHSGeometry,
564	PCVDGEOMETRY pLCHSGeometry,
565	unsigned uPercentStart, unsigned uPercentSpan,
566	PVDINTERFACE pVDIfsDisk,
567	PVDINTERFACE pVDIfsImage,
568	PVDINTERFACE pVDIfsOperation));
569
570	} VBOXHDDBACKEND;
571
572	/** Pointer to VD backend. */
573	typedef VBOXHDDBACKEND *PVBOXHDDBACKEND;
574
575	/** Constant pointer to VD backend. */
576	typedef const VBOXHDDBACKEND *PCVBOXHDDBACKEND;
577
578	/** @copydoc VBOXHDDBACKEND::pfnComposeLocation */
579	DECLINLINE(int) genericFileComposeLocation(PVDINTERFACE pConfig, char **pszLocation)
580	{
581	*pszLocation = NULL;
582	return VINF_SUCCESS;
583	}
584	/** @copydoc VBOXHDDBACKEND::pfnComposeName */
585	DECLINLINE(int) genericFileComposeName(PVDINTERFACE pConfig, char **pszName)
586	{
587	*pszName = NULL;
588	return VINF_SUCCESS;
589	}
590
591	/** Initialization entry point. */
592	typedef DECLCALLBACK(int) VBOXHDDFORMATLOAD(PVBOXHDDBACKEND *ppBackendTable);
593	typedef VBOXHDDFORMATLOAD *PFNVBOXHDDFORMATLOAD;
594	#define VBOX_HDDFORMAT_LOAD_NAME "VBoxHDDFormatLoad"
595
596	/** The prefix to identify Storage Plugins. */
597	#define VBOX_HDDFORMAT_PLUGIN_PREFIX "VBoxHDD"
598	/** The size of the prefix excluding the '\\0' terminator. */
599	#define VBOX_HDDFORMAT_PLUGIN_PREFIX_LENGTH (sizeof(VBOX_HDDFORMAT_PLUGIN_PREFIX)-1)
600
601	#endif

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/VBox/vd-plugin.h@ 35638

Download in other formats: