DriverPlatform-V3.1/CDI/DriverManager.cpp

#include "common_api.h"
#include "DriverManager.h"
#include "DPC.h"
#include "CDI.h"
#include "DrvTree.h"
//#include "logger.h"
#include "LocalConfig.h"
#include "BusUnitClient.h"
#include "LogicDriver.h"
#include "HandleManager.h"
#include "PacketAnalizer.h"
#include <iostream>
#include "LogLocalHelper.h"       // 模块名接口声明（共用）
#include "Log4CPP.h"

typedef DriverDPC*  (*GetDriverDPC)();
typedef void(*ReleaseDriverDPC)(DriverDPC *p);

//extern Log4CPP::Logger* mLog::gLogger;

DriverManager g_DrvManager;

DriverHandle::DriverHandle()
{
	m_DllFileHandle = 0;

	m_pRootDevice = 0;
	m_pDynRootDevice = 0;

	m_pDPC = 0;

	m_HandleStatus = false;

	m_AsRootDriver = false;

	//m_pLog = CreateLogger();
	//m_pDynLog = CreateLogger();

	m_IsRootHandle = false;

	//m_pParent = NULL;
}


DriverHandle::~DriverHandle()
{
	UnloadDriver();
}

void DriverHandle::InitDynLogForDPC(DriverHandle *pParent)
{
	//log init
	//ResDataObject val;
	//string FullLogFileName;
	//if (pParent->m_DllFileTitle.size() > 0)
	//{
	//	m_DllFileTitle = pParent->m_DllFileTitle;
	//	FullLogFileName = m_DynLogPath + m_DllFileTitle + string(".log");
	//}
	//else
	//{
	//	FullLogFileName = m_DynLogPath + "drvlog.log";
	//}
	//m_pDynLog->SetLogFilepath(FullLogFileName.c_str());

	//if (pParent == NULL)
	//{
	//	if (TryGetValue(m_DrvConfig, "LOGLEVEL", val))
	//	{
	//		Logger_Pattern lp;
	//		m_pDynLog->GetLogPattern(lp);
	//		if (lp.SetLevel((LONG)val))
	//		{
	//			m_pDynLog->SetLogPattern(lp);
	//		}
	//	}

	//	//dpc logger
	//	m_pDPC->SetDynLogHandle(m_pDynLog);
	//}
	//else// if (pParent != this)
	//{
	//	if (m_pDPC)
	//	{
	//		LONG Level;
	//		Logger_Pattern lp;
	//		pParent->m_pLog->GetLogPattern(lp);
	//		Level = lp.m_Level;

	//		m_pDynLog->GetLogPattern(lp);
	//		lp.SetLevel(Level);
	//		m_pDynLog->SetLogPattern(lp);

	//		//dpc logger
	//		m_pDPC->SetDynLogHandle(m_pDynLog);

	//	}


	//}
}

void DriverHandle::InitLogForDPC(DriverHandle *pParent)
{

	//log init
	//ResDataObject val;
	//string FullLogFileName;

	//if (pParent == NULL)
	//{
	//	if (TryGetValue(m_DrvConfig, "LOGLEVEL", val))
	//	{
	//		Logger_Pattern lp;
	//		m_pLog->GetLogPattern(lp);
	//		if (lp.SetLevel((LONG)val))
	//		{
	//			m_pLog->SetLogPattern(lp);
	//		}
	//	}

	//	//dpc logger
	//	((DriverDPC*)m_pDPC)->SetLogHandle(m_pLog);
	//}
	////else if (pParent == this)
	////{

	////}
	//else
	//{
	//	if (pParent->m_DllFileTitle.size() > 0)
	//	{
	//		m_DllFileTitle = pParent->m_DllFileTitle;
	//		FullLogFileName = m_LogPath + m_DllFileTitle + string(".log");
	//	}
	//	else
	//	{
	//		FullLogFileName = m_LogPath + "drvlog.log";
	//	}
	//	m_pLog->SetLogFilepath(FullLogFileName.c_str());

	//	if (m_pDPC)
	//	{
	//		Logger_Pattern lp;
	//		pParent->m_pLog->GetLogPattern(lp);
	//		m_pLog->SetLogPattern(lp);

	//		//dpc logger
	//		((DriverDPC*)m_pDPC)->SetLogHandle(m_pLog);

	//	}


	//}
}

bool DriverHandle::GetThreadsLogger(DWORD ThreadId,PVOID &pLogger)
{
	//if (m_NotifyThread.GetTID() == ThreadId)
	//{
	//	pLogger = m_pLog;
	//	return true;
	//}

	return false;
}

bool DriverHandle::InitDynSubDriverObject()
{
	if (m_pDynRootDevice)
	{
		//loop drvtree
		size_t Size = m_pDynRootDevice->size();
		for (size_t i = 0; i < Size; i++)
		{
			DevTreeNode node = (*m_pDynRootDevice)[i];
			if (node.m_NodeType == TYPE_DRIVER)
			{
				LogicDriver *pDPC = (LogicDriver*)node.m_pObject;
				DriverHandle *pSubHandle = new DriverHandle();
				if (DynInitHandle(pSubHandle, pDPC))
				{
					m_DynSubDriverList.PushBack(pSubHandle);
				}
				else
				{
					return false;
				}

			}
		}

	}


	return true;
}

bool DriverHandle::InitSubDriverObject()
{
	FINFO("CDI  ");
	if (m_pRootDevice)
	{
		//loop drvtree
		size_t Size = m_pRootDevice->size();

		FINFO("CDI  ----- DriverHandle::InitSubDriverObject  {$} devices", Size);

		for (size_t i = 0; i < Size; i++)
		{
			DevTreeNode node = (*m_pRootDevice)[i];
			if (node.m_NodeType == TYPE_DRIVER)
			{
				FINFO("CDI  ----- DriverHandle::InitSubDriverObject InitHandle(pSubHandle, pDPC) again  {$}", (int)node.m_NodeType );
				LogicDriver*pDPC = (LogicDriver*)node.m_pObject;
				DriverHandle *pSubHandle = new DriverHandle();

				if (InitHandle(pSubHandle, pDPC))
				{
					m_hSubDriverList.PushBack(pSubHandle);
				}
				else
				{
					FINFO("CDI  ---- DriverHandle::InitSubDriverObject InitHandle(pSubHandle, pDPC) failed", (int)node.m_NodeType);

					return false;
				}

			}
			else {
				FINFO("CDI  ----- DriverHandle::InitSubDriverObject node.m_NodeType", (int)node.m_NodeType);
				
			}
		}

	}


	return true;
}

//这是一个嵌套函数，用的时候要小心
bool DriverHandle::DynInitHandle(DriverHandle *pSubHandle, LogicDriver*pDPC)
{
	bool ret = false;
	string procdir;

	if (m_pDynRootDevice != nullptr)
		return true;

	procdir = GetProcessDirectory();

	pSubHandle->m_pDPC = pDPC;
	std::cout << "CDI  ----- DriverHandle::DynInitHandle" << std::endl;
	FINFO("CDI  ----- DriverHandle::DynInitHandle");

	//Probe
	FINFO("Device_Probe ");
	if (pDPC->Device_Probe(pSubHandle->m_DynProbe))
	{
		FINFO("CDI  After Device_Probe");
		ResDataObject ProcDirRes;
		ProcDirRes = procdir.c_str();
		pSubHandle->m_DynWorkPath = (const char*)MakeWorkPath(pSubHandle->m_DynProbe, pSubHandle->m_Connection, ProcDirRes,true);
		pSubHandle->m_DynLogPath = (const char*)MakeWorkPath(pSubHandle->m_DynProbe, pSubHandle->m_Connection, ProcDirRes, false);
		if (pSubHandle->m_DynWorkPath.size() > 0)
		{
			pSubHandle->InitDynLogForDPC(this);
			if (pDPC->SetDeviceWorkPath(pSubHandle->m_DynWorkPath.c_str()))
			{
				FINFO("CDI pDPC->LoadLogicDevices ");
				PVOID pDevice = pDPC->LoadLogicDevices();
				if (pDevice)
				{
					pSubHandle->m_pDynRootDevice = (DevTree*)pDevice;

					//先假设驱动对象不能动态生成，只能以静态的形式存在！！！
					//do init Driver Object first
					//if (pSubHandle->InitDynSubDriverObject() == false)
					//{
					//	FERROR( "InitSubDriverObject Failed.\n");
					//	return false;
					//}

					FINFO("CDI  do init device Object second");
					//do init device Object second
					if (DynMakeDevicePaths())
					{
						FINFO("CDI  DynMakeDeviceSysIFsAndThreads");
						if (DynMakeDeviceSysIFsAndThreads())
						{
							return true;
						}
						else
						{
							//DWORD errNo = GetLastError();
							FERROR( "MakeDeviceSysIFsAndThreads Failed.ErrNo:{$}\n", dlerror());
							return false;
						}

					}
					else
					{
						//DWORD errNo = GetLastError();
						FERROR( "MakeDevicePaths Failed.ErrNo:{$}\n", dlerror());
						return false;
					}

				}

				//先假设驱动对象不能动态生成，只能以静态的形式存在！！！
				//为Sub对象 创建Driver线程和Notify线程
				//if (pSubHandle->DynMakeDriverPaths())
				//{
				//	if (pSubHandle->DynMakeDriverSysIFsAndThreads())
				//	{
				//		return true;
				//	}
				//	else
				//	{
				//		DWORD errNo = GetLastError();
				//		FERROR( "MakeDriverSysIFsAndThreads Failed.ErrNo:%d\n", errNo);
				//		return false;

				//	}
				//}
				//else
				//{
				//	DWORD errNo = GetLastError();
				//	FERROR( "MakeDriverPaths Failed.ErrNo:%d\n", errNo);
				//	return false;
				//}
			}
			else
			{
				//DWORD errNo = GetLastError();
				FERROR( "SetWorkPath Failed.ErrNo:{$}\n", dlerror());
			}
		}
		else
		{
			//DWORD errNo = GetLastError();
			FERROR( "Probe Info not right.ErrNo:{$}\n", dlerror());
		}
	}
	else
	{
		//DWORD errNo = GetLastError();
		FERROR( "Call Probe Failed.ErrNo:{$}\n", dlerror());
	}
	return false;

}



//这是一个嵌套函数，用的时候要小心
bool DriverHandle::InitHandle(DriverHandle *pSubHandle, LogicDriver*pDPC)
{
	bool ret = false;
	string procdir;
	procdir = GetProcessDirectory();
	//Logger *p = GetGlobalLogger();

	FINFO( "CDI  DriverHandle::InitHandle");
	std::cout << "CDI: DriverHandle::InitHandle" << std::endl;


	pSubHandle->m_pDPC = pDPC;
	//Probe
	std::cout << "CDI: First pDPC->Driver_Probe" << std::endl;
	FINFO("CDI  First pDPC->Driver_Probe");
	if (pDPC->Driver_Probe(pSubHandle->m_Probe))
	{
		std::cout << "CDI: After pDPC->Driver_Probe" << std::endl;
		FINFO("CDI  After pDPC->Driver_Probe");
		if (!m_AsRootDriver)
		{
			std::cout << "CDI: !m_AsRootDriver" << std::endl;
			FINFO("CDI  !m_AsRootDriver");
			GUID guid;
			string guidname;
			((LogicDriver*)m_pDPC)->GetDeviceType(guid);
			guid_2_string(guid, guidname);

			ResDataObject subpath;
			subpath = (guidname).c_str();
			string fullpath = MakeDevicePath(m_Probe, m_Connection, subpath).encode();
			string ccospath = MakeCcosPath(m_Probe, m_Connection, subpath, true).encode();
			//pDPC->SetEbusRoot(fullpath.c_str());
			pDPC->SetClientRootID(fullpath.c_str(), ccospath.c_str());
			std::cout << "CDI: pDPC->SetClientRootID fullpath:[" << fullpath
				<< "]  ccospath:[" << ccospath << "] use subpath["
				<< (const char*)subpath << "] Real CCOS path ["
				<< pDPC->GetCcosRootPath() << "]" << std::endl;
			FINFO("CDI pDPC->SetClientRootID fulpath:[{$}]  ccospath:[{$}] use subpath[{$}] Real CCOS path [{$}]", fullpath, ccospath, (const char*)subpath, pDPC->GetCcosRootPath());
			g_DrvManager.AddDevice(pDPC->GetCcosRootPath().c_str(), pDPC);
			g_DrvManager.AddDevice(pDPC->GetCcosAbstractPath().c_str(), pDPC);
		}


		std::cout << "CDI: SetWorkPath" << std::endl;
		FINFO("CDI  SetWorkPath");
		ResDataObject ProcDirRes;
		ProcDirRes = procdir.c_str();
		pSubHandle->m_WorkPath = (const char*)MakeWorkPath(pSubHandle->m_Probe, pSubHandle->m_Connection, ProcDirRes,true);
		pSubHandle->m_LogPath = (const char*)MakeWorkPath(pSubHandle->m_Probe, pSubHandle->m_Connection, ProcDirRes, false);
		if (pSubHandle->m_WorkPath.size() > 0)
		{
			pSubHandle->InitLogForDPC(this);
			if (pDPC->SetDriverWorkPath(pSubHandle->m_WorkPath.c_str()))
			{
				PVOID pDevice = NULL;
				if(pDPC->GetDPCType() == DPCDRIVER_NORMAL)
				{
					std::cout << "CDI: ----- DriverHandle::InitHandle DPCDRIVER_NORMAL" << std::endl;
					FINFO("CDI  ----- DriverHandle::InitHandle DPCDRIVER_NORMAL");
					
					pDevice = pDPC->LoadDriver(); //从DPC 上拿到设备树
					std::cout << "CDI: pDPC->LoadDriver over." << std::endl;
					FINFO("CDI  pDPC->LoadDriver over.");
				}
				else// if (pDPC->GetDPCType() == DPCDRIVER_MDPC)
				{
					std::cout << "CDI: ----- DriverHandle::InitHandle ??? DPCDRIVER_MDPC ??" << std::endl;
					FINFO("CDI  ----- DriverHandle::InitHandle ??? DPCDRIVER_MDPC ??");
					//no load driver method calling.
				}


				//Step1:do init subdriver first

				if (pDevice)
				{
					std::cout << "CDI: Got DevTree" << std::endl;
					FINFO("CDI  Got DevTree");
					pSubHandle->m_pRootDevice = (DevTree*)pDevice;

					//pDevice 以及有这个树上的子节点了
					for (int x = 0; x < pSubHandle->m_pRootDevice->size(); x++) {
						LogicDriver* pChild = (LogicDriver*)((*(pSubHandle->m_pRootDevice))[x].m_pObject);

						LogicDevice* pDevice = (LogicDevice*)((*(pSubHandle->m_pRootDevice))[x].m_pObject);

						std::cout << "CDI: " << x << " Node " << std::endl;

						FINFO("CDI  {$} Node ", x);
						//*/
						if (!m_AsRootDriver) {
							std::cout << "CDI: !m_AsRootDriver true" << std::endl;

							FINFO("CDI  !m_AsRootDriver true");

							//LogicDevice* pDevice = (LogicDevice*)pChild;
							GUID guid2;
							string guidname;
							//((LogicDevice*)pChild)->GetDeviceType(guid);
							pDevice->GetDeviceType(guid2);
							guid_2_string(guid2, guidname);

							ResDataObject subpath;
							subpath = (guidname).c_str();
							string fullpath = MakeDevicePath(m_Probe, m_Connection, subpath).encode();
							//pDevice->SetEbusRoot(fullpath.c_str());
							string ccospath = MakeCcosPath(m_Probe, m_Connection, subpath).encode();
							pDevice->SetClientRootID(fullpath.c_str(), ccospath.c_str());

							std::cout << "CDI: pDevice->SetClientRootID fullpath :[" << fullpath
								<< "]  ccos path [" << ccospath
								<< "]   Real CCOS path [" << pDevice->GetCcosRootPath() << "] " << std::endl;

							FINFO("CDI pDevice->SetClientRootID fullpath :[{$}]  ccos path [{$}]   Real CCOS path [{$}] ", fullpath, ccospath, pDevice->GetCcosRootPath());

							g_DrvManager.AddDevice(pDevice->GetCcosAbstractPath().c_str(), pDevice);
							g_DrvManager.AddDevice(pDevice->GetCcosRootPath().c_str(), pDevice);
						}
						else
						{
							string path = string(getRootpath());
							pDPC->SetClientRootID(path.c_str(), path.c_str() + 1);
							FINFO("CDI Bus pDPC->SetClientRootID fulpath:[{$}]  ccospath:[{$}] Real CCOS path [{$}]", path, path.c_str() + 1, pDPC->GetCcosRootPath());
							std::cout << "CDI: Bus pDPC->SetClientRootID fulpath:[" << path
								<< "]  ccospath:[" << (path.c_str() + 1)
								<< "] Real CCOS path [" << pDPC->GetCcosRootPath() << "]" << std::endl;
							const std::string& temppath = pDevice->GetCcosRootPath();
							if (!temppath.empty()) {
								g_DrvManager.AddDevice(temppath.c_str(), pDevice);
							}
							else {
								// 添加错误处理日志
								std::cerr << "ERROR: Empty path for device " << pDevice << std::endl;
							}
							std::cout << "CDI: ----- g_DrvManager.AddDevice over" << std::endl;
						}

						std::cout << "CDI: ----- pDPC->AddEbusChildren" << std::endl;
						pDPC->AddEbusChildren(pChild, pChild->GetRootPath().c_str());
						//*/
					}
					
					//do init Driver Object first 
					std::cout << "CDI: ----- DriverHandle::InitHandle DPCDRIVER_NORMAL" << std::endl;
					FINFO("CDI  ----- DriverHandle::InitHandle DPCDRIVER_NORMAL");
					if (pSubHandle->InitSubDriverObject() == false)
					{
						std::cout << "CDI: ----- DriverHandle::InitHandle  InitSubDriverObject Failed" << std::endl;
						std::cout << "InitSubDriverObject Failed." << std::endl;
						FINFO("CDI  ----- DriverHandle::InitHandle  InitSubDriverObject Failed");
						FERROR( "InitSubDriverObject Failed.\n");
						return false;
					}
				}

				//Step2:do init this driver second
				//为Sub对象 创建Driver线程和Notify线程
				
				if (pSubHandle->MakeDriverPaths())
				{
					if (pSubHandle->MakeDriverSysIFsAndThreads() == false)
					{
						int errNo = errno;  // Linux使用errno获取错误码
						std::cout << "CDI: ----- DriverHandle::InitHandle  MakeDriverSysIFsAndThreads Failed.ErrNo " << errNo
							<< " (" << strerror(errNo) << ")" << std::endl;  // strerror将错误码转为描述字符串
						std::cout << "MakeDriverSysIFsAndThreads Failed.ErrNo:" << errNo
							<< " (" << strerror(errNo) << ")" << std::endl;
						FINFO("CDI  ----- DriverHandle::InitHandle  MakeDriverSysIFsAndThreads Failed.ErrNo {$}", errNo);
						FERROR( "MakeDriverSysIFsAndThreads Failed.ErrNo:{$}\n", errNo);
						return false;

					}
				}
				else
				{
					int errNo = errno;
					std::cout << "CDI: ----- DriverHandle::InitHandle  MakeDriverPaths Failed.ErrNo " << errNo
						<< " (" << strerror(errNo) << ")" << std::endl;
					std::cout << "MakeDriverPaths Failed.ErrNo:" << errNo
						<< " (" << strerror(errNo) << ")" << std::endl;
					FINFO("CDI  ----- DriverHandle::InitHandle  MakeDriverPaths Failed.ErrNo {$}", errNo);

					FERROR( "MakeDriverPaths Failed.ErrNo:{$}\n", errNo);
					return false;
				}

				//Step3:do init sub devices third

				if (pDevice)
				{
					std::cout << "CDI: do init device Object second" << std::endl;
					FINFO("CDI  do init device Object second");
					//do init device Object second
					if (pSubHandle->MakeDevicePaths())
					{
						if (pSubHandle->MakeDeviceSysIFsAndThreads())
						{
							std::cout << "CDI: pSubHandle->MakeDeviceSysIFsAndThreads" << std::endl;
							FINFO("CDI  pSubHandle->MakeDeviceSysIFsAndThreads");
							return true;
						}
						else
						{
							int errNo = errno;
							std::cout << "CDI: ----- DriverHandle::InitHandle MakeDeviceSysIFsAndThreads Failed.ErrNo " << errNo
								<< " (" << strerror(errNo) << ")" << std::endl;
							std::cout << "MakeDeviceSysIFsAndThreads Failed.ErrNo:" << errNo
								<< " (" << strerror(errNo) << ")" << std::endl;
							//std::cout << "CDI ----- DriverHandle::InitHandle MakeDeviceSysIFsAndThreads Failed.ErrNo" << errNo << std::endl;
							FERROR( "MakeDeviceSysIFsAndThreads Failed.ErrNo:{$}\n", errNo);
							return false;
						}
					}
					else
					{
						int errNo = errno;
						std::cout << "CDI: ----- DriverHandle::InitHandle MakeDevicePaths Failed.ErrNo " << errNo
							<< " (" << strerror(errNo) << ")" << std::endl;
						std::cout << "MakeDevicePaths Failed.ErrNo:" << errNo
							<< " (" << strerror(errNo) << ")" << std::endl;
						//std::cout << "CDI ----- DriverHandle::InitHandle MakeDevicePaths Failed.ErrNo" << errNo << std::endl;
						FERROR( "MakeDevicePaths Failed.ErrNo:{$}\n", errNo);
						return false;
					}
				}
				return true;
			}
			else
			{
				int errNo = errno;
				std::cout << "CDI: ----- DriverHandle::InitHandle SetDriverWorkPath Failed.ErrNo " << errNo
					<< " (" << strerror(errNo) << ")" << std::endl;
				std::cout << "SetWorkPath Failed.ErrNo:" << errNo
					<< " (" << strerror(errNo) << ")" << std::endl;
				//std::cout << "CDI ----- DriverHandle::InitHandle" << errNo << std::endl;
				FERROR( "SetWorkPath Failed.ErrNo:{$}\n", errNo);
			}
		}
		else
		{
			int errNo = errno;
			std::cout << "CDI: ----- DriverHandle::InitHandle Probe Info not right.ErrNo " << errNo
				<< " (" << strerror(errNo) << ")" << std::endl;
			std::cout << "Probe Info not right.ErrNo:" << errNo
				<< " (" << strerror(errNo) << ")" << std::endl;
			//std::cout << "CDI ----- DriverHandle::InitHandle Probe Info not right.ErrNo" << errNo << std::endl;
			FERROR( "Probe Info not right.ErrNo:{$}\n", errNo);
		}
	}
	else
	{
		int errNo = errno;
		std::cout << "CDI: ----- DriverHandle::InitHandle Call Probe Failed.ErrNo " << errNo
			<< " (" << strerror(errNo) << ")" << std::endl;
		std::cout << "Call Probe Failed.ErrNo:" << errNo
			<< " (" << strerror(errNo) << ")" << std::endl;
		//std::cout << "CDI ----- DriverHandle::InitHandle Call Probe Failed.ErrNo" << errNo << std::endl;
		FERROR( "Call Probe Failed.ErrNo:{$}\n",errNo);
	}

	return false;
}

bool DriverHandle::IsDPCMatch(LogicDriver*pDriver)
{
	return (m_pDPC == pDriver);
}

/// <summary>
/// 驱动统一加载入口，使用DPC
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
bool DriverHandle::LoadDriver(ResDataObject &config)
{
	string procdir;
	string drvpath;
	string root;
	procdir = GetProcessDirectory();
	//Logger *p = GetGlobalLogger();
	FINFO("LoadDriver Begin \n");

	std::cout << "------------ CDI:  DriverHandle::LoadDriver ResDataObject"  << std::endl;
	try {
		//load drvpath
		m_DrvConfig = config["CONFIGURATION"];
		drvpath = (const char *)m_DrvConfig["driver"];
		root = (const char*)m_DrvConfig["MajorID"];
		string temp("%ROOT%");
		drvpath = ReplaceSubString(drvpath, temp, procdir);
		m_DllFileTitle = GetFileTitle(drvpath);
		string FilePath = GetFileDirectory(drvpath);
		AddEnvPath(FilePath.c_str());

		//oemdriver
		int oemidx = m_DrvConfig.GetFirstOf("oemdriver");
		if (oemidx >= 0)
		{
			//exist
			string oemdrvpath = (const char *)m_DrvConfig["oemdriver"];
			string temp("%ROOT%");
			oemdrvpath = ReplaceSubString(oemdrvpath, temp, procdir);
			FilePath = GetFileDirectory(oemdrvpath);
			AddEnvPath(FilePath.c_str());

			m_DrvConfig["oemdriver"] = oemdrvpath.c_str();
		}
		else
		{
			m_DrvConfig.add("oemdriver", "");
		}

		TryGetValue(m_DrvConfig, "connections", m_Connection);

		FINFO("GetDriver ok \n");
	}
	catch (ResDataObjectExption &exp)
	{
		//exp.what()
		FINFO( exp.what());
		FINFO( "Unknown Exp Happened while load drvfile:{$}\n", drvpath.c_str());
		return false;
	}
	catch (...)
	{
		FINFO("Unknown Exp Happened while load drvfile:{$}\n", drvpath.c_str());
		return false;
	}

	m_DllFileHandle = dlopen(drvpath.c_str(), RTLD_LAZY);

	std::cout << "CDI: LoadLibrary :"<< drvpath << std::endl;
	FINFO("CDI: LoadLibrary {$} ", drvpath.c_str());

	if (m_DllFileHandle)
	{
		std::cout << "load drvfile:" << drvpath << " OK" << std::endl;
		FINFO("load drvfile:{$} OK \n", drvpath.c_str());
		typedef LogicDriver* (*GetDriverDPC)();
		GetDriverDPC dpcfunc = (GetDriverDPC)dlsym(m_DllFileHandle, "GetDriverDPC");
		const char* dlsym_error = dlerror();
		if (!dlsym_error)
		{
			std::cout << "Successfully obtained 'GetDriverDPC' function address" << std::endl;
			FINFO("GetDriverDPC FUNC ADDR :{$} OK \n", drvpath.c_str());
			//第一次调用的是OemBusUint DPC 
			//第二次调用是真实的DPC，如ImageSave/NewModuleDPC
			m_pDPC =(LogicDriver*) dpcfunc();
			if (m_pDPC)
			{
				std::cout << "Successfully obtained driver instance from 'GetDriverDPC'" << std::endl;
				FINFO("GetDriverDPC CALL OK \n");
				//取到了DPC->LogicDriver的子类
				LogicDriver* pDriver = (LogicDriver*)m_pDPC;
				
				
				m_pDPC->SetDriverConfigFilePath(m_DriverConfigFilePath.c_str());
				//m_NotifyThread.m_pDPC = m_pDPC;//init dpc notify thread
				std::cout << "Calling DriverEntry with config: " << m_DrvConfig.encode() << std::endl;
				if (m_pDPC->DriverEntry(m_DrvConfig))
				{
					std::cout << "DriverEntry called successfully" << std::endl;
					FINFO("DriverEntry CALL OK \n");

					std::cout << "------------ CDI:  InitHandle start" << std::endl;
					InitLogForDPC(NULL);//for me
					if (InitHandle(this, m_pDPC))
					{
						FINFO("InitHandle CALL OK \n");

						m_HandleStatus = true;
						m_IsRootHandle = true;

						FINFO("LoadDriver Over \n");

						std::cout << "------------ CDI:  InitHandle ok" << std::endl;
						return true;
						//return InitLoadDynDriver();
					}
					std::cout << "------------ CDI:  InitHandle failed" << std::endl;
					FINFO("lib:{$} Load Driver Failed.\n", drvpath.c_str());
				}
				else
				{
					std::cerr << "DriverEntry failed: " << dlerror() << std::endl;
				}
			}
			else
			{
				std::cerr << "No DPC object returned: " << dlerror() << std::endl;
			}

		}
		else
		{
			std::cerr << "Cannot load symbol GetDriverDPC: " << dlsym_error << std::endl;
			dlclose(m_DllFileHandle);
			FINFO( "lib:{$} no GetDriverDPC entry.ErrNo:{$}\n", drvpath.c_str(), dlsym_error);
		}

	}
	else
	{
		std::cerr << "Cannot load library: " << dlerror() << std::endl;
		FINFO("Load lib:{$} fCannot load library:{$}\n", drvpath.c_str(), dlerror());
	}

	FINFO("CDI:  InitHandle fail\n");

	std::cerr << "CDI: InitHandle fail" << std::endl;
	return false;
}

//Process:x64,x32
//StartType:ignore
//LoadType:module, or new
//drvtype:lead,standalone,subsystem,device
//driver:dpcpath
//entrysource:xxx(it must load to memory)
//connection:connections
bool DriverHandle::LoadDriver(const char *pConfigFilepath, bool bCommonDPC)
{
	ResDataObject config;
	//Logger *p = GetGlobalLogger();

	m_bCommonDPC = bCommonDPC;
	//NOT FINISHED YET

	//ignore all other shit,focus on the drvpath
	std::cout << "------------ CDI:  DriverHandle::LoadDriver" << pConfigFilepath << std::endl;

	try {

		if (config.loadFile(pConfigFilepath) == false)
		{
			//log here
			return false;
		}

		m_DriverConfigFilePath = pConfigFilepath;

		//for file path
		//int idx = config["CONFIGURATION"].GetFirstOf("DRIVERCONFIGFILEPATH");
		//if (idx >= 0)
		//{
		//	config["CONFIGURATION"].update("DRIVERCONFIGFILEPATH", pConfigFilepath);
		//}
		//else
		//{
		//	config["CONFIGURATION"].add("DRIVERCONFIGFILEPATH", pConfigFilepath);
		//}


		return LoadDriver(config);

	}
	catch (ResDataObjectExption &exp)
	{
		cout << "What happpend " << exp.what() << endl;
		//exp.what()
		FERROR( exp.what());
	}
	catch (...)
	{
		FERROR( "Unknown Exp Happened\n");
	}



	
	return false;



}

void DriverHandle::MakeShortPaths(string stackpath, DevTree *pDevTree, map<string, vector<LogicDevice*>> &ShortpathMap)
{
	if (stackpath.size() > 0)
	{
		stackpath += "/";
	}
	stackpath += pDevTree->GetName();

	//loop drvtree
	size_t Size = pDevTree->size();
	for (size_t i = 0; i < Size; i++)
	{
		DevTreeNode node = (*pDevTree)[i];
		if (node.m_NodeType == TYPE_DEVICE)
		{
			GUID guid;
			string name;
			string shortname;
			LogicDevice *p = (LogicDevice *)node.m_pObject;
			p->GetDeviceType(guid);
			guid_2_string(guid, name);
			shortname = stackpath + string("/") + name;
			ShortpathMap[shortname].push_back(p);
		}
		else
		{
			//it's a tree
			MakeShortPaths(stackpath, (DevTree*)node.m_pObject, ShortpathMap);
		}
	}


}

bool DriverHandle::DynMakeDriverPaths()
{
	//assert(0);//NOT FINISHED YET
	return true;
}


bool DriverHandle::MakeDriverPaths()
{
	//assert(0);
	//子逻辑设备情况，会有多个设备，且有GUID重复的设备，所以需要map
	//GUID\1,GUID\2这种名字区分开来
	//但是驱动对象就只有一个，就是本驱动
	//路径是 本驱动::Probe+GUID
	//详细参照MakeDriverSysIFsAndThreads


	return true;
}

bool DriverHandle::DynMakeDevicePaths()
{
	if (m_pDynRootDevice)
	{
		map<string, vector<LogicDevice*>> ShortpathMap;

		//loop devtree
		size_t Size = m_pDynRootDevice->size();
		for (size_t i = 0; i < Size; i++)
		{
			DevTreeNode node = (*m_pDynRootDevice)[i];
			if (node.m_NodeType == TYPE_DEVICE)
			{
				GUID guid;
				string name;
				LogicDevice *p = (LogicDevice *)node.m_pObject;
				p->GetDeviceType(guid);
				guid_2_string(guid, name);
				ShortpathMap[name].push_back(p);
			}
			//else
			//{
			//	//it's a driver
			//	//the first level is equivalent to serialNo!!!!!
			//	// major/minor/vendor/product/[serialno]/guid
			//	MakeShortPaths(string(""), (DevTree*)node.m_pObject, ShortpathMap);
			//}
		}

		//loop shortpath
		map<string, vector<LogicDevice*>>::iterator iter = ShortpathMap.begin();
		while (iter != ShortpathMap.end())
		{
			if (iter->second.size() > 1)
			{
				//we have multiple same type devices in a raw
				for (size_t i = 0; i < iter->second.size(); i++)
				{
					string shortname = iter->first;
					shortname += "/";
					std::stringstream strm;
					strm << shortname << i;
					m_DynRootDeviceMap[strm.str()] = (iter->second)[i];
				}

			}
			else
			{
				m_DynRootDeviceMap[iter->first] = (iter->second)[0];
			}
			++iter;
		}

		return true;
	}

	return false;
}

bool DriverHandle::MakeDevicePaths()
{
	if (m_pRootDevice)
	{
		map<string, vector<LogicDevice*>> ShortpathMap;

		//loop devtree
		size_t Size = m_pRootDevice->size();
		for (size_t i = 0; i < Size; i++)
		{
			DevTreeNode node = (*m_pRootDevice)[i];
			if (node.m_NodeType == TYPE_DEVICE)
			{
				GUID guid;
				string name;
				LogicDevice *p = (LogicDevice *)node.m_pObject;
				p->GetDeviceType(guid);
				guid_2_string(guid, name);
				ShortpathMap[name].push_back(p);
			}
			//else
			//{
			//	//it's a driver
			//	//the first level is equivalent to serialNo!!!!!
			//	// major/minor/vendor/product/[serialno]/guid
			//	MakeShortPaths(string(""), (DevTree*)node.m_pObject, ShortpathMap);
			//}
		}

		//loop shortpath
		map<string, vector<LogicDevice*>>::iterator iter = ShortpathMap.begin();
		while (iter != ShortpathMap.end())
		{
			if (iter->second.size() > 1)
			{
				//we have multiple same type devices in a raw
				for (size_t i = 0; i < iter->second.size(); i++)
				{
					string shortname = iter->first;
					shortname += "/";
					std::stringstream strm;
					strm << shortname << i;
					m_RootDeviceMap[strm.str()] = (iter->second)[i];
				}

			}
			else
			{
				m_RootDeviceMap[iter->first] = (iter->second)[0];
			}
			++iter;
		}

		return true;
	}

	return false;
}

#define BusUnitGuidStr "{181F92D6-A546-4ACF-8EF1-2CCAA9EA974E}"

bool DriverHandle::DynMakeDriverSysIFsAndThreads()
{
	//ServerSysIF *pSys = new ServerSysIF();
	//if (pSys)
	{
		//update m_AddressMap
		//UINT64 addr = (UINT64)((LogicDeviceSysIF*)pSys);//be careful..it's changing!!!!
		//m_DynAddressMap[addr] = pSys;

		//bind sys <-> logic
		//((LogicDriver*)m_pDPC)->SetSysLogicDevice((LogicDeviceSysIF*)pSys);

		//pSys->SetLogicDevice(((LogicDriver*)m_pDPC));

		//make full device path
		GUID guid;
		string guidname;
		((LogicDriver*)m_pDPC)->GetDeviceType(guid);
		guid_2_string(guid, guidname);

		ResDataObject subpath;
		subpath = (guidname).c_str();
		string fullpath = MakeDevicePath(m_DynProbe, m_Connection, subpath).encode();
		string ccosfull = MakeCcosPath(m_DynProbe, m_Connection, subpath).encode();

		//map it
		m_DynDeviceFullPathMap[fullpath] = 0;// addr;
		m_CcosDynDeviceFullPathMap[ccosfull] = 0;

		//log config
		//((LogicDevice*)m_pDPC)->SetLogHandle(m_pLog);
		//m_NotifyThread.SetLogger(m_pDynLog);

		FINFO("Set Notify Thread used DPC fullpath [{$}] ccosfull [{$}]", fullpath, ccosfull);
		m_NotifyThread.SetDPC(m_pDPC);


		return true;

	}

	return false;
}


/// <summary>
/// 设置Driver的SysIF 和 Thread
/// </summary>
/// <returns></returns>
bool DriverHandle::MakeDriverSysIFsAndThreads()
{
	std::cout << "============== CDI : DriverHandle::MakeDriverSysIFsAndThreads" << std::endl;
	//ServerSysIF *pSys = new ServerSysIF();
	//if (pSys)
	{
		//update m_AddressMap
		//UINT64 addr = (UINT64)((LogicDeviceSysIF*)pSys);//be careful..it's changing!!!!
		//m_AddressMap[addr] = pSys;

		//bind sys <-> thread
		
		//bind sys <-> logic
		//((LogicDriver*)m_pDPC)->SetSysLogicDevice((LogicDeviceSysIF*)pSys);

		//pSys->SetLogicDevice(((LogicDriver*)m_pDPC));

		//make full device path
		GUID guid;
		string guidname;
		((LogicDriver*)m_pDPC)->GetDeviceType(guid);
		guid_2_string(guid, guidname);

		ResDataObject subpath;
		subpath = (guidname).c_str();
		string fullpath = MakeDevicePath(m_Probe, m_Connection, subpath).encode();
		string ccosfull = MakeCcosPath(m_Probe, m_Connection, subpath).encode();

		//map it
		m_DriverFullPathMap = fullpath;

		m_DeviceFullPathMap[fullpath] = 0; //addr; 原来是SysIF对象地址
		m_CcosDeviceFullPathMap[ccosfull] = 0;


		//m_NotifyThread.SetLogger(m_pLog);
		FINFO("Set Notify Thread used DPC fullpath [{$}] ccosfull [{$}]", fullpath, ccosfull);
		m_NotifyThread.SetDPC(m_pDPC);

		std::cout << "============== CDI : DriverHandle::MakeDriverSysIFsAndThreads  OK" << std::endl;
		return true;

	}
	std::cout << "============== CDI : DriverHandle::MakeDriverSysIFsAndThreads  Failed" << std::endl;
	return false;

}

bool DriverHandle::DynMakeDeviceSysIFsAndThreads()
{
	FINFO("CDI  DriverHandle::DynMakeDeviceSysIFsAndThreads");

	//loop m_DeviceFullPathMap,make SysIF and attach it to logicdevice
	//Dual_Driver_Thread *pMainThread = NULL;
	map<string, LogicDevice*>::iterator iter = m_DynRootDeviceMap.begin();
	while (iter != m_DynRootDeviceMap.end())
	{
		FINFO("CDI  DriverHandle::DynMakeDeviceSysIFsAndThreads {$}", iter->first);

		//ServerSysIF *pSys = new ServerSysIF();
		//if (pSys)
		{
			//update m_AddressMap
			
			//UINT64 addr = (UINT64)((LogicDeviceSysIF*)pSys);//be careful..it's changing!!!!
			//m_DynAddressMap[addr] = pSys;
			/*
			//bind sys <-> thread
			if (iter->second->GetDevice_Thread_Priority() == THREAD_PRIORITY_NONE)
			{
				if (pMainThread == NULL)
				{
					pMainThread = new Dual_Driver_Thread();
					pMainThread->SetLogger(m_pDynLog);
				}

				pSys->SetWorkThread(pMainThread->GetReqThread(), pMainThread->GetResThread());

				pMainThread->RegistSysIFObject((LogicDeviceSysIF*)pSys);
				m_DynThreadMap[pMainThread].push_back(addr);
			}
			else
			{
				//create a thread for the deivce
				Dual_Driver_Thread *pThread = new Dual_Driver_Thread();
				pThread->SetLogger(m_pDynLog);
				//NOT FINISHED YET
				//thread priority need to be set.

				pSys->SetWorkThread(pThread->GetReqThread(), pThread->GetResThread());
				pThread->RegistSysIFObject((LogicDeviceSysIF*)pSys);
				m_DynThreadMap[pThread].push_back(addr);


			}
			*/

			//bind sys <-> logic
			//iter->second->SetSysLogicDevice((LogicDeviceSysIF*)pSys);

			//pSys->SetLogicDevice(iter->second);

			//make full device path
			ResDataObject subpath;
			subpath = (iter->first).c_str();
			string fullpath = MakeDevicePath(m_DynProbe, m_Connection, subpath).encode();
			string ccospath = MakeCcosPath(m_Probe, m_Connection, subpath).encode();

			//map it
			GUID guid;
			string guidname;
			iter->second->GetDeviceType(guid);
			guid_2_string(guid, guidname);
			if (guidname == string(BusUnitGuidStr))
			{
				//it's root device

				fullpath = (const char*)getRootpath();
			}
			m_DynDeviceFullPathMap[fullpath] = 0;//  addr; 原来是SysIf的内存指针地址

			iter->second->SetClientRootID(fullpath.c_str(), ccospath.c_str());

			g_DrvManager.AddDevice(iter->second->GetCcosRootPath().c_str(), iter->second);
			g_DrvManager.AddDevice(iter->second->GetCcosAbstractPath().c_str(), iter->second);

			FINFO("CDI SetClientRootID dev {$} fullpath {$} ccospath {$}  Real CCOS path [{$}]", iter->first, fullpath, ccospath, iter->second->GetCcosRootPath());


			//log config
			//iter->second->SetLogHandle(m_pDynLog);


			//NOT FINISHED YET.
			//only device add succeed.no driver info here
			//这部分已经移到注册的地方，因为设备没有Ready,现在AddDevice有点太快.
			//((LogicDriver*)m_pDPC)->AddDevice(fullpath.c_str());


		}
		//else
		//{
		//	std::cout << "============== CDI : DriverHandle::DynMakeDeviceSysIFsAndThreads failed" << std::endl;
		//	//WTF?
		//	//log here
		//	return false;
		//}

		++iter;
	}
	FINFO("CDI  DriverHandle::DynMakeDeviceSysIFsAndThreads  ok");

	return true;

}

/// <summary>
/// 设置Device的SysIF 和 Thread
/// </summary>
/// <returns></returns>
bool DriverHandle::MakeDeviceSysIFsAndThreads()
{
	FINFO("CDI  DriverHandle::MakeDeviceSysIFsAndThreads ");

	//loop m_DeviceFullPathMap,make SysIF and attach it to logicdevice
	//Dual_Driver_Thread *pMainThread = NULL;
	map<string, LogicDevice*>::iterator iter = m_RootDeviceMap.begin();
	while (iter != m_RootDeviceMap.end())
	{
		FINFO("CDI  DriverHandle::MakeDeviceSysIFsAndThreads {$}", iter->first);

		//ServerSysIF *pSys = new ServerSysIF();
		//if (pSys)
		{
			//update m_AddressMap
			//UINT64 addr = (UINT64)((LogicDeviceSysIF*)pSys);//be careful..it's changing!!!!
			//m_AddressMap[addr] = pSys;

			/*
			//bind sys <-> thread
			if (iter->second->GetDevice_Thread_Priority() == THREAD_PRIORITY_NONE)
			{
				if (pMainThread == NULL)
				{
					pMainThread = new Dual_Driver_Thread();
					pMainThread->SetLogger(m_pLog);
				}

				pSys->SetWorkThread(pMainThread->GetReqThread(), pMainThread->GetResThread());

				pMainThread->RegistSysIFObject((LogicDeviceSysIF*)pSys);
				m_ThreadMap[pMainThread].push_back(addr);

			}
			else
			{
				//create a thread for the deivce
				Dual_Driver_Thread *pThread = new Dual_Driver_Thread();
				pThread->SetLogger(m_pLog);
				//NOT FINISHED YET
				//thread priority need to be set.

				pSys->SetWorkThread(pThread->GetReqThread(), pThread->GetResThread());
				pThread->RegistSysIFObject((LogicDeviceSysIF*)pSys);
				m_ThreadMap[pThread].push_back(addr);

			}
			*/

			//bind sys <-> logic
			//iter->second->SetSysLogicDevice((LogicDeviceSysIF*)pSys);

			//pSys->SetLogicDevice(iter->second);

			//make full device path
			ResDataObject subpath;
			subpath = (iter->first).c_str();
			string fullpath = MakeDevicePath(m_Probe, m_Connection, subpath).encode();
			string ccosfull = MakeCcosPath(m_Probe, m_Connection, subpath).encode();

			//map it
			GUID guid;
			string guidname;
			iter->second->GetDeviceType(guid);
			guid_2_string(guid, guidname);
			if (guidname == string(BusUnitGuidStr))
			{
				//it's root device
				
				fullpath = (const char*)getRootpath();
			}
			else {
				m_CcosDeviceFullPathMap[ccosfull] = 0;
			}
			m_DeviceFullPathMap[fullpath] = 0; // addr; 原来是SysIf对象地址指针

			FINFO("CDI m_DeviceFullPathMap[fullpath] = 0 fullpath {$} ccospath {$}", fullpath, ccosfull);

			//log config
			// 
			//iter->second->SetLogHandle(m_pLog);

			//NOT FINISHED YET.
			//only device add succeed.no driver info here
			//这部分已经移到注册的地方，因为设备没有Ready,现在AddDevice有点太快.
			//((LogicDriver*)m_pDPC)->AddDevice(fullpath.c_str());
			

		}
		//else
		//{
		//	std::cout << "============== CDI : DriverHandle::MakeDeviceSysIFsAndThreads failed" << std::endl;
		//	//WTF?
		//	//log here
		//	return false;
		//}

		++iter;
	}
	FINFO("CDI  DriverHandle::MakeDeviceSysIFsAndThreads ok");

	return true;


}

bool DriverHandle::DynStartWork()
{
	bool ret = false;

	//线程启动之前通知单元设备已经Ready
	//CompleteDynInit(true);

	return true;
	/*
	map<Dual_Driver_Thread*, vector<UINT64>>::iterator iter = m_DynThreadMap.begin();
	while (iter != m_DynThreadMap.end())
	{
		if (iter->first->StartThread() == false)
		{
			return ret;
		}
		iter++;
	}


	return true;*/

}

void DriverHandle::DynStopWork()
{
	/*
	bool ret = false;
	map<Dual_Driver_Thread*, vector<UINT64>>::iterator iter = m_DynThreadMap.begin();
	while (iter != m_DynThreadMap.end())
	{
		if (iter->first->StopThread() == false)
		{
			FINFO("{$} Drv:StopThread Used Terminate!!!!!!!!!!!!!!!", m_DllFileTitle.c_str());
		}
		iter++;

	}*/


	//线程Stop后通知单元设备要退出
	CompleteDynInit(false);

}

void DriverHandle::CompleteStaticInit(bool Init)
{
	FINFO("CDI  {$}", Init);
	//dpc first
	if (m_pDPC)
	{
		std::cout << "CDI  m_pDPC "<< std::endl;
		FINFO("CDI  m_pDPC ");
		if (Init)
		{
			((LogicDriver*)m_pDPC)->CompleteInit();
		}
		else
		{
			((LogicDriver*)m_pDPC)->CompleteUnInit();
		}

		std::cout << "CDI  Driver CompleteInit "<< Init << std::endl;
		FINFO("CDI  Driver CompleteInit {$}", Init);

		//init this 
		map<string, LogicDevice*>::iterator iter = m_RootDeviceMap.begin();
		while (iter != m_RootDeviceMap.end())
		{
			std::cout << "CDI  Try CompleteInit  "<< iter->first << std::endl;
			FINFO("CDI  Try CompleteInit {$}", iter->first);
			if (Init)
			{
				iter->second->CompleteInit();
			}
			else
			{
				iter->second->CompleteUnInit();
			}
			FINFO("CDI CompleteInit over.");

			++iter;
		}

		//sub drivers
		for (size_t i = 0; i < m_hSubDriverList.Size(); i++)
		{
			FINFO("CDI  m_hSubDriverList try CompleteStaticInit {$}", i);
			m_hSubDriverList[i]->CompleteStaticInit(Init);
		}

	}




}

void DriverHandle::CompleteDynInit(bool Init)
{
	FINFO("CDI  {$}", Init);
	//init this 
	map<string, LogicDevice*>::iterator iter = m_DynRootDeviceMap.begin();
	while (iter != m_DynRootDeviceMap.end())
	{

		std::cout << "CDI  Try Dyn CompleteInit " << iter->first << std::endl;
		FINFO("CDI  Try Dyn CompleteInit {$}", iter->first);

		if (Init)
		{
			iter->second->CompleteInit();
		}
		else
		{
			iter->second->CompleteUnInit();
		}

		++iter;
	}

	//sub drivers
	for (size_t i = 0; i < m_DynSubDriverList.Size(); i++)
	{
		FINFO("CDI  m_DynSubDriverList try CompleteStaticInit {$}", i);

		m_DynSubDriverList[i]->CompleteDynInit(Init);
	}


}


bool DriverHandle::StartWork()
{
	bool ret = true;
	FINFO("StartWork Begin with {$}", m_DllFileTitle);
	std::cout << "StartWork Begin with " << m_DllFileTitle << std::endl;
	//线程启动之前通知设备单元，初始化全部结束
	CompleteStaticInit(true);

	
	//工作线程在卸载动态单元的时候，会有Pause通知线程的操作.
	//如果工作线程太快，通知线程还没有启动，工作线程已经进入Pause流程，导致死循环.

	FINFO("CDI DriverHandle::StartWork m_NotifyThread.StartThread()");


	m_NotifyThread.SetName((m_DllFileTitle + "_DriverHandle::Notify").c_str());

	FINFO("Start NotifyThread");
	ret = m_NotifyThread.StartThread();//notify first
	FINFO("Start NotifyThread over with TID=[{$}]", m_NotifyThread.GetTID());

	/*
	map<Dual_Driver_Thread*, vector<UINT64>>::iterator iter = m_ThreadMap.begin();
	while (iter != m_ThreadMap.end())
	{
		printf("iter->first->StartThread() \n ");
		if (iter->first->StartThread() == false)
		{
			return false;
		}
		iter++;
	}*/


	//sub drivers
	if (ret)
	{
		for (size_t i = 0; i < m_hSubDriverList.Size(); i++)
		{
			FINFO("StartWork Start SubDriverList NotifyThread {$}", i);

			ret &= m_hSubDriverList[i]->StartWork();

			FINFO("StartWork Start SubDriverList Over NotifyThread {$}", i);
			if (ret == false)
			{
				return ret;
			}
		}
	}

	FINFO("StartWork Over with {$}" , m_DllFileTitle);

	return ret;

}

void DriverHandle::StopWork()
{
	bool ret = false;

	//map<Dual_Driver_Thread*, vector<UINT64>>::iterator iter = m_ThreadMap.begin();
	/*	while (iter != m_ThreadMap.end())
	{
		if (iter->first->StopThread() == false)
		{
			FINFO("{$} Drv:StopThread Used Terminate!!!!!!!!!!!!!!!", m_DllFileTitle.c_str());
		}
		iter++;

	}*/

	if (m_NotifyThread.StopThread() == false)
	{
		FINFO("{$} Drv:StopNotifyThread Used Terminate!!!!!!!!!!!!!!!", m_DllFileTitle.c_str());
	}

	CompleteStaticInit(false);


	//delete thread
	/*
	iter = m_ThreadMap.begin();
	while (iter != m_ThreadMap.end())
	{
		delete (iter->first);
		iter++;
	}*/
	FINFO("{$} Drv:delete Thread Done", m_DllFileTitle.c_str());

	FINFO("{$} Drv:StopThread Done", m_DllFileTitle.c_str());

}

bool DriverHandle::DynClearDriverHandles()
{
	vector<UINT64> ifList;
	DynGetSysIFList(ifList);
	g_HandleManager.ClearLocalDrvHandles(ifList);

	return true;

}

bool DriverHandle::ClearDriverHandles()
{
	vector<UINT64> ifList;
	GetSysIFList(ifList);
	g_HandleManager.ClearLocalDrvHandles(ifList);

	return true;
}

bool DriverHandle::LoadDynDriver()
{
	bool ret = false;
	DWORD timeout = INFINITE;
	string rootpath = "";

	//check connection first
	if (((LogicDriver*)m_pDPC)->GetConnectionStatus() == false)
	{
		FERROR( "DPC Connection is broken");

		//return ret;
	}

	//after connect succed
	if (m_AsRootDriver == false)
	{
		rootpath = (const char*)getRootpath();
		timeout = 2000;
	}
	else
	{
		rootpath = (const char*)getChannelRootpath();
	}

	//Get logic devices

	//make path & work path etc

	//make Threads

	//start dyn Threads
	m_NotifyThread.PauseThread();

	if (DynInitHandle(this, m_pDPC))
	{
		//if (DynRegistToRoot(rootpath.c_str(),timeout))
		//{
		//	return DynStartWork();
		//}

		ret = true;
	}

	m_NotifyThread.ResumeThread();

	return ret;
}



bool DriverHandle::UnloadDynDriver()
{
	m_NotifyThread.PauseThread();


	if (m_HandleStatus == true)
	{
		DynUnRegistFromRoot();//unregist from root
	}



	//stop thread
	DynStopWork();

	//clear HandleList
	if (DynClearDriverHandles() == false)
	{
		//put some log here
		FINFO("{$} Drv:Dyn Clear Handle Failed", m_DllFileTitle.c_str());
	}

	FINFO("{$} Drv:Unload DPC", m_DllFileTitle.c_str());

	if (m_pDPC)
	{
		//unload devices
		if (m_pDynRootDevice)
		{
			FINFO("{$} Drv:UnloadDriver", m_DllFileTitle.c_str());

			m_pDPC->UnloadLogicDevices();

			((LogicDriver*)m_pDPC)->DisConnect();

			m_pDynRootDevice = NULL;//suppose it deleted DPC::UnloadDriver
		}

	}


	//delete sysif
	//map<UINT64, ServerSysIF*>::iterator iter1 = m_DynAddressMap.begin();
	//while (iter1 != m_DynAddressMap.end())
	//{
	//	delete (iter1->second);
	//	iter1++;
	//}
	//FINFO("%s Drv:Dyn delete sysif Done", m_DllFileTitle.c_str());


	m_NotifyThread.ResumeThread();

	//

	//clear all maps
	m_DynDeviceFullPathMap.clear();



	m_DynRootDeviceMap.clear();
	//m_DynAddressMap.clear();
	//m_DynThreadMap.clear();// thread : DeviceSysIF[]

	FINFO("{$} Drv:UnloadDevice Done", m_DllFileTitle.c_str());

	return true;
}


bool DriverHandle::UnloadDriver()
{

	FINFO("UnloadDrv:{$}", m_DllFileTitle.c_str());

	//unload sub drivers
	for (size_t i = 0; i < m_hSubDriverList.Size(); i++)
	{
		delete m_hSubDriverList[i];
	}
	m_hSubDriverList.Clear();

	UnloadDynDriver();

	if (m_HandleStatus == true)
	{
		// root驱动卸载过程中，把自己从Channel卸载，
		//这个操作因为在自我毁灭过程中进行，所以已经处于加锁状态.
		//因为加锁，外部命令无法反馈到当前驱动模块.
		//
		if (m_AsRootDriver == false)
		{
			UnRegistFromRoot();//unregist from root
		}

	}

	//stop thread
	StopWork();

	//clear HandleList
	if (ClearDriverHandles() == false)
	{
		//put some log here
		FINFO("{$} Drv:Clear Handle Failed", m_DllFileTitle.c_str());
	}

	FINFO( "{$} Drv:Unload DPC", m_DllFileTitle.c_str());

	if (m_pDPC)
	{
		//unload devices
		if (m_pRootDevice /* || m_pDPC->GetDPCType() == DPCDRIVER_MDPC*/)
		{
			FINFO( "{$} Drv:UnloadDriver", m_DllFileTitle.c_str());

			m_pDPC->UnloadDriver();

			m_pRootDevice = NULL;//suppose it deleted DPC::UnloadDriver
		}


		//disconnect
		//m_pDPC->DisConnect();
		//FINFO( "{$} Drv:DisConnectDPC Done", m_DllFileTitle.c_str());

		//only root DPC needs to be deleted
		if (m_IsRootHandle)
		{
			//unload dpc
			ReleaseDriverDPC dpcfunc = (ReleaseDriverDPC)dlsym(m_DllFileHandle, "ReleaseDriverDPC");
			if (dpcfunc)
			{
				dpcfunc(m_pDPC);
				FINFO("{$} Drv:ReleaseDPC Done", m_DllFileTitle.c_str());

			}

		}
		//else
		//{
		//	delete m_pDPC;//不要擅自删除DPC,非ROOT DPC让驱动自行删除.
		//}

		//FreeLibrary(m_DllFileHandle);

		m_pDPC = NULL;

	}


	//delete sysif
	//map<UINT64, ServerSysIF*>::iterator iter1 = m_AddressMap.begin();
	//while (iter1 != m_AddressMap.end())
	//{
	//	//delete (iter1->second);
	//	iter1++;
	//}
	//FINFO( "{$} Drv:delete sysif Done", m_DllFileTitle.c_str());



	//clear all maps
	m_DllFileHandle = NULL;

	m_pRootDevice = NULL;

	m_pDPC = NULL;

	m_Probe.clear();
	m_Connection.clear();

	m_WorkPath = "";

	m_DeviceFullPathMap.clear();
	m_CcosDeviceFullPathMap.clear();
	m_CcosDynDeviceFullPathMap.clear();

	m_RootDeviceMap.clear();
	//m_AddressMap.clear();
	//m_ThreadMap.clear();// thread : DeviceSysIF[]

	//if (m_pLog)
	//{
	//	ReleseLogger(m_pLog);
	//	m_pLog = NULL;
	//}


	m_HandleStatus = false;
	FINFO( "{$} Drv:UnloadDriver Done", m_DllFileTitle.c_str());

	return true;

}

bool DriverHandle::RegistToRoot(const char* RootPath, DWORD timeout)
{
	BusUnitClient rootclient("DriverHandle_regroot");
	
	FINFO("Begain [{$}]", RootPath);
	//sublist first
	for (size_t i = 0; i < m_hSubDriverList.Size(); i++)
	{
		if (m_hSubDriverList[i]->RegistToRoot(RootPath, timeout) == false)
		{
			FERROR("RegistToRoot Failed [{$}]", RootPath);
			return false;
		}
	}

	//me second
	if (rootclient.Open(RootPath, ACTION, timeout) == false)
	{
		FERROR("Open Failed [{$}]", RootPath);
		//printf("Thread:%d,Open Failed\n", GetCurrentThreadId());
		return false;
	}

	if (rootclient.GetExitFlag() == 0)
	{
		map<string, UINT64>::iterator iter = m_DeviceFullPathMap.begin();
		while (iter != m_DeviceFullPathMap.end())
		{
			string path = iter->first;
			UINT64 procId = (UINT64)getpid();
			UINT64 addr = iter->second;
			string TargetType = "Device";
			if (iter->first == m_DriverFullPathMap)
			{
				TargetType = "Driver";
			}
			//regist driver
			FINFO("AddDeviceDescrpt [{$}] Try [{$}]", RootPath, path);
			RET_STATUS ret = (RET_STATUS)rootclient.AddDeviceDescrpt(path.c_str(), TargetType.c_str(),(const char*)getLocalMachineId(), procId, addr);

			if (ret == RET_FAILED)
			{
				FERROR("AddDeviceDescrpt [{$}] Failed [{$}]", RootPath, path);
				//log here
				//try updadate this driver handle
				//assert(0);//NOT FINISHED YET

				//unhook it
				map<string, UINT64>::iterator iterBk = m_DeviceFullPathMap.begin();
				while (iterBk != iter)
				{
					if (rootclient.DelDeviceDescrpt(iterBk->first.c_str()) != RET_SUCCEED)
					{
						//log here
						//shit on going!!!!
						rootclient.Close();
						return false;
					}
					++iterBk;
				}

				rootclient.Close();
				return false;
			}
			else if (ret == RET_INVALID)
			{
				return false;
			}

			++iter;
		}
		// Ccos PATH
		iter = m_CcosDeviceFullPathMap.begin();
		while (iter != m_CcosDeviceFullPathMap.end())
		{
			string path = iter->first;
			UINT64 procId = (UINT64)getpid();
			UINT64 addr = iter->second;
			string TargetType = "Device";
			if (iter->first == m_DriverFullPathMap)
			{
				TargetType = "Driver";
			}
			//regist driver
			RET_STATUS ret = (RET_STATUS)rootclient.AddDeviceDescrpt(path.c_str(), TargetType.c_str(), (const char*)getLocalMachineId(), procId, addr);

			if (ret == RET_FAILED)
			{
				//log here
				//try updadate this driver handle
				//assert(0);//NOT FINISHED YET
				FERROR("AddDeviceDescrpt [{$}] Failed [{$}]", RootPath, path);
				//unhook it
				map<string, UINT64>::iterator iterBk = m_CcosDeviceFullPathMap.begin();
				while (iterBk != iter)
				{
					if (rootclient.DelDeviceDescrpt(iterBk->first.c_str()) != RET_SUCCEED)
					{
						//log here
						//shit on going!!!!
						rootclient.Close();
						return false;
					}
					++iterBk;
				}

				rootclient.Close();
				return false;
			}
			else if (ret == RET_INVALID)
			{
				return false;
			}

			++iter;
		}
	}

	rootclient.Close();

	RegistToDrvObject(false,true);//后执行，保证Regist成功
	FINFO("End of Success. [{$}]", RootPath);

	return true;

}

void DriverHandle::RegistToDrvObject(bool dyn, bool regist)
{
	map<string, UINT64>::iterator iter;
	if (dyn)
	{
		iter = m_DynDeviceFullPathMap.begin();
		while (iter != m_DynDeviceFullPathMap.end())
		{
			string path = iter->first;
			//regist driver
			if (regist)
			{
				((LogicDriver*)m_pDPC)->AddDevice(path.c_str());
			}
			else
			{
				((LogicDriver*)m_pDPC)->DelDevice(path.c_str());
			}

			++iter;
		}
	}
	else
	{
		/*
		if (m_pParent)
		{
			//mdpc parent exist,this is SubDPC object
			string path = m_DriverFullPathMap;

			//regist DPC2MDPC
			if (regist)
			{
				((LogicDriver*)m_pParent)->AddDevice(path.c_str());
			}
			else
			{
				((LogicDriver*)m_pParent)->DelDevice(path.c_str());
			}

		}*/

		//go normal
		iter = m_DeviceFullPathMap.begin();
		while (iter != m_DeviceFullPathMap.end())
		{
			string path = iter->first;
			if (m_DriverFullPathMap == path)
			{
				//exept it's own driver
				++iter;
				continue;
			}
			//regist driver
			if (regist)
			{
				((LogicDriver*)m_pDPC)->AddDevice(path.c_str());
			}
			else
			{
				((LogicDriver*)m_pDPC)->DelDevice(path.c_str());
			}

			++iter;
		}



	}


}


bool DriverHandle::DynRegistToRoot(const char* RootPath, DWORD timeout)
{
	BusUnitClient rootclient("DriverHandle_dyn_reg");

	//me second
	if (rootclient.Open(RootPath, ACTION, timeout) == false)
	{
		std::cout << "Thread:" << GetCurrentThreadId() << ", Open RootPath failed. Path: " << RootPath << ", Timeout: " << timeout << std::endl;
		return false;
	}

	if (rootclient.GetExitFlag() == 0)
	{
		map<string, UINT64>::iterator iter = m_DynDeviceFullPathMap.begin();
		while (iter != m_DynDeviceFullPathMap.end())
		{
			string TargetType = "Device";
			string path = iter->first;
			UINT64 procId = (UINT64)getpid();
			UINT64 addr = iter->second;
			//regist driver
			if (rootclient.AddDeviceDescrpt(path.c_str(), TargetType.c_str(),(const char*)getLocalMachineId(), procId, addr) != RET_SUCCEED)
			{
				//log here
				//unhook it
				std::cout << "Thread:" << GetCurrentThreadId() << ", Starting rollback for m_DynDeviceFullPathMap. Current path: " << path << std::endl;
				map<string, UINT64>::iterator iterBk = m_DynDeviceFullPathMap.begin();
				while (iterBk != iter)
				{
					if (rootclient.DelDeviceDescrpt(iterBk->first.c_str()) != RET_SUCCEED)
					{
						//log here
						//shit on going!!!!
						std::cout << "Thread:" << GetCurrentThreadId() << ", Failed to rollback device. Path: " << iterBk->first << ". Critical error!" << std::endl;
						rootclient.Close();
						return false;
					}
					++iterBk;
				}

				rootclient.Close();
				return false;
			}

			++iter;
		}
		iter = m_CcosDynDeviceFullPathMap.begin();
		while (iter != m_CcosDynDeviceFullPathMap.end())
		{
			string TargetType = "Device";
			string path = iter->first;
			UINT64 procId = (UINT64)getpid();
			UINT64 addr = iter->second;
			//regist driver
			if (rootclient.AddDeviceDescrpt(path.c_str(), TargetType.c_str(), (const char*)getLocalMachineId(), procId, addr) != RET_SUCCEED)
			{
				std::cout << "Thread:" << GetCurrentThreadId() << ", Failed to register Ccos device. Path: " << path << std::endl;
				//log here
				//unhook it
				map<string, UINT64>::iterator iterBk = m_CcosDynDeviceFullPathMap.begin();
				while (iterBk != iter)
				{
					if (rootclient.DelDeviceDescrpt(iterBk->first.c_str()) != RET_SUCCEED)
					{
						//log here
						//shit on going!!!!
						rootclient.Close();
						return false;
					}
					++iterBk;
				}

				rootclient.Close();
				return false;
			}

			++iter;
		}


	}

	rootclient.Close();

	RegistToDrvObject();//后执行，保证Regist成功


	return true;
}

bool DriverHandle::DynUnRegistFromRoot()
{
	DWORD timeout = 0;
	string rootpath;
	BusUnitClient rootclient("DriverHandle_UnReg");

	RegistToDrvObject(true,false);//先执行，不管unregist成功与否

	if (m_AsRootDriver == false)
	{
		rootpath = (const char*)getRootpath();
		timeout = 2000;
	}
	else
	{
		//rootpath = (const char*)getChannelRootpath();
		return true;//DriverManager中已经卸载了Root在Channel中的东西
	}

	if (m_AsRootDriver)
	{
		timeout = 2000;
	}
	else
	{
		timeout = INFINITE;
	}

	if (rootclient.Open(rootpath.c_str(), ACTION, timeout) == false)
	{
		//printf("Thread:%d,Open %s Failed\n", GetCurrentThreadId(), rootpath.c_str());
		return false;
	}
	map<string, UINT64>::iterator iter = m_DynDeviceFullPathMap.begin();
	while (iter != m_DynDeviceFullPathMap.end())
	{
		string path = iter->first;
		//regist driver
		if (rootclient.DelDeviceDescrpt(path.c_str()) != RET_SUCCEED)
		{
			//log here
			rootclient.Close();
			return false;
		}

		++iter;
	}
	iter = m_CcosDynDeviceFullPathMap.begin();
	while (iter != m_CcosDynDeviceFullPathMap.end())
	{
		string path = iter->first;
		//regist driver
		if (rootclient.DelDeviceDescrpt(path.c_str()) != RET_SUCCEED)
		{
			//log here
			rootclient.Close();
			return false;
		}

		++iter;
	}
	rootclient.Close();


	return true;
}


bool DriverHandle::UnRegistFromRoot()
{
	DWORD timeout = 0;
	string rootpath;
	BusUnitClient rootclient("DriverHandle_unregroot");

	RegistToDrvObject(false, false);//先执行，不管unregist成功与否

	if (m_AsRootDriver == false)
	{
		rootpath = (const char*)getRootpath();
		timeout = 2000;
	}
	else
	{
		rootpath = (const char*)getChannelRootpath();
	}

	if (m_AsRootDriver)
	{
		timeout = 2000;
	}
	else
	{
		timeout = INFINITE;
	}

	if (rootclient.Open(rootpath.c_str(), ACTION, timeout) == false)
	{
		//printf("Thread:%d,Open %s Failed\n", GetCurrentThreadId(),rootpath.c_str());
		return false;
	}
	map<string, UINT64>::iterator iter = m_DeviceFullPathMap.begin();
	while (iter != m_DeviceFullPathMap.end())
	{
		string path = iter->first;
		//regist driver
		if (rootclient.DelDeviceDescrpt(path.c_str()) != RET_SUCCEED)
		{
			//log here
			rootclient.Close();
			return false;
		}

		++iter;
	}

	rootclient.Close();


	return true;
}

void DriverHandle::DynGetSysIFList(vector<UINT64> &ifList)
{

}

void DriverHandle::GetSysIFList(vector<UINT64> &ifList)
{

}



//------------drv manager---------------------------

DriverManager::DriverManager()
{
	m_pRootDrvHandle = NULL;
}


DriverManager::~DriverManager()
{
	if (m_pRootDrvHandle == NULL)
		return;
	UnloadDrivers();
	UnloadRootDriver();
}

bool DriverManager::UnRegistFromChannel(DWORD timeout)
{
	string RootPath;
	string ChannelPath;

	BusUnitClient rootclient("DriverManager_unreg");

	RootPath = (const char *)getRootpath();

	ChannelPath = (const char*)getChannelRootpath();

	if (RootPath == ChannelPath)
	{
		return false;
	}

	if (rootclient.Open(ChannelPath.c_str(), ACTION, timeout) == false)
	{
		//printf("Thread:%d,Open %s Failed\n", GetCurrentThreadId(), ChannelPath.c_str());
		return false;
	}

	if (rootclient.DelDeviceDescrpt(RootPath.c_str()) != RET_SUCCEED)
	{
		//log here
		rootclient.Close();
		return false;
	}



	rootclient.Close();


	return true;

}


void DriverManager::UnloadRootDriver()
{
	UnRegistFromChannel(500);

	FINFO("UnRegistFromChannel Fnished");

	Thread_Lock();
	if (m_pRootDrvHandle)
	{
		FINFO("Unload Root Driver Begin");
		//vector<UINT64> ifList;
		//m_pRootDrvHandle->GetSysIFList(ifList);
		//UpdateSysIF(ifList,true);

		delete m_pRootDrvHandle;
		m_pRootDrvHandle = NULL;

		FINFO("Unload Root Driver Done");

	}

	Thread_UnLock();

}

void DriverManager::UnloadDrivers()
{
	while (1)
	{
		DriverHandle* pHandle = NULL;
		Thread_Lock();
		vector<DriverHandle*>::iterator iter = m_SubDriverList.begin();
		if (iter != m_SubDriverList.end())
		{
			pHandle = (*iter);
			iter = m_SubDriverList.erase(iter);
			break;
		}
		Thread_UnLock();

		if (pHandle == NULL)
		{
			break;
		}

		//unload one
		UnloadDynDrvHandle(pHandle);

		UnloadDrvHandle(pHandle);

	}





}


bool DriverManager::DynLoadDriver(DriverHandle *pDrv)
{
	std::cout << "DriverManager::DynLoadDriver IN" << std::endl;
	bool ret = false;
	const char *pRoot = getRootpath();
	//新流程如下.

	//先注册
	if (pDrv->DynRegistToRoot(pRoot) && pDrv->DynStartWork())
	{
		//后插入DPC
		DynAddDriver(pDrv);

		ret = true;
	}
	


	if (ret == false)
	{
		UnloadDynDrvHandle(pDrv);
	}

	return ret;

}


bool DriverManager::DynDriverInitLoadAll()
{
	Thread_Lock();
	int x = 0;
	//auto it = m_SubDriverList.begin();
	//while (it != m_SubDriverList.end()) {
	//	(*it)->InitLoadDynDriver();
	//	it++;
	//	x++;
	//}
	FINFO("Begin");
	std::cout << "DriverManager::DynDriverInitLoadAll m_SubDriverList.size:  " << m_SubDriverList.size() << std::endl;
	for (; x < m_SubDriverList.size(); x++)
	{
		std::cout << "SubDriverList InitLoadDynDriver  " << x << std::endl;
		FINFO("SubDriverList InitLoadDynDriver {$}",x );
		m_SubDriverList[x]->InitLoadDynDriver();
		FINFO("SubDriverList InitLoadDynDriver {$} over.", x);
		std::cout << "SubDriverList InitLoadDynDriver  " << x << " over"<<std::endl;
	}
	FINFO("End");
	Thread_UnLock();
	return true;
}

void DriverManager::DynAddDriver(DriverHandle *pDrv)
{
	std::cout << "DriverManager::DynAddDriver IN" << std::endl;
	Thread_Lock();
	//vector<UINT64> IFList;
	//pDrv->DynGetSysIFList(IFList);
	//UpdateSysIF(IFList);
	for (int x = 0; x < m_SubDriverList.size(); x++)
	{
		if (pDrv == m_SubDriverList[x])
			return;
	}
	m_SubDriverList.push_back(pDrv);
	std::cout << "DriverManager::DynAddDriver m_SubDriverList.push_back->size:" << m_SubDriverList.size() << std::endl;
	Thread_UnLock();
}

void DriverManager::AddDriver(DriverHandle *pDrv)
{
	std::cout << "DriverManager::AddDriver IN" << std::endl;
	Thread_Lock();
	//vector<UINT64> IFList;
	//pDrv->GetSysIFList(IFList);
	//UpdateSysIF(IFList);
	for (int x = 0; x < m_SubDriverList.size(); x++)
	{
		if (pDrv == m_SubDriverList[x])
			return;
	}
	m_SubDriverList.push_back(pDrv);
	std::cout << "DriverManager::AddDriver m_SubDriverList.push_back->size:"<< m_SubDriverList.size() << std::endl;
	Thread_UnLock();
}



bool DriverManager::GetThreadsLogger(DWORD Tid, PVOID &pLogger)
{
	Thread_Lock();
	for (size_t i = 0; i < m_SubDriverList.size(); i++)
	{
		if (m_SubDriverList[i]->GetThreadsLogger(Tid, pLogger))
		{
			Thread_UnLock();
			return true;
		}
	}

	if (m_pRootDrvHandle)
	{
		if (m_pRootDrvHandle->GetThreadsLogger(Tid, pLogger))
		{
			Thread_UnLock();
			return true;
		}
	}

	Thread_UnLock();
	return false;
}

bool DriverManager::UpdateRootDrvStatus(int Status)
{
	std::cout << "UpdateRootDrvStatus IN" << std::endl;
	bool ret = true;
	if (m_pRootDrvHandle)
	{
		BusUnitClient rootclient("DriverManager_UpdateRootDrvStatus");

		if (rootclient.Open(getRootpath(), ACTION) == false)
		{
			std::cout << "Thread:" << GetCurrentThreadId() << ",Open Failed" << std::endl;
			return false;
		}

		if (rootclient.SetDeviceStatus(Status) != RET_SUCCEED)
		{
			std::cout << "Thread:" << GetCurrentThreadId() << ",SetDeviceStatus Failed" << std::endl;
			//printf("Thread:%d,SetDeviceStatus Failed\n", GetCurrentThreadId());
			ret = false;
		}
		rootclient.Close();
		std::cout << "Thread:" << GetCurrentThreadId() << ",SetDeviceStatus Succeed" << std::endl;
		//printf("Thread:%d,SetDeviceStatus Succeed\n", GetCurrentThreadId());
	}

	return ret;

}

void DriverManager::AddDevice(const char* devUri, LogicDevice* pDevice)
{
	std::cout << "Add Device " << devUri<<" with "<< pDevice->GetCcosRootPath()<< endl;
	FINFO("Add Device {$} with {$}", devUri, pDevice->GetCcosRootPath());
	m_CcosDeviceMap[devUri] = pDevice;
}

const char* DriverManager::GetAllDevice(void** pDevices, int& nDevNums)
{
	m_strAllDeviceUri = "";
	auto it = m_CcosDeviceMap.begin();
	nDevNums = 0;
	if (pDevices == nullptr) {
		return m_strAllDeviceUri.c_str();
	}
	while (it != m_CcosDeviceMap.end())
	{
		if (nDevNums >= 30) {
			std::cout << "Warning: Device count exceeds max limit (" << 30 << ")" << std::endl;
			break;
		}
		m_strAllDeviceUri += it->first + ";";
		pDevices[nDevNums++] = it->second;
		it++;
	}
	return m_strAllDeviceUri.c_str();
}

bool DriverManager::LoadRootDrv()
{
	//get busid
	string busId = (const char*)getLocalEbusId();
	if (busId.size() == 0)
	{
		//some log here
		return false;
	}

	//load drv
	DriverHandle *pHandle = new DriverHandle();
	pHandle->m_AsRootDriver = true;//need to set this
	string path = GetProcessDirectory() + "/" + "rootdrv.xml";
	if (pHandle->LoadDriver(path.c_str(), false))
	{
		//load succeed
		//printf("Load %s succeed\n", path.c_str());

		
		//Load only device,not include driver .!!!!!!

		//hook it to tree
		map<string, UINT64>::iterator iter = pHandle->m_DeviceFullPathMap.begin();
		while (iter != pHandle->m_DeviceFullPathMap.end())
		{
			string path = iter->first;
			UINT64 procId = (UINT64)getpid();
			UINT64 addr = iter->second;
			if (path == string(getRootpath()))
			{
				//make tree node
				if (g_DrvTree.AddTree(path.c_str(), procId, addr))
				{
					//done

					//save it
					m_pRootDrvHandle = (pHandle);

					//
					LogicDriver *driver = m_pRootDrvHandle->GetDpcDriver();
					driver->SetTreeRoot(true);
					driver->SetClientRootID(path.c_str(), path.c_str()+1);
					std::cout << "driver SetClientRootID  Real CCOS path ["
						<< path << "] from ["
						<< driver->GetCcosRootPath() << "]" << std::endl;
					FINFO("driver SetClientRootID  Real CCOS path [{$}] ", path, driver->GetCcosRootPath());
					//driver->SubscribeSelf(); //这个是OemBusUnit对象，可以支持Open

					//start it
					{
						//这里有个瑕疵：
						//Driver带着一个Device加载，但是Driver意义不大，故在AddTree中过滤掉.
						//但是SysIF中是带着Driver的地址的....

						//vector<UINT64> ifList;
						//m_pRootDrvHandle->GetSysIFList(ifList);
						//UpdateSysIF(ifList);

						return m_pRootDrvHandle->StartWork();
					}
				}

			}

			++iter;

		}

	}
	//printf("Load %s failed\n", path.c_str());

	delete pHandle;

	return false;

}

bool DriverManager::LoadDrv(ResDataObject &ConfigContext)
{
	//NOT FINISHED YET
	assert(0);

	return false;
}


bool DriverManager::LoadDriver(const char *pConfigFilepath)
{
	bool ret = false;
	DriverHandle *pHandle = new DriverHandle();
	string path = pConfigFilepath;
	std::cout << "------------ CDI:  DriverManager::LoadDriver" << pConfigFilepath << std::endl;
	if (pHandle->LoadDriver(path.c_str(), true))
	{
		//load succeed
		const char *pRoot = getRootpath();

		
		//save it
		AddDriver(pHandle);//这点比较闹心，已经注册到系统，所以...

		LogicDriver *pRootDriver = m_pRootDrvHandle->GetDpcDriver();
		LogicDriver* pClientDriver = pHandle->GetDpcDriver();
		
		pRootDriver->AddEbusChildren(pClientDriver, pClientDriver->GetRootPath().c_str());

		//pHandle->get
		//start it
		ret = pHandle->StartWork();
		if (ret)
		{
			//regist to tree
			ret = pHandle->RegistToRoot(pRoot);
		}

		if (ret == false)
		{
			//所以得先卸载from系统，然后再清除...
			UnloadDrvHandle(pHandle);
		}

	}
	else
	{
		delete pHandle;
	}


	return ret;
}


bool DriverManager::UnloadDynDrvHandle(DriverHandle *pHandle)
{
	bool ret = false;
	if (pHandle)
	{
		Thread_Lock();
		{
			//kick the SysIF from the map
			//vector<UINT64> ifList;
			//pHandle->DynGetSysIFList(ifList);
			//UpdateSysIF(ifList, true);

			pHandle->UnloadDynDriver();

			ret = true;
		}
		Thread_UnLock();



	}

	return ret;
}

bool DriverManager::UnloadDrvHandle(DriverHandle *pHandle)
{
	bool ret = false;
	if (pHandle)
	{
		Thread_Lock();

		vector<DriverHandle*>::iterator iter = find(m_SubDriverList.begin(), m_SubDriverList.end(), pHandle);

		if (iter != m_SubDriverList.end())
		{
			//do unload work
			//kick it from list
			m_SubDriverList.erase(iter);

			//kick the SysIF from the map
			//vector<UINT64> ifList;
			//pHandle->GetSysIFList(ifList);
			//UpdateSysIF(ifList, true);

			ret = true;
		}
		Thread_UnLock();

		//kick the logicdevice from root
		delete pHandle;
		//if (pHandle->UnloadDriver() == false)
		//{
		//	//put some log here
		//}



	}

	return ret;
}



//return next try tick
bool DriverHandle::InitLoadDynDriver()
{
	bool ret = true;

	if (!m_bCommonDPC)
		return true;

	LogicDevice* pDevice = m_pDPC;
	if (pDevice)
	{
		LogicDriver* pDriver = (LogicDriver*)pDevice;

		//check connection
		//if (pDriver->GetConnectionStatus())
		//{
		//	//ok 
		//	return false;
		//}

		//makesure it's disconnected
		//if (m_pDrvHandle)
		{
			//FINFO("Try UnloadDynDrv ");
			//UnloadDynDriver();
			//if (g_DrvManager.UnloadDynDrvHandle(this))
			{
				//do the connection
				FINFO("Try Connect ");
				//if (pDriver->Connect())
				bool bret = pDriver->Connect();
				FINFO("Try LoadDynDriver with Connect Result ={$} ", bret);
				//if(bret)
				{
					//do load logicdevices
					if (LoadDynDriver())
					{
						FINFO("Try DrvManager::DynLoadDriver ");
						if (g_DrvManager.DynLoadDriver(this))
						{
							//ok
							FINFO("Try AutomaticConnect Succeed");

							return true;
						}
						FERROR("Try DrvManager::DynLoadDriver Failed");
					}
					else
					{
						UnloadDynDriver();
					}


					//report error here
					FERROR("Try LoadDynDriver Failed");
					pDriver->DisConnect();
					return false;
				}
			}
		}
	}

	return false;

}