VDPlugin.cpp@ 86327

Last change on this file since 86327 was 84328, checked in by vboxsync, 5 years ago
Storage/VD: ticketref:19579 'VBoxManage internalcommands repairhd' SEGVs with invalid input
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.6 KB

Line
1	/* $Id: VDPlugin.cpp 84328 2020-05-18 13:34:32Z vboxsync $ */
2	/** @file
3	* VD - Virtual disk container implementation, plugin related bits.
4	*/
5
6	/*
7	* Copyright (C) 2017-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
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_VD
23	#include <VBox/err.h>
24	#include <VBox/sup.h>
25	#include <VBox/log.h>
26	#include <VBox/vd-plugin.h>
27
28	#include <iprt/dir.h>
29	#include <iprt/ldr.h>
30	#include <iprt/mem.h>
31	#include <iprt/path.h>
32
33	#include "VDInternal.h"
34	#include "VDBackends.h"
35
36
37	/*********************************************************************************************************************************
38	* Structures and Typedefs *
39	*********************************************************************************************************************************/
40
41	/**
42	* Plugin structure.
43	*/
44	typedef struct VDPLUGIN
45	{
46	/** Pointer to the next plugin structure. */
47	RTLISTNODE NodePlugin;
48	/** Handle of loaded plugin library. */
49	RTLDRMOD hPlugin;
50	/** Filename of the loaded plugin. */
51	char *pszFilename;
52	} VDPLUGIN;
53	/** Pointer to a plugin structure. */
54	typedef VDPLUGIN *PVDPLUGIN;
55
56
57	/*********************************************************************************************************************************
58	* Defined Constants And Macros *
59	*********************************************************************************************************************************/
60
61
62	/*********************************************************************************************************************************
63	* Global Variables *
64	*********************************************************************************************************************************/
65
66	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
67	/** Head of loaded plugin list. */
68	static RTLISTANCHOR g_ListPluginsLoaded;
69	#endif
70
71	/** Number of image backends supported. */
72	static unsigned g_cBackends = 0;
73	/** Array of pointers to the image backends. */
74	static PCVDIMAGEBACKEND *g_apBackends = NULL;
75	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
76	/** Array of handles to the corresponding plugin. */
77	static RTLDRMOD *g_ahBackendPlugins = NULL;
78	#endif
79	/**
80	* Builtin image backends.
81	*
82	* @note As long as the pfnProb() calls aren't scored, the ordering influences
83	* which backend take precedence. In particular, the RAW backend should
84	* be thowards the end of the list.
85	*/
86	static PCVDIMAGEBACKEND aStaticBackends[] =
87	{
88	&g_VmdkBackend,
89	&g_VDIBackend,
90	&g_VhdBackend,
91	&g_ParallelsBackend,
92	&g_DmgBackend,
93	&g_QedBackend,
94	&g_QCowBackend,
95	&g_VhdxBackend,
96	&g_CueBackend,
97	&g_VBoxIsoMakerBackend,
98	&g_RawBackend,
99	&g_ISCSIBackend
100	};
101
102	/** Number of supported cache backends. */
103	static unsigned g_cCacheBackends = 0;
104	/** Array of pointers to the cache backends. */
105	static PCVDCACHEBACKEND *g_apCacheBackends = NULL;
106	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
107	/** Array of handles to the corresponding plugin.
108	*
109	* @todo r=bird: This looks rather pointless.
110	*/
111	static RTLDRMOD *g_ahCacheBackendPlugins = NULL;
112	#endif
113	/** Builtin cache backends. */
114	static PCVDCACHEBACKEND aStaticCacheBackends[] =
115	{
116	&g_VciCacheBackend
117	};
118
119	/** Number of supported filter backends. */
120	static unsigned g_cFilterBackends = 0;
121	/** Array of pointers to the filters backends. */
122	static PCVDFILTERBACKEND *g_apFilterBackends = NULL;
123	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
124	/** Array of handles to the corresponding plugin. */
125	static PRTLDRMOD g_pahFilterBackendPlugins = NULL;
126	#endif
127
128
129	/*********************************************************************************************************************************
130	* Internal Functions *
131	*********************************************************************************************************************************/
132
133	/**
134	* Add an array of image format backends from the given plugin to the list of known
135	* image formats.
136	*
137	* @returns VBox status code.
138	* @param hPlugin The plugin handle the backends belong to, can be NIL_RTLDRMOD
139	* for compiled in backends.
140	* @param ppBackends The array of image backend descriptors to add.
141	* @param cBackends Number of descriptors in the array.
142	*/
143	static int vdAddBackends(RTLDRMOD hPlugin, PCVDIMAGEBACKEND *ppBackends, unsigned cBackends)
144	{
145	PCVDIMAGEBACKEND pTmp = (PCVDIMAGEBACKEND )RTMemRealloc(g_apBackends,
146	(g_cBackends + cBackends) * sizeof(PCVDIMAGEBACKEND));
147	if (RT_UNLIKELY(!pTmp))
148	return VERR_NO_MEMORY;
149	g_apBackends = pTmp;
150	memcpy(&g_apBackends[g_cBackends], ppBackends, cBackends * sizeof(PCVDIMAGEBACKEND));
151
152	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
153	RTLDRMOD pTmpPlugins = (RTLDRMOD)RTMemRealloc(g_ahBackendPlugins,
154	(g_cBackends + cBackends) * sizeof(RTLDRMOD));
155	if (RT_UNLIKELY(!pTmpPlugins))
156	return VERR_NO_MEMORY;
157	g_ahBackendPlugins = pTmpPlugins;
158	for (unsigned i = g_cBackends; i < g_cBackends + cBackends; i++)
159	g_ahBackendPlugins[i] = hPlugin;
160	#else
161	RT_NOREF(hPlugin);
162	#endif
163
164	g_cBackends += cBackends;
165	return VINF_SUCCESS;
166	}
167
168
169	/**
170	* Add an array of cache format backends from the given plugin to the list of known
171	* cache formats.
172	*
173	* @returns VBox status code.
174	* @param hPlugin The plugin handle the backends belong to, can be NIL_RTLDRMOD
175	* for compiled in backends.
176	* @param ppBackends The array of cache backend descriptors to add.
177	* @param cBackends Number of descriptors in the array.
178	*/
179	static int vdAddCacheBackends(RTLDRMOD hPlugin, PCVDCACHEBACKEND *ppBackends, unsigned cBackends)
180	{
181	PCVDCACHEBACKEND pTmp = (PCVDCACHEBACKEND)RTMemReallocTag(g_apCacheBackends,
182	(g_cCacheBackends + cBackends) * sizeof(PCVDCACHEBACKEND),
183	"may-leak:vdAddCacheBackend");
184	if (RT_UNLIKELY(!pTmp))
185	return VERR_NO_MEMORY;
186	g_apCacheBackends = pTmp;
187	memcpy(&g_apCacheBackends[g_cCacheBackends], ppBackends, cBackends * sizeof(PCVDCACHEBACKEND));
188
189	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
190	RTLDRMOD pTmpPlugins = (RTLDRMOD)RTMemReallocTag(g_ahCacheBackendPlugins,
191	(g_cCacheBackends + cBackends) * sizeof(RTLDRMOD),
192	"may-leak:vdAddCacheBackend");
193	if (RT_UNLIKELY(!pTmpPlugins))
194	return VERR_NO_MEMORY;
195	g_ahCacheBackendPlugins = pTmpPlugins;
196	for (unsigned i = g_cCacheBackends; i < g_cCacheBackends + cBackends; i++)
197	g_ahCacheBackendPlugins[i] = hPlugin;
198	#else
199	RT_NOREF(hPlugin);
200	#endif
201
202	g_cCacheBackends += cBackends;
203	return VINF_SUCCESS;
204	}
205
206	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
207	/**
208	* Add a single image format backend to the list of known image formats.
209	*
210	* @returns VBox status code.
211	* @param hPlugin The plugin handle the backend belongs to, can be NIL_RTLDRMOD
212	* for compiled in backends.
213	* @param pBackend The image backend descriptors to add.
214	*/
215	DECLINLINE(int) vdAddBackend(RTLDRMOD hPlugin, PCVDIMAGEBACKEND pBackend)
216	{
217	return vdAddBackends(hPlugin, &pBackend, 1);
218	}
219
220
221	/**
222	* Add a single cache format backend to the list of known cache formats.
223	*
224	* @returns VBox status code.
225	* @param hPlugin The plugin handle the backend belongs to, can be NIL_RTLDRMOD
226	* for compiled in backends.
227	* @param pBackend The cache backend descriptors to add.
228	*/
229	DECLINLINE(int) vdAddCacheBackend(RTLDRMOD hPlugin, PCVDCACHEBACKEND pBackend)
230	{
231	return vdAddCacheBackends(hPlugin, &pBackend, 1);
232	}
233
234
235	/**
236	* Add several filter backends.
237	*
238	* @returns VBox status code.
239	* @param hPlugin Plugin handle to add.
240	* @param ppBackends Array of filter backends to add.
241	* @param cBackends Number of backends to add.
242	*/
243	static int vdAddFilterBackends(RTLDRMOD hPlugin, PCVDFILTERBACKEND *ppBackends, unsigned cBackends)
244	{
245	PCVDFILTERBACKEND pTmp = (PCVDFILTERBACKEND )RTMemRealloc(g_apFilterBackends,
246	(g_cFilterBackends + cBackends) * sizeof(PCVDFILTERBACKEND));
247	if (RT_UNLIKELY(!pTmp))
248	return VERR_NO_MEMORY;
249	g_apFilterBackends = pTmp;
250
251	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
252	PRTLDRMOD pTmpPlugins = (PRTLDRMOD)RTMemRealloc(g_pahFilterBackendPlugins,
253	(g_cFilterBackends + cBackends) * sizeof(RTLDRMOD));
254	if (RT_UNLIKELY(!pTmpPlugins))
255	return VERR_NO_MEMORY;
256
257	g_pahFilterBackendPlugins = pTmpPlugins;
258	memcpy(&g_apFilterBackends[g_cFilterBackends], ppBackends, cBackends * sizeof(PCVDFILTERBACKEND));
259	for (unsigned i = g_cFilterBackends; i < g_cFilterBackends + cBackends; i++)
260	g_pahFilterBackendPlugins[i] = hPlugin;
261	#else
262	RT_NOREF(hPlugin);
263	#endif
264
265	g_cFilterBackends += cBackends;
266	return VINF_SUCCESS;
267	}
268
269
270	/**
271	* Add a single filter backend to the list of supported filters.
272	*
273	* @returns VBox status code.
274	* @param hPlugin Plugin handle to add.
275	* @param pBackend The backend to add.
276	*/
277	DECLINLINE(int) vdAddFilterBackend(RTLDRMOD hPlugin, PCVDFILTERBACKEND pBackend)
278	{
279	return vdAddFilterBackends(hPlugin, &pBackend, 1);
280	}
281
282	/**
283	* @interface_method_impl{VDBACKENDREGISTER,pfnRegisterImage}
284	*/
285	static DECLCALLBACK(int) vdPluginRegisterImage(void *pvUser, PCVDIMAGEBACKEND pBackend)
286	{
287	int rc = VINF_SUCCESS;
288
289	if (VD_VERSION_ARE_COMPATIBLE(VD_IMGBACKEND_VERSION, pBackend->u32Version))
290	vdAddBackend((RTLDRMOD)pvUser, pBackend);
291	else
292	{
293	LogFunc(("ignored plugin: pBackend->u32Version=%u rc=%Rrc\n", pBackend->u32Version, rc));
294	rc = VERR_IGNORED;
295	}
296
297	return rc;
298	}
299
300	/**
301	* @interface_method_impl{VDBACKENDREGISTER,pfnRegisterCache}
302	*/
303	static DECLCALLBACK(int) vdPluginRegisterCache(void *pvUser, PCVDCACHEBACKEND pBackend)
304	{
305	int rc = VINF_SUCCESS;
306
307	if (VD_VERSION_ARE_COMPATIBLE(VD_CACHEBACKEND_VERSION, pBackend->u32Version))
308	vdAddCacheBackend((RTLDRMOD)pvUser, pBackend);
309	else
310	{
311	LogFunc(("ignored plugin: pBackend->u32Version=%u rc=%Rrc\n", pBackend->u32Version, rc));
312	rc = VERR_IGNORED;
313	}
314
315	return rc;
316	}
317
318	/**
319	* @interface_method_impl{VDBACKENDREGISTER,pfnRegisterFilter}
320	*/
321	static DECLCALLBACK(int) vdPluginRegisterFilter(void *pvUser, PCVDFILTERBACKEND pBackend)
322	{
323	int rc = VINF_SUCCESS;
324
325	if (VD_VERSION_ARE_COMPATIBLE(VD_FLTBACKEND_VERSION, pBackend->u32Version))
326	vdAddFilterBackend((RTLDRMOD)pvUser, pBackend);
327	else
328	{
329	LogFunc(("ignored plugin: pBackend->u32Version=%u rc=%Rrc\n", pBackend->u32Version, rc));
330	rc = VERR_IGNORED;
331	}
332
333	return rc;
334	}
335
336	/**
337	* Checks whether the given plugin filename was already loaded.
338	*
339	* @returns Pointer to already loaded plugin, NULL if not found.
340	* @param pszFilename The filename to check.
341	*/
342	static PVDPLUGIN vdPluginFind(const char *pszFilename)
343	{
344	PVDPLUGIN pIt;
345	RTListForEach(&g_ListPluginsLoaded, pIt, VDPLUGIN, NodePlugin)
346	{
347	if (!RTStrCmp(pIt->pszFilename, pszFilename))
348	return pIt;
349	}
350
351	return NULL;
352	}
353
354	/**
355	* Adds a plugin to the list of loaded plugins.
356	*
357	* @returns VBox status code.
358	* @param hPlugin Plugin handle to add.
359	* @param pszFilename The associated filename, used for finding duplicates.
360	*/
361	static int vdAddPlugin(RTLDRMOD hPlugin, const char *pszFilename)
362	{
363	int rc = VINF_SUCCESS;
364	PVDPLUGIN pPlugin = (PVDPLUGIN)RTMemAllocZ(sizeof(VDPLUGIN));
365
366	if (pPlugin)
367	{
368	pPlugin->hPlugin = hPlugin;
369	pPlugin->pszFilename = RTStrDup(pszFilename);
370	if (pPlugin->pszFilename)
371	RTListAppend(&g_ListPluginsLoaded, &pPlugin->NodePlugin);
372	else
373	{
374	RTMemFree(pPlugin);
375	rc = VERR_NO_MEMORY;
376	}
377	}
378	else
379	rc = VERR_NO_MEMORY;
380
381	return rc;
382	}
383
384	/**
385	* Removes a single plugin given by the filename.
386	*
387	* @returns VBox status code.
388	* @param pszFilename The plugin filename to remove.
389	*/
390	static int vdRemovePlugin(const char *pszFilename)
391	{
392	/* Find plugin to be removed from the list. */
393	PVDPLUGIN pIt = vdPluginFind(pszFilename);
394	if (!pIt)
395	return VINF_SUCCESS;
396
397	/** @todo r=klaus: need to add a plugin entry point for unregistering the
398	* backends. Only if this doesn't exist (or fails to work) we should fall
399	* back to the following uncoordinated backend cleanup. */
400	for (unsigned i = 0; i < g_cBackends; i++)
401	{
402	while (i < g_cBackends && g_ahBackendPlugins[i] == pIt->hPlugin)
403	{
404	memmove(&g_apBackends[i], &g_apBackends[i + 1], (g_cBackends - i - 1) * sizeof(PCVDIMAGEBACKEND));
405	memmove(&g_ahBackendPlugins[i], &g_ahBackendPlugins[i + 1], (g_cBackends - i - 1) * sizeof(RTLDRMOD));
406	/** @todo for now skip reallocating, doesn't save much */
407	g_cBackends--;
408	}
409	}
410	for (unsigned i = 0; i < g_cCacheBackends; i++)
411	{
412	while (i < g_cCacheBackends && g_ahCacheBackendPlugins[i] == pIt->hPlugin)
413	{
414	memmove(&g_apCacheBackends[i], &g_apCacheBackends[i + 1], (g_cCacheBackends - i - 1) * sizeof(PCVDCACHEBACKEND));
415	memmove(&g_ahCacheBackendPlugins[i], &g_ahCacheBackendPlugins[i + 1], (g_cCacheBackends - i - 1) * sizeof(RTLDRMOD));
416	/** @todo for now skip reallocating, doesn't save much */
417	g_cCacheBackends--;
418	}
419	}
420	for (unsigned i = 0; i < g_cFilterBackends; i++)
421	{
422	while (i < g_cFilterBackends && g_pahFilterBackendPlugins[i] == pIt->hPlugin)
423	{
424	memmove(&g_apFilterBackends[i], &g_apFilterBackends[i + 1], (g_cFilterBackends - i - 1) * sizeof(PCVDFILTERBACKEND));
425	memmove(&g_pahFilterBackendPlugins[i], &g_pahFilterBackendPlugins[i + 1], (g_cFilterBackends - i - 1) * sizeof(RTLDRMOD));
426	/** @todo for now skip reallocating, doesn't save much */
427	g_cFilterBackends--;
428	}
429	}
430
431	/* Remove the plugin node now, all traces of it are gone. */
432	RTListNodeRemove(&pIt->NodePlugin);
433	RTLdrClose(pIt->hPlugin);
434	RTStrFree(pIt->pszFilename);
435	RTMemFree(pIt);
436
437	return VINF_SUCCESS;
438	}
439
440	#endif /* VBOX_HDD_NO_DYNAMIC_BACKENDS*/
441
442	/**
443	* Returns the number of known image format backends.
444	*
445	* @returns Number of image formats known.
446	*/
447	DECLHIDDEN(uint32_t) vdGetImageBackendCount(void)
448	{
449	return g_cBackends;
450	}
451
452
453	/**
454	* Queries a image backend descriptor by the index.
455	*
456	* @returns VBox status code.
457	* @param idx The index of the backend to query.
458	* @param ppBackend Where to store the pointer to the backend descriptor on success.
459	*/
460	DECLHIDDEN(int) vdQueryImageBackend(uint32_t idx, PCVDIMAGEBACKEND *ppBackend)
461	{
462	if (idx >= g_cBackends)
463	return VERR_OUT_OF_RANGE;
464
465	*ppBackend = g_apBackends[idx];
466	return VINF_SUCCESS;
467	}
468
469
470	/**
471	* Returns the image backend descriptor matching the given identifier if known.
472	*
473	* @returns VBox status code.
474	* @param pszBackend The backend identifier to look for.
475	* @param ppBackend Where to store the pointer to the backend descriptor on success.
476	*/
477	DECLHIDDEN(int) vdFindImageBackend(const char pszBackend, PCVDIMAGEBACKEND ppBackend)
478	{
479	int rc = VERR_NOT_FOUND;
480	PCVDIMAGEBACKEND pBackend = NULL;
481
482	if (!g_apBackends)
483	VDInit();
484
485	for (unsigned i = 0; i < g_cBackends; i++)
486	{
487	if (!RTStrICmp(pszBackend, g_apBackends[i]->pszBackendName))
488	{
489	pBackend = g_apBackends[i];
490	rc = VINF_SUCCESS;
491	break;
492	}
493	}
494	*ppBackend = pBackend;
495	return rc;
496	}
497
498	/**
499	* Returns the number of known cache format backends.
500	*
501	* @returns Number of image formats known.
502	*/
503	DECLHIDDEN(uint32_t) vdGetCacheBackendCount(void)
504	{
505	return g_cCacheBackends;
506	}
507
508
509	/**
510	* Queries a cache backend descriptor by the index.
511	*
512	* @returns VBox status code.
513	* @param idx The index of the backend to query.
514	* @param ppBackend Where to store the pointer to the backend descriptor on success.
515	*/
516	DECLHIDDEN(int) vdQueryCacheBackend(uint32_t idx, PCVDCACHEBACKEND *ppBackend)
517	{
518	if (idx >= g_cCacheBackends)
519	return VERR_OUT_OF_RANGE;
520
521	*ppBackend = g_apCacheBackends[idx];
522	return VINF_SUCCESS;
523	}
524
525
526	/**
527	* Returns the cache backend descriptor matching the given identifier if known.
528	*
529	* @returns VBox status code.
530	* @param pszBackend The backend identifier to look for.
531	* @param ppBackend Where to store the pointer to the backend descriptor on success.
532	*/
533	DECLHIDDEN(int) vdFindCacheBackend(const char pszBackend, PCVDCACHEBACKEND ppBackend)
534	{
535	int rc = VERR_NOT_FOUND;
536	PCVDCACHEBACKEND pBackend = NULL;
537
538	if (!g_apCacheBackends)
539	VDInit();
540
541	for (unsigned i = 0; i < g_cCacheBackends; i++)
542	{
543	if (!RTStrICmp(pszBackend, g_apCacheBackends[i]->pszBackendName))
544	{
545	pBackend = g_apCacheBackends[i];
546	rc = VINF_SUCCESS;
547	break;
548	}
549	}
550	*ppBackend = pBackend;
551	return rc;
552	}
553
554
555	/**
556	* Returns the number of known filter backends.
557	*
558	* @returns Number of image formats known.
559	*/
560	DECLHIDDEN(uint32_t) vdGetFilterBackendCount(void)
561	{
562	return g_cFilterBackends;
563	}
564
565
566	/**
567	* Queries a filter backend descriptor by the index.
568	*
569	* @returns VBox status code.
570	* @param idx The index of the backend to query.
571	* @param ppBackend Where to store the pointer to the backend descriptor on success.
572	*/
573	DECLHIDDEN(int) vdQueryFilterBackend(uint32_t idx, PCVDFILTERBACKEND *ppBackend)
574	{
575	if (idx >= g_cFilterBackends)
576	return VERR_OUT_OF_RANGE;
577
578	*ppBackend = g_apFilterBackends[idx];
579	return VINF_SUCCESS;
580	}
581
582
583	/**
584	* Returns the filter backend descriptor matching the given identifier if known.
585	*
586	* @returns VBox status code.
587	* @param pszFilter The filter identifier to look for.
588	* @param ppBackend Where to store the pointer to the backend descriptor on success.
589	*/
590	DECLHIDDEN(int) vdFindFilterBackend(const char pszFilter, PCVDFILTERBACKEND ppBackend)
591	{
592	int rc = VERR_NOT_FOUND;
593	PCVDFILTERBACKEND pBackend = NULL;
594
595	for (unsigned i = 0; i < g_cFilterBackends; i++)
596	{
597	if (!RTStrICmp(pszFilter, g_apFilterBackends[i]->pszBackendName))
598	{
599	pBackend = g_apFilterBackends[i];
600	rc = VINF_SUCCESS;
601	break;
602	}
603	}
604	*ppBackend = pBackend;
605	return rc;
606	}
607
608
609	/**
610	* Worker for VDPluginLoadFromFilename() and vdPluginLoadFromPath().
611	*
612	* @returns VBox status code.
613	* @param pszFilename The plugin filename to load.
614	*/
615	DECLHIDDEN(int) vdPluginLoadFromFilename(const char *pszFilename)
616	{
617	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
618	/* Plugin loaded? Nothing to do. */
619	if (vdPluginFind(pszFilename))
620	return VINF_SUCCESS;
621
622	RTLDRMOD hPlugin = NIL_RTLDRMOD;
623	int rc = SUPR3HardenedLdrLoadPlugIn(pszFilename, &hPlugin, NULL);
624	if (RT_SUCCESS(rc))
625	{
626	VDBACKENDREGISTER BackendRegister;
627	PFNVDPLUGINLOAD pfnVDPluginLoad = NULL;
628
629	BackendRegister.u32Version = VD_BACKENDREG_CB_VERSION;
630	BackendRegister.pfnRegisterImage = vdPluginRegisterImage;
631	BackendRegister.pfnRegisterCache = vdPluginRegisterCache;
632	BackendRegister.pfnRegisterFilter = vdPluginRegisterFilter;
633
634	rc = RTLdrGetSymbol(hPlugin, VD_PLUGIN_LOAD_NAME, (void**)&pfnVDPluginLoad);
635	if (RT_FAILURE(rc) \|\| !pfnVDPluginLoad)
636	{
637	LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnVDPluginLoad=%#p\n",
638	VD_PLUGIN_LOAD_NAME, pszFilename, rc, pfnVDPluginLoad));
639	if (RT_SUCCESS(rc))
640	rc = VERR_SYMBOL_NOT_FOUND;
641	}
642
643	if (RT_SUCCESS(rc))
644	{
645	/* Get the function table. */
646	rc = pfnVDPluginLoad(hPlugin, &BackendRegister);
647	}
648	else
649	LogFunc(("ignored plugin '%s': rc=%Rrc\n", pszFilename, rc));
650
651	/* Create a plugin entry on success. */
652	if (RT_SUCCESS(rc))
653	vdAddPlugin(hPlugin, pszFilename);
654	else
655	RTLdrClose(hPlugin);
656	}
657
658	return rc;
659	#else
660	RT_NOREF1(pszFilename);
661	return VERR_NOT_IMPLEMENTED;
662	#endif
663	}
664
665	/**
666	* Worker for VDPluginLoadFromPath() and vdLoadDynamicBackends().
667	*
668	* @returns VBox status code.
669	* @param pszPath The path to load plugins from.
670	*/
671	DECLHIDDEN(int) vdPluginLoadFromPath(const char *pszPath)
672	{
673	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
674	/* To get all entries with VBoxHDD as prefix. */
675	char pszPluginFilter = RTPathJoinA(pszPath, VD_PLUGIN_PREFIX "");
676	if (!pszPluginFilter)
677	return VERR_NO_STR_MEMORY;
678
679	PRTDIRENTRYEX pPluginDirEntry = NULL;
680	RTDIR hPluginDir;
681	size_t cbPluginDirEntry = sizeof(RTDIRENTRYEX);
682	int rc = RTDirOpenFiltered(&hPluginDir, pszPluginFilter, RTDIRFILTER_WINNT, 0 /fFlags/);
683	if (RT_SUCCESS(rc))
684	{
685	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
686	if (pPluginDirEntry)
687	{
688	while ( (rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK))
689	!= VERR_NO_MORE_FILES)
690	{
691	char *pszPluginPath = NULL;
692
693	if (rc == VERR_BUFFER_OVERFLOW)
694	{
695	/* allocate new buffer. */
696	RTMemFree(pPluginDirEntry);
697	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(cbPluginDirEntry);
698	if (!pPluginDirEntry)
699	{
700	rc = VERR_NO_MEMORY;
701	break;
702	}
703	/* Retry. */
704	rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
705	if (RT_FAILURE(rc))
706	break;
707	}
708	else if (RT_FAILURE(rc))
709	break;
710
711	/* We got the new entry. */
712	if (!RTFS_IS_FILE(pPluginDirEntry->Info.Attr.fMode))
713	continue;
714
715	/* Prepend the path to the libraries. */
716	pszPluginPath = RTPathJoinA(pszPath, pPluginDirEntry->szName);
717	if (!pszPluginPath)
718	{
719	rc = VERR_NO_STR_MEMORY;
720	break;
721	}
722
723	rc = vdPluginLoadFromFilename(pszPluginPath);
724	RTStrFree(pszPluginPath);
725	}
726
727	RTMemFree(pPluginDirEntry);
728	}
729	else
730	rc = VERR_NO_MEMORY;
731
732	RTDirClose(hPluginDir);
733	}
734	else
735	{
736	/* On Windows the above immediately signals that there are no
737	* files matching, while on other platforms enumerating the
738	* files below fails. Either way: no plugins. */
739	}
740
741	if (rc == VERR_NO_MORE_FILES)
742	rc = VINF_SUCCESS;
743	RTStrFree(pszPluginFilter);
744	return rc;
745	#else
746	RT_NOREF1(pszPath);
747	return VERR_NOT_IMPLEMENTED;
748	#endif
749	}
750
751	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
752	/**
753	* internal: scans plugin directory and loads found plugins.
754	*/
755	static int vdLoadDynamicBackends(void)
756	{
757	/*
758	* Enumerate plugin backends from the application directory where the other
759	* shared libraries are.
760	*/
761	char szPath[RTPATH_MAX];
762	int rc = RTPathAppPrivateArch(szPath, sizeof(szPath));
763	if (RT_FAILURE(rc))
764	return rc;
765
766	return vdPluginLoadFromPath(szPath);
767	}
768	#endif
769
770	/**
771	* Worker for VDPluginUnloadFromFilename() and vdPluginUnloadFromPath().
772	*
773	* @returns VBox status code.
774	* @param pszFilename The plugin filename to unload.
775	*/
776	DECLHIDDEN(int) vdPluginUnloadFromFilename(const char *pszFilename)
777	{
778	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
779	return vdRemovePlugin(pszFilename);
780	#else
781	RT_NOREF1(pszFilename);
782	return VERR_NOT_IMPLEMENTED;
783	#endif
784	}
785
786	/**
787	* Worker for VDPluginUnloadFromPath().
788	*
789	* @returns VBox status code.
790	* @param pszPath The path to unload plugins from.
791	*/
792	DECLHIDDEN(int) vdPluginUnloadFromPath(const char *pszPath)
793	{
794	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
795	/* To get all entries with VBoxHDD as prefix. */
796	char pszPluginFilter = RTPathJoinA(pszPath, VD_PLUGIN_PREFIX "");
797	if (!pszPluginFilter)
798	return VERR_NO_STR_MEMORY;
799
800	PRTDIRENTRYEX pPluginDirEntry = NULL;
801	RTDIR hPluginDir;
802	size_t cbPluginDirEntry = sizeof(RTDIRENTRYEX);
803	int rc = RTDirOpenFiltered(&hPluginDir, pszPluginFilter, RTDIRFILTER_WINNT, 0 /fFlags/);
804	if (RT_SUCCESS(rc))
805	{
806	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
807	if (pPluginDirEntry)
808	{
809	while ((rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK)) != VERR_NO_MORE_FILES)
810	{
811	char *pszPluginPath = NULL;
812
813	if (rc == VERR_BUFFER_OVERFLOW)
814	{
815	/* allocate new buffer. */
816	RTMemFree(pPluginDirEntry);
817	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(cbPluginDirEntry);
818	if (!pPluginDirEntry)
819	{
820	rc = VERR_NO_MEMORY;
821	break;
822	}
823	/* Retry. */
824	rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
825	if (RT_FAILURE(rc))
826	break;
827	}
828	else if (RT_FAILURE(rc))
829	break;
830
831	/* We got the new entry. */
832	if (!RTFS_IS_FILE(pPluginDirEntry->Info.Attr.fMode))
833	continue;
834
835	/* Prepend the path to the libraries. */
836	pszPluginPath = RTPathJoinA(pszPath, pPluginDirEntry->szName);
837	if (!pszPluginPath)
838	{
839	rc = VERR_NO_STR_MEMORY;
840	break;
841	}
842
843	rc = vdPluginUnloadFromFilename(pszPluginPath);
844	RTStrFree(pszPluginPath);
845	}
846
847	RTMemFree(pPluginDirEntry);
848	}
849	else
850	rc = VERR_NO_MEMORY;
851
852	RTDirClose(hPluginDir);
853	}
854	else
855	{
856	/* On Windows the above immediately signals that there are no
857	* files matching, while on other platforms enumerating the
858	* files below fails. Either way: no plugins. */
859	}
860
861	if (rc == VERR_NO_MORE_FILES)
862	rc = VINF_SUCCESS;
863	RTStrFree(pszPluginFilter);
864	return rc;
865	#else
866	RT_NOREF1(pszPath);
867	return VERR_NOT_IMPLEMENTED;
868	#endif
869	}
870
871
872	/**
873	* Initializes the plugin state to be able to load further plugins and populates
874	* the backend lists with the compiled in backends.
875	*
876	* @returns VBox status code.
877	*/
878	DECLHIDDEN(int) vdPluginInit(void)
879	{
880	int rc = vdAddBackends(NIL_RTLDRMOD, aStaticBackends, RT_ELEMENTS(aStaticBackends));
881	if (RT_SUCCESS(rc))
882	{
883	rc = vdAddCacheBackends(NIL_RTLDRMOD, aStaticCacheBackends, RT_ELEMENTS(aStaticCacheBackends));
884	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
885	if (RT_SUCCESS(rc))
886	{
887	RTListInit(&g_ListPluginsLoaded);
888	rc = vdLoadDynamicBackends();
889	}
890	#endif
891	}
892
893	return rc;
894	}
895
896
897	/**
898	* Tears down the plugin related state.
899	*
900	* @returns VBox status code.
901	*/
902	DECLHIDDEN(int) vdPluginTerm(void)
903	{
904	if (!g_apBackends)
905	return VERR_INTERNAL_ERROR;
906
907	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
908	if (g_pahFilterBackendPlugins)
909	RTMemFree(g_pahFilterBackendPlugins);
910	#endif
911	if (g_apFilterBackends)
912	RTMemFree(g_apFilterBackends);
913	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
914	if (g_ahCacheBackendPlugins)
915	RTMemFree(g_ahCacheBackendPlugins);
916	#endif
917	if (g_apCacheBackends)
918	RTMemFree(g_apCacheBackends);
919	RTMemFree(g_apBackends);
920
921	g_cBackends = 0;
922	g_apBackends = NULL;
923
924	/* Clear the supported cache backends. */
925	g_cCacheBackends = 0;
926	g_apCacheBackends = NULL;
927	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
928	g_ahCacheBackendPlugins = NULL;
929	#endif
930
931	/* Clear the supported filter backends. */
932	g_cFilterBackends = 0;
933	g_apFilterBackends = NULL;
934	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
935	g_pahFilterBackendPlugins = NULL;
936	#endif
937
938	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
939	PVDPLUGIN pPlugin, pPluginNext;
940	RTListForEachSafe(&g_ListPluginsLoaded, pPlugin, pPluginNext, VDPLUGIN, NodePlugin)
941	{
942	RTLdrClose(pPlugin->hPlugin);
943	RTStrFree(pPlugin->pszFilename);
944	RTListNodeRemove(&pPlugin->NodePlugin);
945	RTMemFree(pPlugin);
946	}
947	#endif
948
949	return VINF_SUCCESS;
950	}
951
952
953	/**
954	* Returns whether the plugin related state is initialized.
955	*
956	* @returns true if the plugin state is initialized and plugins can be loaded,
957	* false otherwise.
958	*/
959	DECLHIDDEN(bool) vdPluginIsInitialized(void)
960	{
961	return g_apBackends != NULL;
962	}
963

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

source: vbox/trunk/src/VBox/Storage/VDPlugin.cpp@ 86327

Download in other formats: