Пример #1
0
	Item::Item(SC_HANDLE scm, const wchar_t* name, ACCESS_MASK access) :
		m_hndl()
	{
		LogTraceObj(L"begin (%p, '%s', 0x%X)", scm, name, access);
		m_hndl = CheckPointerErr(::OpenServiceW(scm, name, access));
		LogTraceObj("end -> %p", m_hndl);
	}
Пример #2
0
	Scheduler::Scheduler(const char* name, ssize_t stackSize)
	{
		LogTraceObj("('%s', %Id)", name, stackSize);
		impl = simstd::make_unique<SchedulerImpl>(name, stackSize);
		LogTraceObj("('%s', %Id) finished", name, stackSize);

		impl->resume();
	}
Пример #3
0
	HashImpl::HashImpl(const Provider& provider)
	{
		LogTraceObj("begin");
		bool ok = ::CryptCreateHash(reinterpret_cast<HCRYPTPROV>(provider->get_native_handle()), CALG_SHA1, 0, 0, &m_handle);
		LogErrorIf(!ok, "-> %s", totext::api_error().c_str());
		LogTraceObj("end");
		UNUSED(ok);
	}
Пример #4
0
	HashImpl::~HashImpl()
	{
		LogTraceObj("begin");
		if (m_handle) {
			bool ok = ::CryptDestroyHash(m_handle);
			LogErrorIf(!ok, "-> %s", totext::api_error().c_str());
			UNUSED(ok);
		}
		LogTraceObj("end");
	}
Пример #5
0
		FacadeImpl::FacadeImpl(bool activePanel)
			: m_hndl(activePanel ? PANEL_ACTIVE : PANEL_PASSIVE)
			, m_ppi(nullptr)
			, m_dir(nullptr)
		{
			LogTraceObj(L"begin\n");
			LogTrace(L"[%d, %p]\n", activePanel, m_hndl);
			memory::zero(m_pi);
			m_pi.StructSize = sizeof(m_pi);

			m_pi.StructSize = psi().PanelControl(m_hndl, FCTL_GETPANELINFO, 0, &m_pi);
			LogTraceObj(L"end\n");
		}
Пример #6
0
	Item& Item::operator =(this_type&& other)
	{
		LogTraceObj();
		m_hndl = other.m_hndl;
		other.m_hndl = nullptr;
		return *this;
	}
Пример #7
0
		~DebugSymbols()
		{
			LogTraceObj();
			bool ret = os::Dbghelp_dll::inst().SymCleanup(::GetCurrentProcess());
			LogErrorIf(!ret, "%s", totext::api_error().c_str());
			UNUSED(ret);
		}
Пример #8
0
	void Plugin::GetPluginInfo(PluginInfo* info)
	{
		LogTraceObj();
		info->Flags = PF_NONE;

		static GUID PluginMenuGuids[] = {MenuGuid, };
		static const wchar_t* PluginMenuStrings[1];
		PluginMenuStrings[0] = far3::message::get(far3::message::MenuTitle);

		if (get_global_info()->addToPluginsMenu) {
			info->PluginMenu.Guids = PluginMenuGuids;
			info->PluginMenu.Strings = PluginMenuStrings;
			info->PluginMenu.Count = lengthof(PluginMenuStrings);
		}

		static const wchar_t* DiskStrings[1];
		DiskStrings[0] = far3::message::get(far3::message::DiskTitle);
		if (get_global_info()->addToDisksMenu) {
			info->DiskMenu.Guids = PluginMenuGuids;
			info->DiskMenu.Strings = DiskStrings;
			info->DiskMenu.Count = lengthof(DiskStrings);
		}

		info->PluginConfig.Guids = PluginMenuGuids;
		info->PluginConfig.Strings = PluginMenuStrings;
		info->PluginConfig.Count = lengthof(PluginMenuStrings);
		info->CommandPrefix = get_global_info()->prefix.c_str();
	}
Пример #9
0
	void Scheduler::unregister_interest(IEventHandler* callback)
	{
		UNUSED(callback);
		LogTraceObj("%p", callback);
		CRT_ASSERT(callback);
//		impl->del_mapping(callback);
	}
Пример #10
0
	QueueImpl::QueueImpl(const char* name) :
		cs(name),
		se(name),
		name(name)
	{
		LogTraceObj("(%s)", name);
	}
Пример #11
0
	ImplNodeEx::ImplNodeEx(const ustring& name)
		: name_(name)
	{
		LogTraceObj();
		LogTrace2(L"('%s', '%s')", this->name(), parent_ ? parent_->name() : L"");
		memory::zero(data_);
		update();
	}
Пример #12
0
	bool Scheduler::SchedulerImpl::cancel_task(ITask* task)
	{
		LogTraceObj("(%p)", task);
		auto deleted = del_task(task);
		if (!deleted && task == currentTask) {
			LogDebug("we are trying to cancel task already running: %p", task);
			if (thread::get_id() == thread->get_id()) {
				LogInfo("cancelling task from itself: %p", task);
			} else {
				LogAtten("waiting till task is finished: %p", task);
				while (task == currentTask)
					sync::sleep(0);
			}
		}
		LogTraceObj("(%p) -> %d", task, deleted);
		return deleted;
	}
Пример #13
0
	bool Scheduler::SchedulerImpl::add_task(ITask* task, int64_t activateTime)
	{
		LogTraceObj("(%p, %I64d)", task, activateTime);
		auto guard = simstd::auto_lock(*this);
		auto position = simstd::upper_bound(tasksOrder.cbegin(), tasksOrder.cend(), activateTime, TaskPlanGreater());
		auto firstOnExecute = position == tasksOrder.cend(); // sort is descending
		tasksOrder.emplace(position, activateTime, task);
		return firstOnExecute;
	}
Пример #14
0
	Item::~Item()
	{
		LogTraceObj();
//		LogTrace2("%p", m_hndl);
		if (m_hndl) {
			::CloseServiceHandle(m_hndl);
			m_hndl = nullptr;
		}
	}
Пример #15
0
		explicit DebugSymbols(const char* path)
		{
			LogTraceObj();
			os::Dbghelp_dll::inst().SymSetOptions(os::Dbghelp_dll::inst().SymGetOptions() | /*SYMOPT_DEFERRED_LOADS | */SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_LOAD_LINES);
			bool ret = os::Dbghelp_dll::inst().SymInitializeW(::GetCurrentProcess(), sstr::a2w(path).c_str(), TRUE);
			LogDebugIf(ret, "['%s']", path);
			LogErrorIf(!ret, "['%s'] -> %s", path, totext::api_error().c_str());
			UNUSED(ret);
		}
Пример #16
0
	void QueueImpl::put(Message&& message)
	{
		LogTraceObj("['%s'] Message(0x%IX(%Iu, %Iu, %Iu))", name.c_str(), message->get_code(), message->get_a(), message->get_b(), message->get_c());
		{
			auto guard = simstd::auto_lock(cs);
			emplace_back(simstd::move(message));
		}
		se.unlock();
	}
Пример #17
0
	ImplNodeEx::ImplNodeEx(const ustring& name, const Node& parent)
		: name_(name)
		, parent_(parent)
	{
		LogTraceObj();
		LogTrace2(L"('%s')", this->name());
		memory::zero(data_);
		update();
	}
Пример #18
0
traceback::Bfd::Context::~Context()
{
	if (image)
		LogTraceObj(L"[%s]", image);
	HostFree(memory::heap::DefaultStat, symbol);
	if (handle)
		bfd_close(handle);
	HostFree(memory::heap::DefaultStat, image);
}
Пример #19
0
	bool Scheduler::arrange(ITask* task, int64_t timeout)
	{
		LogTraceObj("(%p, %I64d)", task, timeout);
		if (impl->destroying)
			return false;

		if (impl->is_exist(task))
			return true;

		auto nowTime = sync::now();
		auto activateTime = nowTime + timeout;
		LogTraceObj("nowTime: %I64d, activateTime: %I64d", nowTime, activateTime);

		if (impl->add_task(task, activateTime)) {
			LogDebug("task is first in queue, updating wait time");
			impl->messg_queue->put_message(message::Dt::SCHEDULER | message::Et::UPDATE);
		}
		return true;
	}
Пример #20
0
	void Scheduler::SchedulerImpl::fire_tasks()
	{
		LogTraceObj();
		while (get_task_to_activate(currentTask, sync::now())) {
			LogDebug("task starting: %p, '%s'", currentTask, currentTask->get_name());
			currentTask->execute(false);
			LogDebug("task ended: %p", currentTask);
			currentTask = nullptr;
		}
	}
Пример #21
0
	void Scheduler::terminate()
	{
		LogTraceObj();

		if (!impl->destroying) {
			impl->destroying = true;
			impl->messg_queue->put_message(message::Dt::SCHEDULER | message::Et::STOP);
		}

		impl->wait();
	}
Пример #22
0
	WaitResult_t QueueImpl::get(Message& message, int64_t timeout_msec)
	{
		LogTraceObj("['%s'] (0x%I64X%s)", name.c_str(), timeout_msec, timeout_msec == TIMEOUT_INFINITE ? " INFINITE" : "");
		auto waitResult = se.try_lock_ex(timeout_msec);
		if (waitResult == WaitResult_t::SUCCESS) {
			auto guard = simstd::auto_lock(cs);
			message = simstd::move(front());
			erase(cbegin());
		}
		LogAttenIf(waitResult != WaitResult_t::SUCCESS, "['%s'] -> '%S'", name.c_str(), totext::c_str(waitResult));
		LogDebugIf(waitResult == WaitResult_t::SUCCESS, "['%s'] -> '%S' Message(0x%IX(%Iu, %Iu, %Iu))", name.c_str(), totext::c_str(waitResult), message->get_code(), message->get_a(), message->get_b(), message->get_c());
		return waitResult;
	}
Пример #23
0
	void Scheduler::register_interest(IEventHandler* callback, message::param_type /*type*/, message::param_type /*mask*/, bool /*broadcastAlso*/)
	{
		UNUSED(callback);
		LogTraceObj("%p", callback);
		CRT_ASSERT(callback);

		if (impl->destroying)
			return;

//		auto subId = (broadcastAlso) ? delivery::subscribe(impl->messg_queue, type, mask) : delivery::SubscribtionId();

//		impl->add_handler(callback, type, mask, subId);
	}
Пример #24
0
	ImplNodeEx::ImplNodeEx(const fsys::IFindStat& stat, const Node& parent) noexcept
		: name_(stat.name())
		, parent_(parent)
	{
		LogTraceObj();
		LogTrace2(L"('%s', '%s')", this->name(), parent ? parent->name() : L"");
		memory::zero(data_);
		data_.dwFileAttributes = static_cast<decltype(data_.dwFileAttributes)>(stat.attr());
		data_.ftCreationTime.dwHighDateTime = static_cast<decltype(data_.ftCreationTime.dwHighDateTime)>(high_part_64(stat.ctime()));
		data_.ftCreationTime.dwLowDateTime = static_cast<decltype(data_.ftCreationTime.dwLowDateTime)>(low_part_64(stat.ctime()));
		data_.ftLastAccessTime.dwHighDateTime = static_cast<decltype(data_.ftLastAccessTime.dwHighDateTime)>(high_part_64(stat.atime()));
		data_.ftLastAccessTime.dwLowDateTime = static_cast<decltype(data_.ftLastAccessTime.dwLowDateTime)>(low_part_64(stat.atime()));
		data_.ftLastWriteTime.dwHighDateTime = static_cast<decltype(data_.ftLastWriteTime.dwHighDateTime)>(high_part_64(stat.mtime()));
		data_.ftLastWriteTime.dwLowDateTime = static_cast<decltype(data_.ftLastWriteTime.dwLowDateTime)>(low_part_64(stat.mtime()));
		data_.nFileSizeHigh = static_cast<decltype(data_.nFileSizeHigh)>(high_part_64(stat.size()));
		data_.nFileSizeLow = static_cast<decltype(data_.nFileSizeLow)>(low_part_64(stat.size()));
	}
Пример #25
0
traceback::Bfd::Context::Context(const char* image) :
	image(cstr::dup(image)),
	handle(),
	symbol()
{
	LogTraceObj("(%s)", image);

	bfd* b = bfd_openr(image, 0);
	if (!b) {
		LogError("Failed to open bfd from (%s)", image);
		return;
	}

	auto r1 = bfd_check_format(b, bfd_object);
	auto r2 = bfd_check_format_matches(b, bfd_object, NULL);
	auto r3 = bfd_get_file_flags(b) & HAS_SYMS;

	if (!(r1 && r2 && r3)) {
		bfd_close(b);
		LogError("Failed to init bfd from (%d, %d, %d) (%s)", r1, r2, r3, image);
		return;
	}

	void* symbol_table = nullptr;
	unsigned dummy = 0;
	if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) {
		if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) {
			free(symbol_table);
			bfd_close(b);
			LogError("Failed to read symbols from (%s)", image);
			return;
		}
	}

	handle = b;
	symbol = (asymbol**)symbol_table;
}
Пример #26
0
	ssize_t Scheduler::SchedulerImpl::run(void* data)
	{
		UNUSED(data);

		LogTraceObj();
		while (true) {
			auto activateClock = get_activate_time();
//			LogTraceObj(L"activateClock: %I64d", activateClock);
			auto activateTimeout = (activateClock == TIMEOUT_INFINITE) ? TIMEOUT_INFINITE : activateClock - simstd::min(activateClock, sync::now());
//			LogTraceObj(L"activateTimeout: %I64d", activateTimeout);

			Message msg;
			auto reason = messg_queue->get(msg, activateTimeout);
			if (reason == WaitResult_t::SUCCESS) {
				if (msg->check(message::Dt::MASK, message::Dt::SCHEDULER)) {
					if (msg->check(message::Et::MASK, message::Et::STOP)) {
						break;
					}
					if (msg->check(message::Et::MASK, message::Et::UPDATE)) {
						LogDebug2("update message received");
						fire_tasks();
					}
				} else {
					notify(msg);
				}
			} else if (reason == WaitResult_t::TIMEOUT) {
				fire_tasks();
			} else {
				break;
			}
		}

		LogInfo("finishing thread");
		::TerminateThread(::GetCurrentThread(), 0);
		return 0;
	}
Пример #27
0
	Scheduler::SchedulerImpl::~SchedulerImpl()
	{
		LogTraceObj("() [%Id]", messg_queue.use_count());
		CRT_ASSERT(messg_queue.unique());
	}
Пример #28
0
	Queue Scheduler::queue() const
	{
		LogTraceObj();
		return impl->messg_queue;
	}
Пример #29
0
	bool Scheduler::disarrange(ITask* task)
	{
		LogTraceObj("(%p)", task);
		return impl->cancel_task(task);
	}
Пример #30
0
	Scheduler::~Scheduler()
	{
		LogTraceObj();
		terminate();
		LogTraceObj();
	}