void CEsperEngine::MsgEsperRead (const SArchonMessage &Msg)
// MsgEsperRead
//
// Requests a read on the given connection. If we fail, we return an error
// to the caller.
{
CDatum dConnection = Msg.dPayload.GetElement(0);
CString sError;
if (!m_Connections.BeginRead(Msg, dConnection, &sError))
{
SendMessageReplyError(MSG_ERROR_UNABLE_TO_COMPLY, strPattern(ERR_READ_FAILED, sError), Msg);
if (m_bLogTrace)
LogTrace(strPattern("[%x] Read failed: %s", CEsperInterface::ConnectionToFriendlyID(dConnection), sError));
return;
}
#ifdef DEBUG_SOCKET_OPS
if (m_bLogTrace)
LogTrace(strPattern("[%x] Read", CEsperInterface::ConnectionToFriendlyID(dConnection)));
#endif
// We reply when the async operation completes (or we get an error).
}
bool TCPServer::Listen(int port)
{
LogTrace(LOG_NETWORKING, "Listening for incoming connections {port: %d}", port);
struct sockaddr_in bind_address;
uv_ip4_addr("0.0.0.0", port, &bind_address);
int result = uv_tcp_init(uv_default_loop(), &_listener);
if (result)
{
LogError(LOG_NETWORKING, "Listening for incoming connections - failure, reason: %s", uv_err_name(result));
return false;
}
result = uv_tcp_bind(&_listener, (const struct sockaddr *) &bind_address, 0);
if (result)
{
LogError(LOG_NETWORKING, "Listening for incoming connections - failure, reason: %s", uv_err_name(result));
return false;
}
result = uv_listen((uv_stream_t *) &_listener, SOMAXCONN, IncomingConnection);
if (result)
{
LogError(LOG_NETWORKING, "Listening for incoming connections - failure, reason: %s", uv_err_name(result));
return false;
}
LogTrace(LOG_NETWORKING, "Listening for incoming connections - success", port);
return true;
}
void CEsperEngine::MsgEsperWrite (const SArchonMessage &Msg)
// MsgEsperWrite
//
// Requests a write on the given connection.
{
CDatum dConnection = Msg.dPayload.GetElement(0);
const CString &sData = Msg.dPayload.GetElement(1);
CString sError;
if (!m_Connections.BeginWrite(Msg, dConnection, sData, &sError))
{
SendMessageReplyError(MSG_ERROR_UNABLE_TO_COMPLY, strPattern(ERR_WRITE_FAILED, sError), Msg);
if (m_bLogTrace)
LogTrace(strPattern("[%x] Write failed (%d bytes): %s", CEsperInterface::ConnectionToFriendlyID(dConnection), sData.GetLength(), sError));
return;
}
#ifdef DEBUG_SOCKET_OPS
if (m_bLogTrace)
LogTrace(strPattern("[%x] Write %d bytes", CEsperInterface::ConnectionToFriendlyID(dConnection), sData.GetLength()));
#endif
// We reply when the async operation completes (or we get an error).
}
void ExecutorDummy::printSyncs()
{
typedef pair<string, uint64_t> Record;
struct comp
{
bool operator()(Record const &a, Record const &b) const
{
return a.second > b.second;
}
};
vector<Record> sorted;
sorted.reserve(syncs_.size());
for (auto &r : syncs_)
{
string str = methods_->getMethod(r.first).second;
sorted.emplace_back(str, r.second);
}
std::sort(sorted.begin(), sorted.end(), comp());
size_t num = std::min<size_t>(10, sorted.size());
LogTrace("sync stats: " << numFrames_ << " frames");
for (size_t i = 0; i < num; ++i)
LogTrace(sorted[i].first << ": " << sorted[i].second);
syncs_.clear();
numFrames_ = 0;
}
static FORCEINLINE NTSTATUS
__UpdateBackendPath(
IN PXENVBD_FRONTEND Frontend
)
{
NTSTATUS Status;
PCHAR Path;
if (Frontend->BackendPath) {
LogTrace("<< %s\n", Frontend->BackendPath);
AustereFree(Frontend->BackendPath);
Frontend->BackendPath = NULL;
}
Status = StoreRead(NULL, Frontend->FrontendPath,
"backend-id", &Path);
if (NT_SUCCESS(Status)) {
Frontend->BackendId = (USHORT)strtoul(Path, NULL, 10);
AustereFree(Path);
} else {
Frontend->BackendId = 0;
}
Status = StoreRead(NULL, Frontend->FrontendPath,
"backend", &Path);
if (NT_SUCCESS(Status)) {
LogTrace(">> %s\n", Path);
Frontend->BackendPath = Path;
}
return Status;
}
/// Helper function to unhook the CreateFactory2 interface
/// \param hDXGI Input DXGI module
void UnhookCreateDXGIFactory2Function(HMODULE hDXGI)
{
LogTrace(traceENTER, "");
// don't detach twice
if (Real_CreateDXGIFactory2 == NULL)
{
Log(logERROR, "Attempting to call UnhookCreateDXGIFactory2() twice\n");
LogTrace(traceEXIT, "");
return;
}
if (hDXGI != NULL)
{
LONG error;
AMDT::BeginHook();
LogTrace(traceEXIT, "UnhookCreateDXGIFactory2");
UNHOOK(Real_CreateDXGIFactory2, Mine_CreateDXGIFactory2);
if (AMDT::EndHook() != NO_ERROR)
{
Log(logERROR, "UnhookCreateDXGIFactory2 Failed\n");
}
}
Real_CreateDXGIFactory2 = NULL;
LogTrace(traceEXIT, "");
return;
}
void SysConsoleServiceImp::updateLocalGid(std::string& _return, const int32_t localGid, const int32_t groupId, const int64_t timestamp, const std::string& oldIp, const std::string& newIp)
{
LogTrace(Info, "localGid = %d, groupId = %d, oldipStr = %s, newIP = %s", localGid, groupId, oldIp.c_str(), newIp.c_str());
if(!(localGid>=2048 && localGid<=4097))
{
_return = "invalid localGid";
return;
}
IMetaDao *metaDao_mp = sysc->mDao;
Meta m;
m.serverId= localGid;
m.timestamp = sysc->nv->getVersion();
m.name = LOCALGIDMETANAME;
m.groupId = groupId;
m.type = METASERVER_TYPE;
m.data = newIp;
m.isDel = 0;
if(metaDao_mp->updateLocalGid(m,oldIp,timestamp) == -1)
{
LogTrace(Error,"config localGid error, err= %d", myerrno);
char buf[100];
sprintf(buf, "setMeta db error:%d", myerrno);
_return = buf;
}else{
_return = "config ok";
}
}
JobStatus FullSnapJob::onSyncLsn(bool bto, int res)
{
if(bto || res != 0){
return onFailure(bto, res);
}else{
std::vector<Lsn> tmpLsns;
for(std::vector<DLog>::const_iterator it = logs.begin(); it != logs.end(); ++it){
Lsn tmp;
tmp.node = it->node;
tmp.lsn = it->lsn;
tmpLsns.push_back(tmp);
LogTrace(Info, "node = %d, lsn = %lld",tmp.node, tmp.lsn);
}
logs.clear();
cli->lastLsn.swap(tmpLsns); // update session sync's lastlsns
if(cli->lastLsn.empty())
{
LogTrace(Error,"last lsn is empty");
complete = true;
cli->snapGameover = true;
return JOBSTOP;
}
lsnVecIndex = 0;
lastLsnId = 0;
step = SyncDLog_C;
ASYNC_CALL(SnapService, getDLogs, &FullSnapJob::onSyncLog, logs, sessionId,cli->lastLsn[lsnVecIndex].node,lastLsnId,1000);
return SYSDEFAULT;
}
}
JobStatus FullSnapJob::onSyncData(bool bto, int res)
{
if(bto || res != 0){
return onFailure(bto,res);
}else{
for(std::vector<Meta>::const_iterator it = infos.begin(); it != infos.end(); ++it){
const Meta& m = *it;
if((m.serverId&0xFFF) == cli->nv->getUniqNodeId())
{
if(((m.serverId>>16) != 0))
{
LogTrace(Error, "NodeId conflict, please have a check,m.serverId = %lld,mynodeId = %d",m.serverId, cli->nv->getUniqNodeId());
complete = true;
cli->snapGameover = true;
return JOBSTOP;
}
else
{
LogTrace(Warn, "meta about my service, serverId = %lld, name = %s, groupId = %d", m.serverId, m.name.c_str(), m.groupId);
}
}
log(Debug, "set metaId:%lld ts:%lld", m.serverId, m.timestamp);
int ret = cli->mDao->set(m, false);
if(ret < 0 ){
LogTrace(Error, "meta set error, errno = %d", myerrno);
if(myerrno == ETIMESTAMPLT)
{
LogTrace(Error, "this is empty node, meta should not be timeout");
complete = true;
cli->snapGameover = true;
return JOBSTOP;
}
ASYNC_CALL(System, sleep, &FullSnapJob::onWakeup, 1000 * 10);
return SYSDEFAULT;
}
if(m.isDel == 0)
{
syncUndelMetaCount++;
}
else
{
syncDelMetaCount++;
}
lastServerId = it->serverId;
}
size_t sz = infos.size();
LogTrace(Info, "sync meta data, size = %d,lastServerId = %lld ", infos.size(), lastServerId);
infos.clear();
if(sz < 1000){
step = SyncLastLsn_C;
ASYNC_CALL(SnapService, getLsns, &FullSnapJob::onSyncLsn, logs, sessionId);
}else{
ASYNC_CALL(SnapService, getMetas, &FullSnapJob::onSyncData, infos, sessionId, lastServerId, 1000);
}
return SYSDEFAULT;
}
/// 終了処理
/// 全てのメモリ開放
void Graphics::term(void)
{
LogTrace("start\n");
mGeom.term();
mWnd.term();
LogTrace("end \n");
}
DWORD WINAPI CardDeleteContext
(
__inout PCARD_DATA pCardData
)
{
DWORD dwReturn = 0;
LogTrace(LOGTYPE_INFO, WHERE, "Enter API...");
/********************/
/* Check Parameters */
/********************/
if ( pCardData == NULL )
{
LogTrace(LOGTYPE_ERROR, WHERE, "Invalid parameter [pCardData]");
CLEANUP(SCARD_E_INVALID_PARAMETER);
}
LogTrace(LOGTYPE_INFO, WHERE, "Context:[0x%08X]", pCardData->hSCardCtx);
if (pCardData->pvVendorSpecific != NULL)
{
pCardData->pfnCspFree(pCardData->pvVendorSpecific);
pCardData->pvVendorSpecific = NULL;
}
cleanup:
LogTrace(LOGTYPE_INFO, WHERE, "Exit API...");
return (dwReturn);
}
int32 Stealth_CheckSuccess(AActor* oStealther, AActor* oPerceiver)
{
//TODO implement Stealth_CheckSuccess fully
LogTrace(LOG_CHANNEL_COMBAT_ABILITY, "Perception check for " + GetTag(oPerceiver) + " detecting " + GetTag(oStealther));
int32 bCombatState = GetCombatState(oStealther);
int32 nStealthRank = Stealth_GetStealthRank(oStealther);
int32 nPerceptionRank = Stealth_GetPerceptionRank(oPerceiver);
if ((bCombatState == FALSE_) || (nStealthRank >= nPerceptionRank))
{
return TRUE_;
}
else
{
#ifdef DEBUG
LogTrace(LOG_CHANNEL_COMBAT_ABILITY, "DETECTED by " + GetTag(oPerceiver));
#endif
// display stealth detected UI message
UI_DisplayMessage(oStealther, 3511);
UI_DisplayMessage(oPerceiver, 3513);
return FALSE_;
}
}
VOID
FrontendDestroy(
IN PXENVBD_FRONTEND Frontend
)
{
const ULONG TargetId = Frontend->TargetId;
LogTrace("Target[%d] @ (%d) =====>\n", TargetId, KeGetCurrentIrql());
ASSERT3U(Frontend->RingGrantRef, ==, 0);
ASSERT3P(Frontend->EvtchnPort, ==, 0);
// free memory
if (Frontend->FrontendPath) {
AustereFree(Frontend->FrontendPath);
Frontend->FrontendPath = NULL;
}
if (Frontend->TargetPath) {
AustereFree(Frontend->TargetPath);
Frontend->TargetPath = NULL;
}
if (Frontend->BackendPath) {
AustereFree(Frontend->BackendPath);
Frontend->BackendPath = NULL;
}
LogTrace("Target[%d] @ (%d) <=====\n", TargetId, KeGetCurrentIrql());
}
/// Helper function to hook the CreateFactory2 interface
/// \param hDXGI Input DXGI module
void HookCreateDXGIFactory2Function(HMODULE hDXGI)
{
LogTrace(traceENTER, "");
// don't attach twice
if (Real_CreateDXGIFactory2 != NULL)
{
LogTrace(traceEXIT, "already hooked");
return;
}
Real_CreateDXGIFactory2 = (CreateDXGIFactory2_type)GetProcAddress(hDXGI, "CreateDXGIFactory2");
if (Real_CreateDXGIFactory2 != NULL)
{
LONG error;
AMDT::BeginHook();
HOOK(Real_CreateDXGIFactory2, Mine_CreateDXGIFactory2);
if (AMDT::EndHook() != NO_ERROR)
{
Log(logERROR, "HookCreateDXGIFactory2 Failed\n");
}
}
else
{
Log(logERROR, "HookCreateDXGIFactory2 Failed: Cannot find the CreateDXGIFactory2 in the current DXGI module. This is not a real error if you are using Windows7.\n");
}
LogTrace(traceEXIT, "");
return;
}
/// Mine entry point for intercepted function
/// \param lpLibFileName Library file name
/// \param hFile File handle
/// \param dwFlags load flags
/// \return Loaded module.
static HMODULE WINAPI Mine_LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
{
RefTracker rf(&s_dwInsideLoadLibrary);
if (s_dwInsideLoadLibrary == 1)
{
LogTrace(traceENTER, "lpLibFilename = %S, hFile = %p, dwFlags = %d", lpLibFileName, hFile, dwFlags);
}
HMODULE res = Real_LoadLibraryExW(lpLibFileName, hFile, dwFlags);
DWORD realError = GetLastError();
if (my_lstrcmpW(lpLibFileName, L"comctl32.dll") != 0)
{
// This function uses MessageBox - which will load comctl32.dll if necessary
// To avoid recursion problems, only call it when a different DLL is being loaded.
CheckForDebuggerAttach();
}
if (s_dwInsideLoadLibrary == 1)
{
CheckWrappers();
LogTrace(traceEXIT, "returned 0x%p", res);
}
SetLastError(realError);
return res;
}
/// Hook the load library functions
void HookLoadLibrary()
{
LogTrace(traceENTER, "");
AMDT::BeginHook();
LONG error = AMDT::HookAPICall(&(PVOID&)Real_LoadLibraryA, Mine_LoadLibraryA);
PsAssert(error == NO_ERROR);
error = AMDT::HookAPICall(&(PVOID&)Real_LoadLibraryExA, Mine_LoadLibraryExA);
PsAssert(error == NO_ERROR);
error = AMDT::HookAPICall(&(PVOID&)Real_LoadLibraryW, Mine_LoadLibraryW);
PsAssert(error == NO_ERROR);
error = AMDT::HookAPICall(&(PVOID&)Real_LoadLibraryExW, Mine_LoadLibraryExW);
PsAssert(error == NO_ERROR);
error = AMDT::HookAPICall(&(PVOID&)Real_FreeLibrary, Mine_FreeLibrary);
PsAssert(error == NO_ERROR);
if (AMDT::EndHook() != NO_ERROR)
{
Log(logERROR, "HookLoadLibrary() failed\n");
}
// Load the "dxgi.dll" at the beginning as we missed the dxgi loading sometimes.
// TODO: Fix this: This function is called from DllMain(), and according to the
// Microsoft documentation, LoadLibrary() should not be called from DllMain()
LoadLibraryA("dxgi.dll");
LogTrace(traceEXIT, "");
return;
}
NTSTATUS
DllInitialize(
IN PUNICODE_STRING RegistryPath
)
{
PWSTR Name;
NTSTATUS Status;
LogTrace("===>\n");
Name = wcsrchr(RegistryPath->Buffer, L'\\');
if (Name) {
Name++;
if (__StrStarts(Name, L"dump_")) {
__OperatingMode = DUMP_MODE;
} else if (__StrStarts(Name, L"hiber_")) {
__OperatingMode = HIBER_MODE;
} else {
__OperatingMode = NORMAL_MODE;
}
}
Status = STATUS_SUCCESS;
LogTrace("<=== (%08x)\n", Status);
return Status;
}
bool FrameImpl::LoadFromBfd(void* address)
{
TraceFunc();
LogTraceLn();
bool ret = false;
m_address = address;
#if defined(__GNUC__) && defined(DEBUG)
const char* file = nullptr;
const char* func = nullptr;
bfd_fill(file, func, m_line, m_image.c_str(), m_address);
LogTrace(L"file: '%S'\n", file);
LogTrace(L"func: '%S'\n", func);
LogTrace(L"line: %Id\n", m_line);
LogTrace(L"offs: %Id\n", m_offset);
if (file)
m_file = sstr::cp2w(filename_only(file), CP_OEMCP);
if (func) {
char buf[MAX_PATH];
size_t size = sizeof(buf);
int st = 0;
abi::__cxa_demangle(func, buf, &size, &st);
m_function = sstr::cp2w(st ? func : buf, CP_OEMCP);
}
ret = file || func;
#endif
TraceFunc();
return ret;
}
JobStatus FullSnapJob::onMessage(const Message &msg)
{
LogTrace(Debug,"Metahod Entry, msgId = %d", msg.msgId);
JobStatus ret = JOBSTOP;
switch(msg.msgId)
{
case DNS:
//impxxx set client conn factory
LogTrace(Notice, "dsn result, %d", msg.shortArg );
if(msg.longArg != 0)
{
std::vector<std::string>* ipv = (std::vector<std::string>*)msg.longArg;
cli->ipListFromDns.swap(*ipv);
delete ipv;
ret = doReconnect();
}
else
{
LogTrace(Error, "Dns failure, get no host");
}
break;
default:
{
LogTrace(Error, "invalid msgId = %d", msg.msgId);
}
}
return ret;
}
sync::WaitResult_t Pool::wait_all(int64_t timeout) const
{
LogTrace("timeout: %Id", timeout);
sync::WaitResult_t ret = (sync::WaitResult_t)::WaitForMultipleObjectsEx(m_handles.size(), &m_handles[0], TRUE, timeout, TRUE);
LogErrorIf(ret == sync::WaitResult_t::FAILED, "-> %s", totext::api_error().c_str());
LogTrace("ret: '%s'", totext::c_str(ret));
return ret;
}
void
angel_SelectNextTask(void)
{
angel_TaskQueueItem *tqi;
/* Find the task with the highest priority which is not blocked */
for (tqi = angel_TaskQueueHead; tqi != NULL; tqi = tqi->next)
{
/* Ignore this task if it is the application or an Appl Callback
* and the Application is blocked
*/
if (angel_ApplicationBlocked &&
(tqi->pri == TP_Application || tqi->pri == TP_ApplCallBack))
{
LogTrace2("SNT-SKIP-t%d-p%d ", tqi->index, tqi->pri);
continue;
}
/* Otherwise this is the highest priority task so execute it ! */
#ifdef DEBUG_TASKS
LogInfo(LOG_SERLOCK, ("SelectNewTask: Selecting pc %x - t%d - p%d - n%d ",
tqi->rb.r[15], tqi->index, tqi->pri, tqi->new_task));
#endif
angel_LastExecutedTaskPriority = tqi->pri;
angel_FreeToPool(tqi->index);
#if 0
if (tqi->pri == TP_Application)
{
int i;
LogWarning(LOG_SERLOCK, ( "Application starting:\n"));
for (i = 0; i < 16; i++)
{
LogWarning(LOG_SERLOCK, ( "%8X ", tqi->rb.r[i]));
}
LogWarning(LOG_SERLOCK, ( "CPSR=%8X\n", tqi->rb.cpsr));
}
#endif
/* if it's not an interrupted thread, we need to set its environment */
if (tqi->new_task)
angel_SetUpTaskEnvironment(&(tqi->rb), angel_LastExecutedTaskPriority);
else
LogTrace("\n");
angel_StartTask(&(tqi->rb)); /* doesn't return! */
}
if (tqi == NULL)
{
LogTrace("SNT-IDLE ");
angel_LastExecutedTaskPriority = TP_IdleLoop;
angel_IdleLoop();
}
}
//修改上下文菜单
HRESULT CCCopyPathEx::QueryContextMenu (HMENU hmenu,
UINT uMenuIndex,
UINT uidFirstCmd,
UINT uidLastCmd,
UINT uFlags)
{
try
{
UINT idCmd = uidFirstCmd;
LogTrace("菜单值：%d", hmenu);
// Add the new item
::InsertMenu(hmenu, uMenuIndex, MF_STRING | MF_BYPOSITION, idCmd++,
(1 == m_cFiles ? _T("Copy &Path2") : _T("Copy All &Path2") ) );
LogTrace("菜单值：%d", hmenu);
HMENU hmenu1 =::CreatePopupMenu();
UINT idCmd1 = 0;
::InsertMenu(hmenu1, uMenuIndex, MF_STRING , idCmd1++, "test1");
::InsertMenu(hmenu1, uMenuIndex, MF_STRING , idCmd1++, "test2");
::AppendMenu(hmenu, MF_POPUP, (UINT_PTR)hmenu1, "test");
// Very carefully, add the bitmap. This bitmap is XORed by the shell, so it won't
// look very pretty, but it's better than nothing. The next step is apparently to
// create an ownerdraw menu and handle painting the icon with IContextMenu3::HandleMenuMsg2
// so the icons will look pretty like the 'Send To' icons.
//const HINSTANCE hinst = _AtlBaseModule.GetResourceInstance();
//if ( hinst )
//{
// // Add the bitmap for the unchecked state, since that's what it is by default.
// m_hbmpUnchecked = ::LoadBitmap( hinst, MAKEINTRESOURCE(IDB_COPY_PATH) );
// if ( m_hbmpUnchecked )
// {
// ::SetMenuItemBitmaps( hmenu, uMenuIndex, MF_BYPOSITION, m_hbmpUnchecked, NULL );
// }
//}
return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, idCmd - uidFirstCmd);
} catch ( ... )
{
return E_FAIL;
}
//// 如果标志包含 CMF_DEFAULTONLY 我们不作任何事情.
//if ( uFlags & CMF_DEFAULTONLY )
//{
// return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, 0 );
//}
//InsertMenu ( hmenu, uMenuIndex, MF_BYPOSITION, uidFirstCmd, _T("SimpleShlExt Test Item") );
//return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, 1 );
}
//-----------------------------------------------------------
// Stops capturing D3DPerf markers
//-----------------------------------------------------------
LONG CAPTURE_D3DPerfMarkers_Unhook()
{
LogTrace(traceENTER, "");
ScopeLock t(&s_mtx);
if (dwAttached <= 0)
{
Log(logERROR, "Trying to Detach ID3D10Device twice!\n");
return -1;
}
s_pCaptureLayer = NULL;
LONG error;
AMDT::BeginHook();
if (Real_D3DPERF_BeginEvent != NULL)
{
error = AMDT::UnhookAPICall(&(PVOID&)Real_D3DPERF_BeginEvent, Mine_D3DPERF_BeginEvent);
PsAssert(error == NO_ERROR);
}
if (Real_D3DPERF_EndEvent != NULL)
{
error = AMDT::UnhookAPICall(&(PVOID&)Real_D3DPERF_EndEvent, Mine_D3DPERF_EndEvent);
PsAssert(error == NO_ERROR);
}
if (Real_D3DPERF_SetMarker != NULL)
{
error = AMDT::UnhookAPICall(&(PVOID&)Real_D3DPERF_SetMarker, Mine_D3DPERF_SetMarker);
PsAssert(error == NO_ERROR);
}
if (Real_D3DPERF_SetRegion != NULL)
{
error = AMDT::UnhookAPICall(&(PVOID&)Real_D3DPERF_SetRegion, Mine_D3DPERF_SetRegion);
PsAssert(error == NO_ERROR);
}
error = AMDT::EndHook();
if (error != NO_ERROR)
{
Log(logERROR, "failed\n");
}
else
{
dwAttached--;
}
LogTrace(traceEXIT, "");
return error;
}
ssize_t ArchiveTest::execute()
{
LogTrace();
ExtractCallback * callback(new ExtractCallback(m_archive));
LogTrace();
Com::Object<IArchiveExtractCallback> extractCallback(callback);
LogTrace();
m_archive->Extract(nullptr, (UInt32)-1, true, extractCallback);
LogTrace();
return static_cast<ssize_t>(callback->failed_files.size());
}
XEN_API NTSTATUS
XencrshEntryPoint(
IN PDRIVER_OBJECT _DriverObject
)
{
NTSTATUS Status;
HW_INITIALIZATION_DATA InitData;
LogTrace("===> (Irql=%d)\n", KeGetCurrentIrql());
LogVerbose("%s (%s)\n",
MAJOR_VERSION_STR "." MINOR_VERSION_STR "." MICRO_VERSION_STR "." BUILD_NUMBER_STR,
DAY_STR "/" MONTH_STR "/" YEAR_STR);
LogVerbose("Loading PV Disk in %s mode\n", __OperatingModeName());
if (DriverGetOperatingMode() == DUMP_MODE) {
WRITE_PORT_ULONG(CRASH_PORT, 'PLEH');
}
AustereInitialize();
BufferInitialize();
RtlZeroMemory(&InitData, sizeof(InitData));
InitData.HwInitializationDataSize = sizeof(InitData);
InitData.AdapterInterfaceType = Internal;
InitData.HwInitialize = HwInitialize;
InitData.HwStartIo = HwStartIo;
InitData.HwInterrupt = HwInterrupt;
#pragma warning(suppress : 4152)
InitData.HwFindAdapter = HwFindAdapter;
InitData.HwResetBus = HwResetBus;
InitData.HwDmaStarted = NULL;
InitData.HwAdapterState = NULL;
InitData.DeviceExtensionSize = FdoSizeofXenvbdFdo();
InitData.SpecificLuExtensionSize = 0;
InitData.SrbExtensionSize = sizeof(XENVBD_SRBEXT);
InitData.NumberOfAccessRanges = 2;
InitData.MapBuffers = STOR_MAP_NON_READ_WRITE_BUFFERS;
InitData.NeedPhysicalAddresses = TRUE;
InitData.TaggedQueuing = TRUE;
InitData.AutoRequestSense = TRUE;
InitData.MultipleRequestPerLu = TRUE;
InitData.HwAdapterControl = HwAdapterControl;
InitData.HwBuildIo = HwBuildIo;
#pragma prefast(suppress: 6387, "Crash Driver has no registry path")
Status = StorPortInitialize(_DriverObject, NULL, &InitData, NULL);
LogVerbose("(%08x)\n", Status);
LogTrace("<=== (%08x) (Irql=%d)\n", Status, KeGetCurrentIrql());
return Status;
}
DECLSPEC_NOINLINE VOID
PdoD3ToD0(
IN PXENVBD_PDO Pdo
)
{
LogTrace("Target[%d] =====> (Irql=%d)\n", Pdo->Frontend.TargetId, KeGetCurrentIrql());
// connect to backend
FrontendSetState(&Pdo->Frontend, XENVBD_ENABLED);
LogTrace("Target[%d] <===== (Irql=%d)\n", Pdo->Frontend.TargetId, KeGetCurrentIrql());
}
DECLSPEC_NOINLINE VOID
PdoD0ToD3(
IN PXENVBD_PDO Pdo
)
{
LogTrace("Target[%d] =====> (Irql=%d)\n", Pdo->Frontend.TargetId, KeGetCurrentIrql());
// disconnect from backend
FrontendSetState(&Pdo->Frontend, XENVBD_CLOSED);
// target suspended
LogTrace("Target[%d] <===== (Irql=%d)\n", Pdo->Frontend.TargetId, KeGetCurrentIrql());
}
/// 初期化
void Graphics::init(void)
{
LogTrace("\n");
mGeom.init();
mWnd.init();
m_disp_status_enable=true;
m_disp_performance_enable=true;
m_draw_facet_normal_enable=false;
m_disp_bounding_box_enable=false;
m_menu_entries=0;
LogTrace("\n");
return;
}
JobStatus FullSnapJob::doReconnect()
{
LogTrace(Info,"Method Entry");
failCount = 0;
syncLogCount = 0;
syncUndelMetaCount = 0;
syncDelMetaCount = 0;
cli->lastLsn.clear();
int port = 0;
curIp.clear();
if(cli->cfg->isLocalDaemon())
{
if(ipIndex < cli->ipListFromDns.size())
{
curIp = cli->ipListFromDns[ipIndex];
port = cli->cfg->cSnapPort;
}
}
else // daemon
{
if(ipIndex < cli->ipListFromXml.size()){ // after DNS,select a new ip;
curIp = cli->ipListFromXml[ipIndex].ip;
port = cli->ipListFromXml[ipIndex].port;
targetNode = cli->ipListFromXml[ipIndex].gid;
}
}
ipIndex++;
if(curIp.empty())
{
LogTrace(Error,"failure from all daemons, please have a check");
cli->snapGameover = true;
return JOBSTOP;
}
LogTrace(Info,"curIP = %s, isLocalDaemon = %d", curIp.c_str(), cli->cfg->isLocalDaemon());
IAsyncCenter *center = cli->center;
TRowTransportFactory *to = new TRowTransportFactory();
to->init(center->getClientConnFactory(), ctxMgr->getHandler(), curIp, port);
to->setMainThreadQueue(center->getMainQueue());
tf.reset(to);
SETTRANSPORT(SnapService, tf);
step = SyncNotStart_C;
ASYNC_CALL(SnapService, snapStart, &FullSnapJob::onStarted, sessionId, cli->nv->getGid(), targetNode);
return SYSDEFAULT;
}
JobStatus FullSnapJob::onSyncLog(bool bto, int res)
{
if(bto || res != 0){
return onFailure(bto,res);
}else{
size_t sz = logs.size();
bool applyErr = false;
size_t i = 0;
for(; i < sz; ++i){
const DLog& dlog = logs[i];
int ret = cli->mDao->apply(dlog,false);
if(ret<0)
{
LogTrace(Error, "sync log apply error, errno = %d", myerrno);
applyErr = true;
break;
}
lastLsnId = dlog.lsn;
}
syncLogCount += i; // count the stored DLog;
LogTrace(Info, "sync log, sz = %d, total = %d", sz, syncLogCount);
logs.clear();
if(applyErr)
{
ASYNC_CALL(System, sleep, &FullSnapJob::onWakeup, 1000 * 10);
return SYSDEFAULT;
}
if(sz < 1000)
{
lsnVecIndex++;
lastLsnId = 0;
if(lsnVecIndex < cli->lastLsn.size()) // sync Dlog of next nodeid
{
ASYNC_CALL(SnapService, getDLogs, &FullSnapJob::onSyncLog, logs, sessionId,cli->lastLsn[lsnVecIndex].node,lastLsnId,1000);
}
else // sync finished, stop
{
ASYNC_CALL(SnapService, snapStop, &FullSnapJob::onStop, stop, sessionId);
return SYSDEFAULT;
}
}
else
{
ASYNC_CALL(SnapService, getDLogs, &FullSnapJob::onSyncLog, logs, sessionId,cli->lastLsn[lsnVecIndex].node,lastLsnId,1000);
}
return SYSDEFAULT;
}
}
