pils.c

linux集群服务器软件代码包

 *	so they have gpointer arguments.  This *not necessarily* clause
 *	is why they do the g_hash_table_lookup_extended call instead of
 *	just deleting the key.  When called from outside, the key *
 *	may not be pointing at the key to actually free, but a copy
 *	of the key.
 */
static gboolean	/* IsA GHFunc: required for g_hash_table_foreach_remove() */
RmAPILPluginType
(	gpointer pitname	/* Name of this plugin type "real" key */
,	gpointer pitype	/* PILPluginType* */
,	gpointer notused
)
{
	PILPluginType*	Plugintype = pitype;

	g_assert(IS_PILPLUGINTYPE(Plugintype));
	PILValidatePluginType(pitname, pitype, NULL);
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "RmAPILPluginType(%s)"
		,	Plugintype->plugintype);
	}
	/*
	 * This function is usually but not always called by
	 * g_hash_table_foreach_remove()
	 */

	DelPILPluginType(pitype);
	DELETE(pitname);
	return TRUE;
} 
static void
RemoveAPILPluginType(PILPluginType*Plugintype)
{
	PILPluginUniv*	Pluginuniv = Plugintype->piuniv;
	gpointer	key;
	if (g_hash_table_lookup_extended(Pluginuniv->PluginTypes
	,	Plugintype->plugintype, &key, (void*)&Plugintype)) {

		g_hash_table_remove(Pluginuniv->PluginTypes, key);
		RmAPILPluginType(key, Plugintype, NULL);
	}else{
		g_assert_not_reached();
	}
}

/*
 *	InterfaceManager_plugin_init: Initialize the handling of
 *	"Interface Manager" interfaces.
 *
 *	There are a few potential bootstraiffng problems here ;-)
 *
 */
static PIL_rc
InterfaceManager_plugin_init(PILPluginUniv* univ)
{
	PILPluginImports* imports = univ->imports;
	PILPluginType*	pitype;
	PILInterface*	ifinfo;
	PILInterfaceType*	iftype;
	void*		dontcare;
	PILPlugin*	ifmgr_plugin;
	PIL_rc		rc;


	iftype = NewPILInterfaceType(univ->ifuniv, PI_IFMANAGER, &IfExports
	,	NULL);

	g_hash_table_insert(univ->ifuniv->iftypes
	,	g_strdup(PI_IFMANAGER), iftype);

	pitype = NewPILPluginType(univ, PI_IFMANAGER);

	g_hash_table_insert(univ->PluginTypes
	,	g_strdup(PI_IFMANAGER), pitype);

	ifmgr_plugin= NewPILPlugin(pitype, PI_IFMANAGER, NULL, NULL);

	g_hash_table_insert(pitype->Plugins
	,	g_strdup(PI_IFMANAGER), ifmgr_plugin);

	/* We can call register_plugin, since it doesn't depend on us... */
	rc = imports->register_plugin(ifmgr_plugin, &PluginExports);
	if (rc != PIL_OK) {
		PILLog(PIL_CRIT, "register_plugin() failed in init: %s"
		,	PIL_strerror(rc));
		return(rc);
	}
	/*
	 * Now, we're registering interfaces, and are into some deep
	 * Catch-22 if do it the "easy" way, since our code is
	 * needed in order to support interface loading for the type of
	 * interface we are (a Interface interface).
	 *
	 * So, instead of calling imports->register_interface(), we have to
	 * do the work ourselves here...
	 *  
	 * Since no one should yet be registered to handle Interface
	 * interfaces, we need to bypass the hash table handler lookup
	 * that register_interface would do and call the function that
	 * register_interface would call...
	 *
	 */

	/* The first argument is the PILInterfaceType* */
	ifinfo = NewPILInterface(iftype, PI_IFMANAGER, &IfExports
	,	close_ifmgr_interface, NULL, NULL);
	ifinfo->ifmanager = iftype->ifmgr_ref = ifinfo;
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "InterfaceManager_plugin_init(0x%lx/%s)"
		,	(unsigned long)ifinfo, ifinfo->interfacename);
	}
	PILValidatePluginUniv(NULL, univ, NULL);
	ifmgr_register_interface(ifinfo, &dontcare);
	PILValidatePluginUniv(NULL, univ, NULL);

	return(PIL_OK);
}/*InterfaceManager_plugin_init*/


/* Return current IfIf "plugin" version (not very interesting for us) */
static const char *
PIL_PILPluginVersion(void)
{
	return("1.0");
}

/* Return current IfIf debug level */
int
PILpisysGetDebugLevel(void)
{
	return(PluginDebugLevel);
}

/* Set current IfIf debug level */
void
PILpisysSetDebugLevel (int level)
{
	PluginDebugLevel = level;
}
struct set_debug_helper {
	const char *	pitype;
	const char *	piname;
	int		level;
};

static void
PILSetDebugLeveltoPlugin(gpointer key, gpointer plugin, gpointer Helper)
{
	PILPlugin*			p = plugin;
	struct set_debug_helper*	helper = Helper;

	p->pluginops->setdebuglevel(helper->level);  
}

static void
PILSetDebugLevelbyType(const void * key, gpointer plugintype, gpointer Helper)
{
	struct set_debug_helper* helper = Helper;
	
	
	PILPluginType*	t = plugintype;

	if (helper->piname == NULL) {
		g_hash_table_foreach(t->Plugins, PILSetDebugLeveltoPlugin
		,	helper);
	}else{
		PILPlugin*	p = g_hash_table_lookup(t->Plugins
		,	helper->piname);
		if (p != NULL) {
			p->pluginops->setdebuglevel(helper->level);  
		}
	}
}

void
PILSetDebugLevel(PILPluginUniv* u, const char * pitype, const char * piname
,	int level)
{
	struct set_debug_helper helper = {pitype, piname, level};

	if (u == NULL) {
		return;
	}

	if (pitype == NULL) {
		g_hash_table_foreach(u->PluginTypes
			/*
			 * Reason for this next cast:
			 * SetDebugLevelbyType takes const gpointer
			 * arguments, unlike a GHFunc which doesn't.
			 */
		,	(GHFunc)PILSetDebugLevelbyType
		,	&helper);
	}else{
		PILPluginType*	t = g_hash_table_lookup(u->PluginTypes
		,		pitype);
		if (t != NULL) {
			PILSetDebugLevelbyType(pitype, t, &helper);
		}
	}
}


int
PILGetDebugLevel(PILPluginUniv* u, const char * pitype, const char * piname)
{
	PILPluginType*	t;
	PILPlugin*	p;
	if (	u == NULL
	||	pitype == NULL
	||	(t = g_hash_table_lookup(u->PluginTypes, pitype)) == NULL
	||	(p = g_hash_table_lookup(t->Plugins, piname)) == NULL) {
		return -1;
	}
	return p->pluginops->getdebuglevel();
}

/* Close/shutdown our PILPlugin (the interface manager interface plugin) */
/* All our interfaces will have already been shut down and unregistered */
static void
PIL_PILPluginClose (PILPlugin* plugin)
{
}
static const char *
PIL_PILPluginLicense (void)
{
	return LICENSE_LGPL;
}
static const char *
PIL_PILPluginLicenseUrl (void)
{
	return URL_LGPL;
}

/*****************************************************************************
 *
 * This code is for managing interfaces, and interacting with them...
 *
 ****************************************************************************/


static PILInterface*
NewPILInterface(PILInterfaceType*	interfacetype
	,	const char*	interfacename
	,	void *		exports
	,	PILInterfaceFun	closefun
	,	void*		ud_interface
	,	PILPlugin*	loading_plugin)
{
	PILInterface*	ret = NULL;
	PILInterface*	look = NULL;


	if ((look = g_hash_table_lookup(interfacetype->interfaces
	,	interfacename)) != NULL) {
		PILLog(PIL_DEBUG, "Deleting PILInterface!");
		DelPILInterface(look);
	}
	ret = NEW(PILInterface);
	STATNEW(interface);
	ret->MagicNum = PIL_MAGIC_INTERFACE;
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "NewPILInterface(0x%x)", (unsigned long)ret);
	}

	if (ret) {
		ret->interfacetype = interfacetype;
		ret->exports = exports;
		ret->ud_interface = ud_interface;
		ret->interfacename = g_strdup(interfacename);
		ret->ifmanager = interfacetype->ifmgr_ref;
		ret->loadingpi = loading_plugin;
		g_hash_table_insert(interfacetype->interfaces
		,	g_strdup(ret->interfacename), ret);
		
		ret->if_close = closefun;
		ret->refcnt = 1;
		if (DEBUGPLUGIN) {
			PILLog(PIL_DEBUG, "NewPILInterface(0x%lx:%s/%s)*** user_data: 0x%lx *******"
			,	(unsigned long)ret
			,	interfacetype->typename
			,	ret->interfacename
			,	ud_interface);
		}
	}
	return ret;
}
static void
DelPILInterface(PILInterface* intf)
{
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "DelPILInterface(0x%lx/%s)"
		,	(unsigned long)intf, intf->interfacename);
	}
	STATFREE(interface);
	DELETE(intf->interfacename);
	ZAP(intf);
	DELETE(intf);
}

static PILInterfaceType*
NewPILInterfaceType(PILInterfaceUniv*univ, const char * typename
,	void* ifeports, void* user_data)
{
	PILInterfaceType*	ifmgr_types;
	PILInterface*	ifmgr_ref;
	PILInterfaceType*	ret = NEW(PILInterfaceType);


	STATNEW(interfacetype);
	ret->MagicNum = PIL_MAGIC_INTERFACETYPE;
	ret->typename = g_strdup(typename);
	ret->interfaces = g_hash_table_new(g_str_hash, g_str_equal);
	ret->ud_if_type = user_data;
	ret->universe = univ;
	ret->ifmgr_ref = NULL;

	/* Now find the pointer to our if type in the Interface Universe */
	if ((ifmgr_types = g_hash_table_lookup(univ->iftypes, PI_IFMANAGER))
	!=	NULL) {
		if ((ifmgr_ref=g_hash_table_lookup(ifmgr_types->interfaces
		,	typename)) != NULL) {
			ret->ifmgr_ref = ifmgr_ref;
		}else {
		      g_assert(strcmp(typename, PI_IFMANAGER) == 0);
		}
	}else {
		g_assert(strcmp(typename, PI_IFMANAGER) == 0);
	}

	/* Insert ourselves into our parent's table */
	g_hash_table_insert(univ->iftypes, g_strdup(typename), ret);
	return ret;
}
static void
DelPILInterfaceType(PILInterfaceType*ift)
{
	PILInterfaceUniv*	u = ift->universe;
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "DelPILInterfaceType(%s)"
		,	ift->typename);
	}
	STATFREE(interfacetype);

	PILValidateInterfaceUniv(NULL, u, NULL);

	/*
	 *	RmAPILInterface refuses to remove the interface for the
	 *	Interface manager, because it must be removed last.
	 *
	 *	Otherwise we won't be able to unregister interfaces
	 *	for other types of objects, and we'll be very confused.
	 */

	g_hash_table_foreach_remove(ift->interfaces, RmAPILInterface, NULL);

	PILValidateInterfaceUniv(NULL, u, NULL);

	if (g_hash_table_size(ift->interfaces) > 0) {
		gpointer	key, iftype;
		if (DEBUGPLUGIN) {
			PILLog(PIL_DEBUG
			,	"DelPILInterfaceType(%s): table size (%d)"
			,	ift->typename, g_hash_table_size(ift->interfaces));
		}
		if (g_hash_table_lookup_extended(ift->interfaces
		,	PI_IFMANAGER, &key, &iftype)) {
			DelPILInterface((PILInterface*)iftype);
			DELETE(key);
		}
	}
	DELETE(ift->typename);
	g_hash_table_destroy(ift->interfaces);
	ZAP(ift);
	DELETE(ift);
}

/*
 *	These RmA* functions primarily called from hash_table_foreach, 
 *	so they have gpointer arguments.  This *not necessarily* clause
 *	is why they do the g_hash_table_lookup_extended call instead of
 *	just deleting the key.  When called from outside, the key *
 *	may not be pointing at the key to actually free, but a copy
 *	of the key.
 */
