VDPlugin.cpp@ 80074

Last change on this file since 80074 was 79965, checked in by vboxsync, 5 years ago
Storage: Added a desired format parameter to VDGetFormat() so Main can pass along the device type. Bumped the RAW backend down after the CUE and VISO to prevent (impossible) mixups of tiny files. Extended rawProbe() to look for a valid ISO-9660/UDF descriptor sequence on the image if the caller doesn't say it should be a floppy or hdd, only if that fail go by the extension. Note! the pfnProbe callback should probably get a score return parameter to indicate how confient the backend is about the probe result, as this would prevent the RAW backend from accidentally grabbing images which belongs to a plug-in. bugref:9151
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.5 KB

Line
1	/* $Id: VDPlugin.cpp 79965 2019-07-24 20:32:32Z vboxsync $ */
2	/** @file
3	* VD - Virtual disk container implementation, plugin related bits.
4	*/
5
6	/*
7	* Copyright (C) 2017-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_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 = VINF_SUCCESS;
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	break;
491	}
492	}
493	*ppBackend = pBackend;
494	return rc;
495	}
496
497	/**
498	* Returns the number of known cache format backends.
499	*
500	* @returns Number of image formats known.
501	*/
502	DECLHIDDEN(uint32_t) vdGetCacheBackendCount(void)
503	{
504	return g_cCacheBackends;
505	}
506
507
508	/**
509	* Queries a cache backend descriptor by the index.
510	*
511	* @returns VBox status code.
512	* @param idx The index of the backend to query.
513	* @param ppBackend Where to store the pointer to the backend descriptor on success.
514	*/
515	DECLHIDDEN(int) vdQueryCacheBackend(uint32_t idx, PCVDCACHEBACKEND *ppBackend)
516	{
517	if (idx >= g_cCacheBackends)
518	return VERR_OUT_OF_RANGE;
519
520	*ppBackend = g_apCacheBackends[idx];
521	return VINF_SUCCESS;
522	}
523
524
525	/**
526	* Returns the cache backend descriptor matching the given identifier if known.
527	*
528	* @returns VBox status code.
529	* @param pszBackend The backend identifier to look for.
530	* @param ppBackend Where to store the pointer to the backend descriptor on success.
531	*/
532	DECLHIDDEN(int) vdFindCacheBackend(const char pszBackend, PCVDCACHEBACKEND ppBackend)
533	{
534	int rc = VINF_SUCCESS;
535	PCVDCACHEBACKEND pBackend = NULL;
536
537	if (!g_apCacheBackends)
538	VDInit();
539
540	for (unsigned i = 0; i < g_cCacheBackends; i++)
541	{
542	if (!RTStrICmp(pszBackend, g_apCacheBackends[i]->pszBackendName))
543	{
544	pBackend = g_apCacheBackends[i];
545	break;
546	}
547	}
548	*ppBackend = pBackend;
549	return rc;
550	}
551
552
553	/**
554	* Returns the number of known filter backends.
555	*
556	* @returns Number of image formats known.
557	*/
558	DECLHIDDEN(uint32_t) vdGetFilterBackendCount(void)
559	{
560	return g_cFilterBackends;
561	}
562
563
564	/**
565	* Queries a filter backend descriptor by the index.
566	*
567	* @returns VBox status code.
568	* @param idx The index of the backend to query.
569	* @param ppBackend Where to store the pointer to the backend descriptor on success.
570	*/
571	DECLHIDDEN(int) vdQueryFilterBackend(uint32_t idx, PCVDFILTERBACKEND *ppBackend)
572	{
573	if (idx >= g_cFilterBackends)
574	return VERR_OUT_OF_RANGE;
575
576	*ppBackend = g_apFilterBackends[idx];
577	return VINF_SUCCESS;
578	}
579
580
581	/**
582	* Returns the filter backend descriptor matching the given identifier if known.
583	*
584	* @returns VBox status code.
585	* @param pszFilter The filter identifier to look for.
586	* @param ppBackend Where to store the pointer to the backend descriptor on success.
587	*/
588	DECLHIDDEN(int) vdFindFilterBackend(const char pszFilter, PCVDFILTERBACKEND ppBackend)
589	{
590	int rc = VINF_SUCCESS;
591	PCVDFILTERBACKEND pBackend = NULL;
592
593	for (unsigned i = 0; i < g_cFilterBackends; i++)
594	{
595	if (!RTStrICmp(pszFilter, g_apFilterBackends[i]->pszBackendName))
596	{
597	pBackend = g_apFilterBackends[i];
598	break;
599	}
600	}
601	*ppBackend = pBackend;
602	return rc;
603	}
604
605
606	/**
607	* Worker for VDPluginLoadFromFilename() and vdPluginLoadFromPath().
608	*
609	* @returns VBox status code.
610	* @param pszFilename The plugin filename to load.
611	*/
612	DECLHIDDEN(int) vdPluginLoadFromFilename(const char *pszFilename)
613	{
614	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
615	/* Plugin loaded? Nothing to do. */
616	if (vdPluginFind(pszFilename))
617	return VINF_SUCCESS;
618
619	RTLDRMOD hPlugin = NIL_RTLDRMOD;
620	int rc = SUPR3HardenedLdrLoadPlugIn(pszFilename, &hPlugin, NULL);
621	if (RT_SUCCESS(rc))
622	{
623	VDBACKENDREGISTER BackendRegister;
624	PFNVDPLUGINLOAD pfnVDPluginLoad = NULL;
625
626	BackendRegister.u32Version = VD_BACKENDREG_CB_VERSION;
627	BackendRegister.pfnRegisterImage = vdPluginRegisterImage;
628	BackendRegister.pfnRegisterCache = vdPluginRegisterCache;
629	BackendRegister.pfnRegisterFilter = vdPluginRegisterFilter;
630
631	rc = RTLdrGetSymbol(hPlugin, VD_PLUGIN_LOAD_NAME, (void**)&pfnVDPluginLoad);
632	if (RT_FAILURE(rc) \|\| !pfnVDPluginLoad)
633	{
634	LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnVDPluginLoad=%#p\n",
635	VD_PLUGIN_LOAD_NAME, pszFilename, rc, pfnVDPluginLoad));
636	if (RT_SUCCESS(rc))
637	rc = VERR_SYMBOL_NOT_FOUND;
638	}
639
640	if (RT_SUCCESS(rc))
641	{
642	/* Get the function table. */
643	rc = pfnVDPluginLoad(hPlugin, &BackendRegister);
644	}
645	else
646	LogFunc(("ignored plugin '%s': rc=%Rrc\n", pszFilename, rc));
647
648	/* Create a plugin entry on success. */
649	if (RT_SUCCESS(rc))
650	vdAddPlugin(hPlugin, pszFilename);
651	else
652	RTLdrClose(hPlugin);
653	}
654
655	return rc;
656	#else
657	RT_NOREF1(pszFilename);
658	return VERR_NOT_IMPLEMENTED;
659	#endif
660	}
661
662	/**
663	* Worker for VDPluginLoadFromPath() and vdLoadDynamicBackends().
664	*
665	* @returns VBox status code.
666	* @param pszPath The path to load plugins from.
667	*/
668	DECLHIDDEN(int) vdPluginLoadFromPath(const char *pszPath)
669	{
670	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
671	/* To get all entries with VBoxHDD as prefix. */
672	char pszPluginFilter = RTPathJoinA(pszPath, VD_PLUGIN_PREFIX "");
673	if (!pszPluginFilter)
674	return VERR_NO_STR_MEMORY;
675
676	PRTDIRENTRYEX pPluginDirEntry = NULL;
677	RTDIR hPluginDir;
678	size_t cbPluginDirEntry = sizeof(RTDIRENTRYEX);
679	int rc = RTDirOpenFiltered(&hPluginDir, pszPluginFilter, RTDIRFILTER_WINNT, 0 /fFlags/);
680	if (RT_SUCCESS(rc))
681	{
682	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
683	if (pPluginDirEntry)
684	{
685	while ( (rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK))
686	!= VERR_NO_MORE_FILES)
687	{
688	char *pszPluginPath = NULL;
689
690	if (rc == VERR_BUFFER_OVERFLOW)
691	{
692	/* allocate new buffer. */
693	RTMemFree(pPluginDirEntry);
694	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(cbPluginDirEntry);
695	if (!pPluginDirEntry)
696	{
697	rc = VERR_NO_MEMORY;
698	break;
699	}
700	/* Retry. */
701	rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
702	if (RT_FAILURE(rc))
703	break;
704	}
705	else if (RT_FAILURE(rc))
706	break;
707
708	/* We got the new entry. */
709	if (!RTFS_IS_FILE(pPluginDirEntry->Info.Attr.fMode))
710	continue;
711
712	/* Prepend the path to the libraries. */
713	pszPluginPath = RTPathJoinA(pszPath, pPluginDirEntry->szName);
714	if (!pszPluginPath)
715	{
716	rc = VERR_NO_STR_MEMORY;
717	break;
718	}
719
720	rc = vdPluginLoadFromFilename(pszPluginPath);
721	RTStrFree(pszPluginPath);
722	}
723
724	RTMemFree(pPluginDirEntry);
725	}
726	else
727	rc = VERR_NO_MEMORY;
728
729	RTDirClose(hPluginDir);
730	}
731	else
732	{
733	/* On Windows the above immediately signals that there are no
734	* files matching, while on other platforms enumerating the
735	* files below fails. Either way: no plugins. */
736	}
737
738	if (rc == VERR_NO_MORE_FILES)
739	rc = VINF_SUCCESS;
740	RTStrFree(pszPluginFilter);
741	return rc;
742	#else
743	RT_NOREF1(pszPath);
744	return VERR_NOT_IMPLEMENTED;
745	#endif
746	}
747
748	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
749	/**
750	* internal: scans plugin directory and loads found plugins.
751	*/
752	static int vdLoadDynamicBackends(void)
753	{
754	/*
755	* Enumerate plugin backends from the application directory where the other
756	* shared libraries are.
757	*/
758	char szPath[RTPATH_MAX];
759	int rc = RTPathAppPrivateArch(szPath, sizeof(szPath));
760	if (RT_FAILURE(rc))
761	return rc;
762
763	return vdPluginLoadFromPath(szPath);
764	}
765	#endif
766
767	/**
768	* Worker for VDPluginUnloadFromFilename() and vdPluginUnloadFromPath().
769	*
770	* @returns VBox status code.
771	* @param pszFilename The plugin filename to unload.
772	*/
773	DECLHIDDEN(int) vdPluginUnloadFromFilename(const char *pszFilename)
774	{
775	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
776	return vdRemovePlugin(pszFilename);
777	#else
778	RT_NOREF1(pszFilename);
779	return VERR_NOT_IMPLEMENTED;
780	#endif
781	}
782
783	/**
784	* Worker for VDPluginUnloadFromPath().
785	*
786	* @returns VBox status code.
787	* @param pszPath The path to unload plugins from.
788	*/
789	DECLHIDDEN(int) vdPluginUnloadFromPath(const char *pszPath)
790	{
791	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
792	/* To get all entries with VBoxHDD as prefix. */
793	char pszPluginFilter = RTPathJoinA(pszPath, VD_PLUGIN_PREFIX "");
794	if (!pszPluginFilter)
795	return VERR_NO_STR_MEMORY;
796
797	PRTDIRENTRYEX pPluginDirEntry = NULL;
798	RTDIR hPluginDir;
799	size_t cbPluginDirEntry = sizeof(RTDIRENTRYEX);
800	int rc = RTDirOpenFiltered(&hPluginDir, pszPluginFilter, RTDIRFILTER_WINNT, 0 /fFlags/);
801	if (RT_SUCCESS(rc))
802	{
803	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
804	if (pPluginDirEntry)
805	{
806	while ((rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK)) != VERR_NO_MORE_FILES)
807	{
808	char *pszPluginPath = NULL;
809
810	if (rc == VERR_BUFFER_OVERFLOW)
811	{
812	/* allocate new buffer. */
813	RTMemFree(pPluginDirEntry);
814	pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(cbPluginDirEntry);
815	if (!pPluginDirEntry)
816	{
817	rc = VERR_NO_MEMORY;
818	break;
819	}
820	/* Retry. */
821	rc = RTDirReadEx(hPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
822	if (RT_FAILURE(rc))
823	break;
824	}
825	else if (RT_FAILURE(rc))
826	break;
827
828	/* We got the new entry. */
829	if (!RTFS_IS_FILE(pPluginDirEntry->Info.Attr.fMode))
830	continue;
831
832	/* Prepend the path to the libraries. */
833	pszPluginPath = RTPathJoinA(pszPath, pPluginDirEntry->szName);
834	if (!pszPluginPath)
835	{
836	rc = VERR_NO_STR_MEMORY;
837	break;
838	}
839
840	rc = vdPluginUnloadFromFilename(pszPluginPath);
841	RTStrFree(pszPluginPath);
842	}
843
844	RTMemFree(pPluginDirEntry);
845	}
846	else
847	rc = VERR_NO_MEMORY;
848
849	RTDirClose(hPluginDir);
850	}
851	else
852	{
853	/* On Windows the above immediately signals that there are no
854	* files matching, while on other platforms enumerating the
855	* files below fails. Either way: no plugins. */
856	}
857
858	if (rc == VERR_NO_MORE_FILES)
859	rc = VINF_SUCCESS;
860	RTStrFree(pszPluginFilter);
861	return rc;
862	#else
863	RT_NOREF1(pszPath);
864	return VERR_NOT_IMPLEMENTED;
865	#endif
866	}
867
868
869	/**
870	* Initializes the plugin state to be able to load further plugins and populates
871	* the backend lists with the compiled in backends.
872	*
873	* @returns VBox status code.
874	*/
875	DECLHIDDEN(int) vdPluginInit(void)
876	{
877	int rc = vdAddBackends(NIL_RTLDRMOD, aStaticBackends, RT_ELEMENTS(aStaticBackends));
878	if (RT_SUCCESS(rc))
879	{
880	rc = vdAddCacheBackends(NIL_RTLDRMOD, aStaticCacheBackends, RT_ELEMENTS(aStaticCacheBackends));
881	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
882	if (RT_SUCCESS(rc))
883	{
884	RTListInit(&g_ListPluginsLoaded);
885	rc = vdLoadDynamicBackends();
886	}
887	#endif
888	}
889
890	return rc;
891	}
892
893
894	/**
895	* Tears down the plugin related state.
896	*
897	* @returns VBox status code.
898	*/
899	DECLHIDDEN(int) vdPluginTerm(void)
900	{
901	if (!g_apBackends)
902	return VERR_INTERNAL_ERROR;
903
904	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
905	if (g_pahFilterBackendPlugins)
906	RTMemFree(g_pahFilterBackendPlugins);
907	#endif
908	if (g_apFilterBackends)
909	RTMemFree(g_apFilterBackends);
910	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
911	if (g_ahCacheBackendPlugins)
912	RTMemFree(g_ahCacheBackendPlugins);
913	#endif
914	if (g_apCacheBackends)
915	RTMemFree(g_apCacheBackends);
916	RTMemFree(g_apBackends);
917
918	g_cBackends = 0;
919	g_apBackends = NULL;
920
921	/* Clear the supported cache backends. */
922	g_cCacheBackends = 0;
923	g_apCacheBackends = NULL;
924	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
925	g_ahCacheBackendPlugins = NULL;
926	#endif
927
928	/* Clear the supported filter backends. */
929	g_cFilterBackends = 0;
930	g_apFilterBackends = NULL;
931	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
932	g_pahFilterBackendPlugins = NULL;
933	#endif
934
935	#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
936	PVDPLUGIN pPlugin, pPluginNext;
937	RTListForEachSafe(&g_ListPluginsLoaded, pPlugin, pPluginNext, VDPLUGIN, NodePlugin)
938	{
939	RTLdrClose(pPlugin->hPlugin);
940	RTStrFree(pPlugin->pszFilename);
941	RTListNodeRemove(&pPlugin->NodePlugin);
942	RTMemFree(pPlugin);
943	}
944	#endif
945
946	return VINF_SUCCESS;
947	}
948
949
950	/**
951	* Returns whether the plugin related state is initialized.
952	*
953	* @returns true if the plugin state is initialized and plugins can be loaded,
954	* false otherwise.
955	*/
956	DECLHIDDEN(bool) vdPluginIsInitialized(void)
957	{
958	return g_apBackends != NULL;
959	}
960

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

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

Download in other formats: