/**

* @file mce-wakelock.c

* Wakelock multiplexing code for the Mode Control Entity

* <p>

* Copyright (C) 2015 Jolla Ltd.

* <p>

* @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-wakelock.h"

#include "mce-log.h"

#include <stdbool.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <glib.h>

/* ========================================================================= *

* FUNCTIONS & DATA

* ========================================================================= */

/* ------------------------------------------------------------------------- *

* SYSFS_API

* ------------------------------------------------------------------------- */

/** Path to kernel wakelock obtain sysfs file */

static const char mwl_sysfs_lock_path[] = "/sys/power/wake_lock";

/** Path to kernel wakelock release sysfs file */

static const char mwl_sysfs_unlock_path[] = "/sys/power/wake_unlock";

static bool mwl_sysfs_write(const char *path, const char *data, int size);

/* ------------------------------------------------------------------------- *

* RAWLOCK_API

* ------------------------------------------------------------------------- */

/** Name of the multiplexed "real" wakelock */

static const char mwl_rawlock_name[] = "mce_mux";

/** Flag for: "real" wakelock is held */

static bool mce_rawlock_locked = false;

static bool mwl_rawlock_supported (void);

static bool mwl_rawlock_lock (void);

static bool mwl_rawlock_unlock (void);

static void mwl_rawlock_set (bool lock);

/* ------------------------------------------------------------------------- *

* mwl_wakelock_t

* ------------------------------------------------------------------------- */

/** Virtual wakelock object */

typedef struct mwl_wakelock_t

{

/** Name of the virtual wakelock */

gchar *wl_name;

/** Release timer id */

guint wl_timer_id;

} mwl_wakelock_t;

static gboolean mwl_wakelock_timer_cb (gpointer aptr);

static void mwl_wakelock_start_timer (mwl_wakelock_t *self, int delay_ms);

static void mwl_wakelock_stop_timer (mwl_wakelock_t *self);

static mwl_wakelock_t *mwl_wakelock_create (const char *name);

static void mwl_wakelock_delete (mwl_wakelock_t *self);

static void mwl_wakelock_delete_cb (void *self);

/* ------------------------------------------------------------------------- *

* MODULE_API

* ------------------------------------------------------------------------- */

/** Flag for: wakelock module is ready for use */

static bool mce_wakelock_ready = false;

/** Lookup table for tracked wakelock objects */

static GHashTable *mce_wakelock_lut = 0; // [name] -> mwl_wakelock_t *

static mwl_wakelock_t *mce_wakelock_add_entry (const char *name);

static void mce_wakelock_rem_entry (const char *name);

static bool mce_wakelock_have_entries (void);

void mce_wakelock_obtain (const char *name, int duration_ms);

void mce_wakelock_release (const char *name);

void mce_wakelock_init (void);

void mce_wakelock_quit (void);

void mce_wakelock_abort (void);

/* ========================================================================= *

* SYSFS_API

* ========================================================================= */

/** Helper for writing to sysfs files

*/

static bool

mwl_sysfs_write(const char *path, const char *data, int size)

{

bool res = false;

int fd = -1;

if( !path || !data || size <= 0 )

goto cleanup;

if( (fd = open(path, O_WRONLY)) == -1 )

goto cleanup;

if( write(fd, data, size) == -1 )

goto cleanup;

res = true;

cleanup:

if( fd != -1 ) close(fd);

return res;

}

/* ========================================================================= *

* RAWLOCK_API

* ========================================================================= */

/** Predicate for: wakelock sysfs control files exist

*/

static bool

mwl_rawlock_supported(void)

{

return (access(mwl_sysfs_lock_path, W_OK) == 0 &&

access(mwl_sysfs_unlock_path, W_OK) == 0);

}

/** Async signal safe wakelock obtain

*/

static bool

mwl_rawlock_lock(void)

{

return mwl_sysfs_write(mwl_sysfs_lock_path, mwl_rawlock_name,

sizeof mwl_rawlock_name - 1);

}

/** Async signal safe wakelock release

*/

static bool

mwl_rawlock_unlock(void)

{

return mwl_sysfs_write(mwl_sysfs_unlock_path, mwl_rawlock_name,

sizeof mwl_rawlock_name - 1);

}

/** Set wakelock state

*

* @param lock true to obtain real wakelock, false to release

*/

static void

mwl_rawlock_set(bool lock)

{

if( mce_rawlock_locked == lock )

goto EXIT;

mce_log(LL_DEBUG, "wakelock %s", lock ? "obtain" : "release");

errno = 0;

if( (mce_rawlock_locked = lock) ) {

if( !mwl_rawlock_lock() )

mce_log(LL_ERR, "failed to obtain wakelock: %m");

}

else {

if( !mwl_rawlock_unlock() )

mce_log(LL_ERR, "failed to release wakelock: %m");

}

EXIT:

return;

}

/* ========================================================================= *

* mwl_wakelock_t

* ========================================================================= */

/** Timer callback for releasing virtual wakelock

*

* @param aptr wakelock object pointer

*/

static gboolean

mwl_wakelock_timer_cb(gpointer aptr)

{

mwl_wakelock_t *self = aptr;

if( !self )

goto EXIT;

if( !self->wl_timer_id )

goto EXIT;

self->wl_timer_id = 0;

mce_wakelock_release(self->wl_name);

EXIT:

return FALSE;

}

/** Start virtual wakelock object release timer

*

* @param self wakelock object pointer, or NULL

* @param delay_ms delay before releasing wakelock

*/

static void

mwl_wakelock_start_timer(mwl_wakelock_t *self, int delay_ms)

{

if( !self )

goto EXIT;

if( self->wl_timer_id ) {

g_source_remove(self->wl_timer_id),

self->wl_timer_id = 0;

}

if( delay_ms < 0 )

goto EXIT;

if( delay_ms > 0 ) {

self->wl_timer_id = g_timeout_add(delay_ms,

mwl_wakelock_timer_cb,

self);

}

else {

self->wl_timer_id = g_idle_add(mwl_wakelock_timer_cb, self);

}

EXIT:

return;

}

/** Stop virtual wakelock object release timer

*

* @param self wakelock object pointer, or NULL

*/

static void

mwl_wakelock_stop_timer(mwl_wakelock_t *self)

{

if( !self )

goto EXIT;

if( self->wl_timer_id ) {

g_source_remove(self->wl_timer_id),

self->wl_timer_id = 0;

}

EXIT:

return;

}

/** Create virtual wakelock object

*

* @param name Name of wakelock object to create

*

* @return wakelock object pointer

*/

static mwl_wakelock_t *

mwl_wakelock_create(const char *name)

{

mwl_wakelock_t *self = g_malloc0(sizeof *self);

self->wl_name = g_strdup(name);

self->wl_timer_id = 0;

mce_log(LL_DEBUG, "wakelock %s obtain (mux)", self->wl_name);

return self;

}

/** Delete virtual wakelock object

*

* @param self wakelock object pointer, or NULL

*/

static void

mwl_wakelock_delete(mwl_wakelock_t *self)

{

if( !self )

goto EXIT;

mwl_wakelock_stop_timer(self);

mce_log(LL_DEBUG, "wakelock %s release (mux)", self->wl_name);

g_free(self->wl_name);

g_free(self);

EXIT:

return;

}

/** GDestroyNotify compatible delete callback

*

* @param aptr wakelock object pointer (as void pointer), or NULL

*/

static void

mwl_wakelock_delete_cb(void *aptr)

{

mwl_wakelock_delete(aptr);

}

/* ========================================================================= *

* MODULE_API

* ========================================================================= */

/** Lookup or create a wakelock object by name

*

* @param name Name of the virtual wakelock

*

* @return object pointer, or NULL on errors

*/

static mwl_wakelock_t *

mce_wakelock_add_entry(const char *name)

{

mwl_wakelock_t *self = 0;

if( !mce_wakelock_lut )

goto EXIT;

if( !(self = g_hash_table_lookup(mce_wakelock_lut, name)) ) {

self = mwl_wakelock_create(name);

g_hash_table_replace(mce_wakelock_lut, g_strdup(name), self);

}

EXIT:

return self;

}

/** Remove a wakelock object by name

*

* @param name Name of the virtual wakelock

*/

static void

mce_wakelock_rem_entry(const char *name)

{

if( !mce_wakelock_lut )

goto EXIT;

g_hash_table_remove(mce_wakelock_lut, name);

EXIT:

return;

}

/** Predicate for: have virtual wakelocks

*

* @return true if there are active virtual wakelocks, false otherwise

*/

static bool

mce_wakelock_have_entries(void)

{

bool have_entries = false;

if( !mce_wakelock_lut )

goto EXIT;

if( g_hash_table_size(mce_wakelock_lut) > 0 )

have_entries = true;

EXIT:

return have_entries;

}

/** Obtain virtual wakelock

*

* @param name Name of the virtual wakelock

*/

void

mce_wakelock_obtain(const char *name, int duration_ms)

{

if( !mce_wakelock_ready )

goto EXIT;

/* Add entry & start release timer */

mwl_wakelock_start_timer(mce_wakelock_add_entry(name),

duration_ms);

/* Re-evaluate need for real wakelock */

mwl_rawlock_set(mce_wakelock_have_entries());

EXIT:

return;

}

/** Release virtual wakelock

*

* @param name Name of the virtual wakelock

*/

void

mce_wakelock_release(const char *name)

{

if( !mce_wakelock_ready )

goto EXIT;

/* Remove entry */

mce_wakelock_rem_entry(name);

/* Re-evaluate need for real wakelock */

mwl_rawlock_set(mce_wakelock_have_entries());

EXIT:

return;

}

/** Initialize mce wakelock subsystem

*/

void

mce_wakelock_init(void)

{

/* Leave disabled if sysfs control files do not exist */

if( !mwl_rawlock_supported() )

goto EXIT;

/* Setup entry look up table */

if( !mce_wakelock_lut )

mce_wakelock_lut = g_hash_table_new_full(g_str_hash, g_str_equal,

g_free, mwl_wakelock_delete_cb);

/* In case previous mce instance managed to exit without

* clearing wakelocks: unlock without error checking */

mwl_rawlock_unlock();

/* allow locking */

mce_wakelock_ready = true;

EXIT:

mce_log(LL_DEBUG, "wakelock usage %s",

mce_wakelock_ready ? "enabled" : "disabled");

return;

}

/** Cleanup mce wakelock subsystem

*/

void

mce_wakelock_quit(void)

{

/* Deny further locking */

mce_wakelock_ready = false;

/* Flush entry look up table */

if( mce_wakelock_lut )

g_hash_table_unref(mce_wakelock_lut), mce_wakelock_lut = 0;

/* If there were active internal wakelocks,

* remove the real kernel wakelock too */

mwl_rawlock_set(false);

}

/** Async signal safe wakelock cleanup

*/

void

mce_wakelock_abort(void)

{

/* Deny further locking */

mce_wakelock_ready = false;

/* Uncondition unlock, using syscalls only */

mwl_rawlock_unlock();

}