static gboolean	/* IsAGHFunc: required for g_hash_table_foreach_remove() */
RmAPILInterface
(	gpointer ifname	/* Name of this interface */
,	gpointer intf	/* PILInterface* */
,	gpointer notused
)
{
	PILInterface*	If = intf;
	PILInterfaceType*	Iftype = If->interfacetype;

	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "RmAPILInterface(0x%lx/%s)"
		,	(unsigned long)If, If->interfacename);
	}
	g_assert(IS_PILINTERFACE(If));

	/*
	 * Don't remove the master interface manager this way, or
	 * Somebody will have a cow... 
	 */
	if (If == If->ifmanager) {
		if (DEBUGPLUGIN) {
			PILLog(PIL_DEBUG, "RmAPILInterface: skipping (%s)"
			,	If->interfacename);
		}
		return FALSE;
	}
	PILValidateInterface(ifname, If, Iftype);
	PILValidateInterfaceType(NULL, Iftype, NULL);

	/*
	 * This function is usually but not always called by
	 * g_hash_table_foreach_remove()
	 */

	PILunregister_interface(If);
	PILValidateInterface(ifname, If, Iftype);
	PILValidateInterfaceType(NULL, Iftype, NULL);
	DELETE(ifname);
	DelPILInterface(If);
	return TRUE;
}
static PIL_rc
RemoveAPILInterface(PILInterface* pif)
{
	PILInterfaceType*	Iftype = pif->interfacetype;
	gpointer		key;

	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "RemoveAPILInterface(0x%lx/%s)"
		,	(unsigned long)pif, pif->interfacename);
	}
	if (g_hash_table_lookup_extended(Iftype->interfaces
	,	pif->interfacename, &key, (void*)&pif)) {
		g_assert(IS_PILINTERFACE(pif));
		g_hash_table_remove(Iftype->interfaces, key);
		RmAPILInterface(key, pif, NULL);
	}else{
		g_assert_not_reached();
	}

	if (g_hash_table_size(Iftype->interfaces) == 0) {
		/* The generic plugin handler doesn't want us to
		 * delete it's types...
		 */
		if (Iftype->ifmgr_ref->refcnt <= 1) {
			RemoveAPILInterfaceType(Iftype, NULL);
		}
	}
	return PIL_OK;
}


/* Register a Interface Interface (Interface manager) */
static PIL_rc
ifmgr_register_interface(PILInterface* intf
,		void**	imports)
{
	PILInterfaceType*	ift = intf->interfacetype;
	PILInterfaceUniv*	ifuniv = ift->universe;
	PILInterfaceOps* ifops;	/* Ops vector for InterfaceManager */

	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG
		, 	"Registering Implementation manager for"
	       " Interface type '%s'"
		,	intf->interfacename);
	}

	ifops = intf->exports;
	if (ifops->RegisterInterface == NULL
	||	ifops->UnRegisterInterface == NULL)  {
		PILLog(PIL_DEBUG, "ifmgr_register_interface(%s)"
		": NULL exported function pointer"
		,	intf->interfacename);
		return PIL_INVAL;
	}

	*imports = &IFManagerImports;

	if(g_hash_table_lookup(ifuniv->iftypes, intf->interfacename) == NULL){
		/* It registers itself into ifuniv automatically */
		NewPILInterfaceType(ifuniv,intf->interfacename, &IfExports
		,	NULL);
	}
	return PIL_OK;
}

static gboolean
RemoveAllClients(PILInterface*interface, void * managerif)
{
	/*
	 * Careful!  We can't remove ourselves this way... 
	 * This gets taken care of as a special case in DelPILInterfaceUniv...
	 */
	if (managerif == interface) {
		return FALSE;
	}
	PILunregister_interface(interface);
	return TRUE;
}

/* Unconditionally unregister a interface manager (InterfaceMgr Interface) */
static PIL_rc
ifmgr_unregister_interface(PILInterface* interface)
{
	/*
	 * We need to unregister every interface we manage
	 */
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "ifmgr_unregister_interface(%s)"
		,	interface->interfacename);
	}

	IfForEachClientRemove(interface, RemoveAllClients, interface);
	return PIL_OK;
}

/*	Called to close the Interface manager for type Interface */
static PIL_rc
close_ifmgr_interface(PILInterface* us, void* ud_interface)
{
	if (DEBUGPLUGIN) {
		PILLog(PIL_DEBUG, "close_ifmgr_interface(%s)"
		,	us->interfacename);
	}
	/* Nothing much to do */
	return PIL_OK;
}

/* Return the reference count for this interface */
static int
IfRefCount(PILInterface * eifinfo)