dvmgpt.cpp@ 45234

Last change on this file since 45234 was 44529, checked in by vboxsync, 12 years ago
header (C) fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.3 KB

Line
1	/* $Id: dvmgpt.cpp 44529 2013-02-04 15:54:15Z vboxsync $ */
2	/** @file
3	* IPRT Disk Volume Management API (DVM) - GPT format backend.
4	*/
5
6	/*
7	* Copyright (C) 2011-2012 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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#include <iprt/types.h>
32	#include <iprt/assert.h>
33	#include <iprt/mem.h>
34	#include <iprt/dvm.h>
35	#include <iprt/string.h>
36	#include <iprt/uuid.h>
37	#include <iprt/asm.h>
38	#include "internal/dvm.h"
39
40
41	/*******************************************************************************
42	* Structures and Typedefs *
43	*******************************************************************************/
44	/** The GPT signature. */
45	#define RTDVM_GPT_SIGNATURE "EFI PART"
46
47	/**
48	* GPT on disk header.
49	*/
50	#pragma pack(1)
51	typedef struct GptHdr
52	{
53	/** Signature ("EFI PART"). */
54	char abSignature[8];
55	/** Revision. */
56	uint32_t u32Revision;
57	/** Header size. */
58	uint32_t cbHeader;
59	/** CRC of header. */
60	uint32_t u32Crc;
61	} GptHdr;
62	/** Pointer to a GPT header. */
63	typedef struct GptHdr *PGptHdr;
64	#pragma pack()
65	AssertCompileSize(GptHdr, 20);
66
67	/**
68	* Complete GPT table header for revision 1.0.
69	*/
70	#pragma pack(1)
71	typedef struct GptHdrRev1
72	{
73	/** Header. */
74	GptHdr Hdr;
75	/** Reserved. */
76	uint32_t u32Reserved;
77	/** Current LBA. */
78	uint64_t u64LbaCurrent;
79	/** Backup LBA. */
80	uint64_t u64LbaBackup;
81	/** First usable LBA for partitions. */
82	uint64_t u64LbaFirstPartition;
83	/** Last usable LBA for partitions. */
84	uint64_t u64LbaLastPartition;
85	/** Disk UUID. */
86	RTUUID DiskUuid;
87	/** LBA of first partition entry. */
88	uint64_t u64LbaPartitionEntries;
89	/** Number of partition entries. */
90	uint32_t cPartitionEntries;
91	/** Partition entry size. */
92	uint32_t cbPartitionEntry;
93	/** CRC of partition entries. */
94	uint32_t u32CrcPartitionEntries;
95	} GptHdrRev1;
96	/** Pointer to a revision 1.0 GPT header. */
97	typedef GptHdrRev1 *PGptHdrRev1;
98	#pragma pack()
99	AssertCompileSize(GptHdrRev1, 92);
100
101	/**
102	* GPT partition table entry.
103	*/
104	#pragma pack(1)
105	typedef struct GptEntry
106	{
107	/** Partition type UUID. */
108	RTUUID UuidType;
109	/** Partition UUID. */
110	RTUUID UuidPartition;
111	/** First LBA. */
112	uint64_t u64LbaFirst;
113	/** Last LBA. */
114	uint64_t u64LbaLast;
115	/** Attribute flags. */
116	uint64_t u64Flags;
117	/** Partition name (UTF-16LE code units). */
118	RTUTF16 aPartitionName[36];
119	} GptEntry;
120	/** Pointer to a GPT entry. */
121	typedef struct GptEntry *PGptEntry;
122	#pragma pack()
123	AssertCompileSize(GptEntry, 128);
124
125	/** Partition flags - System partition. */
126	#define RTDVM_GPT_ENTRY_SYSTEM RT_BIT_64(0)
127	/** Partition flags - Partition is readonly. */
128	#define RTDVM_GPT_ENTRY_READONLY RT_BIT_64(60)
129	/** Partition flags - Partition is hidden. */
130	#define RTDVM_GPT_ENTRY_HIDDEN RT_BIT_64(62)
131	/** Partition flags - Don't automount this partition. */
132	#define RTDVM_GPT_ENTRY_NO_AUTOMOUNT RT_BIT_64(63)
133
134	/**
135	* GPT volume manager data.
136	*/
137	typedef struct RTDVMFMTINTERNAL
138	{
139	/** Pointer to the underlying disk. */
140	PCRTDVMDISK pDisk;
141	/** GPT header. */
142	GptHdrRev1 HdrRev1;
143	/** GPT array. */
144	PGptEntry paGptEntries;
145	/** Number of occupied partition entries. */
146	uint32_t cPartitions;
147	} RTDVMFMTINTERNAL;
148	/** Pointer to the MBR volume manager. */
149	typedef RTDVMFMTINTERNAL *PRTDVMFMTINTERNAL;
150
151	/**
152	* GPT volume data.
153	*/
154	typedef struct RTDVMVOLUMEFMTINTERNAL
155	{
156	/** Pointer to the volume manager. */
157	PRTDVMFMTINTERNAL pVolMgr;
158	/** Partition table entry index. */
159	uint32_t idxEntry;
160	/** Start offset of the volume. */
161	uint64_t offStart;
162	/** Size of the volume. */
163	uint64_t cbVolume;
164	/** Pointer to the GPT entry in the array. */
165	PGptEntry pGptEntry;
166	} RTDVMVOLUMEFMTINTERNAL;
167	/** Pointer to an MBR volume. */
168	typedef RTDVMVOLUMEFMTINTERNAL *PRTDVMVOLUMEFMTINTERNAL;
169
170	/**
171	* GPT partition type to DVM volume type mapping entry.
172	*/
173
174	typedef struct RTDVMGPTPARTTYPE2VOLTYPE
175	{
176	/** Type UUID. */
177	const char *pcszUuid;
178	/** DVM volume type. */
179	RTDVMVOLTYPE enmVolType;
180	} RTDVMGPTPARTTYPE2VOLTYPE;
181	/** Pointer to a MBR FS Type to volume type mapping entry. */
182	typedef RTDVMGPTPARTTYPE2VOLTYPE *PRTDVMGPTPARTTYPE2VOLTYPE;
183
184	/** Converts a LBA number to the byte offset. */
185	#define RTDVM_GPT_LBA2BYTE(lba, disk) ((lba) * (disk)->cbSector)
186	/** Converts a Byte offset to the LBA number. */
187	#define RTDVM_GPT_BYTE2LBA(lba, disk) ((lba) / (disk)->cbSector)
188
189
190	/*******************************************************************************
191	* Global Variables *
192	*******************************************************************************/
193	/**
194	* Mapping of partition types to DVM volume types.
195	*
196	* From http://en.wikipedia.org/wiki/GUID_Partition_Table
197	*/
198	static const RTDVMGPTPARTTYPE2VOLTYPE g_aPartType2DvmVolTypes[] =
199	{
200	{"0657FD6D-A4AB-43C4-84E5-0933C84B4F4F", RTDVMVOLTYPE_LINUX_SWAP},
201	{"EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", RTDVMVOLTYPE_LINUX_NATIVE},
202	{"E6D6D379-F507-44C2-A23C-238F2A3DF928", RTDVMVOLTYPE_LINUX_LVM},
203	{"A19D880F-05FC-4D3B-A006-743F0F84911E", RTDVMVOLTYPE_LINUX_SOFTRAID},
204
205	{"83BD6B9D-7F41-11DC-BE0B-001560B84F0F", RTDVMVOLTYPE_FREEBSD}, /* Boot */
206	{"516E7CB4-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD}, /* Data */
207	{"516E7CB5-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD}, /* Swap */
208	{"516E7CB6-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD}, /* UFS */
209	{"516E7CB8-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD}, /* Vinum */
210	{"516E7CBA-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD}, /* ZFS */
211
212	{"49F48D32-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD}, /* Swap */
213	{"49F48D5A-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD}, /* FFS */
214	{"49F48D82-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD}, /* LFS */
215	{"49F48DAA-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD}, /* Raid */
216	{"2DB519C4-B10F-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD}, /* Concatenated */
217	{"2DB519EC-B10F-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD}, /* Encrypted */
218
219	{"48465300-0000-11AA-AA11-00306543ECAC", RTDVMVOLTYPE_MAC_OSX_HFS},
220
221	{"6A82CB45-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* Boot */
222	{"6A85CF4D-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* Root */
223	{"6A87C46F-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* Swap */
224	{"6A8B642B-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* Backup */
225	{"6A898CC3-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* /usr */
226	{"6A8EF2E9-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* /var */
227	{"6A90BA39-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* /home */
228	{"6A9283A5-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS}, /* Alternate sector */
229	};
230
231	static DECLCALLBACK(int) rtDvmFmtGptProbe(PCRTDVMDISK pDisk, uint32_t *puScore)
232	{
233	int rc = VINF_SUCCESS;
234	GptHdr Hdr;
235
236	*puScore = RTDVM_MATCH_SCORE_UNSUPPORTED;
237
238	if (rtDvmDiskGetSectors(pDisk) >= 2)
239	{
240	/* Read from the disk and check for the signature. */
241	rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &Hdr, sizeof(GptHdr));
242	if ( RT_SUCCESS(rc)
243	&& !strncmp(&Hdr.abSignature[0], RTDVM_GPT_SIGNATURE, RT_ELEMENTS(Hdr.abSignature))
244	&& RT_LE2H_U32(Hdr.u32Revision) == 0x00010000
245	&& RT_LE2H_U32(Hdr.cbHeader) == sizeof(GptHdrRev1))
246	*puScore = RTDVM_MATCH_SCORE_PERFECT;
247	}
248
249	return rc;
250	}
251
252	static DECLCALLBACK(int) rtDvmFmtGptOpen(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt)
253	{
254	int rc = VINF_SUCCESS;
255	PRTDVMFMTINTERNAL pThis = NULL;
256
257	pThis = (PRTDVMFMTINTERNAL)RTMemAllocZ(sizeof(RTDVMFMTINTERNAL));
258	if (pThis)
259	{
260	pThis->pDisk = pDisk;
261	pThis->cPartitions = 0;
262
263	/* Read the complete GPT header and convert to host endianess. */
264	rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &pThis->HdrRev1, sizeof(pThis->HdrRev1));
265	if (RT_SUCCESS(rc))
266	{
267	pThis->HdrRev1.Hdr.u32Revision = RT_LE2H_U32(pThis->HdrRev1.Hdr.u32Revision);
268	pThis->HdrRev1.Hdr.cbHeader = RT_LE2H_U32(pThis->HdrRev1.Hdr.cbHeader);
269	pThis->HdrRev1.Hdr.u32Crc = RT_LE2H_U32(pThis->HdrRev1.Hdr.u32Crc);
270	pThis->HdrRev1.u64LbaCurrent = RT_LE2H_U64(pThis->HdrRev1.u64LbaCurrent);
271	pThis->HdrRev1.u64LbaBackup = RT_LE2H_U64(pThis->HdrRev1.u64LbaBackup);
272	pThis->HdrRev1.u64LbaFirstPartition = RT_LE2H_U64(pThis->HdrRev1.u64LbaFirstPartition);
273	pThis->HdrRev1.u64LbaLastPartition = RT_LE2H_U64(pThis->HdrRev1.u64LbaLastPartition);
274	/** @todo: Disk UUID */
275	pThis->HdrRev1.u64LbaPartitionEntries = RT_LE2H_U64(pThis->HdrRev1.u64LbaPartitionEntries);
276	pThis->HdrRev1.cPartitionEntries = RT_LE2H_U32(pThis->HdrRev1.cPartitionEntries);
277	pThis->HdrRev1.cbPartitionEntry = RT_LE2H_U32(pThis->HdrRev1.cbPartitionEntry);
278	pThis->HdrRev1.u32CrcPartitionEntries = RT_LE2H_U32(pThis->HdrRev1.u32CrcPartitionEntries);
279
280	if (pThis->HdrRev1.cbPartitionEntry == sizeof(GptEntry))
281	{
282	pThis->paGptEntries = (PGptEntry)RTMemAllocZ(pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry);
283	if (pThis->paGptEntries)
284	{
285	rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(pThis->HdrRev1.u64LbaPartitionEntries, pDisk),
286	pThis->paGptEntries, pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry);
287	if (RT_SUCCESS(rc))
288	{
289	/* Count the occupied entries. */
290	for (unsigned i = 0; i < pThis->HdrRev1.cPartitionEntries; i++)
291	if (!RTUuidIsNull(&pThis->paGptEntries[i].UuidType))
292	{
293	/* Convert to host endianess. */
294	/** @todo: Uuids */
295	pThis->paGptEntries[i].u64LbaFirst = RT_LE2H_U64(pThis->paGptEntries[i].u64LbaFirst);
296	pThis->paGptEntries[i].u64LbaLast = RT_LE2H_U64(pThis->paGptEntries[i].u64LbaLast);
297	pThis->paGptEntries[i].u64Flags = RT_LE2H_U64(pThis->paGptEntries[i].u64Flags);
298	for (unsigned cwc = 0; cwc < RT_ELEMENTS(pThis->paGptEntries[i].aPartitionName); cwc++)
299	pThis->paGptEntries[i].aPartitionName[cwc] = RT_LE2H_U16(pThis->paGptEntries[i].aPartitionName[cwc]);
300
301	pThis->cPartitions++;
302	}
303	}
304
305	if (RT_FAILURE(rc))
306	RTMemFree(pThis->paGptEntries);
307	}
308	else
309	rc = VERR_NO_MEMORY;
310	}
311	else
312	rc = VERR_NOT_SUPPORTED;
313
314	if (RT_SUCCESS(rc))
315	*phVolMgrFmt = pThis;
316	else
317	RTMemFree(pThis);
318	}
319	}
320	else
321	rc = VERR_NO_MEMORY;
322
323	return rc;
324	}
325
326	static DECLCALLBACK(int) rtDvmFmtGptInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt)
327	{
328	NOREF(pDisk); NOREF(phVolMgrFmt);
329	return VERR_NOT_IMPLEMENTED;
330	}
331
332	static DECLCALLBACK(void) rtDvmFmtGptClose(RTDVMFMT hVolMgrFmt)
333	{
334	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
335
336	pThis->pDisk = NULL;
337	memset(&pThis->HdrRev1, 0, sizeof(pThis->HdrRev1));
338	RTMemFree(pThis->paGptEntries);
339
340	pThis->paGptEntries = NULL;
341	RTMemFree(pThis);
342	}
343
344	static DECLCALLBACK(int) rtDvmFmtGptQueryRangeUse(RTDVMFMT hVolMgrFmt,
345	uint64_t off, uint64_t cbRange,
346	bool *pfUsed)
347	{
348	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
349
350	NOREF(cbRange);
351
352	if (off < 33*pThis->pDisk->cbSector)
353	*pfUsed = true;
354	else
355	*pfUsed = false;
356
357	return VINF_SUCCESS;
358	}
359
360	static DECLCALLBACK(uint32_t) rtDvmFmtGptGetValidVolumes(RTDVMFMT hVolMgrFmt)
361	{
362	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
363
364	return pThis->cPartitions;
365	}
366
367	static DECLCALLBACK(uint32_t) rtDvmFmtGptGetMaxVolumes(RTDVMFMT hVolMgrFmt)
368	{
369	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
370
371	return pThis->HdrRev1.cPartitionEntries;
372	}
373
374	/**
375	* Creates a new volume.
376	*
377	* @returns IPRT status code.
378	* @param pThis The MBR volume manager data.
379	* @param pGptEntry The GPT entry.
380	* @param idx The index in the partition array.
381	* @param phVolFmt Where to store the volume data on success.
382	*/
383	static int rtDvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, PGptEntry pGptEntry,
384	uint32_t idx, PRTDVMVOLUMEFMT phVolFmt)
385	{
386	int rc = VINF_SUCCESS;
387	PRTDVMVOLUMEFMTINTERNAL pVol = (PRTDVMVOLUMEFMTINTERNAL)RTMemAllocZ(sizeof(RTDVMVOLUMEFMTINTERNAL));
388
389	if (pVol)
390	{
391	pVol->pVolMgr = pThis;
392	pVol->idxEntry = idx;
393	pVol->pGptEntry = pGptEntry;
394	pVol->offStart = RTDVM_GPT_LBA2BYTE(pGptEntry->u64LbaFirst, pThis->pDisk);
395	pVol->cbVolume = RTDVM_GPT_LBA2BYTE(pGptEntry->u64LbaLast - pGptEntry->u64LbaFirst + 1, pThis->pDisk);
396
397	*phVolFmt = pVol;
398	}
399	else
400	rc = VERR_NO_MEMORY;
401
402	return rc;
403	}
404
405	static DECLCALLBACK(int) rtDvmFmtGptQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt)
406	{
407	int rc = VINF_SUCCESS;
408	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
409
410	if (pThis->cPartitions != 0)
411	{
412	PGptEntry pGptEntry = &pThis->paGptEntries[0];
413
414	/* Search for the first non empty entry. */
415	for (unsigned i = 0; i < pThis->HdrRev1.cPartitionEntries; i++)
416	{
417	if (!RTUuidIsNull(&pGptEntry->UuidType))
418	{
419	rc = rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmt);
420	break;
421	}
422	pGptEntry++;
423	}
424	}
425	else
426	rc = VERR_DVM_MAP_EMPTY;
427
428	return rc;
429	}
430
431	static DECLCALLBACK(int) rtDvmFmtGptQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext)
432	{
433	int rc = VERR_DVM_MAP_NO_VOLUME;
434	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
435	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
436	PGptEntry pGptEntry = pVol->pGptEntry + 1;
437
438	for (unsigned i = pVol->idxEntry + 1; i < pThis->HdrRev1.cPartitionEntries; i++)
439	{
440	if (!RTUuidIsNull(&pGptEntry->UuidType))
441	{
442	rc = rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmtNext);
443	break;
444	}
445	pGptEntry++;
446	}
447
448	return rc;
449	}
450
451	static DECLCALLBACK(void) rtDvmFmtGptVolumeClose(RTDVMVOLUMEFMT hVolFmt)
452	{
453	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
454
455	pVol->pVolMgr = NULL;
456	pVol->offStart = 0;
457	pVol->cbVolume = 0;
458	pVol->pGptEntry = NULL;
459
460	RTMemFree(pVol);
461	}
462
463	static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetSize(RTDVMVOLUMEFMT hVolFmt)
464	{
465	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
466
467	return pVol->cbVolume;
468	}
469
470	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName)
471	{
472	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
473	int rc = VINF_SUCCESS;
474
475	*ppszVolName = NULL;
476	rc = RTUtf16ToUtf8Ex(&pVol->pGptEntry->aPartitionName[0], RT_ELEMENTS(pVol->pGptEntry->aPartitionName),
477	ppszVolName, 0, NULL);
478
479	return rc;
480	}
481
482	static DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtGptVolumeGetType(RTDVMVOLUMEFMT hVolFmt)
483	{
484	RTDVMVOLTYPE enmVolType = RTDVMVOLTYPE_UNKNOWN;
485	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
486
487	for (unsigned i = 0; i < RT_ELEMENTS(g_aPartType2DvmVolTypes); i++)
488	if (!RTUuidCompareStr(&pVol->pGptEntry->UuidType, g_aPartType2DvmVolTypes[i].pcszUuid))
489	{
490	enmVolType = g_aPartType2DvmVolTypes[i].enmVolType;
491	break;
492	}
493
494	return enmVolType;
495	}
496
497	static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt)
498	{
499	NOREF(hVolFmt); /* No supported flags for now. */
500	return 0;
501	}
502
503	DECLCALLBACK(bool) rtDvmFmtGptVolumeIsRangeIntersecting(RTDVMVOLUMEFMT hVolFmt,
504	uint64_t offStart, size_t cbRange,
505	uint64_t *poffVol,
506	uint64_t *pcbIntersect)
507	{
508	bool fIntersect = false;
509	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
510
511	if (RTDVM_RANGE_IS_INTERSECTING(pVol->offStart, pVol->cbVolume, offStart))
512	{
513	fIntersect = true;
514	*poffVol = offStart - pVol->offStart;
515	*pcbIntersect = RT_MIN(cbRange, pVol->offStart + pVol->cbVolume - offStart);
516	}
517
518	return fIntersect;
519	}
520
521	static DECLCALLBACK(int) rtDvmFmtGptVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead)
522	{
523	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
524	AssertReturn(off + cbRead <= pVol->cbVolume, VERR_INVALID_PARAMETER);
525
526	return rtDvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead);
527	}
528
529	static DECLCALLBACK(int) rtDvmFmtGptVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite)
530	{
531	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
532	AssertReturn(off + cbWrite <= pVol->cbVolume, VERR_INVALID_PARAMETER);
533
534	return rtDvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite);
535	}
536
537	RTDVMFMTOPS g_rtDvmFmtGpt =
538	{
539	/* pcszFmt */
540	"GPT",
541	/* pfnProbe */
542	rtDvmFmtGptProbe,
543	/* pfnOpen */
544	rtDvmFmtGptOpen,
545	/* pfnInitialize */
546	rtDvmFmtGptInitialize,
547	/* pfnClose */
548	rtDvmFmtGptClose,
549	/* pfnQueryRangeUse */
550	rtDvmFmtGptQueryRangeUse,
551	/* pfnGetValidVolumes */
552	rtDvmFmtGptGetValidVolumes,
553	/* pfnGetMaxVolumes */
554	rtDvmFmtGptGetMaxVolumes,
555	/* pfnQueryFirstVolume */
556	rtDvmFmtGptQueryFirstVolume,
557	/* pfnQueryNextVolume */
558	rtDvmFmtGptQueryNextVolume,
559	/* pfnVolumeClose */
560	rtDvmFmtGptVolumeClose,
561	/* pfnVolumeGetSize */
562	rtDvmFmtGptVolumeGetSize,
563	/* pfnVolumeQueryName */
564	rtDvmFmtGptVolumeQueryName,
565	/* pfnVolumeGetType */
566	rtDvmFmtGptVolumeGetType,
567	/* pfnVolumeGetFlags */
568	rtDvmFmtGptVolumeGetFlags,
569	/* pfnVolumeIsRangeIntersecting */
570	rtDvmFmtGptVolumeIsRangeIntersecting,
571	/* pfnVolumeRead */
572	rtDvmFmtGptVolumeRead,
573	/* pfnVolumeWrite */
574	rtDvmFmtGptVolumeWrite
575	};
576

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

source: vbox/trunk/src/VBox/Runtime/common/dvm/dvmgpt.cpp@ 45234

Download in other formats: