VDPlugin.cpp@ 69839

Last change on this file since 69839 was 69753, checked in by vboxsync, 7 years ago
iprt/dir: Morphing PRTDIR into a handle named RTDIR. (Been wanting to correct this for years. Don't know why I makde it a pointer rather than an abstrct handle like everything else.)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.1 KB

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

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

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

Download in other formats: