dvmgpt.cpp@ 85938

Last change on this file since 85938 was 85894, checked in by vboxsync, 4 years ago
IPRT/Dvm: Added RTDvmMapQueryTableLocations (for VMDK). Completely untested. bugref:9224
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.3 KB

Line
1	/* $Id: dvmgpt.cpp 85894 2020-08-26 20:50:52Z 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.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/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	/** @copydoc RTDVMFMTOPS::pfnQueryTableLocations */
466	static DECLCALLBACK(int) rtDvmFmtGptQueryTableLocations(RTDVMFMT hVolMgrFmt, uint32_t fFlags, PRTDVMTABLELOCATION paLocations,
467	size_t cLocations, size_t *pcActual)
468	{
469	PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
470
471	/*
472	* The MBR if requested.
473	*/
474	int rc = VINF_SUCCESS;
475	size_t iLoc = 0;
476	if (fFlags & RTDVMMAPQTABLOC_F_INCLUDE_LEGACY)
477	{
478	if (cLocations > 0)
479	{
480	paLocations[iLoc].off = 0;
481	paLocations[iLoc].cb = RTDVM_GPT_LBA2BYTE(1, pThis->pDisk);
482	paLocations[iLoc].cbPadding = 0;
483	}
484	else
485	rc = VERR_BUFFER_OVERFLOW;
486	iLoc++;
487	}
488
489	/*
490	* The GPT.
491	*/
492	if (cLocations > iLoc)
493	{
494	uint64_t const offEnd = (pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry + pThis->pDisk->cbSector - 1)
495	/ pThis->pDisk->cbSector
496	* pThis->pDisk->cbSector;
497	paLocations[iLoc].off = RTDVM_GPT_LBA2BYTE(1, pThis->pDisk);
498	paLocations[iLoc].cb = offEnd - paLocations[iLoc].off;
499
500	uint64_t uLbaFirstPart = pThis->pDisk->cbDisk / pThis->pDisk->cbSector;
501	for (unsigned i = 0; i < pThis->HdrRev1.cPartitionEntries; i++)
502	if ( pThis->paGptEntries[i].u64LbaFirst < uLbaFirstPart
503	&& !RTUuidIsNull(&pThis->paGptEntries[i].UuidType))
504	uLbaFirstPart = pThis->paGptEntries[i].u64LbaFirst;
505
506	paLocations[iLoc].cbPadding = RTDVM_GPT_LBA2BYTE(uLbaFirstPart, pThis->pDisk);
507	if (paLocations[iLoc].cbPadding > offEnd)
508	paLocations[iLoc].cbPadding -= offEnd;
509	else
510	AssertFailedStmt(paLocations[iLoc].cbPadding = 0);
511	}
512	else
513	rc = VERR_BUFFER_OVERFLOW;
514	iLoc++;
515
516	/*
517	* Return values.
518	*/
519	if (pcActual)
520	*pcActual = iLoc;
521	else if (cLocations != iLoc && RT_SUCCESS(rc))
522	{
523	RT_BZERO(&paLocations[iLoc], (cLocations - iLoc) * sizeof(paLocations[0]));
524	rc = VERR_BUFFER_UNDERFLOW;
525	}
526	return rc;
527	}
528
529	static DECLCALLBACK(void) rtDvmFmtGptVolumeClose(RTDVMVOLUMEFMT hVolFmt)
530	{
531	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
532
533	pVol->pVolMgr = NULL;
534	pVol->offStart = 0;
535	pVol->cbVolume = 0;
536	pVol->pGptEntry = NULL;
537
538	RTMemFree(pVol);
539	}
540
541	static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetSize(RTDVMVOLUMEFMT hVolFmt)
542	{
543	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
544
545	return pVol->cbVolume;
546	}
547
548	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName)
549	{
550	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
551
552	*ppszVolName = NULL;
553	return RTUtf16ToUtf8Ex(&pVol->pGptEntry->aPartitionName[0], RT_ELEMENTS(pVol->pGptEntry->aPartitionName),
554	ppszVolName, 0, NULL);
555	}
556
557	static DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtGptVolumeGetType(RTDVMVOLUMEFMT hVolFmt)
558	{
559	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
560
561	for (unsigned i = 0; i < RT_ELEMENTS(g_aPartType2DvmVolTypes); i++)
562	if (!RTUuidCompareStr(&pVol->pGptEntry->UuidType, g_aPartType2DvmVolTypes[i].pcszUuid))
563	return g_aPartType2DvmVolTypes[i].enmVolType;
564
565	return RTDVMVOLTYPE_UNKNOWN;
566	}
567
568	static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt)
569	{
570	NOREF(hVolFmt);
571	return DVMVOLUME_F_CONTIGUOUS;
572	}
573
574	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryRange(RTDVMVOLUMEFMT hVolFmt, uint64_t poffStart, uint64_t poffLast)
575	{
576	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
577	*poffStart = pVol->offStart;
578	*poffLast = pVol->offStart + pVol->cbVolume - 1;
579	return VINF_SUCCESS;
580	}
581
582	static DECLCALLBACK(bool) rtDvmFmtGptVolumeIsRangeIntersecting(RTDVMVOLUMEFMT hVolFmt,
583	uint64_t offStart, size_t cbRange,
584	uint64_t *poffVol,
585	uint64_t *pcbIntersect)
586	{
587	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
588
589	if (RTDVM_RANGE_IS_INTERSECTING(pVol->offStart, pVol->cbVolume, offStart))
590	{
591	*poffVol = offStart - pVol->offStart;
592	*pcbIntersect = RT_MIN(cbRange, pVol->offStart + pVol->cbVolume - offStart);
593	return true;
594	}
595	return false;
596	}
597
598	/** @copydoc RTDVMFMTOPS::pfnVolumeQueryTableLocation */
599	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryTableLocation(RTDVMVOLUMEFMT hVolFmt, uint64_t poffTable, uint64_t pcbTable)
600	{
601	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
602	PRTDVMFMTINTERNAL pVolMgr = pVol->pVolMgr;
603	*poffTable = RTDVM_GPT_LBA2BYTE(1, pVolMgr->pDisk);
604	*pcbTable = RTDVM_GPT_LBA2BYTE(pVolMgr->HdrRev1.u64LbaPartitionEntries, pVolMgr->pDisk)
605	+ RT_ALIGN_Z(pVolMgr->HdrRev1.cPartitionEntries * pVolMgr->HdrRev1.cbPartitionEntry, pVolMgr->pDisk->cbSector)
606	- *poffTable;
607	return VINF_SUCCESS;
608	}
609
610	/** @copydoc RTDVMFMTOPS::pfnVolumeGetIndex */
611	static DECLCALLBACK(uint32_t) rtDvmFmtGptVolumeGetIndex(RTDVMVOLUMEFMT hVolFmt, RTDVMVOLIDX enmIndex)
612	{
613	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
614	switch (enmIndex)
615	{
616	case RTDVMVOLIDX_USER_VISIBLE:
617	case RTDVMVOLIDX_ALL:
618	case RTDVMVOLIDX_LINUX:
619	return pVol->idxEntry + 1;
620
621	case RTDVMVOLIDX_IN_TABLE:
622	return pVol->idxEntry;
623
624	case RTDVMVOLIDX_INVALID:
625	case RTDVMVOLIDX_HOST:
626	case RTDVMVOLIDX_END:
627	case RTDVMVOLIDX_32BIT_HACK:
628	break;
629	/* no default! */
630	}
631	AssertFailed();
632	return UINT32_MAX;
633	}
634
635	/** @copydoc RTDVMFMTOPS::pfnVolumeQueryProp */
636	static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryProp(RTDVMVOLUMEFMT hVolFmt, RTDVMVOLPROP enmProperty,
637	void pvBuf, size_t cbBuf, size_t pcbBuf)
638	{
639	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
640	switch (enmProperty)
641	{
642	case RTDVMVOLPROP_MBR_FIRST_CYLINDER:
643	case RTDVMVOLPROP_MBR_FIRST_HEAD:
644	case RTDVMVOLPROP_MBR_FIRST_SECTOR:
645	case RTDVMVOLPROP_MBR_LAST_CYLINDER:
646	case RTDVMVOLPROP_MBR_LAST_HEAD:
647	case RTDVMVOLPROP_MBR_LAST_SECTOR:
648	case RTDVMVOLPROP_MBR_TYPE:
649	return VERR_NOT_SUPPORTED;
650
651	case RTDVMVOLPROP_GPT_TYPE:
652	*pcbBuf = sizeof(RTUUID);
653	Assert(cbBuf >= *pcbBuf);
654	*(PRTUUID)pvBuf = pVol->pGptEntry->UuidType;
655	return VINF_SUCCESS;
656
657	case RTDVMVOLPROP_GPT_UUID:
658	*pcbBuf = sizeof(RTUUID);
659	Assert(cbBuf >= *pcbBuf);
660	*(PRTUUID)pvBuf = pVol->pGptEntry->UuidPartition;
661	return VINF_SUCCESS;
662
663	case RTDVMVOLPROP_INVALID:
664	case RTDVMVOLPROP_END:
665	case RTDVMVOLPROP_32BIT_HACK:
666	break;
667	/* not default! */
668	}
669	AssertFailed();
670	RT_NOREF(cbBuf);
671	return VERR_NOT_SUPPORTED;
672	}
673
674	static DECLCALLBACK(int) rtDvmFmtGptVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead)
675	{
676	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
677	AssertReturn(off + cbRead <= pVol->cbVolume, VERR_INVALID_PARAMETER);
678
679	return rtDvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead);
680	}
681
682	static DECLCALLBACK(int) rtDvmFmtGptVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite)
683	{
684	PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
685	AssertReturn(off + cbWrite <= pVol->cbVolume, VERR_INVALID_PARAMETER);
686
687	return rtDvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite);
688	}
689
690	DECL_HIDDEN_CONST(const RTDVMFMTOPS) g_rtDvmFmtGpt =
691	{
692	/* pszFmt */
693	"GPT",
694	/* enmFormat, */
695	RTDVMFORMATTYPE_GPT,
696	/* pfnProbe */
697	rtDvmFmtGptProbe,
698	/* pfnOpen */
699	rtDvmFmtGptOpen,
700	/* pfnInitialize */
701	rtDvmFmtGptInitialize,
702	/* pfnClose */
703	rtDvmFmtGptClose,
704	/* pfnQueryRangeUse */
705	rtDvmFmtGptQueryRangeUse,
706	/* pfnQueryDiskUuid */
707	rtDvmFmtGptQueryDiskUuid,
708	/* pfnGetValidVolumes */
709	rtDvmFmtGptGetValidVolumes,
710	/* pfnGetMaxVolumes */
711	rtDvmFmtGptGetMaxVolumes,
712	/* pfnQueryFirstVolume */
713	rtDvmFmtGptQueryFirstVolume,
714	/* pfnQueryNextVolume */
715	rtDvmFmtGptQueryNextVolume,
716	/* pfnQueryTableLocations */
717	rtDvmFmtGptQueryTableLocations,
718	/* pfnVolumeClose */
719	rtDvmFmtGptVolumeClose,
720	/* pfnVolumeGetSize */
721	rtDvmFmtGptVolumeGetSize,
722	/* pfnVolumeQueryName */
723	rtDvmFmtGptVolumeQueryName,
724	/* pfnVolumeGetType */
725	rtDvmFmtGptVolumeGetType,
726	/* pfnVolumeGetFlags */
727	rtDvmFmtGptVolumeGetFlags,
728	/* pfnVolumeQueryRange */
729	rtDvmFmtGptVolumeQueryRange,
730	/* pfnVolumeIsRangeIntersecting */
731	rtDvmFmtGptVolumeIsRangeIntersecting,
732	/* pfnVolumeQueryTableLocation */
733	rtDvmFmtGptVolumeQueryTableLocation,
734	/* pfnVolumeGetIndex */
735	rtDvmFmtGptVolumeGetIndex,
736	/* pfnVolumeQueryProp */
737	rtDvmFmtGptVolumeQueryProp,
738	/* pfnVolumeRead */
739	rtDvmFmtGptVolumeRead,
740	/* pfnVolumeWrite */
741	rtDvmFmtGptVolumeWrite
742	};
743

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

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

Download in other formats: