ProfilerManager.cpp

/*
 * The contents of this file are subject to the Initial
 * Developer's Public License Version 1.0 (the "License");
 * you may not use this file except in compliance with the
 * License. You may obtain a copy of the License at
 * http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
 *
 * Software distributed under the License is distributed AS IS,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied.
 * See the License for the specific language governing rights
 * and limitations under the License.
 *
 * The Original Code was created by Adriano dos Santos Fernandes
 * for the Firebird Open Source RDBMS project.
 *
 * Copyright (c) 2020 Adriano dos Santos Fernandes <adrianosf@gmail.com>
 * and all contributors signed below.
 *
 * All Rights Reserved.
 * Contributor(s): ______________________________________.
*/

#include"firebird.h"
#include"../jrd/ProfilerManager.h"
#include"../jrd/Record.h"
#include"../jrd/ini.h"
#include"../jrd/tra.h"
#include"../jrd/ids.h"
#include"../jrd/recsrc/Cursor.h"
#include"../dsql/BoolNodes.h"
#include"../jrd/dpm_proto.h"
#include"../jrd/lck_proto.h"
#include"../jrd/met_proto.h"
#include"../jrd/pag_proto.h"
#include"../jrd/tra_proto.h"

#include<atomic>

#ifdef WIN_NT
#include<process.h>
#endif

usingnamespaceJrd;
usingnamespaceFirebird;


//--------------------------------------


namespace
{
classProfilerIpcfinal : public IpcObject
 {
public:
enumclassTag : UCHAR
 {
 NOP = 0,

 SERVER_STARTED,
 SERVER_EXITED,

 RESPONSE,
 EXCEPTION,

 FIRST_CLIENT_OP,
 CANCEL_SESSION = FIRST_CLIENT_OP,
 DISCARD,
 FINISH_SESSION,
 FLUSH,
 PAUSE_SESSION,
 RESUME_SESSION,
 SET_FLUSH_INTERVAL,
 START_SESSION
 };

classGuard
 {
public:
explicitGuard(ProfilerIpc* ipc)
 : sharedMemory(ipc->sharedMemory)
 {
 sharedMemory->mutexLock();
 }

~Guard()
 {
 sharedMemory->mutexUnlock();
 }

Guard(const Guard&) = delete;
 Guard& operator=(const Guard&) = delete;

private:
 SharedMemoryBase* const sharedMemory;
 };

structHeader : publicMemoryHeader
 {
event_t serverEvent;
event_t clientEvent;
 USHORT bufferSize;
 std::atomic<Tag> tag;
char userName[USERNAME_LENGTH + 1]; // \0 if has PROFILE_ANY_ATTACHMENT
alignas(FB_ALIGNMENT) UCHAR buffer[4096];
 };

staticconst USHORT VERSION = 2;

public:
ProfilerIpc(thread_db* tdbb, MemoryPool& pool, AttNumber aAttachmentId, bool server = false);
~ProfilerIpc();

ProfilerIpc(const ProfilerIpc&) = delete;
 ProfilerIpc& operator=(const ProfilerIpc&) = delete;

public:
boolinitialize(SharedMemoryBase* sm, bool init) override;
voidmutexBug(int osErrorCode, constchar* text) override;

 USHORT getType() constoverride
 {
return SharedMemoryBase::SRAM_PROFILER;
 }

 USHORT getVersion() constoverride
 {
return VERSION;
 }

constchar* getName() constoverride
 {
return"ProfilerManager";
 }

public:
template <typename Input, typename Output>
voidsendAndReceive(thread_db* tdbb, Tag tag, const Input* in, Output* out)
 {
static_assert(sizeof(*in) <= sizeof(std::declval<Header>().buffer), "Buffer size too small");
internalSendAndReceive(tdbb, tag, in, sizeof(*in), out, sizeof(*out));
 }

template <typename Input>
voidsend(thread_db* tdbb, Tag tag, const Input* in)
 {
static_assert(sizeof(*in) <= sizeof(std::declval<Header>().buffer), "Buffer size too small");
internalSendAndReceive(tdbb, tag, in, sizeof(*in), nullptr, 0);
 }

private:
voidinternalSendAndReceive(thread_db* tdbb, Tag tag, constvoid* in, unsigned inSize, void* out, unsigned outSize);
voidinitClient();

public:
 AutoPtr<SharedMemory<Header>> sharedMemory;
 AttNumber attachmentId;
constbool isServer;
 };
} // anonymous namespace


classJrd::ProfilerListener final
{
public:
explicitProfilerListener(thread_db* tdbb);
~ProfilerListener();

ProfilerListener(const ProfilerListener&) = delete;
 ProfilerListener& operator=(const ProfilerListener&) = delete;

public:
voidexceptionHandler(const Firebird::Exception& ex, ThreadFinishSync<ProfilerListener*>::ThreadRoutine* routine);

private:
voidwatcherThread();

staticvoidwatcherThread(ProfilerListener* listener)
 {
 listener->watcherThread();
 }

voidprocessCommand(thread_db* tdbb);

private:
 Attachment* const attachment;
 Firebird::Semaphore startupSemaphore;
 ThreadFinishSync<ProfilerListener*> cleanupSync;
 Firebird::AutoPtr<ProfilerIpc> ipc;
bool exiting = false;
};


//--------------------------------------


IExternalResultSet* ProfilerPackage::discardProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const DiscardInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::DISCARD, in);
returnnullptr;
 }

constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->discard();

returnnullptr;
}

IExternalResultSet* ProfilerPackage::flushProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const FlushInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::FLUSH, in);
returnnullptr;
 }

constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->flush();

returnnullptr;
}

IExternalResultSet* ProfilerPackage::cancelSessionProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const CancelSessionInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::CANCEL_SESSION, in);
returnnullptr;
 }

constauto transaction = tdbb->getTransaction();
constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->cancelSession();

returnnullptr;
}

IExternalResultSet* ProfilerPackage::finishSessionProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const FinishSessionInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::FINISH_SESSION, in);
returnnullptr;
 }

constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->finishSession(tdbb, in->flush);

returnnullptr;
}

IExternalResultSet* ProfilerPackage::pauseSessionProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const PauseSessionInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::PAUSE_SESSION, in);
returnnullptr;
 }

constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->pauseSession(in->flush);

returnnullptr;
}

IExternalResultSet* ProfilerPackage::resumeSessionProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const ResumeSessionInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::RESUME_SESSION, in);
returnnullptr;
 }

constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->resumeSession();

returnnullptr;
}

IExternalResultSet* ProfilerPackage::setFlushIntervalProcedure(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const SetFlushIntervalInput::Type* in, void* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.send(tdbb, ProfilerIpc::Tag::SET_FLUSH_INTERVAL, in);
returnnullptr;
 }

constauto profilerManager = attachment->getProfilerManager(tdbb);

 profilerManager->setFlushInterval(in->flushInterval);

returnnullptr;
}

voidProfilerPackage::startSessionFunction(ThrowStatusExceptionWrapper* /*status*/,
 IExternalContext* context, const StartSessionInput::Type* in, StartSessionOutput::Type* out)
{
constauto tdbb = JRD_get_thread_data();
constauto attachment = tdbb->getAttachment();

if (!in->attachmentIdNull && AttNumber(in->attachmentId) != attachment->att_attachment_id)
 {
 ProfilerIpc ipc(tdbb, *getDefaultMemoryPool(), in->attachmentId);
 ipc.sendAndReceive(tdbb, ProfilerIpc::Tag::START_SESSION, in, out);
return;
 }

const string description(in->description.str, in->descriptionNull ? 0 : in->description.length);
const Nullable<SLONG> flushInterval(in->flushIntervalNull ?
 Nullable<SLONG>() : Nullable<SLONG>(in->flushInterval));
const PathName pluginName(in->pluginName.str, in->pluginNameNull ? 0 : in->pluginName.length);
const string pluginOptions(in->pluginOptions.str, in->pluginOptionsNull ? 0 : in->pluginOptions.length);

constauto profilerManager = attachment->getProfilerManager(tdbb);

 out->sessionIdNull = FB_FALSE;
 out->sessionId = profilerManager->startSession(tdbb, flushInterval, pluginName, description, pluginOptions);
}


//--------------------------------------


ProfilerManager::ProfilerManager(thread_db* tdbb)
 : activePlugins(*tdbb->getAttachment()->att_pool)
{
constauto attachment = tdbb->getAttachment();

 flushTimer = FB_NEW TimerImpl();

 flushTimer->setOnTimer([this, attachment](auto) {
 FbLocalStatus statusVector;
 EngineContextHolder innerTdbb(&statusVector, attachment->getInterface(), FB_FUNCTION);

flush(false);
updateFlushTimer(false);
 });
}

ProfilerManager::~ProfilerManager()
{
 flushTimer->stop();
}

ProfilerManager* ProfilerManager::create(thread_db* tdbb)
{
returnFB_NEW_POOL(*tdbb->getAttachment()->att_pool) ProfilerManager(tdbb);
}

intProfilerManager::blockingAst(void* astObject)
{
constauto attachment = static_cast<Attachment*>(astObject);

try
 {
constauto dbb = attachment->att_database;
 AsyncContextHolder tdbb(dbb, FB_FUNCTION, attachment->att_profiler_listener_lock);

if (!(attachment->att_flags & ATT_shutdown))
 {
constauto profilerManager = attachment->getProfilerManager(tdbb);

if (!profilerManager->listener)
 profilerManager->listener = FB_NEW_POOL(*attachment->att_pool) ProfilerListener(tdbb);
 }

LCK_release(tdbb, attachment->att_profiler_listener_lock);
 }
catch (const Exception&)
 {} // no-op

return0;
}

SINT64 ProfilerManager::startSession(thread_db* tdbb, Nullable<SLONG> flushInterval,
const PathName& pluginName, const string& description, const string& options)
{
if (flushInterval.isAssigned())
checkFlushInterval(flushInterval.value);

 AutoSetRestore<bool> pauseProfiler(&paused, true);

constauto attachment = tdbb->getAttachment();
 ThrowLocalStatus status;

constauto timestamp = TimeZoneUtil::getCurrentTimeStamp(attachment->att_current_timezone);

if (currentSession)
 {
 currentSession->pluginSession->finish(&status, timestamp);
 currentSession = nullptr;
 }

auto pluginPtr = activePlugins.get(pluginName);

 AutoPlugin<IProfilerPlugin> plugin;

if (pluginPtr)
 {
 (*pluginPtr)->addRef();
 plugin.reset(pluginPtr->get());
 }
else
 {
 GetPlugins<IProfilerPlugin> plugins(IPluginManager::TYPE_PROFILER, pluginName.nullStr());

if (!plugins.hasData())
 {
 string msg;
 msg.printf("Profiler plugin %s is not found", pluginName.c_str());
 (Arg::Gds(isc_random) << msg).raise();
 }

 plugin.reset(plugins.plugin());
 plugin->addRef();

 plugin->init(&status, attachment->getInterface(), (FB_UINT64) fb_utils::query_performance_frequency());

 plugin->addRef();
 activePlugins.put(pluginName)->reset(plugin.get());
 }

 AutoDispose<IProfilerSession> pluginSession = plugin->startSession(&status,
 description.c_str(),
 options.c_str(),
 timestamp);

auto& pool = *tdbb->getAttachment()->att_pool;

 currentSession.reset(FB_NEW_POOL(pool) ProfilerManager::Session(pool));
 currentSession->pluginSession = std::move(pluginSession);
 currentSession->plugin = std::move(plugin);
 currentSession->flags = currentSession->pluginSession->getFlags();

 paused = false;

if (flushInterval.isAssigned())
setFlushInterval(flushInterval.value);

return currentSession->pluginSession->getId();
}

voidProfilerManager::prepareCursor(thread_db* tdbb, Request* request, const Select* select)
{
auto profileStatement = getStatement(request);

if (!profileStatement)
return;

auto cursorId = select->getCursorId();

if (!profileStatement->definedCursors.exist(cursorId))
 {
 currentSession->pluginSession->defineCursor(profileStatement->id, cursorId,
select->getName().nullStr(), select->getLine(), select->getColumn());

 profileStatement->definedCursors.add(cursorId);
 }

prepareRecSource(tdbb, request, select);
}

voidProfilerManager::prepareRecSource(thread_db* tdbb, Request* request, const AccessPath* recordSource)
{
auto profileStatement = getStatement(request);

if (!profileStatement)
return;

if (profileStatement->recSourceSequence.exist(recordSource->getRecSourceId()))
return;

fb_assert(profileStatement->definedCursors.exist(recordSource->getCursorId()));

structPlanItem : PermanentStorage
 {
explicitPlanItem(MemoryPool& p)
 : PermanentStorage(p)
 {
 }

const AccessPath* recordSource = nullptr;
const AccessPath* parentRecordSource = nullptr;
 string accessPath{getPool()};
unsigned level = 0;
 };

 ObjectsArray<PlanItem> planItems;
 planItems.add().recordSource = recordSource;

for (unsigned pos = 0; pos < planItems.getCount(); ++pos)
 {
auto& planItem = planItems[pos];
constauto thisRsb = planItem.recordSource;

 string& accessPath = planItem.accessPath;
 thisRsb->print(tdbb, accessPath, true, 0, false);

constexprauto INDENT_MARKER = "\n";
constexprunsigned INDENT_COUNT = 4;

if (accessPath.find(INDENT_MARKER) == 0)
 {
unsigned pos = 0;

do {
 accessPath.erase(pos + 1, 4);
 } while ((pos = accessPath.find(INDENT_MARKER, pos + 1)) != string::npos);
 }

if (accessPath.hasData() && accessPath[0] == '\n')
 accessPath.erase(0, 1);

 Array<const RecordSource*> children;
 thisRsb->getChildren(children);

unsigned level = planItem.level;

if (constauto lastLinePos = accessPath.find_last_of('\n'); lastLinePos != string::npos)
 level += (accessPath.find_first_not_of('', lastLinePos + 1) - lastLinePos + 1) / INDENT_COUNT;

unsigned childPos = pos;

for (constauto child : children)
 {
auto& inserted = planItems.insert(++childPos);
 inserted.recordSource = child;
 inserted.parentRecordSource = thisRsb;
 inserted.level = level + 1;
 }
 }

 NonPooledMap<ULONG, ULONG> idSequenceMap;
auto sequencePtr = profileStatement->cursorNextSequence.getOrPut(recordSource->getCursorId());

for (constauto& planItem : planItems)
 {
constauto cursorId = planItem.recordSource->getCursorId();
constauto recSourceId = planItem.recordSource->getRecSourceId();
 idSequenceMap.put(recSourceId, ++*sequencePtr);

 ULONG parentSequence = 0;

if (planItem.parentRecordSource)
 parentSequence = *idSequenceMap.get(planItem.parentRecordSource->getRecSourceId());

 currentSession->pluginSession->defineRecordSource(profileStatement->id, cursorId,
 *sequencePtr, planItem.level, planItem.accessPath.c_str(), parentSequence);

 profileStatement->recSourceSequence.put(recSourceId, *sequencePtr);
 }
}

voidProfilerManager::onRequestFinish(Request* request, Stats& stats)
{
if (constauto profileRequestId = getRequest(request, 0))
 {
constauto profileStatement = getStatement(request);
constauto timestamp = TimeZoneUtil::getCurrentTimeStamp(request->req_attachment->att_current_timezone);

 LogLocalStatus status("Profiler onRequestFinish");
 currentSession->pluginSession->onRequestFinish(&status, profileStatement->id, profileRequestId,
 timestamp, &stats);

 currentSession->requests.findAndRemove(profileRequestId);
 }
}

voidProfilerManager::cancelSession()
{
if (currentSession)
 {
 LogLocalStatus status("Profiler cancelSession");

 currentSession->pluginSession->cancel(&status);
 currentSession = nullptr;
 }
}

voidProfilerManager::finishSession(thread_db* tdbb, bool flushData)
{
if (currentSession)
 {
constauto attachment = tdbb->getAttachment();
constauto timestamp = TimeZoneUtil::getCurrentTimeStamp(attachment->att_current_timezone);
 LogLocalStatus status("Profiler finish");

 currentSession->pluginSession->finish(&status, timestamp);
 currentSession = nullptr;
 }

if (flushData)
flush();
}

voidProfilerManager::pauseSession(bool flushData)
{
if (currentSession)
 paused = true;

if (flushData)
flush();
}

voidProfilerManager::resumeSession()
{
if (currentSession)
 {
 paused = false;
updateFlushTimer();
 }
}

voidProfilerManager::setFlushInterval(SLONG interval)
{
checkFlushInterval(interval);

 currentFlushInterval = (unsigned) interval;

updateFlushTimer();
}

voidProfilerManager::discard()
{
 currentSession = nullptr;
 activePlugins.clear();
}

voidProfilerManager::flush(bool updateTimer)
{
 { // scope
 AutoSetRestore<bool> pauseProfiler(&paused, true);

auto pluginAccessor = activePlugins.accessor();

for (bool hasNext = pluginAccessor.getFirst(); hasNext;)
 {
auto& pluginName = pluginAccessor.current()->first;
auto& plugin = pluginAccessor.current()->second;

 LogLocalStatus status("Profiler flush");
 plugin->flush(&status);

 hasNext = pluginAccessor.getNext();

if (!currentSession || plugin.get() != currentSession->plugin.get())
 activePlugins.remove(pluginName);
 }
 }

if (updateTimer)
updateFlushTimer();
}

voidProfilerManager::updateFlushTimer(bool canStopTimer)
{
if (currentSession && !paused && currentFlushInterval)
 flushTimer->reset(currentFlushInterval);
elseif (canStopTimer)
 flushTimer->stop();
}

ProfilerManager::Statement* ProfilerManager::getStatement(Request* request)
{
if (!isActive())
returnnullptr;

auto mainProfileStatement = currentSession->statements.get(request->getStatement()->getStatementId());

if (mainProfileStatement)
return mainProfileStatement;

for (constauto* statement = request->getStatement();
 statement && !currentSession->statements.exist(statement->getStatementId());
 statement = statement->parentStatement)
 {
 MetaName packageName;
 MetaName routineName;
constchar* type;

if (constauto routine = statement->getRoutine())
 {
if (statement->procedure)
 type = "PROCEDURE";
elseif (statement->function)
 type = "FUNCTION";

 packageName = routine->getName().package;
 routineName = routine->getName().identifier;
 }
elseif (statement->triggerName.hasData())
 {
 type = "TRIGGER";
 routineName = statement->triggerName;
 }
else
 type = "BLOCK";

const StmtNumber parentStatementId = statement->parentStatement ?
 statement->parentStatement->getStatementId() : 0;

 LogLocalStatus status("Profiler defineStatement");
 currentSession->pluginSession->defineStatement(&status,
 (SINT64) statement->getStatementId(), (SINT64) parentStatementId,
 type, packageName.nullStr(), routineName.nullStr(),
 (statement->sqlText.hasData() ? statement->sqlText->c_str() : ""));

auto profileStatement = currentSession->statements.put(statement->getStatementId());
 profileStatement->id = statement->getStatementId();

if (!mainProfileStatement)
 mainProfileStatement = profileStatement;
 }

return mainProfileStatement;
}


//--------------------------------------


ProfilerIpc::ProfilerIpc(thread_db* tdbb, MemoryPool& pool, AttNumber aAttachmentId, bool server)
 : attachmentId(aAttachmentId),
 isServer(server)
{
constauto database = tdbb->getDatabase();

 string fileName;
static_assert(std::is_same<decltype(attachmentId), FB_UINT64>::value);
 fileName.printf(PROFILER_FILE, database->getUniqueFileId().c_str(), attachmentId);

try
 {
 sharedMemory = FB_NEW_POOL(pool) SharedMemory<Header>(fileName.c_str(), sizeof(Header), this);
 }
catch (const Exception& ex)
 {
iscLogException("ProfilerManager: cannot initialize the shared memory region", ex);
throw;
 }

constauto header = sharedMemory->getHeader();
checkHeader(header);

if (isServer)
 {
 Guard guard(this);

if (sharedMemory->eventInit(&header->serverEvent) != FB_SUCCESS)
 (Arg::Gds(isc_random) << "ProfilerIpc eventInit(serverEvent) failed").raise();
 }
}

ProfilerIpc::~ProfilerIpc()
{
 Guard guard(this);

constauto header = sharedMemory->getHeader();

event_t* evnt = this->isServer ? &header->serverEvent : &header->clientEvent;
if (evnt->event_pid)
 {
 sharedMemory->eventFini(evnt);
 evnt->event_pid = 0;
 }

if (header->serverEvent.event_pid == 0 && header->clientEvent.event_pid == 0)
 sharedMemory->removeMapFile();
}

boolProfilerIpc::initialize(SharedMemoryBase* sm, bool init)
{
if (init)
 {
constauto header = reinterpret_cast<Header*>(sm->sh_mem_header);

// Initialize the shared data header.
initHeader(header);
 }

returntrue;
}

voidProfilerIpc::mutexBug(int osErrorCode, constchar* text)
{
iscLogStatus("Error when working with profiler shared memory",
 (Arg::Gds(isc_sys_request) << text << Arg::OsError(osErrorCode)).value());
}

voidProfilerIpc::internalSendAndReceive(thread_db* tdbb, Tag tag,
constvoid* in, unsigned inSize, void* out, unsigned outSize)
{
constauto attachment = tdbb->getAttachment();

 { // scope
 ThreadStatusGuard tempStatus(tdbb);

 Lock tempLock(tdbb, sizeof(SINT64), LCK_attachment);
 tempLock.setKey(attachmentId);

// Check if attachment is alive.
if (LCK_lock(tdbb, &tempLock, LCK_EX, LCK_NO_WAIT))
 {
LCK_release(tdbb, &tempLock);
 (Arg::Gds(isc_random) << "Cannot start remote profile session - attachment is not active").raise();
 }

// Ask remote attachment to initialize the profile listener.

 tempLock.lck_type = LCK_profiler_listener;

if (LCK_lock(tdbb, &tempLock, LCK_SR, LCK_WAIT))
LCK_release(tdbb, &tempLock);
 }

 Guard guard(this);

constauto header = sharedMemory->getHeader();

initClient();

 Cleanup finiClient([&] {
if (header->clientEvent.event_pid)
 {
 sharedMemory->eventFini(&header->clientEvent);
 header->clientEvent.event_pid = 0;
 }
 });

const SLONG value = sharedMemory->eventClear(&header->clientEvent);

const Tag oldTag = header->tag.exchange(tag);
switch (oldTag)
 {
case Tag::NOP:
 header->tag = oldTag;
 (Arg::Gds(isc_random) << "Remote attachment failed to start listener thread").raise();
break;

case Tag::SERVER_EXITED:
 header->tag = oldTag;
 (Arg::Gds(isc_random) << "Cannot start remote profile session - attachment exited").raise();
break;

default:
break;
 };

if (attachment->locksmith(tdbb, PROFILE_ANY_ATTACHMENT))
 header->userName[0] = '\0';
else
strcpy(header->userName, attachment->getUserName().c_str());

 header->bufferSize = inSize;

fb_assert(inSize <= sizeof(header->buffer));
memcpy(header->buffer, in, inSize);

if (sharedMemory->eventPost(&header->serverEvent) != FB_SUCCESS)
 (Arg::Gds(isc_random) << "Cannot start remote profile session - attachment exited").raise();

 {
const SLONG TIMEOUT = 500 * 1000; // 0.5 sec

constint serverPID = header->serverEvent.event_pid;
while (true)
 {
 {
 EngineCheckout cout(tdbb, FB_FUNCTION);
if (sharedMemory->eventWait(&header->clientEvent, value, TIMEOUT) == FB_SUCCESS)
break;

if (serverPID != getpid() && !ISC_check_process_existence(serverPID))
 {
// Server process was died or exited
fb_assert((header->tag == tag) || header->tag == Tag::SERVER_EXITED);

if (header->tag == tag)
 {
 header->tag = Tag::SERVER_EXITED;
if (header->serverEvent.event_pid)
 {
 sharedMemory->eventFini(&header->serverEvent);
 header->serverEvent.event_pid = 0;
 }
 }
break;
 }
 }
JRD_reschedule(tdbb, true);
 }
 }

switch (header->tag)
 {
case Tag::SERVER_EXITED:
 (Arg::Gds(isc_random) << "Cannot start remote profile session - attachment exited").raise();
break;

case Tag::RESPONSE:
fb_assert(outSize == header->bufferSize);
memcpy(out, header->buffer, header->bufferSize);
break;

case Tag::EXCEPTION:
 (Arg::Gds(isc_random) << (char*) header->buffer).raise();
break;

default:
fb_assert(false);
 }
}

voidProfilerIpc::initClient()
{
// Shared memory mutex must be locked by caller

fb_assert(isServer == false);

constauto header = sharedMemory->getHeader();

// Here should not be event created by another alive client

if (header->clientEvent.event_pid)
 {
fb_assert(header->clientEvent.event_pid != getpid());

if (header->clientEvent.event_pid != getpid())
 {
if (ISC_check_process_existence(header->clientEvent.event_pid))
 (Arg::Gds(isc_random) << "ProfilerIpc eventInit(clientEvent) failed").raise();
 }

 sharedMemory->eventFini(&header->clientEvent);
 }

if (sharedMemory->eventInit(&header->clientEvent) != FB_SUCCESS)
 (Arg::Gds(isc_random) << "ProfilerIpc eventInit(clientEvent) failed").raise();
}


//--------------------------------------


ProfilerListener::ProfilerListener(thread_db* tdbb)
 : attachment(tdbb->getAttachment()),
 cleanupSync(*attachment->att_pool, watcherThread, THREAD_medium)
{
auto& pool = *attachment->att_pool;

 ipc = FB_NEW_POOL(pool) ProfilerIpc(tdbb, pool, attachment->att_attachment_id, true);

 cleanupSync.run(this);
 startupSemaphore.enter();
}

ProfilerListener::~ProfilerListener()
{