dvmgpt.cpp@ 85887

Last change on this file since 85887 was 85887, checked in by vboxsync, 5 years ago
IPRT/RTDvm: Added RTDVMVOLIDX_HOST index. bugref:9224
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.1 KB

Line
1	/* $Id: dvmgpt.cpp 85887 2020-08-25 21:05:37Z vboxsync $ */
2	/** @file
3	* IPRT Disk Volume Management API (DVM) - GPT format backend.
4	*/
5
6	/*
7	* Copyright (C) 2011-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. 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/dvm.h>
32
33	#include <iprt/assert.h>
34	#include <iprt/asm.h>
35	#include <iprt/mem.h>
36	#include <iprt/string.h>
37	#include <iprt/utf16.h>
38	#include <iprt/uuid.h>
39	#include "internal/dvm.h"
40
41
42	/*********************************************************************************************************************************
43	* Structures and Typedefs *
44	*********************************************************************************************************************************/
45	/** The GPT signature. */
46	#define RTDVM_GPT_SIGNATURE "EFI PART"
47
48	/**
49	* GPT on disk header.
50	*/
51	typedef struct GPTHDR
52	{
53	/** 0x00: Signature ("EFI PART"). */
54	char abSignature[8];
55	/** 0x08: Revision. */
56	uint32_t u32Revision;
57	/** 0x0c: Header size. */
58	uint32_t cbHeader;
59	/** 0x10: CRC of header. */
60	uint32_t u32Crc;
61	} GPTHDR;
62	/** Pointer to a GPT header. */
63	typedef struct GPTHDR *PGPTHDR;
64	AssertCompileSize(GPTHDR, 20);
65
66	/**
67	* Complete GPT table header for revision 1.0.
68	*/
69	#pragma pack(1)
70	typedef struct GPTHDRREV1
71	{
72	/** 0x00: Header. */
73	GPTHDR Hdr;
74	/** 0x14: Reserved. */
75	uint32_t u32Reserved;
76	/** 0x18: Current LBA. */
77	uint64_t u64LbaCurrent;
78	/** 0x20: Backup LBA. */
79	uint64_t u64LbaBackup;
80	/** 0x28:First usable LBA for partitions. */
81	uint64_t u64LbaFirstPartition;
82	/** 0x30: Last usable LBA for partitions. */
83	uint64_t u64LbaLastPartition;
84	/** 0x38: Disk UUID. */
85	RTUUID DiskUuid;
86	/** 0x48: LBA of first partition entry. */
87	uint64_t u64LbaPartitionEntries;
88	/** 0x50: Number of partition entries. */
89	uint32_t cPartitionEntries;
90	/** 0x54: Partition entry size. */
91	uint32_t cbPartitionEntry;
92	/** 0x58: CRC of partition entries. */
93	uint32_t u32CrcPartitionEntries;
94	} GPTHDRREV1;
95	/** Pointer to a revision 1.0 GPT header. */
96	typedef GPTHDRREV1 *PGPTHDRREV1;
97	#pragma pack()
98	AssertCompileSize(GPTHDRREV1, 92);
99
100	/**
101	* GPT partition table entry.
102	*/
103	typedef struct GPTENTRY
104	{
105	/** 0x00: Partition type UUID. */
106	RTUUID UuidType;
107	/** 0x10: Partition UUID. */
108	RTUUID UuidPartition;
109	/** 0x20: First LBA. */
110	uint64_t u64LbaFirst;
111	/** 0x28: Last LBA. */
112	uint64_t u64LbaLast;
113	/** 0x30: Attribute flags. */
114	uint64_t u64Flags;
115	/** 0x38: Partition name (UTF-16LE code units). */
116	RTUTF16 aPartitionName[36];
117	} GPTENTRY;
118	/** Pointer to a GPT entry. */
119	typedef struct GPTENTRY *PGPTENTRY;
120	AssertCompileSize(GPTENTRY, 128);
121
122	/** Partition flags - System partition. */
123	#define RTDVM_GPT_ENTRY_SYSTEM RT_BIT_64(0)
124	/** Partition flags - Partition is readonly. */
125	#define RTDVM_GPT_ENTRY_READONLY RT_BIT_64(60)
126	/** Partition flags - Partition is hidden. */
127	#define RTDVM_GPT_ENTRY_HIDDEN RT_BIT_64(62)
128	/** Partition flags - Don't automount this partition. */
129	#define RTDVM_GPT_ENTRY_NO_AUTOMOUNT RT_BIT_64(63)
130
131	/**
132	* GPT volume manager data.
133	*/
134	typedef struct RTDVMFMTINTERNAL
135	{
136	/** Pointer to the underlying disk. */
137	PCRTDVMDISK pDisk;
138	/** GPT header. */
139	GPTHDRREV1 HdrRev1;
140	/** GPT array. */
141	PGPTENTRY paGptEntries;
142	/** Number of occupied partition entries. */
143	uint32_t cPartitions;
144	} RTDVMFMTINTERNAL;
145	/** Pointer to the MBR volume manager. */
146	typedef RTDVMFMTINTERNAL *PRTDVMFMTINTERNAL;
147
148	/**
149	* GPT volume data.
150	*/
151	typedef struct RTDVMVOLUMEFMTINTERNAL
152	{
153	/** Pointer to the volume manager. */
154	PRTDVMFMTINTERNAL pVolMgr;
155	/** Partition table entry index. */
156	uint32_t idxEntry;
157	/** Start offset of the volume. */
158	uint64_t offStart;
159	/** Size of the volume. */
160	uint64_t cbVolume;
161	/** Pointer to the GPT entry in the array. */
162	PGPTENTRY pGptEntry;
163	} RTDVMVOLUMEFMTINTERNAL;
164	/** Pointer to an MBR volume. */
165	typedef RTDVMVOLUMEFMTINTERNAL *PRTDVMVOLUMEFMTINTERNAL;
166
167	/**
168	* GPT partition type to DVM volume type mapping entry.
169	*/
170
171	typedef struct RTDVMGPTPARTTYPE2VOLTYPE
172	{
173	/** Type UUID. */
174	const char *pcszUuid;
175	/** DVM volume type. */
176	RTDVMVOLTYPE enmVolType;
177	} RTDVMGPTPARTTYPE2VOLTYPE;
178	/** Pointer to a MBR FS Type to volume type mapping entry. */
179	typedef RTDVMGPTPARTTYPE2VOLTYPE *PRTDVMGPTPARTTYPE2VOLTYPE;
180
181	/** Converts a LBA number to the byte offset. */
182	#define RTDVM_GPT_LBA2BYTE(lba, disk) ((lba) * (disk)->cbSector)
183	/** Converts a Byte offset to the LBA number. */
184	#define RTDVM_GPT_BYTE2LBA(lba, disk) ((lba) / (disk)->cbSector)
185
186
187	/*********************************************************************************************************************************
188	* Global Variables *
189	*********************************************************************************************************************************/
190	/**
191	* Mapping of partition types to DVM volume types.
192	*
193	* From http://en.wikipedia.org/wiki/GUID_Partition_Table
194	*/
195	static const RTDVMGPTPARTTYPE2VOLTYPE g_aPartType2DvmVolTypes[] =
196	{
197	{ "C12A7328-F81F-11D2-BA4B-00A0C93EC93B", RTDVMVOLTYPE_EFI_SYSTEM },
198
199	{ "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", RTDVMVOLTYPE_WIN_BASIC },
200	{ "E3C9E316-0B5C-4DB8-817D-F92DF00215AE", RTDVMVOLTYPE_WIN_MSR },
201	{ "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3", RTDVMVOLTYPE_WIN_LDM_META },
202	{ "AF9B60A0-1431-4F62-BC68-3311714A69AD", RTDVMVOLTYPE_WIN_LDM_DATA },
203	{ "DE94BBA4-06D1-4D40-A16A-BFD50179D6AC", RTDVMVOLTYPE_WIN_RECOVERY },
204	{ "E75CAF8F-F680-4CEE-AFA3-B001E56EFC2D", RTDVMVOLTYPE_WIN_STORAGE_SPACES },
205
206	{ "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F", RTDVMVOLTYPE_LINUX_SWAP },
207	{ "0FC63DAF-8483-4772-8E79-3D69D8477DE4", RTDVMVOLTYPE_LINUX_NATIVE },
208	{ "44479540-F297-41B2-9AF7-D131D5F0458A", RTDVMVOLTYPE_LINUX_NATIVE }, /* x86 root */
209	{ "4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709", RTDVMVOLTYPE_LINUX_NATIVE }, /* AMD64 root */
210	{ "69DAD710-2CE4-4E3C-B16C-21A1D49ABED3", RTDVMVOLTYPE_LINUX_NATIVE }, /* ARM32 root */
211	{ "B921B045-1DF0-41C3-AF44-4C6F280D3FAE", RTDVMVOLTYPE_LINUX_NATIVE }, /* ARM64 root */
212	{ "E6D6D379-F507-44C2-A23C-238F2A3DF928", RTDVMVOLTYPE_LINUX_LVM },
213	{ "A19D880F-05FC-4D3B-A006-743F0F84911E", RTDVMVOLTYPE_LINUX_SOFTRAID },
214
215	{ "83BD6B9D-7F41-11DC-BE0B-001560B84F0F", RTDVMVOLTYPE_FREEBSD }, /* Boot */
216	{ "516E7CB4-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD }, /* Data */
217	{ "516E7CB5-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD }, /* Swap */
218	{ "516E7CB6-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD }, /* UFS */
219	{ "516E7CB8-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD }, /* Vinum */
220	{ "516E7CBA-6ECF-11D6-8FF8-00022D09712B", RTDVMVOLTYPE_FREEBSD }, /* ZFS */
221
222	{ "49F48D32-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD }, /* Swap */
223	{ "49F48D5A-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD }, /* FFS */
224	{ "49F48D82-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD }, /* LFS */
225	{ "49F48DAA-B10E-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD }, /* Raid */
226	{ "2DB519C4-B10F-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD }, /* Concatenated */
227	{ "2DB519EC-B10F-11DC-B99B-0019D1879648", RTDVMVOLTYPE_NETBSD }, /* Encrypted */
228
229	{ "48465300-0000-11AA-AA11-00306543ECAC", RTDVMVOLTYPE_DARWIN_HFS },
230	{ "7C3457EF-0000-11AA-AA11-00306543ECAC", RTDVMVOLTYPE_DARWIN_APFS },
231
232	{ "6A82CB45-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* Boot */
233	{ "6A85CF4D-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* Root */
234	{ "6A87C46F-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* Swap */
235	{ "6A8B642B-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* Backup */
236	{ "6A898CC3-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* /usr */
237	{ "6A8EF2E9-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* /var */
238	{ "6A90BA39-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* /home */
239	{ "6A9283A5-1DD2-11B2-99A6-080020736631", RTDVMVOLTYPE_SOLARIS }, /* Alternate sector */
240
241	{ "37AFFC90-EF7D-4E96-91C3-2D7AE055B174", RTDVMVOLTYPE_IBM_GPFS },
242	};
243
244	static DECLCALLBACK(int) rtDvmFmtGptProbe(PCRTDVMDISK pDisk, uint32_t *puScore)
245	{
246	int rc = VINF_SUCCESS;
247	GPTHDR Hdr;
248
249	*puScore = RTDVM_MATCH_SCORE_UNSUPPORTED;
250
251	if (rtDvmDiskGetSectors(pDisk) >= 2)
252	{
253	/* Read from the disk and check for the signature. */
254	rc = rtDvmDiskReadUnaligned(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &Hdr, sizeof(GPTHDR));
255	if ( RT_SUCCESS(rc)
256	&& !strncmp(&Hdr.abSignature[0], RTDVM_GPT_SIGNATURE, RT_ELEMENTS(Hdr.abSignature))
257	&& RT_LE2H_U32(Hdr.u32Revision) == 0x00010000
258	&& RT_LE2H_U32(Hdr.cbHeader) == sizeof(GPTHDRREV1))
259	*puScore = RTDVM_MATCH_SCORE_PERFECT;
260	}
261
262	return rc;
263	}
264
265	static DECLCALLBACK(int) rtDvmFmtGptOpen(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt)
266	{
267	int rc = VINF_SUCCESS;
268	PRTDVMFMTINTERNAL pThis = NULL;
269
270	pThis = (PRTDVMFMTINTERNAL)RTMemAllocZ(sizeof(RTDVMFMTINTERNAL));
271	if (pThis)
272	{
273	pThis->pDisk = pDisk;
274	pThis->cPartitions = 0;
275
276	/* Read the complete GPT header and convert to host endianess. */
277	rc = rtDvmDiskReadUnaligned(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &pThis->HdrRev1, sizeof(pThis->HdrRev1));
278	if (RT_SUCCESS(rc))
279	{
280	pThis->HdrRev1.Hdr.u32Revision = RT_LE2H_U32(pThis->HdrRev1.Hdr.u32Revision);
281	pThis->HdrRev1.Hdr.cbHeader = RT_LE2H_U32(pThis->HdrRev1.Hdr.cbHeader);
282	pThis->HdrRev1.Hdr.u32Crc = RT_LE2H_U32(pThis->HdrRev1.Hdr.u32Crc);
283	pThis->HdrRev1.u64LbaCurrent = RT_LE2H_U64(pThis->HdrRev1.u64LbaCurrent);
284	pThis->HdrRev1.u64LbaBackup = RT_LE2H_U64(pThis->HdrRev1.u64LbaBackup);
285	pThis->HdrRev1.u64LbaFirstPartition = RT_LE2H_U64(pThis->HdrRev1.u64LbaFirstPartition);
286	pThis->HdrRev1.u64LbaLastPartition = RT_LE2H_U64(pThis->HdrRev1.u64LbaLastPartition);
287	/** @todo Disk UUID */
288	pThis->HdrRev1.u64LbaPartitionEntries = RT_LE2H_U64(pThis->HdrRev1.u64LbaPartitionEntries);
289	pThis->HdrRev1.cPartitionEntries = RT_LE2H_U32(pThis->HdrRev1.cPartitionEntries);
290	pThis->HdrRev1.cbPartitionEntry = RT_LE2H_U32(pThis->HdrRev1.cbPartitionEntry);
291	pThis->HdrRev1.u32CrcPartitionEntries = RT_LE2H_U32(pThis->HdrRev1.u32CrcPartitionEntries);
292
293	if (pThis->HdrRev1.cbPartitionEntry == sizeof(GPTENTRY))
294	{
295	size_t cbAlignedGptEntries = RT_ALIGN_Z(pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry, pDisk->cbSector);
296	pThis->paGptEntries = (PGPTENTRY)RTMemAllocZ(cbAlignedGptEntries);
297	if (pThis->paGptEntries)
298	{
299	rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(pThis->HdrRev1.u64LbaPartitionEntries, pDisk),
300	pThis->paGptEntries, cbAlignedGptEntries);
301	if (RT_SUCCESS(rc))
302	{
303	/* Count the occupied entries. */
304	for (unsigned i = 0; i < pThis->HdrRev1.cPartitionEntries; i++)
305	if (!RTUuidIsNull(&pThis->paGptEntries[i].UuidType))
306	{
307	/* Convert to host endianess. */
308	/** @todo Uuids */
309	pThis->paGptEntries[i].u64LbaFirst = RT_LE2H_U64(pThis->paGptEntries[i].u64LbaFirst);
310	pThis->paGptEntries[i].u64LbaLast = RT_LE2H_U64(pThis->paGptEntries[i].u64LbaLast);
311	pThis->paGptEntries[i].u64Flags = RT_LE2H_U64(pThis->paGptEntries[i].u64Flags);
312	for (unsigned cwc = 0; cwc < RT_ELEMENTS(pThis->paGptEntries[i].aPartitionName); cwc++)
313	pThis->paGptEntries[i].aPartitionName[cwc] = RT_LE2H_U16(pThis->paGptEntries[i].aPartitionName[cwc]);
314
315	pThis->cPartitions++;
316	}
317
318	if (RT_SUCCESS(rc))
319	{
320	*phVolMgrFmt = pThis;
321	return rc;
322	}
323	}
324	RTMemFree(pThis->paGptEntries);
325	}
326	else
327	rc = VERR_NO_MEMORY;
328	}
329	else
330	rc = VERR_NOT_SUPPORTED;
331	}
332	RTMemFree(pThis);
333	}
334	else
335	rc = VERR_NO_MEMORY;
336
337	return rc;
338	}
339
340	static DECLCALLBACK(int) rtDvmFmtGptInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt)
341	{
342	NOREF(pDisk); NOREF(phVolMgrFmt);
343	return VERR_NOT_IMPLEMENTED;
344	}
345
346	static DECLCALLBACK(void) rtDvmFmtGptClose(RTDVMFMT hVolMgrFmt)
347	{
348	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
349
350	pThis->pDisk = NULL;
351	RT_ZERO(pThis->HdrRev1);
352
353	RTMemFree(pThis->paGptEntries);
354	pThis->paGptEntries = NULL;
355
356	RTMemFree(pThis);
357	}
358
359	static DECLCALLBACK(int) rtDvmFmtGptQueryRangeUse(RTDVMFMT hVolMgrFmt,
360	uint64_t off, uint64_t cbRange,
361	bool *pfUsed)
362	{
363	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
364
365	NOREF(cbRange);
366
367	if (off < 33*pThis->pDisk->cbSector)
368	*pfUsed = true;
369	else
370	*pfUsed = false;
371
372	return VINF_SUCCESS;
373	}
374
375	/** @copydoc RTDVMFMTOPS::pfnQueryDiskUuid */
376	static DECLCALLBACK(int) rtDvmFmtGptQueryDiskUuid(RTDVMFMT hVolMgrFmt, PRTUUID pUuid)
377	{
378	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
379
380	*pUuid = pThis->HdrRev1.DiskUuid;
381	return VINF_SUCCESS;
382	}
383
384	static DECLCALLBACK(uint32_t) rtDvmFmtGptGetValidVolumes(RTDVMFMT hVolMgrFmt)
385	{
386	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
387
388	return pThis->cPartitions;
389	}
390
391	static DECLCALLBACK(uint32_t) rtDvmFmtGptGetMaxVolumes(RTDVMFMT hVolMgrFmt)
392	{
393	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
394
395	return pThis->HdrRev1.cPartitionEntries;
396	}
397
398	/**
399	* Creates a new volume.
400	*
401	* @returns IPRT status code.
402	* @param pThis The MBR volume manager data.
403	* @param pGptEntry The GPT entry.
404	* @param idx The index in the partition array.
405	* @param phVolFmt Where to store the volume data on success.
406	*/
407	static int rtDvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, PGPTENTRY pGptEntry,
408	uint32_t idx, PRTDVMVOLUMEFMT phVolFmt)
409	{
410	int rc = VINF_SUCCESS;
411	PRTDVMVOLUMEFMTINTERNAL pVol = (PRTDVMVOLUMEFMTINTERNAL)RTMemAllocZ(sizeof(RTDVMVOLUMEFMTINTERNAL));
412
413	if (pVol)
414	{
415	pVol->pVolMgr = pThis;
416	pVol->idxEntry = idx;
417	pVol->pGptEntry = pGptEntry;
418	pVol->offStart = RTDVM_GPT_LBA2BYTE(pGptEntry->u64LbaFirst, pThis->pDisk);
419	pVol->cbVolume = RTDVM_GPT_LBA2BYTE(pGptEntry->u64LbaLast - pGptEntry->u64LbaFirst + 1, pThis->pDisk);
420
421	*phVolFmt = pVol;
422	}
423	else
424	rc = VERR_NO_MEMORY;
425
426	return rc;
427	}
428
429	static DECLCALLBACK(int) rtDvmFmtGptQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt)
430	{
431	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
432
433	if (pThis->cPartitions != 0)
434	{
435	PGPTENTRY pGptEntry = &pThis->paGptEntries[0];
436
437	/* Search for the first non empty entry. */
438	for (unsigned i = 0; i < pThis->HdrRev1.cPartitionEntries; i++)
439	{
440	if (!RTUuidIsNull(&pGptEntry->UuidType))
441	return rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmt);
442	pGptEntry++;
443	}
444	AssertFailed();
445	}
446	return VERR_DVM_MAP_EMPTY;
447	}
448
449	static DECLCALLBACK(int) rtDvmFmtGptQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext)
450	{
451	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
452	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
453	PGPTENTRY pGptEntry = pVol->pGptEntry + 1;
454
455	for (unsigned i = pVol->idxEntry + 1; i < pThis->HdrRev1.cPartitionEntries; i++)
456	{
457	if (!RTUuidIsNull(&pGptEntry->UuidType))
458	return rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmtNext);
459	pGptEntry++;
460	}
461
462	return VERR_DVM_MAP_NO_VOLUME;
463	}
464
465	static DECLCALLBACK(void) rtDvmFmtGptVolumeClose(RTDVMVOLUMEFMT hVolFmt)
466	{
467	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
468
469	pVol->pVolMgr = NULL;
470	pVol->offStart = 0;
471	pVol->cbVolume = 0;
472	pVol->pGptEntry = NULL;
473
474	RTMemFree(pVol);
475	}
476
477	static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetSize(RTDVMVOLUMEFMT hVolFmt)
478	{
479	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
480
481	return pVol->cbVolume;
482	}
483
484	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName)
485	{
486	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
487
488	*ppszVolName = NULL;
489	return RTUtf16ToUtf8Ex(&pVol->pGptEntry->aPartitionName[0], RT_ELEMENTS(pVol->pGptEntry->aPartitionName),
490	ppszVolName, 0, NULL);
491	}
492
493	static DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtGptVolumeGetType(RTDVMVOLUMEFMT hVolFmt)
494	{
495	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
496
497	for (unsigned i = 0; i < RT_ELEMENTS(g_aPartType2DvmVolTypes); i++)
498	if (!RTUuidCompareStr(&pVol->pGptEntry->UuidType, g_aPartType2DvmVolTypes[i].pcszUuid))
499	return g_aPartType2DvmVolTypes[i].enmVolType;
500
501	return RTDVMVOLTYPE_UNKNOWN;
502	}
503
504	static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt)
505	{
506	NOREF(hVolFmt);
507	return DVMVOLUME_F_CONTIGUOUS;
508	}
509
510	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryRange(RTDVMVOLUMEFMT hVolFmt, uint64_t poffStart, uint64_t poffLast)
511	{
512	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
513	*poffStart = pVol->offStart;
514	*poffLast = pVol->offStart + pVol->cbVolume - 1;
515	return VINF_SUCCESS;
516	}
517
518	static DECLCALLBACK(bool) rtDvmFmtGptVolumeIsRangeIntersecting(RTDVMVOLUMEFMT hVolFmt,
519	uint64_t offStart, size_t cbRange,
520	uint64_t *poffVol,
521	uint64_t *pcbIntersect)
522	{
523	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
524
525	if (RTDVM_RANGE_IS_INTERSECTING(pVol->offStart, pVol->cbVolume, offStart))
526	{
527	*poffVol = offStart - pVol->offStart;
528	*pcbIntersect = RT_MIN(cbRange, pVol->offStart + pVol->cbVolume - offStart);
529	return true;
530	}
531	return false;
532	}
533
534	/** @copydoc RTDVMFMTOPS::pfnVolumeQueryTableLocation */
535	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryTableLocation(RTDVMVOLUMEFMT hVolFmt, uint64_t poffTable, uint64_t pcbTable)
536	{
537	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
538	PRTDVMFMTINTERNAL pVolMgr = pVol->pVolMgr;
539	*poffTable = RTDVM_GPT_LBA2BYTE(1, pVolMgr->pDisk);
540	*pcbTable = RTDVM_GPT_LBA2BYTE(pVolMgr->HdrRev1.u64LbaPartitionEntries, pVolMgr->pDisk)
541	+ RT_ALIGN_Z(pVolMgr->HdrRev1.cPartitionEntries * pVolMgr->HdrRev1.cbPartitionEntry, pVolMgr->pDisk->cbSector)
542	- *poffTable;
543	return VINF_SUCCESS;
544	}
545
546	/** @copydoc RTDVMFMTOPS::pfnVolumeGetIndex */
547	static DECLCALLBACK(uint32_t) rtDvmFmtGptVolumeGetIndex(RTDVMVOLUMEFMT hVolFmt, RTDVMVOLIDX enmIndex)
548	{
549	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
550	switch (enmIndex)
551	{
552	case RTDVMVOLIDX_USER_VISIBLE:
553	case RTDVMVOLIDX_ALL:
554	case RTDVMVOLIDX_LINUX:
555	return pVol->idxEntry + 1;
556
557	case RTDVMVOLIDX_IN_TABLE:
558	return pVol->idxEntry;
559
560	case RTDVMVOLIDX_INVALID:
561	case RTDVMVOLIDX_HOST:
562	case RTDVMVOLIDX_END:
563	case RTDVMVOLIDX_32BIT_HACK:
564	break;
565	/* no default! */
566	}
567	AssertFailed();
568	return UINT32_MAX;
569	}
570
571	/** @copydoc RTDVMFMTOPS::pfnVolumeQueryProp */
572	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryProp(RTDVMVOLUMEFMT hVolFmt, RTDVMVOLPROP enmProperty,
573	void pvBuf, size_t cbBuf, size_t pcbBuf)
574	{
575	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
576	switch (enmProperty)
577	{
578	case RTDVMVOLPROP_MBR_FIRST_CYLINDER:
579	case RTDVMVOLPROP_MBR_FIRST_HEAD:
580	case RTDVMVOLPROP_MBR_FIRST_SECTOR:
581	case RTDVMVOLPROP_MBR_LAST_CYLINDER:
582	case RTDVMVOLPROP_MBR_LAST_HEAD:
583	case RTDVMVOLPROP_MBR_LAST_SECTOR:
584	case RTDVMVOLPROP_MBR_TYPE:
585	return VERR_NOT_SUPPORTED;
586
587	case RTDVMVOLPROP_GPT_TYPE:
588	*pcbBuf = sizeof(RTUUID);
589	Assert(cbBuf >= *pcbBuf);
590	*(PRTUUID)pvBuf = pVol->pGptEntry->UuidType;
591	return VINF_SUCCESS;
592
593	case RTDVMVOLPROP_GPT_UUID:
594	*pcbBuf = sizeof(RTUUID);
595	Assert(cbBuf >= *pcbBuf);
596	*(PRTUUID)pvBuf = pVol->pGptEntry->UuidPartition;
597	return VINF_SUCCESS;
598
599	case RTDVMVOLPROP_INVALID:
600	case RTDVMVOLPROP_END:
601	case RTDVMVOLPROP_32BIT_HACK:
602	break;
603	/* not default! */
604	}
605	AssertFailed();
606	RT_NOREF(cbBuf);
607	return VERR_NOT_SUPPORTED;
608	}
609
610	static DECLCALLBACK(int) rtDvmFmtGptVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead)
611	{
612	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
613	AssertReturn(off + cbRead <= pVol->cbVolume, VERR_INVALID_PARAMETER);
614
615	return rtDvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead);
616	}
617
618	static DECLCALLBACK(int) rtDvmFmtGptVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite)
619	{
620	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
621	AssertReturn(off + cbWrite <= pVol->cbVolume, VERR_INVALID_PARAMETER);
622
623	return rtDvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite);
624	}
625
626	DECL_HIDDEN_CONST(const RTDVMFMTOPS) g_rtDvmFmtGpt =
627	{
628	/* pszFmt */
629	"GPT",
630	/* enmFormat, */
631	RTDVMFORMATTYPE_GPT,
632	/* pfnProbe */
633	rtDvmFmtGptProbe,
634	/* pfnOpen */
635	rtDvmFmtGptOpen,
636	/* pfnInitialize */
637	rtDvmFmtGptInitialize,
638	/* pfnClose */
639	rtDvmFmtGptClose,
640	/* pfnQueryRangeUse */
641	rtDvmFmtGptQueryRangeUse,
642	/* pfnQueryDiskUuid */
643	rtDvmFmtGptQueryDiskUuid,
644	/* pfnGetValidVolumes */
645	rtDvmFmtGptGetValidVolumes,
646	/* pfnGetMaxVolumes */
647	rtDvmFmtGptGetMaxVolumes,
648	/* pfnQueryFirstVolume */
649	rtDvmFmtGptQueryFirstVolume,
650	/* pfnQueryNextVolume */
651	rtDvmFmtGptQueryNextVolume,
652	/* pfnVolumeClose */
653	rtDvmFmtGptVolumeClose,
654	/* pfnVolumeGetSize */
655	rtDvmFmtGptVolumeGetSize,
656	/* pfnVolumeQueryName */
657	rtDvmFmtGptVolumeQueryName,
658	/* pfnVolumeGetType */
659	rtDvmFmtGptVolumeGetType,
660	/* pfnVolumeGetFlags */
661	rtDvmFmtGptVolumeGetFlags,
662	/* pfnVolumeQueryRange */
663	rtDvmFmtGptVolumeQueryRange,
664	/* pfnVolumeIsRangeIntersecting */
665	rtDvmFmtGptVolumeIsRangeIntersecting,
666	/* pfnVolumeQueryTableLocation */
667	rtDvmFmtGptVolumeQueryTableLocation,
668	/* pfnVolumeGetIndex */
669	rtDvmFmtGptVolumeGetIndex,
670	/* pfnVolumeQueryProp */
671	rtDvmFmtGptVolumeQueryProp,
672	/* pfnVolumeRead */
673	rtDvmFmtGptVolumeRead,
674	/* pfnVolumeWrite */
675	rtDvmFmtGptVolumeWrite
676	};
677

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

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

Download in other formats: