HBDMgmt-darwin.cpp@ 81019

Last change on this file since 81019 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.8 KB

Line
1	/* $Id: HBDMgmt-darwin.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* VBox storage devices: Host block device management API - darwin specifics.
4	*/
5
6	/*
7	* Copyright (C) 2015-2019 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
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DRV_VD
23	#include <VBox/cdefs.h>
24	#include <VBox/err.h>
25	#include <VBox/log.h>
26	#include <iprt/assert.h>
27	#include <iprt/list.h>
28	#include <iprt/mem.h>
29	#include <iprt/string.h>
30	#include <iprt/once.h>
31	#include <iprt/semaphore.h>
32	#include <iprt/path.h>
33	#include <iprt/thread.h>
34
35	#include <DiskArbitration/DiskArbitration.h>
36
37	#include "HBDMgmt.h"
38
39
40	/*********************************************************************************************************************************
41	* Defined Constants And Macros *
42	*********************************************************************************************************************************/
43
44
45	/*********************************************************************************************************************************
46	* Structures and Typedefs *
47	*********************************************************************************************************************************/
48
49	/**
50	* Claimed block device state.
51	*/
52	typedef struct HBDMGRDEV
53	{
54	/** List node. */
55	RTLISTNODE ListNode;
56	/** Handle to the DA Disk object. */
57	DADiskRef hDiskRef;
58	} HBDMGRDEV;
59	/** Pointer to a claimed block device. */
60	typedef HBDMGRDEV *PHBDMGRDEV;
61
62	/**
63	* Internal Host block device manager state.
64	*/
65	typedef struct HBDMGRINT
66	{
67	/** Session handle to the DiskArbitration daemon. */
68	DASessionRef hSessionRef;
69	/** Runloop reference of the worker thread. */
70	CFRunLoopRef hRunLoopRef;
71	/** Runloop source for waking up the worker thread. */
72	CFRunLoopSourceRef hRunLoopSrcWakeRef;
73	/** List of claimed block devices. */
74	RTLISTANCHOR ListClaimed;
75	/** Fast mutex protecting the list. */
76	RTSEMFASTMUTEX hMtxList;
77	/** Event sempahore to signal callback completion. */
78	RTSEMEVENT hEvtCallback;
79	/** Thread processing DA events. */
80	RTTHREAD hThrdDAEvts;
81	/** Flag whether the thread should keep running. */
82	volatile bool fRunning;
83	} HBDMGRINT;
84	/** Pointer to an interal block device manager state. */
85	typedef HBDMGRINT *PHBDMGRINT;
86
87	/**
88	* Helper structure containing the arguments
89	* for the claim/unmount callbacks.
90	*/
91	typedef struct HBDMGRDACLBKARGS
92	{
93	/** Pointer to the block device manager. */
94	PHBDMGRINT pThis;
95	/** The status code returned by the callback, after the operation completed. */
96	DAReturn rcDA;
97	/** A detailed error string in case of an error, can be NULL.
98	* Must be freed with RTStrFree(). */
99	char *pszErrDetail;
100	} HBDMGRDACLBKARGS;
101	typedef HBDMGRDACLBKARGS *PHBDMGRDACLBKARGS;
102
103
104	/*********************************************************************************************************************************
105	* Global Variables *
106	*********************************************************************************************************************************/
107
108
109	/*********************************************************************************************************************************
110	* Internal Functions *
111	*********************************************************************************************************************************/
112
113	/**
114	* Unclaims the given block device and frees its state removing it from the list.
115	*
116	* @returns nothing.
117	* @param pDev The block device to unclaim.
118	*/
119	static void hbdMgrDevUnclaim(PHBDMGRDEV pDev)
120	{
121	DADiskUnclaim(pDev->hDiskRef);
122	CFRelease(pDev->hDiskRef);
123	RTListNodeRemove(&pDev->ListNode);
124	RTMemFree(pDev);
125	}
126
127	/**
128	* Returns the block device given by the filename if claimed or NULL.
129	*
130	* @returns Pointer to the claimed block device or NULL if not claimed.
131	* @param pThis The block device manager.
132	* @param pszFilename The name to look for.
133	*/
134	static PHBDMGRDEV hbdMgrDevFindByName(PHBDMGRINT pThis, const char *pszFilename)
135	{
136	bool fFound = false;
137	const char *pszFilenameStripped = RTPathFilename(pszFilename);
138
139	AssertPtrReturn(pszFilenameStripped, NULL);
140
141	PHBDMGRDEV pIt;
142	RTListForEach(&pThis->ListClaimed, pIt, HBDMGRDEV, ListNode)
143	{
144	const char *pszBSDName = DADiskGetBSDName(pIt->hDiskRef);
145	if (!RTStrCmp(pszFilenameStripped, pszBSDName))
146	{
147	fFound = true;
148	break;
149	}
150	}
151
152	return fFound ? pIt : NULL;
153	}
154
155	/**
156	* Converts a given DA return code to a VBox status code.
157	*
158	* @returns VBox status code.
159	* @param hReturn The status code returned by a DA API call.
160	*/
161	static int hbdMgrDAReturn2VBoxStatus(DAReturn hReturn)
162	{
163	int rc = VERR_UNRESOLVED_ERROR;
164
165	switch (hReturn)
166	{
167	case kDAReturnBusy:
168	rc = VERR_RESOURCE_BUSY;
169	break;
170	case kDAReturnNotMounted:
171	case kDAReturnBadArgument:
172	rc = VERR_INVALID_PARAMETER;
173	break;
174	case kDAReturnNotPermitted:
175	case kDAReturnNotPrivileged:
176	case kDAReturnExclusiveAccess:
177	rc = VERR_ACCESS_DENIED;
178	break;
179	case kDAReturnNoResources:
180	rc = VERR_NO_MEMORY;
181	break;
182	case kDAReturnNotFound:
183	rc = VERR_NOT_FOUND;
184	break;
185	case kDAReturnNotReady:
186	rc = VERR_TRY_AGAIN;
187	break;
188	case kDAReturnNotWritable:
189	rc = VERR_WRITE_PROTECT;
190	break;
191	case kDAReturnUnsupported:
192	rc = VERR_NOT_SUPPORTED;
193	break;
194	case kDAReturnError:
195	default:
196	rc = VERR_UNRESOLVED_ERROR;
197	}
198
199	return rc;
200	}
201
202	/**
203	* Implements the OS X callback DADiskClaimCallback.
204	*
205	* This notifies us that the async DADiskClaim()/DADiskUnmount call has
206	* completed.
207	*
208	* @param hDiskRef The disk that was attempted claimed / unmounted.
209	* @param hDissenterRef NULL on success, contains details on failure.
210	* @param pvContext Pointer to the return code variable.
211	*/
212	static void hbdMgrDACallbackComplete(DADiskRef hDiskRef, DADissenterRef hDissenterRef, void *pvContext)
213	{
214	RT_NOREF(hDiskRef);
215	PHBDMGRDACLBKARGS pArgs = (PHBDMGRDACLBKARGS)pvContext;
216	pArgs->pszErrDetail = NULL;
217
218	if (!hDissenterRef)
219	pArgs->rcDA = kDAReturnSuccess;
220	else
221	{
222	CFStringRef hStrErr = DADissenterGetStatusString(hDissenterRef);
223	if (hStrErr)
224	{
225	const char *pszErrDetail = CFStringGetCStringPtr(hStrErr, kCFStringEncodingUTF8);
226	if (pszErrDetail)
227	pArgs->pszErrDetail = RTStrDup(pszErrDetail);
228	CFRelease(hStrErr);
229	}
230	pArgs->rcDA = DADissenterGetStatus(hDissenterRef);
231
232	}
233	RTSemEventSignal(pArgs->pThis->hEvtCallback);
234	}
235
236	/**
237	* Implements the OS X callback DADiskMountApprovalCallback.
238	*
239	* This notifies us about any attempt to mount a volume. If we claimed the
240	* volume or the complete disk containing the volume we will deny the attempt.
241	*
242	* @returns Reference to a DADissenter object which contains the result.
243	* @param hDiskRef The disk that is about to be mounted.
244	* @param pvContext Pointer to the block device manager.
245	*/
246	static DADissenterRef hbdMgrDAMountApprovalCallback(DADiskRef hDiskRef, void *pvContext)
247	{
248	PHBDMGRINT pThis = (PHBDMGRINT)pvContext;
249	DADiskRef hDiskParentRef = DADiskCopyWholeDisk(hDiskRef);
250	const char *pszBSDName = DADiskGetBSDName(hDiskRef);
251	const char *pszBSDNameParent = hDiskParentRef ? DADiskGetBSDName(hDiskParentRef) : NULL;
252	DADissenterRef hDissenterRef = NULL;
253
254	RTSemFastMutexRequest(pThis->hMtxList);
255	PHBDMGRDEV pIt;
256	RTListForEach(&pThis->ListClaimed, pIt, HBDMGRDEV, ListNode)
257	{
258	const char *pszBSDNameCur = DADiskGetBSDName(pIt->hDiskRef);
259	/*
260	* Prevent mounting any volume we have in use. This applies to the case
261	* where we have the whole disk occupied but a single volume is about to be
262	* mounted.
263	*/
264	if ( !RTStrCmp(pszBSDNameCur, pszBSDName)
265	\|\| ( pszBSDNameParent
266	&& !RTStrCmp(pszBSDNameParent, pszBSDNameCur)))
267	{
268	CFStringRef hStrReason = CFStringCreateWithCString(kCFAllocatorDefault, "The disk is currently in use by VirtualBox and cannot be mounted", kCFStringEncodingUTF8);
269	hDissenterRef = DADissenterCreate(kCFAllocatorDefault, kDAReturnExclusiveAccess, hStrReason);
270	break;
271	}
272	}
273
274	RTSemFastMutexRelease(pThis->hMtxList);
275
276	if (hDiskParentRef)
277	CFRelease(hDiskParentRef);
278	return hDissenterRef;
279	}
280
281
282	/**
283	* Implements OS X callback CFRunLoopSourceContext::perform.
284	*
285	* Dummy handler for the wakeup source to kick the worker thread.
286	*
287	* @returns nothing.
288	* @param pInfo Opaque user data given during source creation, unused.
289	*/
290	static void hbdMgrDAPerformWakeup(void *pInfo)
291	{
292	RT_NOREF(pInfo);
293	}
294
295
296	/**
297	* Worker function of the thread processing messages from the Disk Arbitration daemon.
298	*
299	* @returns IPRT status code.
300	* @param hThreadSelf The thread handle.
301	* @param pvUser Opaque user data, the block device manager instance.
302	*/
303	static DECLCALLBACK(int) hbdMgrDAWorker(RTTHREAD hThreadSelf, void *pvUser)
304	{
305	PHBDMGRINT pThis = (PHBDMGRINT)pvUser;
306
307	/* Provide the runloop reference. */
308	pThis->hRunLoopRef = CFRunLoopGetCurrent();
309	RTThreadUserSignal(hThreadSelf);
310
311	/* Add the wake source to our runloop so we get notified about state changes. */
312	CFRunLoopAddSource(pThis->hRunLoopRef, pThis->hRunLoopSrcWakeRef, kCFRunLoopCommonModes);
313
314	/* Do what we are here for. */
315	while (ASMAtomicReadBool(&pThis->fRunning))
316	{
317	CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10.0, true);
318	}
319
320	/* Remove the wakeup source form our runloop. */
321	CFRunLoopRemoveSource(pThis->hRunLoopRef, pThis->hRunLoopSrcWakeRef, kCFRunLoopCommonModes);
322
323	return VINF_SUCCESS;
324	}
325
326	DECLHIDDEN(int) HBDMgrCreate(PHBDMGR phHbdMgr)
327	{
328	AssertPtrReturn(phHbdMgr, VERR_INVALID_POINTER);
329
330	PHBDMGRINT pThis = (PHBDMGRINT)RTMemAllocZ(sizeof(HBDMGRINT));
331	if (RT_UNLIKELY(!pThis))
332	return VERR_NO_MEMORY;
333
334	int rc = VINF_SUCCESS;
335	RTListInit(&pThis->ListClaimed);
336	pThis->fRunning = true;
337	pThis->hSessionRef = DASessionCreate(kCFAllocatorDefault);
338	if (pThis->hSessionRef)
339	{
340	rc = RTSemFastMutexCreate(&pThis->hMtxList);
341	if (RT_SUCCESS(rc))
342	{
343	rc = RTSemEventCreate(&pThis->hEvtCallback);
344	if (RT_SUCCESS(rc))
345	{
346	CFRunLoopSourceContext CtxRunLoopSource;
347	CtxRunLoopSource.version = 0;
348	CtxRunLoopSource.info = NULL;
349	CtxRunLoopSource.retain = NULL;
350	CtxRunLoopSource.release = NULL;
351	CtxRunLoopSource.copyDescription = NULL;
352	CtxRunLoopSource.equal = NULL;
353	CtxRunLoopSource.hash = NULL;
354	CtxRunLoopSource.schedule = NULL;
355	CtxRunLoopSource.cancel = NULL;
356	CtxRunLoopSource.perform = hbdMgrDAPerformWakeup;
357	pThis->hRunLoopSrcWakeRef = CFRunLoopSourceCreate(NULL, 0, &CtxRunLoopSource);
358	if (CFRunLoopSourceIsValid(pThis->hRunLoopSrcWakeRef))
359	{
360	rc = RTThreadCreate(&pThis->hThrdDAEvts, hbdMgrDAWorker, pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "HbdDA-Wrk");
361	if (RT_SUCCESS(rc))
362	{
363	/* Wait for the thread to start up and provide the runloop reference. */
364	rc = RTThreadUserWait(pThis->hThrdDAEvts, RT_INDEFINITE_WAIT);
365	AssertRC(rc);
366	AssertPtr(pThis->hRunLoopRef);
367
368	DARegisterDiskMountApprovalCallback(pThis->hSessionRef, NULL, hbdMgrDAMountApprovalCallback, pThis);
369	DASessionScheduleWithRunLoop(pThis->hSessionRef, pThis->hRunLoopRef, kCFRunLoopDefaultMode);
370	*phHbdMgr = pThis;
371	return VINF_SUCCESS;
372	}
373	CFRelease(pThis->hRunLoopSrcWakeRef);
374	}
375	}
376
377	RTSemFastMutexDestroy(pThis->hMtxList);
378	}
379
380	CFRelease(pThis->hSessionRef);
381	}
382	else
383	rc = VERR_NO_MEMORY;
384
385	RTMemFree(pThis);
386	return rc;
387	}
388
389
390	DECLHIDDEN(void) HBDMgrDestroy(HBDMGR hHbdMgr)
391	{
392	PHBDMGRINT pThis = hHbdMgr;
393	AssertPtrReturnVoid(pThis);
394
395	/* Unregister the mount approval and DA session from the runloop. */
396	DASessionUnscheduleFromRunLoop(pThis->hSessionRef, pThis->hRunLoopRef, kCFRunLoopDefaultMode);
397	DAUnregisterApprovalCallback(pThis->hSessionRef, (void *)hbdMgrDAMountApprovalCallback, pThis);
398
399	/* Kick the worker thread to exit. */
400	ASMAtomicXchgBool(&pThis->fRunning, false);
401	CFRunLoopSourceSignal(pThis->hRunLoopSrcWakeRef);
402	CFRunLoopWakeUp(pThis->hRunLoopRef);
403	int rcThrd = VINF_SUCCESS;
404	int rc = RTThreadWait(pThis->hThrdDAEvts, RT_INDEFINITE_WAIT, &rcThrd);
405	AssertRC(rc); AssertRC(rcThrd);
406
407	CFRelease(pThis->hRunLoopSrcWakeRef);
408
409	/* Go through all claimed block devices and release them. */
410	RTSemFastMutexRequest(pThis->hMtxList);
411	PHBDMGRDEV pIt, pItNext;
412	RTListForEachSafe(&pThis->ListClaimed, pIt, pItNext, HBDMGRDEV, ListNode)
413	{
414	hbdMgrDevUnclaim(pIt);
415	}
416	RTSemFastMutexRelease(pThis->hMtxList);
417
418	CFRelease(pThis->hSessionRef);
419	RTSemFastMutexDestroy(pThis->hMtxList);
420	RTSemEventDestroy(pThis->hEvtCallback);
421	RTMemFree(pThis);
422	}
423
424
425	DECLHIDDEN(bool) HBDMgrIsBlockDevice(const char *pszFilename)
426	{
427	bool fIsBlockDevice = RTStrNCmp(pszFilename, "/dev/disk", sizeof("/dev/disk") - 1) == 0 ? true : false;
428	if (!fIsBlockDevice)
429	fIsBlockDevice = RTStrNCmp(pszFilename, "/dev/rdisk", sizeof("/dev/rdisk") - 1) == 0 ? true : false;
430	return fIsBlockDevice;
431	}
432
433
434	DECLHIDDEN(int) HBDMgrClaimBlockDevice(HBDMGR hHbdMgr, const char *pszFilename)
435	{
436	PHBDMGRINT pThis = hHbdMgr;
437	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
438	AssertReturn(HBDMgrIsBlockDevice(pszFilename), VERR_INVALID_PARAMETER);
439
440	int rc = VINF_SUCCESS;
441	PHBDMGRDEV pDev = hbdMgrDevFindByName(pThis, pszFilename);
442	if (!pDev)
443	{
444	DADiskRef hDiskRef = DADiskCreateFromBSDName(kCFAllocatorDefault, pThis->hSessionRef, pszFilename);
445	if (hDiskRef)
446	{
447	HBDMGRDACLBKARGS CalllbackArgs;
448	CalllbackArgs.pThis = pThis;
449	CalllbackArgs.rcDA = kDAReturnSuccess;
450
451	/* Claim the device. */
452	DADiskClaim(hDiskRef, kDADiskClaimOptionDefault, NULL, NULL, hbdMgrDACallbackComplete, &CalllbackArgs);
453	rc = RTSemEventWait(pThis->hEvtCallback, 120 * RT_MS_1SEC);
454	if ( RT_SUCCESS(rc)
455	&& CalllbackArgs.rcDA == kDAReturnSuccess)
456	{
457	/* Unmount anything which might be mounted. */
458	DADiskUnmount(hDiskRef, kDADiskUnmountOptionWhole, hbdMgrDACallbackComplete, &CalllbackArgs);
459	rc = RTSemEventWait(pThis->hEvtCallback, 120 * RT_MS_1SEC);
460	if ( RT_SUCCESS(rc)
461	&& ( CalllbackArgs.rcDA == kDAReturnSuccess
462	\|\| CalllbackArgs.rcDA == kDAReturnNotMounted))
463	{
464	pDev = (PHBDMGRDEV)RTMemAllocZ(sizeof(HBDMGRDEV));
465	if (RT_LIKELY(pDev))
466	{
467	pDev->hDiskRef = hDiskRef;
468	RTSemFastMutexRequest(pThis->hMtxList);
469	RTListAppend(&pThis->ListClaimed, &pDev->ListNode);
470	RTSemFastMutexRelease(pThis->hMtxList);
471	rc = VINF_SUCCESS;
472	}
473	else
474	rc = VERR_NO_MEMORY;
475	}
476	else if (RT_SUCCESS(rc))
477	{
478	rc = hbdMgrDAReturn2VBoxStatus(CalllbackArgs.rcDA);
479	LogRel(("HBDMgrClaimBlockDevice: DADiskUnmount(\"%s\") failed with %Rrc (%s)\n",
480	pszFilename, rc, CalllbackArgs.pszErrDetail ? CalllbackArgs.pszErrDetail : "<no detail>"));
481	if (CalllbackArgs.pszErrDetail)
482	RTStrFree(CalllbackArgs.pszErrDetail);
483	}
484	}
485	else if (RT_SUCCESS(rc))
486	{
487	rc = hbdMgrDAReturn2VBoxStatus(CalllbackArgs.rcDA);
488	LogRel(("HBDMgrClaimBlockDevice: DADiskClaim(\"%s\") failed with %Rrc (%s)\n",
489	pszFilename, rc, CalllbackArgs.pszErrDetail ? CalllbackArgs.pszErrDetail : "<no detail>"));
490	if (CalllbackArgs.pszErrDetail)
491	RTStrFree(CalllbackArgs.pszErrDetail);
492	}
493	if (RT_FAILURE(rc))
494	CFRelease(hDiskRef);
495	}
496	else
497	rc = VERR_NO_MEMORY;
498	}
499	else
500	rc = VERR_ALREADY_EXISTS;
501
502	return rc;
503	}
504
505
506	DECLHIDDEN(int) HBDMgrUnclaimBlockDevice(HBDMGR hHbdMgr, const char *pszFilename)
507	{
508	PHBDMGRINT pThis = hHbdMgr;
509	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
510
511	RTSemFastMutexRequest(pThis->hMtxList);
512	int rc = VINF_SUCCESS;
513	PHBDMGRDEV pDev = hbdMgrDevFindByName(pThis, pszFilename);
514	if (pDev)
515	hbdMgrDevUnclaim(pDev);
516	else
517	rc = VERR_NOT_FOUND;
518	RTSemFastMutexRelease(pThis->hMtxList);
519
520	return rc;
521	}
522
523
524	DECLHIDDEN(bool) HBDMgrIsBlockDeviceClaimed(HBDMGR hHbdMgr, const char *pszFilename)
525	{
526	PHBDMGRINT pThis = hHbdMgr;
527	AssertPtrReturn(pThis, false);
528
529	RTSemFastMutexRequest(pThis->hMtxList);
530	PHBDMGRDEV pIt = hbdMgrDevFindByName(pThis, pszFilename);
531	RTSemFastMutexRelease(pThis->hMtxList);
532
533	return pIt ? true : false;
534	}

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

source: vbox/trunk/src/VBox/Devices/Storage/HBDMgmt-darwin.cpp@ 81019

Download in other formats: