ControllerManager::~ControllerManager() {
emit(requestShutdown());
m_pThread->wait();
delete m_pThread;
delete m_pControllerLearningEventFilter;
delete m_pPresetInfoManager;
}
void Initializer::initActivePlugin(const std::string& type,
const std::string& name) const {
// Use a delay, meaning the amount of milliseconds waited for extensions.
size_t delay = 0;
// The timeout is the maximum microseconds in seconds to wait for extensions.
size_t timeout = atoi(FLAGS_extensions_timeout.c_str()) * 1000000;
if (timeout < kExtensionInitializeLatencyUS * 10) {
timeout = kExtensionInitializeLatencyUS * 10;
}
// Attempt to set the request plugin as active.
Status status;
do {
status = Registry::setActive(type, name);
if (status.ok()) {
// The plugin was found, and is not active.
return;
}
if (!Watcher::hasManagedExtensions()) {
// The plugin was found locally, and is not active, problem.
break;
}
// The plugin is not local and is not active, wait and retry.
delay += kExtensionInitializeLatencyUS;
::usleep(kExtensionInitializeLatencyUS);
} while (delay < timeout);
LOG(ERROR) << "Cannot activate " << name << " " << type
<< " plugin: " << status.getMessage();
requestShutdown(EXIT_CATASTROPHIC);
}
void Initializer::initWatcher() const {
// The watcher takes a list of paths to autoload extensions from.
// The loadExtensions call will populate the watcher's list of extensions.
osquery::loadExtensions();
// Add a watcher service thread to start/watch an optional worker and list
// of optional extensions from the autoload paths.
if (Watcher::hasManagedExtensions() || !FLAGS_disable_watchdog) {
Dispatcher::addService(std::make_shared<WatcherRunner>(
*argc_, *argv_, !FLAGS_disable_watchdog));
}
// If there are no autoloaded extensions, the watcher service will end,
// otherwise it will continue as a background thread and respawn them.
// If the watcher is also a worker watchdog it will do nothing but monitor
// the extensions and worker process.
if (!FLAGS_disable_watchdog) {
Dispatcher::joinServices();
// Execution should only reach this point if a signal was handled by the
// worker and watcher.
auto retcode = 0;
if (kHandledSignal > 0) {
retcode = 128 + kHandledSignal;
} else if (Watcher::getWorkerStatus() >= 0) {
retcode = Watcher::getWorkerStatus();
} else {
retcode = EXIT_FAILURE;
}
requestShutdown(retcode);
}
}
// Do the real work associated with terminating a Linux task
void OsTaskLinux::doLinuxTerminateTask(UtlBoolean doForce)
{
OsStatus res;
pthread_t savedTaskId;
OsSysLog::add(FAC_KERNEL, PRI_DEBUG,
"OsTaskLinux::doLinuxTerminateTask, deleting task thread: %x,"
" force = %d", (int)mTaskId, doForce);
// if there is no low-level task, or entry in the name database, just return
if ((mState != UNINITIALIZED) && ((int)mTaskId != 0))
{
// DEBUGGING HACK: Suspend requestor if target is suspended $$$
while (isSuspended())
{
suspend();
}
if (!doForce)
{
// We are being well behaved and will wait until the task is no longer
// safe from deletes. A task is made safe from deletes by acquiring
// a read lock on its mDeleteGuard. In order to delete a task, the
// application must acquire a write lock. This will only happen after
// all of the read lock holders have released their locks.
res = mDeleteGuard.acquireWrite();
assert(res == OS_SUCCESS);
}
savedTaskId = mTaskId; // taskUnregister sets mTaskId to zero;
taskUnregister();
// Send the thread the actual cancellation request.
if (mState == STARTED)
{
requestShutdown();
/* maybe replace this with a call to waitUntilShutDown() ? */
for(int i = 0; i < 10 && isShuttingDown(); i++)
{
delay(100);
}
}
if (mState == SHUTTING_DOWN)
{
if (savedTaskId != 0)
{
pthread_cancel(savedTaskId);
}
}
if (!doForce)
{
res = mDeleteGuard.releaseWrite(); // release the write lock
assert(res == OS_SUCCESS);
}
}
mState = UNINITIALIZED;
}
ControllerManager::ControllerManager(ConfigObject<ConfigValue>* pConfig)
: QObject(),
m_pConfig(pConfig),
// WARNING: Do not parent m_pControllerLearningEventFilter to
// ControllerManager because the CM is moved to its own thread and runs
// its own event loop.
m_pControllerLearningEventFilter(new ControllerLearningEventFilter()),
m_pollTimer(this) {
qRegisterMetaType<ControllerPresetPointer>("ControllerPresetPointer");
// Create controller mapping paths in the user's home directory.
QString userPresets = userPresetsPath(m_pConfig);
if (!QDir(userPresets).exists()) {
qDebug() << "Creating user controller presets directory:" << userPresets;
QDir().mkpath(userPresets);
}
QString localPresets = localPresetsPath(m_pConfig);
if (!QDir(localPresets).exists()) {
qDebug() << "Creating local controller presets directory:" << localPresets;
QDir().mkpath(localPresets);
}
// Initialize preset info parsers
m_pPresetInfoManager = new PresetInfoEnumerator(m_pConfig);
// Instantiate all enumerators
m_enumerators.append(new PortMidiEnumerator());
#ifdef __HSS1394__
m_enumerators.append(new Hss1394Enumerator());
#endif
#ifdef __BULK__
m_enumerators.append(new BulkEnumerator());
#endif
#ifdef __HID__
m_enumerators.append(new HidEnumerator());
#endif
m_pollTimer.setInterval(kPollIntervalMillis);
connect(&m_pollTimer, SIGNAL(timeout()),
this, SLOT(pollDevices()));
m_pThread = new QThread;
m_pThread->setObjectName("Controller");
// Moves all children (including the poll timer) to m_pThread
moveToThread(m_pThread);
// Controller processing needs to be prioritized since it can affect the
// audio directly, like when scratching
m_pThread->start(QThread::HighPriority);
connect(this, SIGNAL(requestSetUpDevices()),
this, SLOT(slotSetUpDevices()));
connect(this, SIGNAL(requestShutdown()),
this, SLOT(slotShutdown()));
connect(this, SIGNAL(requestSave(bool)),
this, SLOT(slotSavePresets(bool)));
}
// stop the BDM thread
void BlockDataManagerThread::shutdownAndWait()
{
requestShutdown();
if (pimpl->tID)
{
pthread_join(pimpl->tID, nullptr);
pimpl->tID=0;
}
}
void TaoListeningTask::shutdownListeners()
{
requestShutdown();
// For each client request shutdown
int iteratorHandle = agentList.getIteratorHandle();
TaoTransportAgent* pAgent = NULL;
while ((pAgent = (TaoTransportAgent*)agentList.next(iteratorHandle)))
{
pAgent->requestShutdown();
}
agentList.releaseIteratorHandle(iteratorHandle);
}
// Wait until the task is shut down and the run method has exited.
// Most sub classes of OsTask should call this method in
// the destructor before deleting any members which are
// accessed by the run method.
UtlBoolean OsTaskBase::waitUntilShutDown(int milliSecToWait)
{
// If task is already shut down, just return.
if (isShutDown())
return TRUE;
UtlString taskName = getName();
if (isStarted() || isUnInitialized())
{
requestShutdown(); // ask the task to shut itself down
yield(); // yield the CPU so the target task can terminate
}
// wait up to another nineteen seconds (20 total) for the task to terminate
// printing out a console complaint every second
if (isShuttingDown())
{
int i;
// wait up to a second for the task to terminate.
for (i = 0; (i < 10) && isShuttingDown(); i++)
delay(milliSecToWait/200); // wait 1/10 second
for (i = 1; (i < 20) && isShuttingDown(); i++)
{
OsSysLog::add(FAC_KERNEL, PRI_WARNING, "Task: %s failed to terminate after %f seconds",
taskName.data(), (milliSecToWait * i) / 20000.0);
delay(milliSecToWait/20);
}
// if still no response from the task, assume it is unresponsive and
// destroy the object
if (isShuttingDown())
{
OsSysLog::add(FAC_KERNEL, PRI_ERR, "Task: %s failed to terminate after %f seconds",
taskName.data(), milliSecToWait / 1000.0);
}
}
// Do not exit if not shut down
while (isShuttingDown())
{
OsSysLog::add(FAC_KERNEL, PRI_ERR, "Task: %s failed to terminate, waiting...",
taskName.data());
delay(300000);
}
return(isShutDown());
}
void shutdownCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result)
{
int num_params = 0;
if (params.getType() == XmlRpc::XmlRpcValue::TypeArray)
num_params = params.size();
if (num_params > 1)
{
std::string reason = params[1];
ROS_WARN("Shutdown request received.");
ROS_WARN("Reason given for shutdown: [%s]", reason.c_str());
requestShutdown();
}
result = xmlrpc::responseInt(1, "", 0);
}
// Destructor
SipClient::~SipClient()
{
Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
"SipClient[%s]::~ called",
mName.data());
// Tell the associated thread to shut itself down.
requestShutdown();
// Do not delete the event listers, as they are not subordinate.
// Free the socket
if(mClientSocket)
{
// Close the socket to unblock the run method
// in case it is blocked in a waitForReadyToRead or
// a read on the mClientSocket. This should also
// cause the run method to exit.
if (!mbSharedSocket)
{
Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "SipClient[%s]::~ %p socket %p closing %s socket",
mName.data(), this,
mClientSocket, OsSocket::ipProtocolString(mSocketType));
mClientSocket->close();
}
// Wait for the task to exit so that it does not
// reference the socket or other members after they
// get deleted.
if(isStarted() || isShuttingDown())
{
waitUntilShutDown();
}
if (!mbSharedSocket)
{
delete mClientSocket;
}
mClientSocket = NULL;
}
else if(isStarted() || isShuttingDown())
{
// It should not get here but just in case
waitUntilShutDown();
}
}
void Initializer::waitForWatcher() const {
// If there are no autoloaded extensions, the watcher service will end,
// otherwise it will continue as a background thread and respawn them.
// If the watcher is also a worker watchdog it will do nothing but monitor
// the extensions and worker process.
if (!FLAGS_disable_watchdog) {
Dispatcher::joinServices();
// Execution should only reach this point if a signal was handled by the
// worker and watcher.
auto retcode = 0;
if (kHandledSignal > 0) {
retcode = 128 + kHandledSignal;
} else if (Watcher::getWorkerStatus() >= 0) {
retcode = Watcher::getWorkerStatus();
} else {
retcode = EXIT_FAILURE;
}
requestShutdown(retcode);
}
}
void Initializer::initActivePlugin(const std::string& type,
const std::string& name) const {
auto status = applyExtensionDelay(([type, name](bool& stop) {
auto rs = RegistryFactory::get().setActive(type, name);
if (rs.ok()) {
// The plugin was found, and is now active.
return rs;
}
if (!Watcher::hasManagedExtensions()) {
// The plugin must be local, and is not active, problem.
stop = true;
}
return rs;
}));
if (!status.ok()) {
LOG(ERROR) << "Cannot activate " << name << " " << type
<< " plugin: " << status.getMessage();
requestShutdown(EXIT_CATASTROPHIC);
}
}
void Initializer::requestShutdown(int retcode, const std::string& system_log) {
systemLog(system_log);
requestShutdown(retcode);
}
// Handle a timer service request.
// Return TRUE if the request was handled, otherwise FALSE.
UtlBoolean OsTimerTask::handleMessage(OsMsg& rMsg)
{
// Process a message.
// If not an OS_TIMERTASK_COMMAND message, return FALSE to indicate it should be
// passed to our superclass.
if (rMsg.getMsgType() != OsMsg::OS_TIMERTASK_COMMAND)
{
return FALSE;
}
// Process an OS_TIMERTASK_COMMAND message.
OsTimerTaskCommandMsg& message = dynamic_cast <OsTimerTaskCommandMsg&> (rMsg);
// Process a OS_TIMER_SHUTDOWN message, which is special
if (message.getMsgSubType() == OsTimerTaskCommandMsg::OS_TIMER_SHUTDOWN)
{
OsSysLog::add(FAC_KERNEL, PRI_INFO,
"OsTimerTask::handleMessage OS_TIMER_SHUTDOWN seen, mState = %d",
mState);
// Verify that there are no other requests in the timer task's queue.
assert(getMessageQueue()->isEmpty());
// Stop all the timers in the timer queue.
OsTimer* link;
for (OsTimer* timer = mTimerQueue; timer; timer = link)
{
// This lock should never block, since the application should not
// be accessing the timer.
OsLock lock(timer->mBSem);
// Check that the application and task states are the same.
// If they aren't, the application is mucking with the timer.
assert(timer->mTaskState == timer->mApplicationState);
// Increment the state fields, to show the timer is stopped.
timer->mTaskState =
timer->mApplicationState = timer->mApplicationState + 1;
// Get the link field.
link = timer->mTimerQueueLink;
// Clear the link field of the timer.
timer->mTimerQueueLink = 0;
}
// Empty the timer queue.
mTimerQueue = 0;
// Change mState so the main loop will exit.
requestShutdown();
// Signal the event so our caller knows we're done.
message.getEventP()->signal(0);
OsSysLog::add(FAC_KERNEL, PRI_INFO,
"OsTimerTask::handleMessage OS_TIMER_SHUTDOWN seen, mState = %d",
mState);
return TRUE;
}
OsTimer* timer = message.getTimerP();
#ifndef NDEBUG
CHECK_VALIDITY(timer);
#endif
unsigned int applicationState;
OsTimer::Time expiresAt;
UtlBoolean periodic;
OsTimer::Interval period;
{
OsLock lock(timer->mBSem);
// mDeleting may be true, if the destructor has started running.
// Decrement the outstanding message count.
timer->mOutstandingMessages--;
// Get mApplicationState.
applicationState = timer->mApplicationState;
// Get the timing information.
expiresAt = timer->mExpiresAt;
periodic = timer->mPeriodic;
period = timer->mPeriod;
}
// Determine whether the timer needs to be stopped.
// (The comparison between applicationState and mTaskState is really
// ">", taking into account wraparound. But that is difficult to
// implement, so given that mApplicationState is always >= mTaskState
// by design, we can use "!=".)
if (applicationState != timer->mTaskState &&
OsTimer::isStarted(timer->mTaskState))
{
// Stop the timer.
removeTimer(timer);
}
// Determine whether the timer needs to be started.
if (applicationState != timer->mTaskState &&
OsTimer::isStarted(applicationState))
{
// Start the timer.
// Set the saved timing information.
timer->mQueuedExpiresAt = expiresAt;
timer->mQueuedPeriodic = periodic;
timer->mQueuedPeriod = period;
insertTimer(timer);
}
// Update the task state.
timer->mTaskState = applicationState;
switch (message.getMsgSubType())
{
case OsTimerTaskCommandMsg::OS_TIMER_UPDATE:
// No further processing is needed.
break;
case OsTimerTaskCommandMsg::OS_TIMER_UPDATE_SYNC:
// If it is an UPDATE_SYNC message, signal the event.
message.getEventP()->signal(0);
break;
case OsTimerTaskCommandMsg::OS_TIMER_UPDATE_DELETE:
// If it is an UPDATE_DELETE, delete the timer.
// Timer will not be accessed by any other thread, so we
// can access it without locking.
#ifndef NDEBUG
// Deletion in progress.
assert(timer->mDeleting);
#endif
// Timer should be stopped already.
assert(OsTimer::isStopped(timer->mApplicationState));
// No outstanding messages.
assert(timer->mOutstandingMessages == 0);
#ifndef NDEBUG
// Set mDeleting to FALSE to the destructor won't fail.
timer->mDeleting = FALSE;
#endif
// Use ordinary destructor to delete the timer.
// Because of the state of the timer, it will not send a message to
// the timer task.
delete timer;
break;
default:
// Catch invalid values.
assert(FALSE);
}
return TRUE;
}
void SipTlsServer::shutdownListener()
{
requestShutdown();
shutdownClients();
}
OsPooledTask::~OsPooledTask()
{
requestShutdown();
}
/*********************************************
SDL event loop
**********************************************/
void Application::processEvents(){
SDL_Event event;
while ( SDL_PollEvent( &event ) ){
switch( event.type ){
case SDL_VIDEORESIZE:
mSurface.onResize(event.resize.w, event.resize.h);
break;
case SDL_QUIT:
//handle quit requests
requestShutdown();
break;
case SDL_MOUSEBUTTONDOWN:
onMouseEvent(event.button.button, event.type);
break;
case SDL_MOUSEBUTTONUP:
onMouseEvent(event.button.button, event.type);
break;
case SDL_KEYDOWN:
onKeyEvent(event.key.keysym.sym, event.type);
break;
case SDL_KEYUP:
onKeyEvent(event.key.keysym.sym, event.type);
break;
default:
break;
}
}
/*
if (!done){
//Do one frames worth of work and figure out the length of time
uint32_t startTime = SDL_GetTicks();
renderMain();
updateMain();
uint32_t endTime = SDL_GetTicks();
//Figure out the scaling factor for FPS-independent movement
uint32_t diff = endTime - startTime;
fTimeScale = (float)diff * fTimeScaleScale;
//Every hour, do a cleanup
if(fCleanupTimer < 0.0f){
ps()->doPeriodicCleanup();
fCleanupTimer = CLEANUP_TIMER;
}
//Update our various timers
fCleanupTimer -= fTimeScale;
fUptime += fTimeScale;
fParticleFPS = fTimeScale;
}
*/
}
void Initializer::start() const {
// Load registry/extension modules before extensions.
osquery::loadModules();
// Pre-extension manager initialization options checking.
// If the shell or daemon does not need extensions and it will exit quickly,
// prefer to disable the extension manager.
if ((FLAGS_config_check || FLAGS_config_dump) &&
!Watcher::hasManagedExtensions()) {
FLAGS_disable_extensions = true;
}
// A watcher should not need access to the backing store.
// If there are spurious access then warning logs will be emitted since the
// set-allow-open will never be called.
if (!isWatcher()) {
DatabasePlugin::setAllowOpen(true);
// A daemon must always have R/W access to the database.
DatabasePlugin::setRequireWrite(tool_ == OSQUERY_TOOL_DAEMON);
if (!DatabasePlugin::initPlugin()) {
LOG(ERROR) << RLOG(1629) << binary_
<< " initialize failed: Could not initialize database";
auto retcode = (isWorker()) ? EXIT_CATASTROPHIC : EXIT_FAILURE;
requestShutdown(retcode);
}
}
// Bind to an extensions socket and wait for registry additions.
// After starting the extension manager, osquery MUST shutdown using the
// internal 'shutdown' method.
osquery::startExtensionManager();
// Then set the config plugin, which uses a single/active plugin.
initActivePlugin("config", FLAGS_config_plugin);
// Run the setup for all lazy registries (tables, SQL).
Registry::setUp();
if (FLAGS_config_check) {
// The initiator requested an initialization and config check.
auto s = Config::getInstance().load();
if (!s.ok()) {
std::cerr << "Error reading config: " << s.toString() << "\n";
}
// A configuration check exits the application.
// Make sure to request a shutdown as plugins may have created services.
requestShutdown(s.getCode());
}
if (FLAGS_database_dump) {
dumpDatabase();
requestShutdown();
}
// Load the osquery config using the default/active config plugin.
auto s = Config::getInstance().load();
if (!s.ok()) {
auto message = "Error reading config: " + s.toString();
if (tool_ == OSQUERY_TOOL_DAEMON) {
LOG(WARNING) << message;
} else {
LOG(INFO) << message;
}
}
// Initialize the status and result plugin logger.
if (!FLAGS_disable_logging) {
initActivePlugin("logger", FLAGS_logger_plugin);
}
initLogger(binary_);
// Initialize the distributed plugin, if necessary
if (!FLAGS_disable_distributed) {
if (Registry::exists("distributed", FLAGS_distributed_plugin)) {
initActivePlugin("distributed", FLAGS_distributed_plugin);
}
}
// Start event threads.
osquery::attachEvents();
EventFactory::delay();
}
void LoginState::requestQuit()
{
requestShutdown();
}
