Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/**
* @file mce-dsme.c
* Interface code and logic between
* DSME (the Device State Management Entity)
* and MCE (the Mode Control Entity)
* <p>
* Copyright © 2004-2011 Nokia Corporation and/or its subsidiary(-ies).
* Copyright © 2012-2019 Jolla Ltd.
* <p>
* @author David Weinehall <david.weinehall@nokia.com>
* @author Ismo Laitinen <ismo.laitinen@nokia.com>
* @author Tapio Rantala <ext-tapio.rantala@nokia.com>
* @author Santtu Lakkala <ext-santtu.1.lakkala@nokia.com>
* @author Simo Piiroinen <simo.piiroinen@jollamobile.com>
*
* mce is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 2.1 as published by the Free Software Foundation.
*
* mce is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mce. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mce-dsme.h"
#include "mce.h"
#include "mce-log.h"
#include "mce-dbus.h"
#include "mce-worker.h"
#include <stdlib.h>
#include <unistd.h>
#include <dsme/state.h>
#include <dsme/protocol.h>
#include <dsme/processwd.h>
#include <dsme/thermalmanager_dbus_if.h>
/* ========================================================================= *
* MODULE DATA
* ========================================================================= */
/** Pointer to the dsmesock connection */
static dsmesock_connection_t *mce_dsme_socket_connection = NULL;
/** I/O watch for mce_dsme_socket_connection */
static guint mce_dsme_socket_recv_id = 0;
/** ID for delayed state transition reporting timer */
static guint mce_dsme_transition_id = 0;
/** Availability of dsme; from dsme_service_state_pipe */
static service_state_t dsme_service_state = SERVICE_STATE_UNDEF;
/** Availability of thermalmanager; from thermalmanager_service_state_pipe */
static service_state_t thermalmanager_service_state = SERVICE_STATE_UNDEF;
/** System state from dsme; fed to system_state_pipe */
static system_state_t system_state = MCE_SYSTEM_STATE_UNDEF;
/** Thermal state from thermalmanager (dsme); fed to thermal_state_pipe */
static thermal_state_t thermal_state = THERMAL_STATE_UNDEF;
/** Shutdown warning from dsme; fed to shutting_down_pipe */
static bool mce_dsme_shutting_down_flag = false;
/** Cached init_done state; assume unknown */
static tristate_t init_done = TRISTATE_UNKNOWN;
/* ========================================================================= *
* MODULE FUNCTIONS
* ========================================================================= */
/* ------------------------------------------------------------------------- *
* UTILITY_FUNCTIONS
* ------------------------------------------------------------------------- */
static thermal_state_t mce_dsme_parse_thermal_state (const char *name);
static system_state_t mce_dsme_normalise_system_state (dsme_state_t dsmestate);
/* ------------------------------------------------------------------------- *
* WORKER_WATCHDOG
* ------------------------------------------------------------------------- */
static void mce_dsme_worker_done_cb (void *aptr, void *reply);
static void *mce_dsme_worker_pong_cb (void *aptr);
static void mce_dsme_worker_ping (void);;
/* ------------------------------------------------------------------------- *
* PROCESS_WATCHDOG
* ------------------------------------------------------------------------- */
static void mce_dsme_processwd_pong (void);
static void mce_dsme_processwd_init (void);
static void mce_dsme_processwd_quit (void);
/* ------------------------------------------------------------------------- *
* SYSTEM_STATE
* ------------------------------------------------------------------------- */
static void mce_dsme_query_system_state (void);
void mce_dsme_request_powerup (void);
void mce_dsme_request_reboot (void);
void mce_dsme_request_normal_shutdown (void);
/* ------------------------------------------------------------------------- *
* TRANSITION_SUBMODE
* ------------------------------------------------------------------------- */
static gboolean mce_dsme_transition_cb (gpointer data);
static void mce_dsme_transition_cancel (void);
static void mce_dsme_transition_schedule (void);
/* ------------------------------------------------------------------------- *
* SHUTTING_DOWN
* ------------------------------------------------------------------------- */
static bool mce_dsme_is_shutting_down (void);
static void mce_dsme_set_shutting_down (bool shutting_down);
/* ------------------------------------------------------------------------- *
* SOCKET_CONNECTION
* ------------------------------------------------------------------------- */
static bool mce_dsme_socket_send (void *msg);
static gboolean mce_dsme_socket_recv_cb (GIOChannel *source, GIOCondition condition, gpointer data);
static bool mce_dsme_socket_is_connected (void);
static bool mce_dsme_socket_connect (void);
static void mce_dsme_socket_disconnect (void);
/* ------------------------------------------------------------------------- *
* DBUS_HANDLERS
* ------------------------------------------------------------------------- */
static gboolean mce_dsme_dbus_thermal_state_change_cb (DBusMessage *const msg);
static void mce_dsme_dbus_thermal_state_reply_cb (DBusPendingCall *pc, void *aptr);
static void mce_dsme_dbus_cancel_thermal_state_query(void);
static void mce_dsme_dbus_start_thermal_state_query (void);
static gboolean mce_dsme_dbus_init_done_cb (DBusMessage *const msg);
static gboolean mce_dsme_dbus_shutdown_cb (DBusMessage *const msg);
static gboolean mce_dsme_dbus_thermal_shutdown_cb (DBusMessage *const msg);
static gboolean mce_dsme_dbus_battery_empty_shutdown_cb (DBusMessage *const msg);
static void mce_dsme_dbus_init(void);
static void mce_dsme_dbus_quit(void);
/* ------------------------------------------------------------------------- *
* DATAPIPE_TRACKING
* ------------------------------------------------------------------------- */
static void mce_dsme_datapipe_set_thermal_state (thermal_state_t state);
static void mce_dsme_datapipe_dsme_service_state_cb (gconstpointer data);
static void mce_dsme_datapipe_thermalmanager_service_state_cb(gconstpointer const data);
static void mce_dsme_datapipe_init_done_cb (gconstpointer data);
static void mce_dsme_datapipe_system_state_cb (gconstpointer data);
static void mce_dsme_datapipe_init(void);
static void mce_dsme_datapipe_quit(void);
/* ------------------------------------------------------------------------- *
* MODULE_INIT_EXIT
* ------------------------------------------------------------------------- */
gboolean mce_dsme_init(void);
void mce_dsme_exit(void);
/* ========================================================================= *
* UTILITY_FUNCTIONS
* ========================================================================= */
/** Convert system states used by dsme to the ones used in mce datapipes
*
* @param dsmestate System state constant used by dsme
*
* @return System state constant used within mce
*/
static system_state_t mce_dsme_normalise_system_state(dsme_state_t dsmestate)
{
system_state_t state = MCE_SYSTEM_STATE_UNDEF;
switch (dsmestate) {
case DSME_STATE_SHUTDOWN:
state = MCE_SYSTEM_STATE_SHUTDOWN;
break;
case DSME_STATE_USER:
state = MCE_SYSTEM_STATE_USER;
break;
case DSME_STATE_ACTDEAD:
state = MCE_SYSTEM_STATE_ACTDEAD;
break;
case DSME_STATE_REBOOT:
state = MCE_SYSTEM_STATE_REBOOT;
break;
case DSME_STATE_BOOT:
state = MCE_SYSTEM_STATE_BOOT;
break;
case DSME_STATE_NOT_SET:
break;
case DSME_STATE_TEST:
mce_log(LL_WARN,
"Received DSME_STATE_TEST; treating as undefined");
break;
case DSME_STATE_MALF:
mce_log(LL_WARN,
"Received DSME_STATE_MALF; treating as undefined");
break;
case DSME_STATE_LOCAL:
mce_log(LL_WARN,
"Received DSME_STATE_LOCAL; treating as undefined");
break;
default:
mce_log(LL_ERR,
"Received an unknown state from DSME; "
"treating as undefined");
break;
}
return state;
}
/** Convert thermal manager thermal state name to mce thermal_state_t
*
* @param name Thermal state name as received over D-Bus
*
* @return name mapped to thermal_state_t enumeration value
*/
static thermal_state_t mce_dsme_parse_thermal_state(const char *name)
{
thermal_state_t state = THERMAL_STATE_UNDEF;
if( name == 0 )
;
else if( !strcmp(name, thermalmanager_thermal_status_low) )
state = THERMAL_STATE_OK;
else if( !strcmp(name, thermalmanager_thermal_status_normal) )
state = THERMAL_STATE_OK;
else if( !strcmp(name, thermalmanager_thermal_status_warning) )
state = THERMAL_STATE_OK;
else if( !strcmp(name, thermalmanager_thermal_status_alert) )
state = THERMAL_STATE_OVERHEATED;
else if( !strcmp(name, thermalmanager_thermal_status_fatal) )
state = THERMAL_STATE_OVERHEATED;
return state;
}
/* ========================================================================= *
* WORKER_WATCHDOG
* ========================================================================= */
/** Validation context for the jobs passed from this module */
#define MCE_DSME_WORKERWD_JOB_CONTEXT "mce-dsme"
/** Descriptive name for the dummy sanity check worker thread jobs */
#define MCE_DSME_WORKERWD_JOB_NAME "ping"
/** Number of worker jobs scheduled */
static guint mce_dsme_worker_ping_cnt = 0;
/** Number of worker jobs executed */
static guint mce_dsme_worker_pong_cnt = 0;
/** Number of worker jobs notified */
static guint mce_dsme_worker_done_cnt = 0;
/** Flag for: worker thread issues noticed */
static bool mce_dsme_worker_misbehaving = false;
/** Handle dummy job finished notification
*
* @param aptr Ping count passed to the worker thread (as void pointer)
* @param reply Ping count returned from the worker thread (as void pointer)
*/
static void mce_dsme_worker_done_cb(void *aptr, void *reply)
{
(void)reply;
mce_dsme_worker_done_cnt = GPOINTER_TO_INT(aptr);
/* Check if the last job scheduled matches what got executed
* and notified as finished */
if( mce_dsme_worker_ping_cnt != mce_dsme_worker_pong_cnt ||
mce_dsme_worker_ping_cnt != mce_dsme_worker_done_cnt ) {
mce_log(LL_CRIT, "worker thread is misbehaving");
mce_dsme_worker_misbehaving = true;
}
}
/** Dummy job to be executed by the worker thread
*
* @param aptr Ping count (as void pointer)
*
* @return Ping count (as void pointer)
*/
static void *mce_dsme_worker_pong_cb(void *aptr)
{
/* Note: This is executed in the worker thread context */
mce_dsme_worker_pong_cnt = GPOINTER_TO_INT(aptr);
/* Check if the job we got to execute is the latest one
* scheduled from the main thread */
if( mce_dsme_worker_ping_cnt != mce_dsme_worker_pong_cnt ) {
mce_log(LL_CRIT, "worker thread is misbehaving");
mce_dsme_worker_misbehaving = true;
}
return aptr;
}
/** Run a dummy job through worker thread to make sure it is still functioning
*/
static void mce_dsme_worker_ping(void)
{
/* Check if previous job got executed as expected */
if( mce_dsme_worker_ping_cnt != mce_dsme_worker_pong_cnt ||
mce_dsme_worker_ping_cnt != mce_dsme_worker_done_cnt ) {
mce_log(LL_CRIT, "worker thread is possibly stuck");
mce_dsme_worker_misbehaving = true;
}
else if( mce_dsme_worker_misbehaving ) {
mce_dsme_worker_misbehaving = false;
mce_log(LL_CRIT, "worker thread is working again");
}
mce_dsme_worker_ping_cnt += 1;
mce_worker_add_job(MCE_DSME_WORKERWD_JOB_CONTEXT,
MCE_DSME_WORKERWD_JOB_NAME,
mce_dsme_worker_pong_cb,
mce_dsme_worker_done_cb,
GINT_TO_POINTER(mce_dsme_worker_ping_cnt));
}
/* ========================================================================= *
* PROCESS_WATCHDOG
* ========================================================================= */
/**
* Send pong message to the DSME process watchdog
*/
static void mce_dsme_processwd_pong(void)
{
/* Set up the message */
DSM_MSGTYPE_PROCESSWD_PONG msg =
DSME_MSG_INIT(DSM_MSGTYPE_PROCESSWD_PONG);
msg.pid = getpid();
/* Send the message */
mce_dsme_socket_send(&msg);
/* Run worker thread sanity check */
mce_dsme_worker_ping();
/* Execute hearbeat actions even if ping-pong ipc failed */
datapipe_exec_full(&heartbeat_event_pipe, GINT_TO_POINTER(0));
}
/**
* Register to DSME process watchdog
*/
static void mce_dsme_processwd_init(void)
{
/* Set up the message */
DSM_MSGTYPE_PROCESSWD_CREATE msg =
DSME_MSG_INIT(DSM_MSGTYPE_PROCESSWD_CREATE);
msg.pid = getpid();
/* Send the message */
mce_dsme_socket_send(&msg);
}
/**
* Unregister from DSME process watchdog
*/
static void mce_dsme_processwd_quit(void)
{
mce_log(LL_DEBUG, "Disabling DSME process watchdog");
/* Set up the message */
DSM_MSGTYPE_PROCESSWD_DELETE msg =
DSME_MSG_INIT(DSM_MSGTYPE_PROCESSWD_DELETE);
msg.pid = getpid();
/* Send the message */
mce_dsme_socket_send(&msg);
}
/* ========================================================================= *
* SYSTEM_STATE
* ========================================================================= */
/** Send system state inquiry
*/
static void mce_dsme_query_system_state(void)
{
/* Set up the message */
DSM_MSGTYPE_STATE_QUERY msg = DSME_MSG_INIT(DSM_MSGTYPE_STATE_QUERY);
/* Send the message */
mce_dsme_socket_send(&msg);
}
/** Request powerup
*/
void mce_dsme_request_powerup(void)
{
/* Set up the message */
DSM_MSGTYPE_POWERUP_REQ msg = DSME_MSG_INIT(DSM_MSGTYPE_POWERUP_REQ);
/* Send the message */
mce_dsme_socket_send(&msg);
}
/** Request reboot
*/
void mce_dsme_request_reboot(void)
{
if( datapipe_get_gint(osupdate_running_pipe) ) {
mce_log(LL_WARN, "reboot blocked; os update in progress");
goto EXIT;
}
/* Set up the message */
DSM_MSGTYPE_REBOOT_REQ msg = DSME_MSG_INIT(DSM_MSGTYPE_REBOOT_REQ);
/* Send the message */
mce_dsme_socket_send(&msg);
EXIT:
return;
}
/** Request normal shutdown
*/
void mce_dsme_request_normal_shutdown(void)
{
if( datapipe_get_gint(osupdate_running_pipe) ) {
mce_log(LL_WARN, "shutdown blocked; os update in progress");
goto EXIT;
}
/* Set up the message */
DSM_MSGTYPE_SHUTDOWN_REQ msg = DSME_MSG_INIT(DSM_MSGTYPE_SHUTDOWN_REQ);
/* Send the message */
mce_dsme_socket_send(&msg);
EXIT:
return;
}
/* ========================================================================= *
* TRANSITION_SUBMODE
* ========================================================================= */
/** Timer callback for ending transition submode
*
* @param data (not used)
*
* @return Always returns FALSE, to disable the timeout
*/
static gboolean mce_dsme_transition_cb(gpointer data)
{
(void)data;
mce_dsme_transition_id = 0;
mce_rem_submode_int32(MCE_SUBMODE_TRANSITION);
return FALSE;
}
/** Cancel delayed end of transition submode
*/
static void mce_dsme_transition_cancel(void)
{
if( mce_dsme_transition_id ) {
g_source_remove(mce_dsme_transition_id),
mce_dsme_transition_id = 0;
}
}
/** Schedule delayed end of transition submode
*/
static void mce_dsme_transition_schedule(void)
{
/* Remove existing timeout */
mce_dsme_transition_cancel();
/* Check if we have transition to end */
if( !(mce_get_submode_int32() & MCE_SUBMODE_TRANSITION) )
goto EXIT;
#if TRANSITION_DELAY > 0
/* Setup new timeout */
mce_dsme_transition_id =
g_timeout_add(TRANSITION_DELAY, mce_dsme_transition_cb, NULL);
#elif TRANSITION_DELAY == 0
/* Set up idle callback */
mce_dsme_transition_id =
g_idle_add(mce_dsme_transition_cb, NULL);
#else
/* Trigger immediately */
mce_dsme_transition_cb(0);
#endif
EXIT:
return;
}
/* ========================================================================= *
* SHUTTING_DOWN
* ========================================================================= */
/** Predicate for: device is shutting down
*
* @return true if shutdown is in progress, false otherwise
*/
static bool mce_dsme_is_shutting_down(void)
{
return mce_dsme_shutting_down_flag;
}
/** Update device is shutting down state
*
* @param shutting_down true if shutdown has started, false otherwise
*/
static void mce_dsme_set_shutting_down(bool shutting_down)
{
if( mce_dsme_shutting_down_flag == shutting_down )
goto EXIT;
mce_dsme_shutting_down_flag = shutting_down;
mce_log(LL_DEVEL, "Shutdown %s",
mce_dsme_shutting_down_flag ? "started" : "canceled");
/* Re-evaluate dsmesock connection */
if( !mce_dsme_shutting_down_flag )
mce_dsme_socket_connect();
datapipe_exec_full(&shutting_down_pipe,
GINT_TO_POINTER(mce_dsme_shutting_down_flag));
EXIT:
return;
}
/* ========================================================================= *
* SOCKET_CONNECTION
* ========================================================================= */
/**
* Generic send function for dsmesock messages
*
* @param msg A pointer to the message to send
*/
static bool mce_dsme_socket_send(void *msg)
{
bool res = false;
if( !mce_dsme_socket_connection ) {
mce_log(LL_WARN, "failed to send %s to dsme; %s",
dsmemsg_name(msg), "not connected");
goto EXIT;
}
if( dsmesock_send(mce_dsme_socket_connection, msg) == -1) {
mce_log(LL_ERR, "failed to send %s to dsme; %m",
dsmemsg_name(msg));
}
mce_log(LL_DEBUG, "%s sent to DSME", dsmemsg_name(msg));
res = true;
EXIT:
return res;
}
/** Callback for pending I/O from dsmesock
*
* @param source (not used)
* @param condition I/O condition that caused the callback to be called
* @param data (not used)
*
* @return TRUE if iowatch is to be kept, or FALSE if it should be removed
*/
static gboolean mce_dsme_socket_recv_cb(GIOChannel *source,
GIOCondition condition,
gpointer data)
{
gboolean keep_going = TRUE;
dsmemsg_generic_t *msg = 0;
DSM_MSGTYPE_STATE_CHANGE_IND *msg2;
(void)source;
(void)data;
if( condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL) ) {
if( !mce_dsme_is_shutting_down() )
mce_log(LL_CRIT, "DSME socket hangup/error");
keep_going = FALSE;
goto EXIT;
}
if( !(msg = dsmesock_receive(mce_dsme_socket_connection)) )
goto EXIT;
if( DSMEMSG_CAST(DSM_MSGTYPE_CLOSE, msg) ) {
if( !mce_dsme_is_shutting_down() )
mce_log(LL_WARN, "DSME socket closed");
keep_going = FALSE;
}
else if( DSMEMSG_CAST(DSM_MSGTYPE_PROCESSWD_PING, msg) ) {
mce_dsme_processwd_pong();
}
else if( (msg2 = DSMEMSG_CAST(DSM_MSGTYPE_STATE_CHANGE_IND, msg)) ) {
system_state_t state = mce_dsme_normalise_system_state(msg2->state);
datapipe_exec_full(&system_state_pipe,
GINT_TO_POINTER(state));
}
else {
mce_log(LL_DEBUG, "Unhandled %s message received from DSME",
dsmemsg_name(msg));
}
EXIT:
free(msg);
if( !keep_going ) {
if( !mce_dsme_is_shutting_down() ) {
mce_log(LL_WARN, "DSME i/o notifier disabled;"
" assuming dsme was stopped");
}
/* mark notifier as removed */
mce_dsme_socket_recv_id = 0;
/* close and wait for possible dsme restart */
mce_dsme_socket_disconnect();
}
return keep_going;
}
/** Predicate for: socket connection to dsme exists
*
* @return true if connected, false otherwise
*/
static bool mce_dsme_socket_is_connected(void)
{
return mce_dsme_socket_connection && mce_dsme_socket_recv_id;
}
/** Initialise dsmesock connection
*
* @return true on success, false on failure
*/
static bool mce_dsme_socket_connect(void)
{
GIOChannel *iochan = NULL;
/* No new connections during shutdown */
if( mce_dsme_is_shutting_down() )
goto EXIT;
/* No new connections unless dsme dbus service is up */
if( dsme_service_state != SERVICE_STATE_RUNNING )
goto EXIT;
/* Already connected ? */
if( mce_dsme_socket_recv_id )
goto EXIT;
mce_log(LL_DEBUG, "Opening DSME socket");
if( !(mce_dsme_socket_connection = dsmesock_connect()) ) {
mce_log(LL_ERR, "Failed to open DSME socket");
goto EXIT;
}
mce_log(LL_DEBUG, "Adding DSME socket notifier");
if( !(iochan = g_io_channel_unix_new(mce_dsme_socket_connection->fd)) ) {
mce_log(LL_ERR,"Failed to set up I/O channel for DSME socket");
goto EXIT;
}
mce_dsme_socket_recv_id =
g_io_add_watch(iochan,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
mce_dsme_socket_recv_cb, NULL);
/* Query the current system state; if the mainloop isn't running,
* this will trigger an update when the mainloop starts
*/
mce_dsme_query_system_state();
/* Register with DSME's process watchdog */
mce_dsme_processwd_init();
EXIT:
if( iochan ) g_io_channel_unref(iochan);
if( !mce_dsme_socket_recv_id )
mce_dsme_socket_disconnect();
return mce_dsme_socket_is_connected();
}
/** Close dsmesock connection
*/
static void mce_dsme_socket_disconnect(void)
{
if( mce_dsme_socket_recv_id ) {
mce_log(LL_DEBUG, "Removing DSME socket notifier");
g_source_remove(mce_dsme_socket_recv_id);
mce_dsme_socket_recv_id = 0;
/* Still having had a live socket notifier means: We have
* initiated the dsmesock disconnect and need to deactivate
* the process watchdog before actually disconnecting. */
mce_dsme_processwd_quit();
}
if( mce_dsme_socket_connection ) {
mce_log(LL_DEBUG, "Closing DSME socket");
dsmesock_close(mce_dsme_socket_connection);
mce_dsme_socket_connection = 0;
}
}
/* ========================================================================= *
* DBUS_HANDLERS
* ========================================================================= */
/** Pending thermal state query */
static DBusPendingCall *mce_dsme_thermal_state_query_pc = 0;
/** D-Bus callback for the thermal state change notification signal
*
* @param msg The D-Bus message
*
* @return TRUE
*/
static gboolean
mce_dsme_dbus_thermal_state_change_cb(DBusMessage *const msg)
{
DBusError error = DBUS_ERROR_INIT;
const char *name = 0;
if( !dbus_message_get_args(msg, &error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID)) {
mce_log(LL_ERR, "Failed to parse %s.%s; %s: %s",
dbus_message_get_interface(msg),
dbus_message_get_member(msg),
error.name, error.message);
goto EXIT;
}
mce_log(LL_WARN, "thermal state signal: %s", name);
thermal_state_t state = mce_dsme_parse_thermal_state(name);
mce_dsme_datapipe_set_thermal_state(state);
EXIT:
dbus_error_free(&error);
return TRUE;
}
/** Handle reply to async query made from mce_dsme_thermal_state_query_async()
*/
static void
mce_dsme_dbus_thermal_state_reply_cb(DBusPendingCall *pc, void *aptr)
{
(void)aptr;
DBusMessage *rsp = 0;
DBusError err = DBUS_ERROR_INIT;
const char *name = 0;
if( pc != mce_dsme_thermal_state_query_pc )
goto EXIT;
dbus_pending_call_unref(mce_dsme_thermal_state_query_pc),
mce_dsme_thermal_state_query_pc = 0;
if( !(rsp = dbus_pending_call_steal_reply(pc)) ) {
mce_log(LL_WARN, "no reply");
goto EXIT;
}
if( dbus_set_error_from_message(&err, rsp) ) {
mce_log(LL_WARN, "error reply: %s: %s", err.name, err.message);
goto EXIT;
}
if( !dbus_message_get_args(rsp, &err,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID) ) {
mce_log(LL_WARN, "parse error: %s: %s", err.name, err.message);
goto EXIT;
}
mce_log(LL_DEBUG, "thermal state reply: %s", name);
thermal_state_t state = mce_dsme_parse_thermal_state(name);
mce_dsme_datapipe_set_thermal_state(state);
EXIT:
if( rsp ) dbus_message_unref(rsp);
dbus_error_free(&err);
return;
}
/** Cancel pending async thermal state query
*/
static void
mce_dsme_dbus_cancel_thermal_state_query(void)
{
if( mce_dsme_thermal_state_query_pc ) {
mce_log(LL_DEBUG, "cancel thermal state query");
dbus_pending_call_cancel(mce_dsme_thermal_state_query_pc);
dbus_pending_call_unref(mce_dsme_thermal_state_query_pc);
mce_dsme_thermal_state_query_pc = 0;
}
}
/** Initiate async query to find out current thermal state
*/
static void
mce_dsme_dbus_start_thermal_state_query(void)
{
mce_dsme_dbus_cancel_thermal_state_query();
mce_log(LL_DEBUG, "start thermal state query");
dbus_send_ex(thermalmanager_service,
thermalmanager_path,
thermalmanager_interface,
thermalmanager_get_thermal_state,
mce_dsme_dbus_thermal_state_reply_cb, 0, 0,
&mce_dsme_thermal_state_query_pc,
DBUS_TYPE_INVALID);
}
/** D-Bus callback for the init done notification signal
*
* @param msg The D-Bus message
*
* @return TRUE
*/
static gboolean mce_dsme_dbus_init_done_cb(DBusMessage *const msg)
{
(void)msg;
mce_log(LL_DEVEL, "Received init done notification");
/* Remove transition submode after brief delay */
mce_dsme_transition_schedule();
return TRUE;
}
/** D-Bus callback for the shutdown notification signal
*
* @param msg The D-Bus message
*
* @return TRUE
*/
static gboolean mce_dsme_dbus_shutdown_cb(DBusMessage *const msg)
{
(void)msg;
mce_log(LL_WARN, "Received shutdown notification");
mce_dsme_set_shutting_down(true);
return TRUE;
}
/** D-Bus callback for the thermal shutdown notification signal
*
* @param msg The D-Bus message
*
* @return TRUE
*/
static gboolean
mce_dsme_dbus_thermal_shutdown_cb(DBusMessage *const msg)
{
(void)msg;
mce_log(LL_WARN, "Received thermal shutdown notification");
mce_datapipe_request_display_state(MCE_DISPLAY_ON);
return TRUE;
}
/** D-Bus callback for the battery empty shutdown notification signal
*
* @param msg The D-Bus message
*
* @return TRUE
*/
static gboolean
mce_dsme_dbus_battery_empty_shutdown_cb(DBusMessage *const msg)
{
(void)msg;
mce_log(LL_WARN, "Received battery empty shutdown notification");
mce_datapipe_request_display_state(MCE_DISPLAY_ON);
return TRUE;
}
/** Array of dbus message handlers */
static mce_dbus_handler_t mce_dsme_dbus_handlers[] =
{
/* signals */
{
.interface = "com.nokia.startup.signal",
.name = "init_done",
.type = DBUS_MESSAGE_TYPE_SIGNAL,
.callback = mce_dsme_dbus_init_done_cb,
},
{
.interface = "com.nokia.dsme.signal",
.name = "shutdown_ind",
.type = DBUS_MESSAGE_TYPE_SIGNAL,
.callback = mce_dsme_dbus_shutdown_cb,
},
{
.interface = "com.nokia.dsme.signal",
.name = "thermal_shutdown_ind",
.type = DBUS_MESSAGE_TYPE_SIGNAL,
.callback = mce_dsme_dbus_thermal_shutdown_cb,
},
{
.interface = "com.nokia.dsme.signal",
.name = "battery_empty_ind",
.type = DBUS_MESSAGE_TYPE_SIGNAL,
.callback = mce_dsme_dbus_battery_empty_shutdown_cb,
},
{
.interface = thermalmanager_interface,
.name = thermalmanager_state_change_ind,
.type = DBUS_MESSAGE_TYPE_SIGNAL,
.callback = mce_dsme_dbus_thermal_state_change_cb,
},
/* sentinel */
{
.interface = 0
}
};
/** Add dbus handlers
*/
static void mce_dsme_dbus_init(void)
{
mce_dbus_handler_register_array(mce_dsme_dbus_handlers);
}
/** Remove dbus handlers
*/
static void mce_dsme_dbus_quit(void)
{
mce_dbus_handler_unregister_array(mce_dsme_dbus_handlers);
}
/* ========================================================================= *
* DATAPIPE_TRACKING
* ========================================================================= */
static void mce_dsme_datapipe_set_thermal_state(thermal_state_t state)
{
if( thermal_state != state ) {
/* All thermal state transitions are of interest - except for the
* UNDEF -> OK that is expected to happen during mce startup. */
int level = LL_WARN;
if( thermal_state == THERMAL_STATE_UNDEF && state == THERMAL_STATE_OK )
level = LL_DEBUG;
mce_log(level, "thermal state changed: %s -> %s",
thermal_state_repr(thermal_state),
thermal_state_repr(state));
thermal_state = state;
datapipe_exec_full(&thermal_state_pipe, GINT_TO_POINTER(thermal_state));
}
}
/** Datapipe trigger for dsme availability
*
* @param data DSME D-Bus service availability (as a void pointer)
*/
static void mce_dsme_datapipe_dsme_service_state_cb(gconstpointer const data)
{
service_state_t prev = dsme_service_state;
dsme_service_state = GPOINTER_TO_INT(data);
if( dsme_service_state == prev )
goto EXIT;
mce_log(LL_DEVEL, "DSME dbus service: %s -> %s",
service_state_repr(prev),
service_state_repr(dsme_service_state));
/* Re-evaluate dsmesock connection */
if( dsme_service_state == SERVICE_STATE_RUNNING )
mce_dsme_socket_connect();
EXIT:
return;
}
/** Datapipe trigger for thermalmanager availability
*
* @param data thermalmanager D-Bus service availability (as a void pointer)
*/
static void mce_dsme_datapipe_thermalmanager_service_state_cb(gconstpointer const data)
{
service_state_t prev = thermalmanager_service_state;
thermalmanager_service_state = GPOINTER_TO_INT(data);
if( thermalmanager_service_state == prev )
goto EXIT;
mce_log(LL_DEBUG, "thermalmanager dbus service: %s -> %s",
service_state_repr(prev),
service_state_repr(thermalmanager_service_state));
if( thermalmanager_service_state == SERVICE_STATE_RUNNING )
mce_dsme_dbus_start_thermal_state_query();
else
mce_dsme_dbus_cancel_thermal_state_query();
EXIT:
return;
}
/** Change notifications for init_done
*/
static void mce_dsme_datapipe_init_done_cb(gconstpointer data)
{
tristate_t prev = init_done;
init_done = GPOINTER_TO_INT(data);
if( init_done == prev )
goto EXIT;
mce_log(LL_DEBUG, "init_done = %s -> %s",
tristate_repr(prev),
tristate_repr(init_done));
if( init_done == TRISTATE_TRUE ) {
/* Remove transition submode after brief delay */
mce_dsme_transition_schedule();
}
EXIT:
return;
}
/** Handle system_state_pipe notifications
*
* Implemented as an input trigger to ensure this function gets
* executed before output triggers from other modules/plugins.
*
* @param data The system state (as a void pointer)
*/
static void mce_dsme_datapipe_system_state_cb(gconstpointer data)
{
system_state_t prev = system_state;
system_state = GPOINTER_TO_INT(data);
if( system_state == prev )
goto EXIT;
mce_log(LL_DEVEL, "system_state: %s -> %s",
system_state_repr(prev),
system_state_repr(system_state));
/* Set transition submode unless coming from MCE_SYSTEM_STATE_UNDEF */
if( prev != MCE_SYSTEM_STATE_UNDEF )
mce_add_submode_int32(MCE_SUBMODE_TRANSITION);
/* Handle LED patterns */
switch( system_state ) {
case MCE_SYSTEM_STATE_USER:
datapipe_exec_full(&led_pattern_activate_pipe,
MCE_LED_PATTERN_DEVICE_ON);
break;
case MCE_SYSTEM_STATE_SHUTDOWN:
case MCE_SYSTEM_STATE_REBOOT:
datapipe_exec_full(&led_pattern_deactivate_pipe,
MCE_LED_PATTERN_DEVICE_ON);
break;
default:
break;
}
/* Handle shutdown flag */
switch( system_state ) {
case MCE_SYSTEM_STATE_ACTDEAD:
case MCE_SYSTEM_STATE_USER:
/* Re-entry to actdead/user also means shutdown
* has been cancelled */
mce_dsme_set_shutting_down(false);
break;
case MCE_SYSTEM_STATE_SHUTDOWN:
case MCE_SYSTEM_STATE_REBOOT:
mce_dsme_set_shutting_down(true);
break;
default:
break;
}
EXIT:
return;
}
/** Array of datapipe handlers */
static datapipe_handler_t mce_dsme_datapipe_handlers[] =
{
// input triggers
{
.datapipe = &system_state_pipe,
.input_cb = mce_dsme_datapipe_system_state_cb,
},
// output triggers
{
.datapipe = &dsme_service_state_pipe,
.output_cb = mce_dsme_datapipe_dsme_service_state_cb,
},
{
.datapipe = &thermalmanager_service_state_pipe,
.output_cb = mce_dsme_datapipe_thermalmanager_service_state_cb,
},
{
.datapipe = &init_done_pipe,
.output_cb = mce_dsme_datapipe_init_done_cb,
},
// sentinel
{
.datapipe = 0,
}
};
static datapipe_bindings_t mce_dsme_datapipe_bindings =
{
.module = "mce-dsme",
.handlers = mce_dsme_datapipe_handlers,
};
/** Append triggers/filters to datapipes
*/
static void mce_dsme_datapipe_init(void)
{
mce_datapipe_init_bindings(&mce_dsme_datapipe_bindings);
}
/** Remove triggers/filters from datapipes
*/
static void mce_dsme_datapipe_quit(void)
{
mce_datapipe_quit_bindings(&mce_dsme_datapipe_bindings);
}
/* ========================================================================= *
* MODULE_INIT_EXIT
* ========================================================================= */
/** Init function for the mce-dsme component
*
* @return TRUE on success, FALSE on failure
*/
gboolean mce_dsme_init(void)
{
mce_worker_add_context(MCE_DSME_WORKERWD_JOB_CONTEXT);
mce_dsme_datapipe_init();
mce_dsme_dbus_init();
return TRUE;
}
/** Exit function for the mce-dsme component
*/
void mce_dsme_exit(void)
{
mce_worker_rem_context(MCE_DSME_WORKERWD_JOB_CONTEXT);
mce_dsme_dbus_quit();
mce_dsme_socket_disconnect();
mce_dsme_datapipe_quit();
/* Remove all timer sources & pending calls before returning */
mce_dsme_transition_cancel();
mce_dsme_dbus_cancel_thermal_state_query();
return;
}