cmpilocalprovidermanager.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#include "CMPI_Version.h"

#include <Pegasus/Common/Constants.h>
#include <Pegasus/Common/Time.h>
#include <Pegasus/Common/Tracer.h>
#include <Pegasus/Common/PegasusVersion.h>

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/ProviderManager2/CMPI/CMPIProvider.h>
#include <Pegasus/ProviderManager2/CMPI/CMPIProviderModule.h>
#include <Pegasus/ProviderManager2/CMPI/CMPILocalProviderManager.h>

PEGASUS_USING_STD;
PEGASUS_NAMESPACE_BEGIN
#define DDD(X)   if (_cmpi_trace) X;

extern int _cmpi_trace;

#undef IDLE_LIMIT
#define IDLE_LIMIT 50

/* Thread deletion specific */
Semaphore CMPILocalProviderManager::_pollingSem(0);
AtomicInt CMPILocalProviderManager::_stopPolling(0);
Thread *CMPILocalProviderManager::_reaperThread = 0;
List<CMPILocalProviderManager::cleanupThreadRecord,Mutex> CMPILocalProviderManager::_finishedThreadList;
Mutex CMPILocalProviderManager::_reaperMutex;

  CMPILocalProviderManager::CMPILocalProviderManager (void):
_idle_timeout (IDLE_LIMIT)
{
}

CMPILocalProviderManager::~CMPILocalProviderManager (void)
{
  Uint32 ccode;

  _provider_ctrl (UNLOAD_ALL_PROVIDERS, this, &ccode);
  // Since all of the providers are deleted we can delete the 
  //  modules too.
  for (ModuleTable::Iterator j = _modules.start (); j != 0; j++)
    {
      CMPIProviderModule *module = j.value ();
      delete module;
    }

  if (_reaperThread) 
    {
		AutoMutex lock(_reaperMutex);
  		_stopPolling++;
  		_pollingSem.signal();
  		// Wait until it finishes itself.
 		_reaperThread->join(); 
  		delete _reaperThread; 
		_reaperThread = 0;
  	}
 PEGASUS_ASSERT(_finishedThreadList.size() == 0);

}

Sint32
CMPILocalProviderManager::_provider_ctrl (CTRL code, void *parm, void *ret)
{

  static Uint32 quantum;
  PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, "_provider_ctrl");

  Sint32 ccode = 0;
  CTRL_STRINGS *parms = reinterpret_cast < CTRL_STRINGS * >(parm);

  switch (code)
    {

    case GET_PROVIDER:
      {

        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::GET_PROVIDER");

        String providerName = *(parms->providerName);
        String moduleFileName = *(parms->fileName);
        String location = *(parms->location);

        CMPIProvider *pr = 0;
        CMPIProvider::OpProviderHolder * ph =
          reinterpret_cast < CMPIProvider::OpProviderHolder * >(ret);

        pr = _lookupProvider (providerName);

        if (pr->getStatus () != CMPIProvider::INITIALIZED)
          {
            pr->setLocation (location);
            _initProvider (pr, moduleFileName);

            if (pr->getStatus () != CMPIProvider::INITIALIZED)
              {
                PEG_METHOD_EXIT ();
                throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED,
                                             "provider initialization failed");
              }
          }


        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                          "Returning Provider" + providerName);


        ph->SetProvider (pr);
        ph->GetProvider ().update_idle_timer ();
        break;
      }

    case UNLOAD_PROVIDER:
      {

        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::UNLOAD_PROVIDER");
        CMPIProvider *pr = 0;
	pr = _lookupProvider (*(parms->providerName));
        if ((pr->getStatus () == CMPIProvider::INITIALIZED))
          {

            PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                              "Unloading CMPIProvider: " + pr->getName());

            AutoMutex lock (_providerTableMutex);
            // The provider table must be locked before unloading. 
            _providers.remove (pr->_name);
            _unloadProvider (pr);
            delete pr;

          }
	    else {
			// No need to have a memory leak.
			_providers.remove(pr->_name);
			delete pr;
		}
        break;
      }

    case LOOKUP_PROVIDER:
      {

        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::LOOKUP_PROVIDER");

        AutoMutex lock (_providerTableMutex);

        if (true == _providers.lookup (*(parms->providerName),
                                       *(reinterpret_cast <
                                         CMPIProvider * *>(ret))))
          {
            PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                              "Found CMPIProvider in cache: " +
                              *(parms->providerName));

            (*(reinterpret_cast < CMPIProvider * *>(ret)))->
              update_idle_timer ();
          }
        else
          {

            PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                              "Could not find  CMPIProvider in cache: " +
                              *(parms->providerName));
            ccode = -1;
          }

        break;
      }

    case LOOKUP_MODULE:
      {

        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::LOOKUP_MODULE");

        AutoMutex lock (_providerTableMutex);

        if (false == _modules.lookup (*(parms->fileName),
                                      *(reinterpret_cast <
                                        CMPIProviderModule * *>(ret))))
          {
            PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                              "Could not find  CMPIProvider Module in cache: "
                              + *(parms->fileName));
            ccode = -1;
          }

        break;
      }

    case INSERT_PROVIDER:
      {

        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::INSERT_PROVIDER");

        AutoMutex lock (_providerTableMutex);
	
        if (false == _providers.insert (*(parms->providerName),
                                        *reinterpret_cast <
                                        CMPIProvider * *>(parm)))
          ccode = -1;
        break;
      }
    case INSERT_MODULE:
      {
        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::INSERT_MODULE");
        AutoMutex lock (_providerTableMutex);
        if (false == _modules.insert (*(parms->fileName),
                                      *reinterpret_cast <
                                      CMPIProviderModule * *>(parm)))
          ccode = -1;
        break;
      }

    case UNLOAD_ALL_PROVIDERS:
      {
        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::UNLOAD_ALL_PROVIDERS");
        CMPILocalProviderManager *myself =
          reinterpret_cast < CMPILocalProviderManager * >(parm);
        CMPIProvider *provider = 0;
        // Locked provider mutex.
        AutoMutex lock (_providerTableMutex);

        Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                       "providers in cache = %d", myself->_providers.size ());
        ProviderTable::Iterator i = myself->_providers.start ();
        try
        {
          for (; i != 0; i++)
            {

              provider = i.value ();
              PEGASUS_ASSERT (provider != 0);
              if (provider->getStatus () == CMPIProvider::UNINITIALIZED)
                {
                  // Delete the skeleton.
		delete provider;
                  continue;
                }
              else
                {
                  _unloadProvider (provider);
                  delete provider;
                }
            }
          // All the providers are removed. Clear the hash-table
          _providers.clear ();
        }
        catch (...)
        {
          PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                            "Unexpected Exception in UNLOAD_ALL_PROVIDERS.");
        }
        break;
      }
    case UNLOAD_IDLE_PROVIDERS:
      {
        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                          "_provider_ctrl::UNLOAD_IDLE_PROVIDERS");
        AutoMutex lock (_providerTableMutex);

        quantum++;
        CMPILocalProviderManager *myself =
          reinterpret_cast < CMPILocalProviderManager * >(parm);
        CMPIProvider *provider = 0;
        Uint32 numProviders = myself->_providers.size ();

        if (numProviders)
          {
            // Rather than removing the provider immediately while
            // iterating through the list we remember all candidates
            // for unload in a simple array.
            CMPIProvider **unloadProviderArray =
              new CMPIProvider *[numProviders];
            Uint32 upaIndex = 0;

            try
            {
              struct timeval now;
              Time::gettimeofday (&now);
              ProviderTable::Iterator i = myself->_providers.start ();

              for (; i != 0; i++)
                {
                  provider = i.value ();
                  PEGASUS_ASSERT (provider != 0);

                  if (provider->getStatus () == CMPIProvider::UNINITIALIZED)
                    {
                      continue;
                    }

                  if (provider->_quantum == quantum)